base::Bind: Convert proxy_resolution_service_provider.cc.

chrome/browser/chromeos/dbus/proxy_resolution_service_provider.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 "chrome/browser/chromeos/dbus/proxy_resolution_service_provider.h"
 
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/threading/platform_thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/exported_object.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 // The ProxyResolverInterface implementation used in production.
 class ProxyResolverImpl : public ProxyResolverInterface {
  public:
   // Data being used in one proxy resolution.
   class Request {
    public:
     explicit Request(const std::string& source_url)
-        : ALLOW_THIS_IN_INITIALIZER_LIST(
-            completion_callback_(this, &Request::OnCompletion)),
+        : ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
+            base::Bind(&Request::OnCompletion, base::Unretained(this)))),
           source_url_(source_url) {
     }
 
     virtual ~Request() {}
 
     // Callback on IO thread for when net::ProxyService::ResolveProxy
     // completes, synchronously or asynchronously.
     void OnCompletion(int result) {
       DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
       // Generate the error message if the error message is not yet set,
       // and there was an error.
       if (error_.empty() && result != net::OK)
         error_ = net::ErrorToString(result);
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, notify_task_);
     }
 
-    net::OldCompletionCallbackImpl<Request> completion_callback_;
+    net::CompletionCallback callback_;
 
     std::string source_url_;  // URL being resolved.
     net::ProxyInfo proxy_info_;  // ProxyInfo resolved for source_url_.
     std::string error_;  // Error from proxy resolution.
     base::Closure notify_task_;  // Task to notify of resolution result.
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Request);
   };
 
@@ skipping 68 matching lines @@
     if (!proxy_service) {
       request->error_ = "No proxy service in chrome";
       request->OnCompletion(net::ERR_UNEXPECTED);
       return;
     }
 
     VLOG(1) << "Starting network proxy resolution for "
             << request->source_url_;
     const int result = proxy_service->ResolveProxy(
         GURL(request->source_url_), &request->proxy_info_,
-        &request->completion_callback_, NULL, net::BoundNetLog());
+        request->callback_, NULL, net::BoundNetLog());
     if (result != net::ERR_IO_PENDING) {
       VLOG(1) << "Network proxy resolution completed synchronously.";
       request->OnCompletion(result);
     }
   }
 
   // Called on UI thread as task posted from Request::OnCompletion on IO
   // thread.
   void NotifyProxyResolved(
       const std::string& signal_interface,
@@ skipping 124 matching lines @@
 ProxyResolutionServiceProvider*
 ProxyResolutionServiceProvider::CreateForTesting(
     ProxyResolverInterface* resolver) {
   return new ProxyResolutionServiceProvider(resolver);
 }
 
 ProxyResolverInterface::~ProxyResolverInterface() {
 }
 
 }  // namespace chromeos