base::Bind: Convert net/proxy.

net/proxy/dhcp_proxy_script_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_fetcher_win.h"
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/perftimer.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/dhcp_proxy_script_adapter_fetcher_win.h"
 
 #include <winsock2.h>
 #include <iphlpapi.h>
 #pragma comment(lib, "iphlpapi.lib")
 
@@ skipping 12 matching lines @@
   ERROR_NO_DATA,
 };
 
 }  // namespace
 
 namespace net {
 
 DhcpProxyScriptFetcherWin::DhcpProxyScriptFetcherWin(
     URLRequestContext* url_request_context)
     : state_(STATE_START),
-      ALLOW_THIS_IN_INITIALIZER_LIST(fetcher_callback_(
-          this, &DhcpProxyScriptFetcherWin::OnFetcherDone)),
       num_pending_fetchers_(0),
       url_request_context_(url_request_context) {
   DCHECK(url_request_context_);
 }
 
 DhcpProxyScriptFetcherWin::~DhcpProxyScriptFetcherWin() {
   // Count as user-initiated if we are not yet in STATE_DONE.
   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<DhcpProxyScriptFetcherWin>::DetachFromThread();
 }
 
 int DhcpProxyScriptFetcherWin::Fetch(string16* utf16_text,
-                                     OldCompletionCallback* callback) {
+                                     const CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   if (state_ != STATE_START && state_ != STATE_DONE) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
 
   fetch_start_time_ = base::TimeTicks::Now();
 
   state_ = STATE_WAIT_ADAPTERS;
-  client_callback_ = callback;
+  callback_ = callback;
   destination_string_ = utf16_text;
 
   last_query_ = ImplCreateAdapterQuery();
   base::WorkerPool::PostTaskAndReply(
       FROM_HERE,
       base::Bind(
           &DhcpProxyScriptFetcherWin::AdapterQuery::GetCandidateAdapterNames,
           last_query_.get()),
       base::Bind(
           &DhcpProxyScriptFetcherWin::OnGetCandidateAdapterNamesDone,
@@ skipping 14 matching lines @@
                         base::TimeTicks::Now() - fetch_start_time_);
   }
 
   CancelImpl();
 }
 
 void DhcpProxyScriptFetcherWin::CancelImpl() {
   DCHECK(CalledOnValidThread());
 
   if (state_ != STATE_DONE) {
-    client_callback_ = NULL;
+    callback_.Reset();
     wait_timer_.Stop();
     state_ = STATE_DONE;
 
     for (FetcherVector::iterator it = fetchers_.begin();
          it != fetchers_.end();
          ++it) {
       (*it)->Cancel();
     }
 
     fetchers_.reset();
@@ skipping 24 matching lines @@
 
   if (adapter_names.empty()) {
     TransitionToDone();
     return;
   }
 
   for (std::set<std::string>::const_iterator it = adapter_names.begin();
        it != adapter_names.end();
        ++it) {
     DhcpProxyScriptAdapterFetcher* fetcher(ImplCreateAdapterFetcher());
-    fetcher->Fetch(*it, &fetcher_callback_);
+    fetcher->Fetch(
+        *it, base::Bind(&DhcpProxyScriptFetcherWin::OnFetcherDone,
+                        base::Unretained(this)));
     fetchers_.push_back(fetcher);
   }
   num_pending_fetchers_ = fetchers_.size();
 }
 
 std::string DhcpProxyScriptFetcherWin::GetFetcherName() const {
   DCHECK(CalledOnValidThread());
   return "win";
 }
 
@@ skipping 79 matching lines @@
         if ((*it)->DidFinish()) {
           result = (*it)->GetResult();
           if (result != ERR_PAC_NOT_IN_DHCP) {
             break;
           }
         }
       }
     }
   }
 
-  OldCompletionCallback* callback = client_callback_;
+  CompletionCallback callback = callback_;
   CancelImpl();
   DCHECK_EQ(state_, STATE_DONE);
   DCHECK(fetchers_.empty());
-  DCHECK(!client_callback_);  // Invariant of data.
+  DCHECK(callback_.is_null());  // Invariant of data.
 
   UMA_HISTOGRAM_TIMES("Net.DhcpWpadCompletionTime",
                       base::TimeTicks::Now() - fetch_start_time_);
 
   if (result != OK) {
     UMA_HISTOGRAM_CUSTOM_ENUMERATION(
         "Net.DhcpWpadFetchError", std::abs(result), GetAllErrorCodesForUma());
   }
 
   // We may be deleted re-entrantly within this outcall.
-  callback->Run(result);
+  callback.Run(result);
 }
 
 int DhcpProxyScriptFetcherWin::num_pending_fetchers() const {
   return num_pending_fetchers_;
 }
 
 URLRequestContext* DhcpProxyScriptFetcherWin::url_request_context() const {
   return url_request_context_;
 }
 
@@ skipping 91 matching lines @@
     DhcpProxyScriptFetcherWin::AdapterQuery::adapter_names() const {
   return adapter_names_;
 }
 
 bool DhcpProxyScriptFetcherWin::AdapterQuery::ImplGetCandidateAdapterNames(
     std::set<std::string>* adapter_names) {
   return DhcpProxyScriptFetcherWin::GetCandidateAdapterNames(adapter_names);
 }
 
 }  // namespace net