proxy_resolution_service_provider.cc revision 5d1f7b1de12d16ceb2c938c56701a3e8bfa558f7 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/chromeos/dbus/proxy_resolution_service_provider.h"
6
7#include "base/bind.h"
8#include "base/bind_helpers.h"
9#include "base/threading/platform_thread.h"
10#include "chrome/browser/profiles/profile_manager.h"
11#include "content/public/browser/browser_thread.h"
12#include "dbus/bus.h"
13#include "dbus/message.h"
14#include "dbus/exported_object.h"
15#include "net/base/net_errors.h"
16#include "net/proxy/proxy_service.h"
17#include "net/url_request/url_request_context.h"
18#include "net/url_request/url_request_context_getter.h"
19#include "third_party/cros_system_api/dbus/service_constants.h"
20
21using content::BrowserThread;
22
23namespace chromeos {
24
25// The ProxyResolverInterface implementation used in production.
26class ProxyResolverImpl : public ProxyResolverInterface {
27 public:
28  // Data being used in one proxy resolution.
29  class Request {
30   public:
31    explicit Request(const std::string& source_url)
32        : callback_(base::Bind(&Request::OnCompletion, base::Unretained(this))),
33          source_url_(source_url) {
34    }
35
36    virtual ~Request() {}
37
38    // Callback on IO thread for when net::ProxyService::ResolveProxy
39    // completes, synchronously or asynchronously.
40    void OnCompletion(int result) {
41      DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
42      // Generate the error message if the error message is not yet set,
43      // and there was an error.
44      if (error_.empty() && result != net::OK)
45        error_ = net::ErrorToString(result);
46      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, notify_task_);
47    }
48
49    net::CompletionCallback callback_;
50
51    std::string source_url_;  // URL being resolved.
52    net::ProxyInfo proxy_info_;  // ProxyInfo resolved for source_url_.
53    std::string error_;  // Error from proxy resolution.
54    base::Closure notify_task_;  // Task to notify of resolution result.
55
56   private:
57    DISALLOW_COPY_AND_ASSIGN(Request);
58  };
59
60  ProxyResolverImpl()
61      : origin_thread_id_(base::PlatformThread::CurrentId()),
62        weak_ptr_factory_(this) {
63  }
64
65  virtual ~ProxyResolverImpl() {
66    DCHECK(OnOriginThread());
67
68    for (std::set<Request*>::iterator iter = all_requests_.begin();
69         iter != all_requests_.end(); ++iter) {
70      Request* request = *iter;
71      LOG(WARNING) << "Pending request for " << request->source_url_;
72      delete request;
73    }
74  }
75
76  // ProxyResolverInterface override.
77  virtual void ResolveProxy(
78      const std::string& source_url,
79      const std::string& signal_interface,
80      const std::string& signal_name,
81      scoped_refptr<dbus::ExportedObject> exported_object) OVERRIDE {
82    DCHECK(OnOriginThread());
83
84    // Create a request slot for this proxy resolution request.
85    Request* request = new Request(source_url);
86    request->notify_task_ = base::Bind(
87        &ProxyResolverImpl::NotifyProxyResolved,
88        weak_ptr_factory_.GetWeakPtr(),
89        signal_interface,
90        signal_name,
91        exported_object,
92        request);
93    all_requests_.insert(request);
94
95    // GetPrimaryUserProfile() and GetRequestContext() must be called on UI
96    // thread.
97    Profile* profile = ProfileManager::GetPrimaryUserProfile();
98    scoped_refptr<net::URLRequestContextGetter> getter =
99        profile->GetRequestContext();
100
101    BrowserThread::PostTask(
102        BrowserThread::IO, FROM_HERE,
103        base::Bind(&ProxyResolverImpl::ResolveProxyInternal,
104                   request,
105                   getter,
106                   exported_object));
107  }
108
109 private:
110  // Helper function for ResolveProxy().
111  static void ResolveProxyInternal(
112      Request* request,
113      scoped_refptr<net::URLRequestContextGetter> getter,
114      scoped_refptr<dbus::ExportedObject> exported_object) {
115    // Make sure we're running on IO thread.
116    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
117
118    // Check if we have the URLRequestContextGetter.
119    if (!getter.get()) {
120      request->error_ = "No URLRequestContextGetter";
121      request->OnCompletion(net::ERR_UNEXPECTED);
122      return;
123    }
124
125    // Retrieve ProxyService from profile's request context.
126    net::ProxyService* proxy_service =
127        getter->GetURLRequestContext()->proxy_service();
128    if (!proxy_service) {
129      request->error_ = "No proxy service in chrome";
130      request->OnCompletion(net::ERR_UNEXPECTED);
131      return;
132    }
133
134    VLOG(1) << "Starting network proxy resolution for "
135            << request->source_url_;
136    const int result = proxy_service->ResolveProxy(
137        GURL(request->source_url_), &request->proxy_info_,
138        request->callback_, NULL, net::BoundNetLog());
139    if (result != net::ERR_IO_PENDING) {
140      VLOG(1) << "Network proxy resolution completed synchronously.";
141      request->OnCompletion(result);
142    }
143  }
144
145  // Called on UI thread as task posted from Request::OnCompletion on IO
146  // thread.
147  void NotifyProxyResolved(
148      const std::string& signal_interface,
149      const std::string& signal_name,
150      scoped_refptr<dbus::ExportedObject> exported_object,
151      Request* request) {
152    DCHECK(OnOriginThread());
153
154    // Send a signal to the client.
155    dbus::Signal signal(signal_interface, signal_name);
156    dbus::MessageWriter writer(&signal);
157    writer.AppendString(request->source_url_);
158    writer.AppendString(request->proxy_info_.ToPacString());
159    writer.AppendString(request->error_);
160    exported_object->SendSignal(&signal);
161    VLOG(1) << "Sending signal: " << signal.ToString();
162
163    std::set<Request*>::iterator iter = all_requests_.find(request);
164    if (iter == all_requests_.end()) {
165      LOG(ERROR) << "can't find request slot(" << request->source_url_
166                 << ") in proxy-resolution queue";
167    } else {
168      all_requests_.erase(iter);
169    }
170    delete request;
171  }
172
173  // Returns true if the current thread is on the origin thread.
174  bool OnOriginThread() {
175    return base::PlatformThread::CurrentId() == origin_thread_id_;
176  }
177
178  base::PlatformThreadId origin_thread_id_;
179  std::set<Request*> all_requests_;
180  base::WeakPtrFactory<ProxyResolverImpl> weak_ptr_factory_;
181
182  DISALLOW_COPY_AND_ASSIGN(ProxyResolverImpl);
183};
184
185ProxyResolutionServiceProvider::ProxyResolutionServiceProvider(
186    ProxyResolverInterface* resolver)
187    : resolver_(resolver),
188      origin_thread_id_(base::PlatformThread::CurrentId()),
189      weak_ptr_factory_(this) {
190}
191
192ProxyResolutionServiceProvider::~ProxyResolutionServiceProvider() {
193}
194
195void ProxyResolutionServiceProvider::Start(
196    scoped_refptr<dbus::ExportedObject> exported_object) {
197  DCHECK(OnOriginThread());
198  exported_object_ = exported_object;
199  VLOG(1) << "ProxyResolutionServiceProvider started";
200  exported_object_->ExportMethod(
201      kLibCrosServiceInterface,
202      kResolveNetworkProxy,
203      // Weak pointers can only bind to methods without return values,
204      // hence we cannot bind ResolveProxyInternal here. Instead we use a
205      // static function to solve this problem.
206      base::Bind(&ProxyResolutionServiceProvider::CallResolveProxyHandler,
207                 weak_ptr_factory_.GetWeakPtr()),
208      base::Bind(&ProxyResolutionServiceProvider::OnExported,
209                 weak_ptr_factory_.GetWeakPtr()));
210}
211
212void ProxyResolutionServiceProvider::OnExported(
213    const std::string& interface_name,
214    const std::string& method_name,
215    bool success) {
216  if (!success) {
217    LOG(ERROR) << "Failed to export " << interface_name << "."
218               << method_name;
219  }
220  VLOG(1) << "Method exported: " << interface_name << "." << method_name;
221}
222
223bool ProxyResolutionServiceProvider::OnOriginThread() {
224  return base::PlatformThread::CurrentId() == origin_thread_id_;
225}
226
227void ProxyResolutionServiceProvider::ResolveProxyHandler(
228    dbus::MethodCall* method_call,
229    dbus::ExportedObject::ResponseSender response_sender) {
230  DCHECK(OnOriginThread());
231  VLOG(1) << "Handing method call: " << method_call->ToString();
232  // The method call should contain the three string parameters.
233  dbus::MessageReader reader(method_call);
234  std::string source_url;
235  std::string signal_interface;
236  std::string signal_name;
237  if (!reader.PopString(&source_url) ||
238      !reader.PopString(&signal_interface) ||
239      !reader.PopString(&signal_name)) {
240    LOG(ERROR) << "Unexpected method call: " << method_call->ToString();
241    response_sender.Run(scoped_ptr<dbus::Response>());
242    return;
243  }
244
245  resolver_->ResolveProxy(source_url,
246                          signal_interface,
247                          signal_name,
248                          exported_object_);
249
250  // Send an empty response for now. We'll send a signal once the network proxy
251  // resolution is completed.
252  response_sender.Run(dbus::Response::FromMethodCall(method_call));
253}
254
255// static
256void ProxyResolutionServiceProvider::CallResolveProxyHandler(
257    base::WeakPtr<ProxyResolutionServiceProvider> provider_weak_ptr,
258    dbus::MethodCall* method_call,
259    dbus::ExportedObject::ResponseSender response_sender) {
260  if (!provider_weak_ptr) {
261    LOG(WARNING) << "Called after the object is deleted";
262    response_sender.Run(scoped_ptr<dbus::Response>());
263    return;
264  }
265  provider_weak_ptr->ResolveProxyHandler(method_call, response_sender);
266}
267
268ProxyResolutionServiceProvider* ProxyResolutionServiceProvider::Create() {
269  return new ProxyResolutionServiceProvider(new ProxyResolverImpl);
270}
271
272ProxyResolutionServiceProvider*
273ProxyResolutionServiceProvider::CreateForTesting(
274    ProxyResolverInterface* resolver) {
275  return new ProxyResolutionServiceProvider(resolver);
276}
277
278ProxyResolverInterface::~ProxyResolverInterface() {
279}
280
281}  // namespace chromeos
282