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

net/http/http_stream_factory_impl_job.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/http/http_stream_factory_impl_job.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/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_cert_request_info.h"
@@ skipping 89 matching lines @@
                                 const HttpRequestInfo& request_info,
                                 const SSLConfig& server_ssl_config,
                                 const SSLConfig& proxy_ssl_config,
                                 const BoundNetLog& net_log)
     : request_(NULL),
       request_info_(request_info),
       server_ssl_config_(server_ssl_config),
       proxy_ssl_config_(proxy_ssl_config),
       net_log_(BoundNetLog::Make(net_log.net_log(),
                                  NetLog::SOURCE_HTTP_STREAM_JOB)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(this, &Job::OnIOComplete)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(old_io_callback_(
+          this, &Job::OnIOComplete)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
+          base::Bind(&Job::OnIOComplete, base::Unretained(this)))),
       connection_(new ClientSocketHandle),
       session_(session),
       stream_factory_(stream_factory),
       next_state_(STATE_NONE),
       pac_request_(NULL),
       blocking_job_(NULL),
       dependent_job_(NULL),
       using_ssl_(false),
       using_spdy_(false),
       force_spdy_always_(HttpStreamFactory::force_spdy_always()),
@@ skipping 437 matching lines @@
   DCHECK(!pac_request_);
 
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
   if (request_info_.load_flags & LOAD_BYPASS_PROXY) {
     proxy_info_.UseDirect();
     return OK;
   }
 
   return session_->proxy_service()->ResolveProxy(
-      request_info_.url, &proxy_info_, &io_callback_, &pac_request_,
-      net_log_);
+      request_info_.url, &proxy_info_, io_callback_, &pac_request_, net_log_);
 }
 
 int HttpStreamFactoryImpl::Job::DoResolveProxyComplete(int result) {
   pac_request_ = NULL;
 
   if (result == OK) {
     // Remove unsupported proxies from the list.
     proxy_info_.RemoveProxiesWithoutScheme(
         ProxyServer::SCHEME_DIRECT |
         ProxyServer::SCHEME_HTTP | ProxyServer::SCHEME_HTTPS |
@@ skipping 121 matching lines @@
         session_,
         proxy_info_,
         ShouldForceSpdySSL(),
         want_spdy_over_npn,
         server_ssl_config_,
         proxy_ssl_config_,
         net_log_,
         num_streams_);
   } else {
     return InitSocketHandleForHttpRequest(
-        origin_url_,
-        request_info_.extra_headers,
-        request_info_.load_flags,
-        request_info_.priority,
-        session_,
-        proxy_info_,
-        ShouldForceSpdySSL(),
-        want_spdy_over_npn,
-        server_ssl_config_,
-        proxy_ssl_config_,
-        net_log_,
-        connection_.get(),
-        &io_callback_);
+        origin_url_, request_info_.extra_headers, request_info_.load_flags,
+        request_info_.priority, session_, proxy_info_, ShouldForceSpdySSL(),
+        want_spdy_over_npn, server_ssl_config_, proxy_ssl_config_, net_log_,
+        connection_.get(), io_callback_);
   }
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnectionComplete(int result) {
   if (IsPreconnecting()) {
     DCHECK_EQ(OK, result);
     return OK;
   }
 
   // TODO(willchan): Make this a bit more exact. Maybe there are recoverable
@@ skipping 208 matching lines @@
 
   session_->proxy_service()->ReportSuccess(proxy_info_);
   next_state_ = STATE_NONE;
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoRestartTunnelAuth() {
   next_state_ = STATE_RESTART_TUNNEL_AUTH_COMPLETE;
   ProxyClientSocket* proxy_socket =
       static_cast<ProxyClientSocket*>(connection_->socket());
-  return proxy_socket->RestartWithAuth(&io_callback_);
+  return proxy_socket->RestartWithAuth(&old_io_callback_);
 }
 
 int HttpStreamFactoryImpl::Job::DoRestartTunnelAuthComplete(int result) {
   if (result == ERR_PROXY_AUTH_REQUESTED)
     return result;
 
   if (result == OK) {
     // Now that we've got the ProxyClientSocket prepared to restart.  We have
     // to release it as an idle socket into the pool and start the connection
     // process from the beginning.  Trying to pass it in with the
@@ skipping 113 matching lines @@
   if (request_info_.load_flags & LOAD_BYPASS_PROXY) {
     return error;
   }
 
   if (proxy_info_.is_https() && proxy_ssl_config_.send_client_cert) {
     session_->ssl_client_auth_cache()->Remove(
         proxy_info_.proxy_server().host_port_pair().ToString());
   }
 
   int rv = session_->proxy_service()->ReconsiderProxyAfterError(
-      request_info_.url, &proxy_info_, &io_callback_, &pac_request_,
-      net_log_);
+      request_info_.url, &proxy_info_, io_callback_, &pac_request_, net_log_);
   if (rv == OK || rv == ERR_IO_PENDING) {
     // If the error was during connection setup, there is no socket to
     // disconnect.
     if (connection_->socket())
       connection_->socket()->Disconnect();
     connection_->Reset();
     if (request_)
       request_->RemoveRequestFromSpdySessionRequestMap();
     next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
   } else {
@@ skipping 99 matching lines @@
     return false;
   }
   if (request_info_.method != "GET" && request_info_.method != "HEAD") {
     return false;
   }
   return stream_factory_->http_pipelined_host_pool_.IsHostEligibleForPipelining(
       origin_);
 }
 
 }  // namespace net