base::Bind: Convert net/proxy.

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/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 90 matching lines @@
     *config = ProxyConfig::CreateDirect();
     return CONFIG_VALID;
   }
 };
 
 // Proxy resolver that fails every time.
 class ProxyResolverNull : public ProxyResolver {
  public:
   ProxyResolverNull() : ProxyResolver(false /*expects_pac_bytes*/) {}
 
-  // ProxyResolver implementation:
+  // ProxyResolver implementation.
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
-                             OldCompletionCallback* callback,
+                             const CompletionCallback& callback,
                              RequestHandle* request,
                              const BoundNetLog& net_log) OVERRIDE {
     return ERR_NOT_IMPLEMENTED;
   }
 
   virtual void CancelRequest(RequestHandle request) OVERRIDE {
     NOTREACHED();
   }
 
   virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
   virtual LoadState GetLoadStateThreadSafe(
       RequestHandle request) const OVERRIDE {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
   virtual void CancelSetPacScript() OVERRIDE {
     NOTREACHED();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& /*script_data*/,
-      OldCompletionCallback* /*callback*/) OVERRIDE {
+      const CompletionCallback& /*callback*/) OVERRIDE {
     return ERR_NOT_IMPLEMENTED;
   }
 };
 
 // ProxyResolver that simulates a PAC script which returns
 // |pac_string| for every single URL.
 class ProxyResolverFromPacString : public ProxyResolver {
  public:
   ProxyResolverFromPacString(const std::string& pac_string)
       : ProxyResolver(false /*expects_pac_bytes*/),
         pac_string_(pac_string) {}
 
   virtual int GetProxyForURL(const GURL& url,
                              ProxyInfo* results,
-                             OldCompletionCallback* callback,
+                             const CompletionCallback& callback,
                              RequestHandle* request,
                              const BoundNetLog& net_log) OVERRIDE {
     results->UsePacString(pac_string_);
     return OK;
   }
 
   virtual void CancelRequest(RequestHandle request) OVERRIDE {
     NOTREACHED();
   }
 
   virtual LoadState GetLoadState(RequestHandle request) const OVERRIDE {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
   virtual LoadState GetLoadStateThreadSafe(
       RequestHandle request) const OVERRIDE {
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
 
   virtual void CancelSetPacScript() OVERRIDE {
     NOTREACHED();
   }
 
   virtual int SetPacScript(
       const scoped_refptr<ProxyResolverScriptData>& pac_script,
-      OldCompletionCallback* callback) OVERRIDE {
+      const CompletionCallback& callback) OVERRIDE {
     return OK;
   }
 
  private:
   const std::string pac_string_;
 };
 
 // This factory creates V8ProxyResolvers with appropriate javascript bindings.
 class ProxyResolverFactoryForV8 : public ProxyResolverFactory {
  public:
@@ skipping 132 matching lines @@
 // things similar. It will probably end up changing while solving bug 90581.
 
 class ProxyService::InitProxyResolver {
  public:
   InitProxyResolver(ProxyResolver* proxy_resolver,
                     ProxyScriptFetcher* proxy_script_fetcher,
                     DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher,
                     NetLog* net_log)
       : decider_(proxy_script_fetcher, dhcp_proxy_script_fetcher, net_log),
         effective_config_(NULL),
-        proxy_resolver_(proxy_resolver),
-        user_callback_(NULL),
-        ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
-            this, &InitProxyResolver::OnIOCompletion)) {
+        proxy_resolver_(proxy_resolver) {
   }
 
   ~InitProxyResolver() {
     // Note that the destruction of ProxyScriptDecider will automatically cancel
     // any outstanding work.
     if (next_state_ == STATE_SET_PAC_SCRIPT_COMPLETE) {
       proxy_resolver_->CancelSetPacScript();
     }
   }
 
   int Init(const ProxyConfig& config,
            base::TimeDelta wait_delay,
            ProxyConfig* effective_config,
-           OldCompletionCallback* callback) {
+           const CompletionCallback& callback) {
     config_ = config;
     wait_delay_ = wait_delay;
     effective_config_ = effective_config;
-    user_callback_ = callback;
+    callback_ = callback;
 
     next_state_ = STATE_DECIDE_PROXY_SCRIPT;
     return DoLoop(OK);
   }
 
  private:
   enum State {
     STATE_NONE,
     STATE_DECIDE_PROXY_SCRIPT,
     STATE_DECIDE_PROXY_SCRIPT_COMPLETE,
@@ skipping 29 matching lines @@
       }
     } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
     return rv;
   }
 
   int DoDecideProxyScript() {
     next_state_ = STATE_DECIDE_PROXY_SCRIPT_COMPLETE;
 
     return decider_.Start(
         config_, wait_delay_, proxy_resolver_->expects_pac_bytes(),
-        &io_callback_);
+        base::Bind(&InitProxyResolver::OnIOCompletion, base::Unretained(this)));
   }
 
   int DoDecideProxyScriptComplete(int result) {
     if (result != OK)
       return result;
 
     *effective_config_ = decider_.effective_config();
     next_state_ = STATE_SET_PAC_SCRIPT;
     return OK;
   }
 
   int DoSetPacScript() {
     DCHECK(decider_.script_data());
     // TODO(eroman): Should log this latency to the NetLog.
     next_state_ = STATE_SET_PAC_SCRIPT_COMPLETE;
-    return proxy_resolver_->SetPacScript(decider_.script_data(), &io_callback_);
+    return proxy_resolver_->SetPacScript(
+        decider_.script_data(),
+        base::Bind(&InitProxyResolver::OnIOCompletion, base::Unretained(this)));
   }
 
   int DoSetPacScriptComplete(int result) {
     return result;
   }
 
   void OnIOCompletion(int result) {
     DCHECK_NE(STATE_NONE, next_state_);
     int rv = DoLoop(result);
     if (rv != ERR_IO_PENDING)
       DoCallback(rv);
   }
 
   void DoCallback(int result) {
     DCHECK_NE(ERR_IO_PENDING, result);
-    user_callback_->Run(result);
+    callback_.Run(result);
   }
 
   ProxyConfig config_;
   base::TimeDelta wait_delay_;
   ProxyScriptDecider decider_;
   ProxyConfig* effective_config_;
   ProxyResolver* proxy_resolver_;
-  OldCompletionCallback* user_callback_;
-  OldCompletionCallbackImpl<InitProxyResolver> io_callback_;
+  CompletionCallback callback_;
   State next_state_;
 
   DISALLOW_COPY_AND_ASSIGN(InitProxyResolver);
 };
 
 // ProxyService::PacRequest ---------------------------------------------------
 
 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),
-        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,
+    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(
-        url_, results_, &io_callback_, &resolve_job_, net_log_);
+        url_, results_,
+        base::Bind(&PacRequest::QueryComplete, base::Unretained(this)),
+        &resolve_job_, net_log_);
   }
 
   bool is_started() const {
     // Note that !! casts to bool. (VS gives a warning otherwise).
     return !!resolve_job_;
   }
 
   void StartAndCompleteCheckingForSynchronous() {
     int rv = service_->TryToCompleteSynchronously(url_, results_);
     if (rv == ERR_IO_PENDING)
@@ skipping 11 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;
-    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 old_user_callback_ == NULL && user_callback_.is_null();
+    return 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 17 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|).
-    if (old_user_callback_) {
-      OldCompletionCallback* callback = old_user_callback_;
-      service_->RemovePendingRequest(this);
-      callback->Run(result_code);
-    } else if (!user_callback_.is_null()){
+    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* 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 ---------------------------------------------------------------
 
 ProxyService::ProxyService(ProxyConfigService* config_service,
                            ProxyResolver* resolver,
                            NetLog* net_log)
     : resolver_(resolver),
       next_config_id_(1),
-      ALLOW_THIS_IN_INITIALIZER_LIST(init_proxy_resolver_callback_(
-          this, &ProxyService::OnInitProxyResolverComplete)),
       current_state_(STATE_NONE) ,
       net_log_(net_log),
       stall_proxy_auto_config_delay_(
           base::TimeDelta::FromMilliseconds(
               kNumMillisToStallAfterNetworkChanges)) {
   NetworkChangeNotifier::AddIPAddressObserver(this);
   ResetConfigService(config_service);
 }
 
 // static
@@ skipping 103 matching lines @@
   scoped_ptr<ProxyResolver> proxy_resolver(
       new ProxyResolverFromPacString(pac_string));
 
   return new ProxyService(proxy_config_service.release(),
                           proxy_resolver.release(),
                           NULL);
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
                                ProxyInfo* result,
-                               OldCompletionCallback* callback,
-                               PacRequest** pac_request,
-                               const BoundNetLog& net_log) {
-  DCHECK(CalledOnValidThread());
-  DCHECK(callback);
-
-  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::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)
@@ skipping 434 matching lines @@
       new InitProxyResolver(resolver_.get(),
                             proxy_script_fetcher_.get(),
                             dhcp_proxy_script_fetcher_.get(),
                             net_log_));
 
   // If we changed networks recently, we should delay running proxy auto-config.
   base::TimeDelta wait_delay =
       stall_proxy_autoconfig_until_ - base::TimeTicks::Now();
 
   int rv = init_proxy_resolver_->Init(
-      fetched_config_, wait_delay, &config_, &init_proxy_resolver_callback_);
+      fetched_config_, wait_delay, &config_,
+      base::Bind(&ProxyService::OnInitProxyResolverComplete,
+                 base::Unretained(this)));
 
   if (rv != ERR_IO_PENDING)
     OnInitProxyResolverComplete(rv);
 }
 
 void ProxyService::OnIPAddressChanged() {
   // See the comment block by |kNumMillisToStallAfterNetworkChanges| for info.
   stall_proxy_autoconfig_until_ =
       base::TimeTicks::Now() + stall_proxy_auto_config_delay_;
 
@@ skipping 11 matching lines @@
           base::Bind(&SyncProxyServiceHelper::OnCompletion,
                      base::Unretained(this)))) {
   DCHECK(io_message_loop_ != MessageLoop::current());
 }
 
 int SyncProxyServiceHelper::ResolveProxy(const GURL& url,
                                          ProxyInfo* proxy_info,
                                          const BoundNetLog& net_log) {
   DCHECK(io_message_loop_ != MessageLoop::current());
 
-  io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SyncProxyServiceHelper::StartAsyncResolve, url, net_log));
+  io_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&SyncProxyServiceHelper::StartAsyncResolve, this, url,
+                 net_log));
 
   event_.Wait();
 
   if (result_ == net::OK) {
     *proxy_info = proxy_info_;
   }
   return result_;
 }
 
 int SyncProxyServiceHelper::ReconsiderProxyAfterError(
     const GURL& url, ProxyInfo* proxy_info, const BoundNetLog& net_log) {
   DCHECK(io_message_loop_ != MessageLoop::current());
 
-  io_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &SyncProxyServiceHelper::StartAsyncReconsider, url, net_log));
+  io_message_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&SyncProxyServiceHelper::StartAsyncReconsider, this, url,
+                 net_log));
 
   event_.Wait();
 
   if (result_ == net::OK) {
     *proxy_info = proxy_info_;
   }
   return result_;
 }
 
 SyncProxyServiceHelper::~SyncProxyServiceHelper() {}
@@ skipping 15 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net