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

5 files changed, 94 insertions, 147 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*/) {
diff --git a/net/spdy/spdy_proxy_client_socket.h b/net/spdy/spdy_proxy_client_socket.h
index fb2d9a3..9c210b2 100644
--- a/net/spdy/spdy_proxy_client_socket.h
+++ b/net/spdy/spdy_proxy_client_socket.h
@@ -61,7 +61,6 @@ class NET_EXPORT_PRIVATE SpdyProxyClientSocket : public ProxyClientSocket,
   virtual const scoped_refptr<HttpAuthController>& auth_controller() OVERRIDE;
 
   // StreamSocket implementation.
-  virtual int Connect(OldCompletionCallback* callback) OVERRIDE;
   virtual int Connect(const CompletionCallback& callback) OVERRIDE;
   virtual void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
@@ -77,13 +76,10 @@ class NET_EXPORT_PRIVATE SpdyProxyClientSocket : public ProxyClientSocket,
   // Socket implementation.
   virtual int Read(IOBuffer* buf,
                    int buf_len,
-                   OldCompletionCallback* callback) OVERRIDE;
-  virtual int Read(IOBuffer* buf,
-                   int buf_len,
                    const CompletionCallback& callback) OVERRIDE;
   virtual int Write(IOBuffer* buf,
                     int buf_len,
-                    OldCompletionCallback* callback) OVERRIDE;
+                    const CompletionCallback& callback) OVERRIDE;
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
   virtual int GetPeerAddress(AddressList* address) const OVERRIDE;
@@ -134,10 +130,9 @@ class NET_EXPORT_PRIVATE SpdyProxyClientSocket : public ProxyClientSocket,
 
   // Stores the callback to the layer above, called on completing Read() or
   // Connect().
-  OldCompletionCallback* old_read_callback_;
   CompletionCallback read_callback_;
   // Stores the callback to the layer above, called on completing Write().
-  OldCompletionCallback* write_callback_;
+  CompletionCallback write_callback_;
 
   // CONNECT request and response.
   HttpRequestInfo request_;
diff --git a/net/spdy/spdy_proxy_client_socket_unittest.cc b/net/spdy/spdy_proxy_client_socket_unittest.cc
index 4ec8a48..25be93a 100644
--- a/net/spdy/spdy_proxy_client_socket_unittest.cc
+++ b/net/spdy/spdy_proxy_client_socket_unittest.cc
@@ -100,8 +100,9 @@ class SpdyProxyClientSocketTest : public PlatformTest {
   }
 
   scoped_ptr<SpdyProxyClientSocket> sock_;
-  TestOldCompletionCallback read_callback_;
-  TestOldCompletionCallback write_callback_;
+  TestCompletionCallback read_callback_;
+  TestOldCompletionCallback read_callback_old_;
+  TestCompletionCallback write_callback_;
   scoped_refptr<DeterministicSocketData> data_;
 
  private:
@@ -126,8 +127,6 @@ class SpdyProxyClientSocketTest : public PlatformTest {
 
 SpdyProxyClientSocketTest::SpdyProxyClientSocketTest()
     : sock_(NULL),
-      read_callback_(),
-      write_callback_(),
       data_(NULL),
       session_(NULL),
       read_buf_(NULL),
@@ -212,13 +211,13 @@ scoped_refptr<IOBufferWithSize> SpdyProxyClientSocketTest::CreateBuffer(
 }
 
 void SpdyProxyClientSocketTest::AssertConnectSucceeds() {
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(&read_callback_));
+  ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(read_callback_.callback()));
   data_->Run();
   ASSERT_EQ(OK, read_callback_.WaitForResult());
 }
 
 void SpdyProxyClientSocketTest::AssertConnectFails(int result) {
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(&read_callback_));
+  ASSERT_EQ(ERR_IO_PENDING, sock_->Connect(read_callback_.callback()));
   data_->Run();
   ASSERT_EQ(result, read_callback_.WaitForResult());
 }
@@ -233,7 +232,7 @@ void SpdyProxyClientSocketTest::AssertConnectionEstablished() {
 void SpdyProxyClientSocketTest::AssertSyncReadEquals(const char* data,
                                                      int len) {
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
-  ASSERT_EQ(len, sock_->Read(buf, len, NULL));
+  ASSERT_EQ(len, sock_->Read(buf, len, CompletionCallback()));
   ASSERT_EQ(std::string(data, len), std::string(buf->data(), len));
   ASSERT_TRUE(sock_->IsConnected());
 }
@@ -243,7 +242,7 @@ void SpdyProxyClientSocketTest::AssertAsyncReadEquals(const char* data,
   data_->StopAfter(1);
   // Issue the read, which will be completed asynchronously
   scoped_refptr<IOBuffer> buf(new IOBuffer(len));
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Read(buf, len, &read_callback_));
+  ASSERT_EQ(ERR_IO_PENDING, sock_->Read(buf, len, read_callback_.callback()));
   EXPECT_TRUE(sock_->IsConnected());
   data_->Run();
 
@@ -258,7 +257,8 @@ void SpdyProxyClientSocketTest::AssertReadStarts(const char* data, int len) {
   data_->StopAfter(1);
   // Issue the read, which will be completed asynchronously
   read_buf_ = new IOBuffer(len);
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Read(read_buf_, len, &read_callback_));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Read(read_buf_, len, read_callback_.callback()));
   EXPECT_TRUE(sock_->IsConnected());
 }
 
@@ -280,7 +280,7 @@ void SpdyProxyClientSocketTest::AssertAsyncWriteSucceeds(const char* data,
 void SpdyProxyClientSocketTest::AssertWriteReturns(const char* data, int len,
                                                    int rv) {
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len));
-  EXPECT_EQ(rv, sock_->Write(buf, buf->size(), &write_callback_));
+  EXPECT_EQ(rv, sock_->Write(buf, buf->size(), write_callback_.callback()));
 }
 
 void SpdyProxyClientSocketTest::AssertWriteLength(int len) {
@@ -291,7 +291,8 @@ void SpdyProxyClientSocketTest::AssertAsyncWriteWithReadsSucceeds(
     const char* data, int len, int num_reads) {
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(data, len));
 
-  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(), &write_callback_));
+  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(),
+                                         write_callback_.callback()));
 
   for (int i = 0; i < num_reads; i++) {
     Run(1);
@@ -541,7 +542,7 @@ TEST_F(SpdyProxyClientSocketTest, ConnectWithAuthRestart) {
 
   AddAuthToCache();
 
-  ASSERT_EQ(OK, sock_->RestartWithAuth(&read_callback_));
+  ASSERT_EQ(OK, sock_->RestartWithAuth(&read_callback_old_));
   // A SpdyProxyClientSocket sits on a single SPDY stream which can
   // only be used for a single request/response.
   ASSERT_FALSE(sock_->IsConnectedAndIdle());
@@ -675,7 +676,8 @@ TEST_F(SpdyProxyClientSocketTest, WriteSplitsLargeDataIntoMultipleFrames) {
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(big_data.data(),
                                                    big_data.length()));
 
-  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(), &write_callback_));
+  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(),
+                                         write_callback_.callback()));
   data_->RunFor(3);
 
   EXPECT_EQ(buf->size(), write_callback_.WaitForResult());
@@ -875,7 +877,7 @@ TEST_F(SpdyProxyClientSocketTest, MultipleReadsFromSameLargeFrame) {
 
   // Now attempt to do a read of more data than remains buffered
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen33));
-  ASSERT_EQ(kLen3, sock_->Read(buf, kLen33, &read_callback_));
+  ASSERT_EQ(kLen3, sock_->Read(buf, kLen33, read_callback_.callback()));
   ASSERT_EQ(std::string(kMsg3, kLen3), std::string(buf->data(), kLen3));
   ASSERT_TRUE(sock_->IsConnected());
 }
@@ -928,10 +930,11 @@ TEST_F(SpdyProxyClientSocketTest, ReadErrorResponseBody) {
 
   Run(2);  // SpdySession consumes the next two reads and sends then to
            // sock_ to be buffered.
-  EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Read(NULL, 1, NULL));
+  EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED,
+            sock_->Read(NULL, 1, CompletionCallback()));
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1 + kLen2));
   scoped_ptr<HttpStream> stream(sock_->CreateConnectResponseStream());
-  stream->ReadResponseBody(buf, kLen1 + kLen2, &read_callback_);
+  stream->ReadResponseBody(buf, kLen1 + kLen2, &read_callback_old_);
 }
 
 // ----------- Reads and Writes
@@ -1030,9 +1033,9 @@ TEST_F(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsZero) {
   Run(1);
 
   ASSERT_FALSE(sock_->IsConnected());
-  ASSERT_EQ(0, sock_->Read(NULL, 1, NULL));
-  ASSERT_EQ(0, sock_->Read(NULL, 1, NULL));
-  ASSERT_EQ(0, sock_->Read(NULL, 1, NULL));
+  ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
+  ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
+  ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
   ASSERT_FALSE(sock_->IsConnectedAndIdle());
 }
 
@@ -1079,7 +1082,8 @@ TEST_F(SpdyProxyClientSocketTest, ReadOnDisconnectSocketReturnsNotConnected) {
 
   sock_->Disconnect();
 
-  ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Read(NULL, 1, NULL));
+  ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
+            sock_->Read(NULL, 1, CompletionCallback()));
 }
 
 // Reading buffered data from an already closed socket should return
@@ -1106,13 +1110,14 @@ TEST_F(SpdyProxyClientSocketTest, ReadOnClosedSocketReturnsBufferedData) {
 
   ASSERT_FALSE(sock_->IsConnected());
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1));
-  ASSERT_EQ(kLen1, sock_->Read(buf, kLen1, NULL));
+  ASSERT_EQ(kLen1, sock_->Read(buf, kLen1, CompletionCallback()));
   ASSERT_EQ(std::string(kMsg1, kLen1), std::string(buf->data(), kLen1));
 
-  ASSERT_EQ(0, sock_->Read(NULL, 1, NULL));
-  ASSERT_EQ(0, sock_->Read(NULL, 1, NULL));
+  ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
+  ASSERT_EQ(0, sock_->Read(NULL, 1, CompletionCallback()));
   sock_->Disconnect();
-  ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Read(NULL, 1, NULL));
+  ASSERT_EQ(ERR_SOCKET_NOT_CONNECTED,
+            sock_->Read(NULL, 1, CompletionCallback()));
 }
 
 // Calling Write() on a closed socket is an error
@@ -1135,7 +1140,8 @@ TEST_F(SpdyProxyClientSocketTest, WriteOnClosedStream) {
 
   Run(1);  // Read EOF which will close the stream
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
-  EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Write(buf, buf->size(), NULL));
+  EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED,
+            sock_->Write(buf, buf->size(), CompletionCallback()));
 }
 
 // Calling Write() on a disconnected socket is an error
@@ -1159,7 +1165,8 @@ TEST_F(SpdyProxyClientSocketTest, WriteOnDisconnectedSocket) {
   sock_->Disconnect();
 
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
-  EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED, sock_->Write(buf, buf->size(), NULL));
+  EXPECT_EQ(ERR_SOCKET_NOT_CONNECTED,
+            sock_->Write(buf, buf->size(), CompletionCallback()));
 }
 
 // If the socket is closed with a pending Write(), the callback
@@ -1184,7 +1191,8 @@ TEST_F(SpdyProxyClientSocketTest, WritePendingOnClose) {
   EXPECT_TRUE(sock_->IsConnected());
 
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
-  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(), &write_callback_));
+  EXPECT_EQ(ERR_IO_PENDING,
+            sock_->Write(buf, buf->size(), write_callback_.callback()));
 
   Run(1);
 
@@ -1213,7 +1221,8 @@ TEST_F(SpdyProxyClientSocketTest, DisconnectWithWritePending) {
   EXPECT_TRUE(sock_->IsConnected());
 
   scoped_refptr<IOBufferWithSize> buf(CreateBuffer(kMsg1, kLen1));
-  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(buf, buf->size(), &write_callback_));
+  EXPECT_EQ(ERR_IO_PENDING,
+            sock_->Write(buf, buf->size(), write_callback_.callback()));
 
   sock_->Disconnect();
 
@@ -1242,7 +1251,8 @@ TEST_F(SpdyProxyClientSocketTest, DisconnectWithReadPending) {
   EXPECT_TRUE(sock_->IsConnected());
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(kLen1));
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Read(buf, kLen1, &read_callback_));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Read(buf, kLen1, read_callback_.callback()));
 
   sock_->Disconnect();
 
@@ -1273,11 +1283,13 @@ TEST_F(SpdyProxyClientSocketTest, RstWithReadAndWritePending) {
   EXPECT_TRUE(sock_->IsConnected());
 
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Read(read_buf, kLen1, &read_callback_));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Read(read_buf, kLen1, read_callback_.callback()));
 
   scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1));
-  EXPECT_EQ(ERR_IO_PENDING, sock_->Write(write_buf, write_buf->size(),
-                                         &write_callback_));
+  EXPECT_EQ(ERR_IO_PENDING,
+            sock_->Write(write_buf, write_buf->size(),
+                         write_callback_.callback()));
 
   Run(2);
 
@@ -1332,11 +1344,14 @@ TEST_F(SpdyProxyClientSocketTest, RstWithReadAndWritePendingDelete) {
   DeleteSockCallback read_callback(&sock_);
 
   scoped_refptr<IOBuffer> read_buf(new IOBuffer(kLen1));
-  ASSERT_EQ(ERR_IO_PENDING, sock_->Read(read_buf, kLen1, &read_callback));
+  ASSERT_EQ(ERR_IO_PENDING,
+            sock_->Read(read_buf, kLen1,
+                        base::Bind(&DeleteSockCallback::Run<int>,
+                                   base::Unretained(&read_callback))));
 
   scoped_refptr<IOBufferWithSize> write_buf(CreateBuffer(kMsg1, kLen1));
   EXPECT_EQ(ERR_IO_PENDING, sock_->Write(write_buf, write_buf->size(),
-                                         &write_callback_));
+                                         write_callback_.callback()));
 
   Run(2);
 
diff --git a/net/spdy/spdy_session.cc b/net/spdy/spdy_session.cc
index 686f4ae..17c18eb 100644
--- a/net/spdy/spdy_session.cc
+++ b/net/spdy/spdy_session.cc
@@ -252,11 +252,7 @@ SpdySession::SpdySession(const HostPortProxyPair& host_port_proxy_pair,
                          HttpServerProperties* http_server_properties,
                          bool verify_domain_authentication,
                          NetLog* net_log)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(
-          read_callback_(this, &SpdySession::OnReadComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          write_callback_(this, &SpdySession::OnWriteComplete)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       host_port_proxy_pair_(host_port_proxy_pair),
       spdy_session_pool_(spdy_session_pool),
       http_server_properties_(http_server_properties),
@@ -428,8 +424,8 @@ void SpdySession::ProcessPendingCreateStreams() {
             CallbackResultPair(pending_create.callback, error);
         MessageLoop::current()->PostTask(
             FROM_HERE,
-            method_factory_.NewRunnableMethod(
-                &SpdySession::InvokeUserStreamCreationCallback, stream));
+            base::Bind(&SpdySession::InvokeUserStreamCreationCallback,
+                       weak_factory_.GetWeakPtr(), stream));
         break;
       }
     }
@@ -757,9 +753,10 @@ net::Error SpdySession::ReadSocket() {
 
   CHECK(connection_.get());
   CHECK(connection_->socket());
-  int bytes_read = connection_->socket()->Read(read_buffer_.get(),
-                                               kReadBufferSize,
-                                               &read_callback_);
+  int bytes_read = connection_->socket()->Read(
+      read_buffer_.get(),
+      kReadBufferSize,
+      base::Bind(&SpdySession::OnReadComplete, base::Unretained(this)));
   switch (bytes_read) {
     case 0:
       // Socket is closed!
@@ -776,8 +773,8 @@ net::Error SpdySession::ReadSocket() {
       read_pending_ = true;
       MessageLoop::current()->PostTask(
           FROM_HERE,
-          method_factory_.NewRunnableMethod(
-              &SpdySession::OnReadComplete, bytes_read));
+          base::Bind(&SpdySession::OnReadComplete,
+                     weak_factory_.GetWeakPtr(), bytes_read));
       break;
   }
   return OK;
@@ -793,7 +790,7 @@ void SpdySession::WriteSocketLater() {
   delayed_write_pending_ = true;
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(&SpdySession::WriteSocket));
+      base::Bind(&SpdySession::WriteSocket, weak_factory_.GetWeakPtr()));
 }
 
 void SpdySession::WriteSocket() {
@@ -850,8 +847,10 @@ void SpdySession::WriteSocket() {
     }
 
     write_pending_ = true;
-    int rv = connection_->socket()->Write(in_flight_write_.buffer(),
-        in_flight_write_.buffer()->BytesRemaining(), &write_callback_);
+    int rv = connection_->socket()->Write(
+        in_flight_write_.buffer(),
+        in_flight_write_.buffer()->BytesRemaining(),
+        base::Bind(&SpdySession::OnWriteComplete, base::Unretained(this)));
     if (rv == net::ERR_IO_PENDING)
       break;
 
@@ -1596,7 +1595,7 @@ void SpdySession::PlanToSendTrailingPing() {
   trailing_ping_pending_ = true;
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(&SpdySession::SendTrailingPing),
+      base::Bind(&SpdySession::SendTrailingPing, weak_factory_.GetWeakPtr()),
       trailing_ping_delay_time_ms_);
 }
 
@@ -1632,8 +1631,8 @@ void SpdySession::PlanToCheckPingStatus() {
   check_ping_status_pending_ = true;
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(
-          &SpdySession::CheckPingStatus, base::TimeTicks::Now()),
+      base::Bind(&SpdySession::CheckPingStatus, weak_factory_.GetWeakPtr(),
+                 base::TimeTicks::Now()),
       hung_interval_ms_);
 }
 
@@ -1664,7 +1663,8 @@ void SpdySession::CheckPingStatus(base::TimeTicks last_check_time) {
   // Check the status of connection after a delay.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      method_factory_.NewRunnableMethod(&SpdySession::CheckPingStatus, now),
+      base::Bind(&SpdySession::CheckPingStatus, weak_factory_.GetWeakPtr(),
+                 now),
       delay.InMilliseconds());
 }
 
diff --git a/net/spdy/spdy_session.h b/net/spdy/spdy_session.h
index ce02d5e..a05bd3c 100644
--- a/net/spdy/spdy_session.h
+++ b/net/spdy/spdy_session.h
@@ -16,7 +16,6 @@
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
-#include "base/task.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
@@ -262,7 +261,7 @@ class NET_EXPORT SpdySession : public base::RefCounted<SpdySession>,
   typedef std::priority_queue<SpdyIOBuffer> OutputQueue;
 
   struct CallbackResultPair {
-    CallbackResultPair() : callback(NULL), result(OK) {}
+    CallbackResultPair() : result(OK) {}
     CallbackResultPair(OldCompletionCallback* callback_in, int result_in)
         : callback(callback_in), result(result_in) {}
 
@@ -431,15 +430,11 @@ class NET_EXPORT SpdySession : public base::RefCounted<SpdySession>,
 
   bool check_ping_status_pending() const { return check_ping_status_pending_; }
 
-  // Callbacks for the Spdy session.
-  OldCompletionCallbackImpl<SpdySession> read_callback_;
-  OldCompletionCallbackImpl<SpdySession> write_callback_;
-
   // Used for posting asynchronous IO tasks.  We use this even though
   // SpdySession is refcounted because we don't need to keep the SpdySession
   // alive if the last reference is within a RunnableMethod.  Just revoke the
   // method.
-  ScopedRunnableMethodFactory<SpdySession> method_factory_;
+  base::WeakPtrFactory<SpdySession> weak_factory_;
 
   // Map of the SpdyStreams for which we have a pending Task to invoke a
   // callback.  This is necessary since, before we invoke said callback, it's