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

This changes Socket::Read(), Socket::Write, and StreamSocket::Connect() to use CompletionCallback and fixes all users.

BUG=none
TEST=existing.

Review URL: http://codereview.chromium.org/8824006

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@113825 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 22 insertions, 80 deletions

diff --git a/net/spdy/spdy_proxy_client_socket.cc b/net/spdy/spdy_proxy_client_socket.cc
index 7b2c83b..77ea05b 100644
--- a/net/spdy/spdy_proxy_client_socket.cc
+++ b/net/spdy/spdy_proxy_client_socket.cc
@@ -33,8 +33,6 @@ SpdyProxyClientSocket::SpdyProxyClientSocket(
           io_callback_(this, &SpdyProxyClientSocket::OnIOComplete)),
       next_state_(STATE_DISCONNECTED),
       spdy_stream_(spdy_stream),
-      old_read_callback_(NULL),
-      write_callback_(NULL),
       endpoint_(endpoint),
       auth_(
           new HttpAuthController(HttpAuth::AUTH_PROXY,
@@ -91,21 +89,8 @@ HttpStream* SpdyProxyClientSocket::CreateConnectResponseStream() {
 // by creating a new stream for the subsequent request.
 // TODO(rch): create a more appropriate error code to disambiguate
 // the HTTPS Proxy tunnel failure from an HTTP Proxy tunnel failure.
-int SpdyProxyClientSocket::Connect(OldCompletionCallback* callback) {
-  DCHECK(!old_read_callback_ && read_callback_.is_null());
-  if (next_state_ == STATE_OPEN)
-    return OK;
-
-  DCHECK_EQ(STATE_DISCONNECTED, next_state_);
-  next_state_ = STATE_GENERATE_AUTH_TOKEN;
-
-  int rv = DoLoop(OK);
-  if (rv == ERR_IO_PENDING)
-    old_read_callback_ = callback;
-  return rv;
-}
 int SpdyProxyClientSocket::Connect(const CompletionCallback& callback) {
-  DCHECK(!old_read_callback_ && read_callback_.is_null());
+  DCHECK(read_callback_.is_null());
   if (next_state_ == STATE_OPEN)
     return OK;
 
@@ -121,12 +106,11 @@ int SpdyProxyClientSocket::Connect(const CompletionCallback& callback) {
 void SpdyProxyClientSocket::Disconnect() {
   read_buffer_.clear();
   user_buffer_ = NULL;
-  old_read_callback_ = NULL;
   read_callback_.Reset();
 
   write_buffer_len_ = 0;
   write_bytes_outstanding_ = 0;
-  write_callback_ = NULL;
+  write_callback_.Reset();
 
   next_state_ = STATE_DISCONNECTED;
 
@@ -173,32 +157,8 @@ base::TimeDelta SpdyProxyClientSocket::GetConnectTimeMicros() const {
 }
 
 int SpdyProxyClientSocket::Read(IOBuffer* buf, int buf_len,
-                                OldCompletionCallback* callback) {
-  DCHECK(!old_read_callback_ && read_callback_.is_null());
-  DCHECK(!user_buffer_);
-
-  if (next_state_ == STATE_DISCONNECTED)
-    return ERR_SOCKET_NOT_CONNECTED;
-
-  if (next_state_ == STATE_CLOSED && read_buffer_.empty()) {
-    return 0;
-  }
-
-  DCHECK(next_state_ == STATE_OPEN || next_state_ == STATE_CLOSED);
-  DCHECK(buf);
-  user_buffer_ = new DrainableIOBuffer(buf, buf_len);
-  int result = PopulateUserReadBuffer();
-  if (result == 0) {
-    DCHECK(callback);
-    old_read_callback_ = callback;
-    return ERR_IO_PENDING;
-  }
-  user_buffer_ = NULL;
-  return result;
-}
-int SpdyProxyClientSocket::Read(IOBuffer* buf, int buf_len,
                                 const CompletionCallback& callback) {
-  DCHECK(!old_read_callback_ && read_callback_.is_null());
+  DCHECK(read_callback_.is_null());
   DCHECK(!user_buffer_);
 
   if (next_state_ == STATE_DISCONNECTED)
@@ -243,8 +203,8 @@ int SpdyProxyClientSocket::PopulateUserReadBuffer() {
 }
 
 int SpdyProxyClientSocket::Write(IOBuffer* buf, int buf_len,
-                                 OldCompletionCallback* callback) {
-  DCHECK(!write_callback_);
+                                 const CompletionCallback& callback) {
+  DCHECK(write_callback_.is_null());
   if (next_state_ != STATE_OPEN)
     return ERR_SOCKET_NOT_CONNECTED;
 
@@ -309,15 +269,9 @@ void SpdyProxyClientSocket::OnIOComplete(int result) {
   DCHECK_NE(STATE_DISCONNECTED, next_state_);
   int rv = DoLoop(result);
   if (rv != ERR_IO_PENDING) {
-    if (old_read_callback_) {
-      OldCompletionCallback* c = old_read_callback_;
-      old_read_callback_ = NULL;
-      c->Run(rv);
-    } else {
-      CompletionCallback c = read_callback_;
-      read_callback_.Reset();
-      c.Run(rv);
-    }
+    CompletionCallback c = read_callback_;
+    read_callback_.Reset();
+    c.Run(rv);
   }
 }
 
@@ -516,13 +470,7 @@ void SpdyProxyClientSocket::OnDataReceived(const char* data, int length) {
         make_scoped_refptr(new DrainableIOBuffer(io_buffer, length)));
   }
 
-  if (old_read_callback_) {
-    int rv = PopulateUserReadBuffer();
-    OldCompletionCallback* c = old_read_callback_;
-    old_read_callback_ = NULL;
-    user_buffer_ = NULL;
-    c->Run(rv);
-  } else if (!read_callback_.is_null()) {
+  if (!read_callback_.is_null()) {
     int rv = PopulateUserReadBuffer();
     CompletionCallback c = read_callback_;
     read_callback_.Reset();
@@ -532,7 +480,7 @@ void SpdyProxyClientSocket::OnDataReceived(const char* data, int length) {
 }
 
 void SpdyProxyClientSocket::OnDataSent(int length)  {
-  DCHECK(write_callback_);
+  DCHECK(!write_callback_.is_null());
 
   write_bytes_outstanding_ -= length;
 
@@ -542,9 +490,9 @@ void SpdyProxyClientSocket::OnDataSent(int length)  {
     int rv = write_buffer_len_;
     write_buffer_len_ = 0;
     write_bytes_outstanding_ = 0;
-    OldCompletionCallback* c = write_callback_;
-    write_callback_ = NULL;
-    c->Run(rv);
+    CompletionCallback c = write_callback_;
+    write_callback_.Reset();
+    c.Run(rv);
   }
 }
 
@@ -561,31 +509,25 @@ void SpdyProxyClientSocket::OnClose(int status)  {
     next_state_ = STATE_DISCONNECTED;
 
   base::WeakPtr<SpdyProxyClientSocket> weak_ptr = weak_factory_.GetWeakPtr();
-  OldCompletionCallback* write_callback = write_callback_;
-  write_callback_ = NULL;
+  CompletionCallback write_callback = write_callback_;
+  write_callback_.Reset();
   write_buffer_len_ = 0;
   write_bytes_outstanding_ = 0;
 
   // If we're in the middle of connecting, we need to make sure
   // we invoke the connect callback.
   if (connecting) {
-    DCHECK(old_read_callback_ || !read_callback_.is_null());
-    if (old_read_callback_) {
-      OldCompletionCallback* read_callback = old_read_callback_;
-      old_read_callback_ = NULL;
-      read_callback->Run(status);
-    } else {
-      CompletionCallback read_callback = read_callback_;
-      read_callback_.Reset();
-      read_callback.Run(status);
-    }
-  } else if (old_read_callback_ || !read_callback_.is_null()) {
+    DCHECK(!read_callback_.is_null());
+    CompletionCallback read_callback = read_callback_;
+    read_callback_.Reset();
+    read_callback.Run(status);
+  } else if (!read_callback_.is_null()) {
     // If we have a read_callback_, the we need to make sure we call it back.
     OnDataReceived(NULL, 0);
   }
   // This may have been deleted by read_callback_, so check first.
-  if (weak_ptr && write_callback)
-    write_callback->Run(ERR_CONNECTION_CLOSED);
+  if (weak_ptr && !write_callback.is_null())
+    write_callback.Run(ERR_CONNECTION_CLOSED);
 }
 
 void SpdyProxyClientSocket::set_chunk_callback(ChunkCallback* /*callback*/) {