base::Bind: Convert most of net/http.

net/http/http_proxy_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 "net/http/http_proxy_client_socket.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/auth.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_net_log_params.h"
@@ skipping 10 matching lines @@
     ClientSocketHandle* transport_socket,
     const GURL& request_url,
     const std::string& user_agent,
     const HostPortPair& endpoint,
     const HostPortPair& proxy_server,
     HttpAuthCache* http_auth_cache,
     HttpAuthHandlerFactory* http_auth_handler_factory,
     bool tunnel,
     bool using_spdy,
     bool is_https_proxy)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(
-          io_callback_(this, &HttpProxyClientSocket::OnIOComplete)),
+    : ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
+        base::Bind(&HttpProxyClientSocket::OnIOComplete,
+                   base::Unretained(this)))),
       next_state_(STATE_NONE),
       transport_(transport_socket),
       endpoint_(endpoint),
       auth_(tunnel ?
           new HttpAuthController(HttpAuth::AUTH_PROXY,
                                  GURL((is_https_proxy ? "https://" : "http://")
                                       + proxy_server.ToString()),
                                  http_auth_cache,
                                  http_auth_handler_factory)
           : NULL),
       tunnel_(tunnel),
       using_spdy_(using_spdy),
       is_https_proxy_(is_https_proxy),
       net_log_(transport_socket->socket()->NetLog()) {
   // Synthesize the bits of a request that we actually use.
   request_.url = request_url;
   request_.method = "GET";
   if (!user_agent.empty())
     request_.extra_headers.SetHeader(HttpRequestHeaders::kUserAgent,
                                      user_agent);
 }
 
 HttpProxyClientSocket::~HttpProxyClientSocket() {
   Disconnect();
 }
 
-int HttpProxyClientSocket::RestartWithAuth(OldCompletionCallback* callback) {
+int HttpProxyClientSocket::RestartWithAuth(const CompletionCallback& callback) {
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK(user_callback_.is_null());
 
   int rv = PrepareForAuthRestart();
   if (rv != OK)
     return rv;
 
   rv = DoLoop(OK);
-  if (rv == ERR_IO_PENDING)
-    if (callback) {
-      user_callback_ = base::Bind(&OldCompletionCallback::Run<int>,
-                                  base::Unretained(callback));
-    }
+  if (rv == ERR_IO_PENDING) {
+    if (!callback.is_null())
+      user_callback_ =  callback;
+  }
+
   return rv;
 }
 
 const HttpResponseInfo* HttpProxyClientSocket::GetConnectResponseInfo() const {
   return response_.headers ? &response_ : NULL;
 }
 
 HttpStream* HttpProxyClientSocket::CreateConnectResponseStream() {
   return new HttpBasicStream(transport_.release(),
                              http_stream_parser_.release(), false);
@@ skipping 274 matching lines @@
         rv = ERR_UNEXPECTED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE &&
            next_state_ != STATE_DONE);
   return rv;
 }
 
 int HttpProxyClientSocket::DoGenerateAuthToken() {
   next_state_ = STATE_GENERATE_AUTH_TOKEN_COMPLETE;
-  return auth_->MaybeGenerateAuthToken(&request_, &io_callback_, net_log_);
+  return auth_->MaybeGenerateAuthToken(&request_, io_callback_, net_log_);
 }
 
 int HttpProxyClientSocket::DoGenerateAuthTokenComplete(int result) {
   DCHECK_NE(ERR_IO_PENDING, result);
   if (result == OK)
     next_state_ = STATE_SEND_REQUEST;
   return result;
 }
 
 int HttpProxyClientSocket::DoSendRequest() {
@@ skipping 13 matching lines @@
           NetLog::TYPE_HTTP_TRANSACTION_SEND_TUNNEL_HEADERS,
           make_scoped_refptr(new NetLogHttpRequestParameter(
               request_line_, request_headers_)));
     }
   }
 
   parser_buf_ = new GrowableIOBuffer();
   http_stream_parser_.reset(
       new HttpStreamParser(transport_.get(), &request_, parser_buf_, net_log_));
   return http_stream_parser_->SendRequest(request_line_, request_headers_, NULL,
-                                          &response_, &io_callback_);
+                                          &response_, io_callback_);
 }
 
 int HttpProxyClientSocket::DoSendRequestComplete(int result) {
   if (result < 0)
     return result;
 
   next_state_ = STATE_READ_HEADERS;
   return OK;
 }
 
 int HttpProxyClientSocket::DoReadHeaders() {
   next_state_ = STATE_READ_HEADERS_COMPLETE;
-  return http_stream_parser_->ReadResponseHeaders(&io_callback_);
+  return http_stream_parser_->ReadResponseHeaders(io_callback_);
 }
 
 int HttpProxyClientSocket::DoReadHeadersComplete(int result) {
   if (result < 0)
     return result;
 
   // Require the "HTTP/1.x" status line for SSL CONNECT.
   if (response_.headers->GetParsedHttpVersion() < HttpVersion(1, 0))
     return ERR_TUNNEL_CONNECTION_FAILED;
 
@@ skipping 37 matching lines @@
       LogBlockedTunnelResponse(response_.headers->response_code());
       return ERR_TUNNEL_CONNECTION_FAILED;
   }
 }
 
 int HttpProxyClientSocket::DoDrainBody() {
   DCHECK(drain_buf_);
   DCHECK(transport_->is_initialized());
   next_state_ = STATE_DRAIN_BODY_COMPLETE;
   return http_stream_parser_->ReadResponseBody(drain_buf_, kDrainBodyBufferSize,
-                                               &io_callback_);
+                                               io_callback_);
 }
 
 int HttpProxyClientSocket::DoDrainBodyComplete(int result) {
   if (result < 0)
     return result;
 
   if (http_stream_parser_->IsResponseBodyComplete())
     return DidDrainBodyForAuthRestart(true);
 
   // Keep draining.
   next_state_ = STATE_DRAIN_BODY;
   return OK;
 }
 
 int HttpProxyClientSocket::DoTCPRestart() {
   next_state_ = STATE_TCP_RESTART_COMPLETE;
   return transport_->socket()->Connect(
       base::Bind(&HttpProxyClientSocket::OnIOComplete, base::Unretained(this)));
 }
 
 int HttpProxyClientSocket::DoTCPRestartComplete(int result) {
   if (result != OK)
     return result;
 
   next_state_ = STATE_GENERATE_AUTH_TOKEN;
   return result;
 }
 
 }  // namespace net