Migrate net/socket/socket.h, net/socket/stream_socket.h to base::Bind().

net/socket_stream/socket_stream.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.
 //
 // TODO(ukai): code is similar with http_network_transaction.cc.  We should
 //   think about ways to share code, if possible.
 
 #include "net/socket_stream/socket_stream.h"
 
 #include <set>
@@ skipping 53 matching lines @@
       proxy_mode_(kDirectConnection),
       proxy_url_(url),
       pac_request_(NULL),
       // Unretained() is required; without it, Bind() creates a circular
       // dependency and the SocketStream object will not be freed.
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(base::Bind(&SocketStream::OnIOCompleted,
                                   base::Unretained(this)))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_old_(this, &SocketStream::OnIOCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          read_callback_old_(this, &SocketStream::OnReadCompleted)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          write_callback_old_(this, &SocketStream::OnWriteCompleted)),
       read_buf_(NULL),
       write_buf_(NULL),
       current_write_buf_(NULL),
       write_buf_offset_(0),
       write_buf_size_(0),
       closing_(false),
       server_closed_(false),
       metrics_(new SocketStreamMetrics(url)) {
   DCHECK(MessageLoop::current()) <<
       "The current MessageLoop must exist";
@@ skipping 573 matching lines @@
   if (result != OK) {
     next_state_ = STATE_CLOSE;
     return result;
   }
   next_state_ = STATE_TCP_CONNECT_COMPLETE;
   DCHECK(factory_);
   socket_.reset(factory_->CreateTransportClientSocket(addresses_,
                                                       net_log_.net_log(),
                                                       net_log_.source()));
   metrics_->OnStartConnection();
-  return socket_->Connect(&io_callback_old_);
+  return socket_->Connect(io_callback_);
 }
 
 int SocketStream::DoTcpConnectComplete(int result) {
   // TODO(ukai): if error occured, reconsider proxy after error.
   if (result != OK) {
     next_state_ = STATE_CLOSE;
     return result;
   }
 
   if (proxy_mode_ == kTunnelProxy) {
@@ skipping 72 matching lines @@
         GetHostAndPort(url_).c_str(),
         GetHostAndOptionalPort(url_).c_str());
     if (!authorization_headers.empty())
       tunnel_request_headers_->headers_ += authorization_headers;
     tunnel_request_headers_->headers_ += "\r\n";
   }
   tunnel_request_headers_->SetDataOffset(tunnel_request_headers_bytes_sent_);
   int buf_len = static_cast<int>(tunnel_request_headers_->headers_.size() -
                                  tunnel_request_headers_bytes_sent_);
   DCHECK_GT(buf_len, 0);
-  return socket_->Write(tunnel_request_headers_, buf_len, &io_callback_old_);
+  return socket_->Write(tunnel_request_headers_, buf_len, io_callback_);
 }
 
 int SocketStream::DoWriteTunnelHeadersComplete(int result) {
   DCHECK_EQ(kTunnelProxy, proxy_mode_);
 
   if (result < 0) {
     next_state_ = STATE_CLOSE;
     return result;
   }
 
@@ skipping 16 matching lines @@
     tunnel_response_headers_capacity_ = kMaxTunnelResponseHeadersSize;
     tunnel_response_headers_->Realloc(tunnel_response_headers_capacity_);
     tunnel_response_headers_len_ = 0;
   }
 
   int buf_len = tunnel_response_headers_capacity_ -
       tunnel_response_headers_len_;
   tunnel_response_headers_->SetDataOffset(tunnel_response_headers_len_);
   CHECK(tunnel_response_headers_->data());
 
-  return socket_->Read(tunnel_response_headers_, buf_len, &io_callback_old_);
+  return socket_->Read(tunnel_response_headers_, buf_len, io_callback_);
 }
 
 int SocketStream::DoReadTunnelHeadersComplete(int result) {
   DCHECK_EQ(kTunnelProxy, proxy_mode_);
 
   if (result < 0) {
     next_state_ = STATE_CLOSE;
     return result;
   }
 
@@ skipping 76 matching lines @@
   StreamSocket* s = socket_.release();
   HostResolver::RequestInfo req_info(HostPortPair::FromURL(url_));
 
   DCHECK(!proxy_info_.is_empty());
   if (proxy_info_.proxy_server().scheme() == ProxyServer::SCHEME_SOCKS5)
     s = new SOCKS5ClientSocket(s, req_info);
   else
     s = new SOCKSClientSocket(s, req_info, host_resolver_);
   socket_.reset(s);
   metrics_->OnCountConnectionType(SocketStreamMetrics::SOCKS_CONNECTION);
-  return socket_->Connect(&io_callback_old_);
+  return socket_->Connect(io_callback_);
 }
 
 int SocketStream::DoSOCKSConnectComplete(int result) {
   DCHECK_EQ(kSOCKSProxy, proxy_mode_);
 
   if (result == OK) {
     if (is_secure())
       next_state_ = STATE_SSL_CONNECT;
     else
       result = DidEstablishConnection();
@@ skipping 10 matching lines @@
   ssl_context.origin_bound_cert_service = origin_bound_cert_service_;
   // TODO(agl): look into plumbing SSLHostInfo here.
   socket_.reset(factory_->CreateSSLClientSocket(
       socket_.release(),
       proxy_info_.proxy_server().host_port_pair(),
       proxy_ssl_config_,
       NULL /* ssl_host_info */,
       ssl_context));
   next_state_ = STATE_SECURE_PROXY_CONNECT_COMPLETE;
   metrics_->OnCountConnectionType(SocketStreamMetrics::SECURE_PROXY_CONNECTION);
-  return socket_->Connect(&io_callback_old_);
+  return socket_->Connect(io_callback_);
 }
 
 int SocketStream::DoSecureProxyConnectComplete(int result) {
   DCHECK_EQ(STATE_NONE, next_state_);
   result = DidEstablishSSL(result, &proxy_ssl_config_);
   if (next_state_ != STATE_NONE)
     return result;
   if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED)
     return HandleCertificateRequest(result);
   if (result == OK)
     next_state_ = STATE_WRITE_TUNNEL_HEADERS;
   else
     next_state_ = STATE_CLOSE;
   return result;
 }
 
 int SocketStream::DoSSLConnect() {
   DCHECK(factory_);
   SSLClientSocketContext ssl_context;
   ssl_context.cert_verifier = cert_verifier_;
   ssl_context.origin_bound_cert_service = origin_bound_cert_service_;
   // TODO(agl): look into plumbing SSLHostInfo here.
   socket_.reset(factory_->CreateSSLClientSocket(socket_.release(),
                                                 HostPortPair::FromURL(url_),
                                                 server_ssl_config_,
                                                 NULL /* ssl_host_info */,
                                                 ssl_context));
   next_state_ = STATE_SSL_CONNECT_COMPLETE;
   metrics_->OnCountConnectionType(SocketStreamMetrics::SSL_CONNECTION);
-  return socket_->Connect(&io_callback_old_);
+  return socket_->Connect(io_callback_);
 }
 
 int SocketStream::DoSSLConnectComplete(int result) {
   DCHECK_EQ(STATE_NONE, next_state_);
   result = DidEstablishSSL(result, &server_ssl_config_);
   if (next_state_ != STATE_NONE)
     return result;
   // TODO(toyoshim): Upgrade to SPDY through TLS NPN extension if possible.
   // If we use HTTPS and this is the first connection to the SPDY server,
   // we should take care of TLS NPN extension here.
@@ skipping 24 matching lines @@
     return OK;
   }
 
   next_state_ = STATE_READ_WRITE;
 
   // If server already closed the socket, we don't try to read.
   if (!server_closed_) {
     if (!read_buf_) {
       // No read pending and server didn't close the socket.
       read_buf_ = new IOBuffer(kReadBufferSize);
-      result = socket_->Read(read_buf_, kReadBufferSize, &read_callback_old_);
+      result = socket_->Read(read_buf_, kReadBufferSize,
+                             base::Bind(&SocketStream::OnReadCompleted,
+                                        base::Unretained(this)));
       if (result > 0) {
         return DidReceiveData(result);
       } else if (result == 0) {
         // 0 indicates end-of-file, so socket was closed.
         next_state_ = STATE_CLOSE;
         server_closed_ = true;
         return ERR_CONNECTION_CLOSED;
       }
       // If read is pending, try write as well.
       // Otherwise, return the result and do next loop (to close the
       // connection).
       if (result != ERR_IO_PENDING) {
         next_state_ = STATE_CLOSE;
         server_closed_ = true;
         return result;
       }
     }
     // Read is pending.
     DCHECK(read_buf_);
   }
 
   if (write_buf_ && !current_write_buf_) {
     // No write pending.
     current_write_buf_ = new DrainableIOBuffer(write_buf_, write_buf_size_);
     current_write_buf_->SetOffset(write_buf_offset_);
     result = socket_->Write(current_write_buf_,
                             current_write_buf_->BytesRemaining(),
-                            &write_callback_old_);
+                            base::Bind(&SocketStream::OnWriteCompleted,
+                                       base::Unretained(this)));
     if (result > 0) {
       return DidSendData(result);
     }
     // If write is not pending, return the result and do next loop (to close
     // the connection).
     if (result != 0 && result != ERR_IO_PENDING) {
       next_state_ = STATE_CLOSE;
       return result;
     }
     return result;
@@ skipping 145 matching lines @@
 
 SSLConfigService* SocketStream::ssl_config_service() const {
   return context_->ssl_config_service();
 }
 
 ProxyService* SocketStream::proxy_service() const {
   return context_->proxy_service();
 }
 
 }  // namespace net