src/chrome/browser/chromeos/dbus/proxy_resolution_service_provider.cc

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