base::Bind: Convert net/proxy.

net/proxy/proxy_script_decider.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_script_decider.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/net_log.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/dhcp_proxy_script_fetcher.h"
 #include "net/proxy/dhcp_proxy_script_fetcher_factory.h"
 #include "net/proxy/proxy_script_fetcher.h"
@@ skipping 25 matching lines @@
 // For more details, also check out this comment:
 // http://code.google.com/p/chromium/issues/detail?id=18575#c20
 static const char kWpadUrl[] = "http://wpad/wpad.dat";
 
 ProxyScriptDecider::ProxyScriptDecider(
     ProxyScriptFetcher* proxy_script_fetcher,
     DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher,
     NetLog* net_log)
     : proxy_script_fetcher_(proxy_script_fetcher),
       dhcp_proxy_script_fetcher_(dhcp_proxy_script_fetcher),
-      ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
-          this, &ProxyScriptDecider::OnIOCompletion)),
-      user_callback_(NULL),
       current_pac_source_index_(0u),
       pac_mandatory_(false),
       next_state_(STATE_NONE),
       net_log_(BoundNetLog::Make(
           net_log, NetLog::SOURCE_PROXY_SCRIPT_DECIDER)),
       fetch_pac_bytes_(false) {
 }
 
 ProxyScriptDecider::~ProxyScriptDecider() {
   if (next_state_ != STATE_NONE)
     Cancel();
 }
 
-int ProxyScriptDecider::Start(const ProxyConfig& config,
-                              const base::TimeDelta wait_delay,
-                              bool fetch_pac_bytes,
-                              OldCompletionCallback* callback) {
+int ProxyScriptDecider::Start(
+    const ProxyConfig& config, const base::TimeDelta wait_delay,
+    bool fetch_pac_bytes, const CompletionCallback& callback) {
   DCHECK_EQ(STATE_NONE, next_state_);
-  DCHECK(callback);
+  DCHECK(!callback.is_null());
   DCHECK(config.HasAutomaticSettings());
 
   net_log_.BeginEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER, NULL);
 
   fetch_pac_bytes_ = fetch_pac_bytes;
 
   // Save the |wait_delay| as a non-negative value.
   wait_delay_ = wait_delay;
   if (wait_delay_ < base::TimeDelta())
     wait_delay_ = base::TimeDelta();
 
   pac_mandatory_ = config.pac_mandatory();
 
   pac_sources_ = BuildPacSourcesFallbackList(config);
   DCHECK(!pac_sources_.empty());
 
   next_state_ = STATE_WAIT;
 
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
-    user_callback_ = callback;
+    callback_ = callback;
   else
     DidComplete();
 
   return rv;
 }
 
 const ProxyConfig& ProxyScriptDecider::effective_config() const {
   DCHECK_EQ(STATE_NONE, next_state_);
   return effective_config_;
 }
@@ skipping 62 matching lines @@
         NOTREACHED() << "bad state";
         rv = ERR_UNEXPECTED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
   return rv;
 }
 
 void ProxyScriptDecider::DoCallback(int result) {
   DCHECK_NE(ERR_IO_PENDING, result);
-  DCHECK(user_callback_);
-  user_callback_->Run(result);
+  DCHECK(!callback_.is_null());
+  callback_.Run(result);
 }
 
 int ProxyScriptDecider::DoWait() {
   next_state_ = STATE_WAIT_COMPLETE;
 
   // If no waiting is required, continue on to the next state.
   if (wait_delay_.ToInternalValue() == 0)
     return OK;
 
   // Otherwise wait the specified amount of time.
@@ skipping 27 matching lines @@
   net_log_.BeginEvent(
       NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT,
       make_scoped_refptr(log_parameter));
 
   if (pac_source.type == PacSource::WPAD_DHCP) {
     if (!dhcp_proxy_script_fetcher_) {
       net_log_.AddEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER_HAS_NO_FETCHER, NULL);
       return ERR_UNEXPECTED;
     }
 
-    return dhcp_proxy_script_fetcher_->Fetch(&pac_script_, &io_callback_);
+    return dhcp_proxy_script_fetcher_->Fetch(
+        &pac_script_, base::Bind(&ProxyScriptDecider::OnIOCompletion,
+                                 base::Unretained(this)));
   }
 
   if (!proxy_script_fetcher_) {
     net_log_.AddEvent(NetLog::TYPE_PROXY_SCRIPT_DECIDER_HAS_NO_FETCHER, NULL);
     return ERR_UNEXPECTED;
   }
 
   return proxy_script_fetcher_->Fetch(
-      effective_pac_url, &pac_script_, &io_callback_);
+      effective_pac_url, &pac_script_,
+      base::Bind(&ProxyScriptDecider::OnIOCompletion, base::Unretained(this)));
 }
 
 int ProxyScriptDecider::DoFetchPacScriptComplete(int result) {
   DCHECK(fetch_pac_bytes_);
 
   net_log_.EndEventWithNetErrorCode(
       NetLog::TYPE_PROXY_SCRIPT_DECIDER_FETCH_PAC_SCRIPT, result);
   if (result != OK)
     return TryToFallbackPacSource(result);
 
@@ skipping 141 matching lines @@
   }
 
   // This is safe to call in any state.
   if (dhcp_proxy_script_fetcher_)
     dhcp_proxy_script_fetcher_->Cancel();
 
   DidComplete();
 }
 
 }  // namespace net