base::Bind: Convert proxy_resolution_service_provider.cc.

net/proxy/proxy_service.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/proxy/proxy_service.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "googleurl/src/gurl.h"
+#include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/init_proxy_resolver.h"
 #include "net/proxy/multi_threaded_proxy_resolver.h"
 #include "net/proxy/network_delegate_error_observer.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/proxy/proxy_resolver.h"
 #include "net/proxy/proxy_resolver_js_bindings.h"
@@ skipping 291 matching lines @@
 
 class ProxyService::PacRequest
     : public base::RefCounted<ProxyService::PacRequest> {
  public:
   PacRequest(ProxyService* service,
              const GURL& url,
              ProxyInfo* results,
              OldCompletionCallback* user_callback,
              const BoundNetLog& net_log)
       : service_(service),
-        user_callback_(user_callback),
+        old_user_callback_(user_callback),
         ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
             this, &PacRequest::QueryComplete)),
         results_(results),
         url_(url),
         resolve_job_(NULL),
         config_id_(ProxyConfig::kInvalidConfigID),
         net_log_(net_log) {
     DCHECK(user_callback);
   }
 
+  PacRequest(ProxyService* service,
+             const GURL& url,
+             ProxyInfo* results,
+             const net::CompletionCallback& user_callback,
+             const BoundNetLog& net_log)
+      : service_(service),
+        old_user_callback_(NULL),
+        user_callback_(user_callback),
+        ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
+            this, &PacRequest::QueryComplete)),
+        results_(results),
+        url_(url),
+        resolve_job_(NULL),
+        config_id_(ProxyConfig::kInvalidConfigID),
+        net_log_(net_log) {
+    DCHECK(!user_callback.is_null());
+  }
+
   // Starts the resolve proxy request.
   int Start() {
     DCHECK(!was_cancelled());
     DCHECK(!is_started());
 
     DCHECK(service_->config_.is_valid());
 
     config_id_ = service_->config_.id();
 
     return resolver()->GetProxyForURL(
@@ skipping 22 matching lines @@
   }
 
   void Cancel() {
     net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
 
     if (is_started())
       CancelResolveJob();
 
     // Mark as cancelled, to prevent accessing this again later.
     service_ = NULL;
-    user_callback_ = NULL;
+    old_user_callback_ = NULL;
+    user_callback_.Reset();
     results_ = NULL;
 
     net_log_.EndEvent(NetLog::TYPE_PROXY_SERVICE, NULL);
   }
 
   // Returns true if Cancel() has been called.
-  bool was_cancelled() const { return user_callback_ == NULL; }
+  bool was_cancelled() const {
+    return old_user_callback_ == NULL && user_callback_.is_null();
+  }
 
   // Helper to call after ProxyResolver completion (both synchronous and
   // asynchronous). Fixes up the result that is to be returned to user.
   int QueryDidComplete(int result_code) {
     DCHECK(!was_cancelled());
 
     // Make a note in the results which configuration was in use at the
     // time of the resolve.
     results_->config_id_ = config_id_;
 
@@ skipping 16 matching lines @@
   friend class base::RefCounted<ProxyService::PacRequest>;
 
   ~PacRequest() {}
 
   // Callback for when the ProxyResolver request has completed.
   void QueryComplete(int result_code) {
     result_code = QueryDidComplete(result_code);
 
     // Remove this completed PacRequest from the service's pending list.
     /// (which will probably cause deletion of |this|).
-    OldCompletionCallback* callback = user_callback_;
-    service_->RemovePendingRequest(this);
-
-    callback->Run(result_code);
+    if (old_user_callback_) {
+      OldCompletionCallback* callback = old_user_callback_;
+      service_->RemovePendingRequest(this);
+      callback->Run(result_code);
+    } else if (!user_callback_.is_null()){
+      net::CompletionCallback callback = user_callback_;
+      service_->RemovePendingRequest(this);
+      callback.Run(result_code);
+    }
   }
 
   ProxyResolver* resolver() const { return service_->resolver_.get(); }
 
   // Note that we don't hold a reference to the ProxyService. Outstanding
   // requests are cancelled during ~ProxyService, so this is guaranteed
   // to be valid throughout our lifetime.
   ProxyService* service_;
-  OldCompletionCallback* user_callback_;
+  OldCompletionCallback* old_user_callback_;
+  net::CompletionCallback user_callback_;
   OldCompletionCallbackImpl<PacRequest> io_callback_;
   ProxyInfo* results_;
   GURL url_;
   ProxyResolver::RequestHandle resolve_job_;
   ProxyConfig::ID config_id_;  // The config id when the resolve was started.
   BoundNetLog net_log_;
 };
 
 // ProxyService ---------------------------------------------------------------
 
@@ skipping 166 matching lines @@
   DCHECK(!ContainsPendingRequest(req));
   pending_requests_.push_back(req);
 
   // Completion will be notifed through |callback|, unless the caller cancels
   // the request using |pac_request|.
   if (pac_request)
     *pac_request = req.get();
   return rv;  // ERR_IO_PENDING
 }
 
+int ProxyService::ResolveProxy(const GURL& raw_url,
+                               ProxyInfo* result,
+                               const net::CompletionCallback& callback,
+                               PacRequest** pac_request,
+                               const BoundNetLog& net_log) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!callback.is_null());
+
+  net_log.BeginEvent(NetLog::TYPE_PROXY_SERVICE, NULL);
+
+  config_service_->OnLazyPoll();
+  if (current_state_ == STATE_NONE)
+    ApplyProxyConfigIfAvailable();
+
+  // Strip away any reference fragments and the username/password, as they
+  // are not relevant to proxy resolution.
+  GURL url = SimplifyUrlForRequest(raw_url);
+
+  // Check if the request can be completed right away. (This is the case when
+  // using a direct connection for example).
+  int rv = TryToCompleteSynchronously(url, result);
+  if (rv != ERR_IO_PENDING)
+    return DidFinishResolvingProxy(result, rv, net_log);
+
+  scoped_refptr<PacRequest> req(
+      new PacRequest(this, url, result, callback, net_log));
+
+  if (current_state_ == STATE_READY) {
+    // Start the resolve request.
+    rv = req->Start();
+    if (rv != ERR_IO_PENDING)
+      return req->QueryDidComplete(rv);
+  } else {
+    req->net_log()->BeginEvent(NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC,
+                               NULL);
+  }
+
+  DCHECK_EQ(ERR_IO_PENDING, rv);
+  DCHECK(!ContainsPendingRequest(req));
+  pending_requests_.push_back(req);
+
+  // Completion will be notified through |callback|, unless the caller cancels
+  // the request using |pac_request|.
+  if (pac_request)
+    *pac_request = req.get();
+  return rv;  // ERR_IO_PENDING
+}
+
 int ProxyService::TryToCompleteSynchronously(const GURL& url,
                                              ProxyInfo* result) {
   DCHECK_NE(STATE_NONE, current_state_);
 
   if (current_state_ != STATE_READY)
     return ERR_IO_PENDING;  // Still initializing.
 
   DCHECK_NE(config_.id(), ProxyConfig::kInvalidConfigID);
 
   // If it was impossible to fetch or parse the PAC script, we cannot complete
@@ skipping 471 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net