base::Bind: Convert proxy_resolving_client_socket.[cc,h] and deps.

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"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
@@ skipping 41 matching lines @@
 // The reason we play this game is that our signal for detecting network
 // changes (NetworkChangeNotifier) may fire *before* the system's networking
 // dependencies are fully configured. This is a problem since it means if
 // we were to run proxy auto-config right away, it could fail due to spurious
 // DNS failures. (see http://crbug.com/50779 for more details.)
 //
 // By adding the wait window, we give things a chance to get properly set up.
 // Now by the time we run the proxy-autoconfig there is a lower chance of
 // getting transient DNS / connect failures.
 //
-// Admitedly this is a hack. Ideally we would have NetworkChangeNotifier
+// Admittedly this is a hack. Ideally we would have NetworkChangeNotifier
 // deliver a reliable signal indicating that the network has changed AND is
 // ready for action... But until then, we can reduce the likelihood of users
 // getting wedged because of proxy detection failures on network switch.
 //
 // The obvious downside to this strategy is it introduces an additional
 // latency when switching networks. This delay shouldn't be too disruptive
 // assuming network switches are infrequent and user initiated. However if
 // NetworkChangeNotifier delivers network changes more frequently this could
 // cause jankiness. (NetworkChangeNotifier broadcasts a change event when ANY
 // interface goes up/down. So in theory if the non-primary interface were
 // hopping on and off wireless networks our constant delayed reconfiguration
 // could add noticeable jank.)
 //
 // The specific hard-coded wait time below is arbitrary.
 // Basically I ran some experiments switching between wireless networks on
 // a Linux Ubuntu (Lucid) laptop, and experimentally found this timeout fixes
-// things. It is entirely possible that the value is insuficient for other
+// things. It is entirely possible that the value is insufficient for other
 // setups.
 const int64 kNumMillisToStallAfterNetworkChanges = 2000;
 
 // Config getter that always returns direct settings.
 class ProxyConfigServiceDirect : public ProxyConfigService {
  public:
   // ProxyConfigService implementation:
   virtual void AddObserver(Observer* observer) OVERRIDE {}
   virtual void RemoveObserver(Observer* observer) OVERRIDE {}
   virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config)
@@ skipping 672 matching lines @@
       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 notifed through |callback|, unless the caller cancels
+  // 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,
@@ skipping 162 matching lines @@
 
   config_.set_id(fetched_config_.id());
 
   // Resume any requests which we had to defer until the PAC script was
   // downloaded.
   SetReady();
 }
 
 int ProxyService::ReconsiderProxyAfterError(const GURL& url,
                                             ProxyInfo* result,
-                                            OldCompletionCallback* callback,
+                                            const CompletionCallback& callback,
                                             PacRequest** pac_request,
                                             const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
 
   // Check to see if we have a new config since ResolveProxy was called.  We
   // want to re-run ResolveProxy in two cases: 1) we have a new config, or 2) a
   // direct connection failed and we never tried the current config.
 
   bool re_resolve = result->config_id_ != config_.id();
 
@@ skipping 281 matching lines @@
   if (previous_state != STATE_NONE)
     ApplyProxyConfigIfAvailable();
 }
 
 SyncProxyServiceHelper::SyncProxyServiceHelper(MessageLoop* io_message_loop,
                                                ProxyService* proxy_service)
     : io_message_loop_(io_message_loop),
       proxy_service_(proxy_service),
       event_(false, false),
       ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
-          this, &SyncProxyServiceHelper::OnCompletion)) {
+          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));
@@ skipping 19 matching lines @@
     *proxy_info = proxy_info_;
   }
   return result_;
 }
 
 SyncProxyServiceHelper::~SyncProxyServiceHelper() {}
 
 void SyncProxyServiceHelper::StartAsyncResolve(const GURL& url,
                                                const BoundNetLog& net_log) {
   result_ = proxy_service_->ResolveProxy(
-      url, &proxy_info_, &callback_, NULL, net_log);
+      url, &proxy_info_, callback_, NULL, net_log);
   if (result_ != net::ERR_IO_PENDING) {
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::StartAsyncReconsider(const GURL& url,
                                                   const BoundNetLog& net_log) {
   result_ = proxy_service_->ReconsiderProxyAfterError(
-      url, &proxy_info_, &callback_, NULL, net_log);
+      url, &proxy_info_, callback_, NULL, net_log);
   if (result_ != net::ERR_IO_PENDING) {
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net