base::Bind: Convert net/proxy.

net/proxy/dhcp_proxy_script_adapter_fetcher_win.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/dhcp_proxy_script_adapter_fetcher_win.h"
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/worker_pool.h"
 #include "base/time.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/dhcpcsvc_init_win.h"
 #include "net/proxy/proxy_script_fetcher_impl.h"
 #include "net/url_request/url_request_context.h"
 
 #include <windows.h>
 #include <winsock2.h>
 #include <dhcpcsdk.h>
 #pragma comment(lib, "dhcpcsvc.lib")
 
 namespace {
 
 // Maximum amount of time to wait for response from the Win32 DHCP API.
 const int kTimeoutMs = 2000;
 
 }  // namespace
 
 namespace net {
 
 DhcpProxyScriptAdapterFetcher::DhcpProxyScriptAdapterFetcher(
     URLRequestContext* url_request_context)
     : state_(STATE_START),
       result_(ERR_IO_PENDING),
-      callback_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          script_fetcher_callback_(
-              this, &DhcpProxyScriptAdapterFetcher::OnFetcherDone)),
       url_request_context_(url_request_context) {
 }
 
 DhcpProxyScriptAdapterFetcher::~DhcpProxyScriptAdapterFetcher() {
   Cancel();
 
   // The WeakPtr we passed to the worker thread may be destroyed on the
   // worker thread.  This detaches any outstanding WeakPtr state from
   // the current thread.
   base::SupportsWeakPtr<DhcpProxyScriptAdapterFetcher>::DetachFromThread();
 }
 
 void DhcpProxyScriptAdapterFetcher::Fetch(
-    const std::string& adapter_name, OldCompletionCallback* callback) {
+    const std::string& adapter_name, const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(state_, STATE_START);
   result_ = ERR_IO_PENDING;
   pac_script_ = string16();
   state_ = STATE_WAIT_DHCP;
   callback_ = callback;
 
   wait_timer_.Start(FROM_HERE, ImplGetTimeout(),
                     this, &DhcpProxyScriptAdapterFetcher::OnTimeout);
   scoped_refptr<DhcpQuery> dhcp_query(ImplCreateDhcpQuery());
   base::WorkerPool::PostTaskAndReply(
       FROM_HERE,
       base::Bind(
           &DhcpProxyScriptAdapterFetcher::DhcpQuery::GetPacURLForAdapter,
           dhcp_query.get(),
           adapter_name),
       base::Bind(
           &DhcpProxyScriptAdapterFetcher::OnDhcpQueryDone,
           AsWeakPtr(),
           dhcp_query),
       true);
 }
 
 void DhcpProxyScriptAdapterFetcher::Cancel() {
   DCHECK(CalledOnValidThread());
-  callback_ = NULL;
+  callback_.Reset();
   wait_timer_.Stop();
   script_fetcher_.reset();
 
   switch (state_) {
     case STATE_WAIT_DHCP:
       // Nothing to do here, we let the worker thread run to completion,
       // the task it posts back when it completes will check the state.
       break;
     case STATE_WAIT_URL:
       break;
@@ skipping 64 matching lines @@
 
   wait_timer_.Stop();
 
   pac_url_ = GURL(dhcp_query->url());
   if (pac_url_.is_empty() || !pac_url_.is_valid()) {
     result_ = ERR_PAC_NOT_IN_DHCP;
     TransitionToFinish();
   } else {
     state_ = STATE_WAIT_URL;
     script_fetcher_.reset(ImplCreateScriptFetcher());
-    script_fetcher_->Fetch(pac_url_, &pac_script_, &script_fetcher_callback_);
+    script_fetcher_->Fetch(
+        pac_url_, &pac_script_,
+        base::Bind(&DhcpProxyScriptAdapterFetcher::OnFetcherDone,
+                   base::Unretained(this)));
   }
 }
 
 void DhcpProxyScriptAdapterFetcher::OnTimeout() {
   DCHECK_EQ(state_, STATE_WAIT_DHCP);
   result_ = ERR_TIMED_OUT;
   TransitionToFinish();
 }
 
 void DhcpProxyScriptAdapterFetcher::OnFetcherDone(int result) {
   DCHECK(CalledOnValidThread());
   DCHECK(state_ == STATE_WAIT_URL || state_ == STATE_CANCEL);
   if (state_ == STATE_CANCEL)
     return;
 
   // At this point, pac_script_ has already been written to.
   script_fetcher_.reset();
   result_ = result;
   TransitionToFinish();
 }
 
 void DhcpProxyScriptAdapterFetcher::TransitionToFinish() {
   DCHECK(state_ == STATE_WAIT_DHCP || state_ == STATE_WAIT_URL);
   state_ = STATE_FINISH;
-  OldCompletionCallback* callback = callback_;
-  callback_ = NULL;
+  CompletionCallback callback = callback_;
+  callback_.Reset();
 
   // Be careful not to touch any member state after this, as the client
   // may delete us during this callback.
-  callback->Run(result_);
+  callback.Run(result_);
 }
 
 DhcpProxyScriptAdapterFetcher::State
     DhcpProxyScriptAdapterFetcher::state() const {
   return state_;
 }
 
 ProxyScriptFetcher* DhcpProxyScriptAdapterFetcher::ImplCreateScriptFetcher() {
   return new ProxyScriptFetcherImpl(url_request_context_);
 }
@@ skipping 77 matching lines @@
     // back a buffer with embedded NULLs, something is broken anyway.
     return std::string(
         std::string(reinterpret_cast<const char *>(wpad_params.Data),
                     wpad_params.nBytesData).c_str());
   }
 
   return "";
 }
 
 }  // namespace net