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

jingle/notifier/base/proxy_resolving_client_socket.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 "jingle/notifier/base/proxy_resolving_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"

[csilv, 2011/12/14 20:10:19]

#include base/bind_helpers.h

[James Hawkins, 2011/12/14 20:59:05]

Done.

 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_network_session.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_manager.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace notifier {
 
 ProxyResolvingClientSocket::ProxyResolvingClientSocket(
     net::ClientSocketFactory* socket_factory,
     const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
     const net::SSLConfig& ssl_config,
     const net::HostPortPair& dest_host_port_pair)
-        : proxy_resolve_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
-                        &ProxyResolvingClientSocket::ProcessProxyResolveDone),
-          connect_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
-                            &ProxyResolvingClientSocket::ProcessConnectDone),
+        : ALLOW_THIS_IN_INITIALIZER_LIST(proxy_resolve_callback_(
+              base::Bind(&ProxyResolvingClientSocket::ProcessProxyResolveDone,
+                         base::Unretained(this)))),
+          ALLOW_THIS_IN_INITIALIZER_LIST(connect_callback_(
+              base::Bind(&ProxyResolvingClientSocket::ProcessConnectDone,
+                         base::Unretained(this)))),
           ssl_config_(ssl_config),
           pac_request_(NULL),
           dest_host_port_pair_(dest_host_port_pair),
           tried_direct_connect_fallback_(false),
           bound_net_log_(
               net::BoundNetLog::Make(
                   request_context_getter->GetURLRequestContext()->net_log(),
                   net::NetLog::SOURCE_SOCKET)),
           ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(request_context_getter);
@@ skipping 61 matching lines @@
     const net::CompletionCallback& callback) {
   DCHECK(user_connect_callback_.is_null());
 
   tried_direct_connect_fallback_ = false;
 
   // First we try and resolve the proxy.
   GURL url("http://" + dest_host_port_pair_.ToString());
   int status = network_session_->proxy_service()->ResolveProxy(
       url,
       &proxy_info_,
-      &proxy_resolve_callback_,
+      proxy_resolve_callback_,
       &pac_request_,
       bound_net_log_);
   if (status != net::ERR_IO_PENDING) {
     // We defer execution of ProcessProxyResolveDone instead of calling it
     // directly here for simplicity. From the caller's point of view,
     // the connect always happens asynchronously.
     MessageLoop* message_loop = MessageLoop::current();
     CHECK(message_loop);
     message_loop->PostTask(
         FROM_HERE,
@@ skipping 39 matching lines @@
     } else {
       CloseTransportSocket();
       RunUserConnectCallback(status);
       return;
     }
   }
 
   transport_.reset(new net::ClientSocketHandle);
   // Now that we have resolved the proxy, we need to connect.
   status = net::InitSocketHandleForRawConnect(
-      dest_host_port_pair_,
-      network_session_.get(),
-      proxy_info_,
-      ssl_config_,
-      ssl_config_,
-      bound_net_log_,
-      transport_.get(),
-      &connect_callback_);
+      dest_host_port_pair_, network_session_.get(), proxy_info_, ssl_config_,
+      ssl_config_, bound_net_log_, transport_.get(), connect_callback_);
   if (status != net::ERR_IO_PENDING) {
     // Since this method is always called asynchronously. it is OK to call
     // ProcessConnectDone synchronously.
     ProcessConnectDone(status);
   }
 }
 
 void ProxyResolvingClientSocket::ProcessConnectDone(int status) {
   if (status != net::OK) {
     // If the connection fails, try another proxy.
@@ skipping 57 matching lines @@
       return error;
   }
 
   if (proxy_info_.is_https() && ssl_config_.send_client_cert) {
     network_session_->ssl_client_auth_cache()->Remove(
         proxy_info_.proxy_server().host_port_pair().ToString());
   }
 
   GURL url("http://" + dest_host_port_pair_.ToString());
   int rv = network_session_->proxy_service()->ReconsiderProxyAfterError(
-      url, &proxy_info_, &proxy_resolve_callback_, &pac_request_,
+      url, &proxy_info_, proxy_resolve_callback_, &pac_request_,
       bound_net_log_);
   if (rv == net::OK || rv == net::ERR_IO_PENDING) {
     CloseTransportSocket();
   } else {
     // If ReconsiderProxyAfterError() failed synchronously, it means
     // there was nothing left to fall-back to, so fail the transaction
     // with the last connection error we got.
     rv = error;
   }
 
@@ skipping 102 matching lines @@
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
 void ProxyResolvingClientSocket::CloseTransportSocket() {
   if (transport_.get() && transport_->socket())
     transport_->socket()->Disconnect();
   transport_.reset();
 }
 
 }  // namespace notifier