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

6 files changed, 91 insertions, 250 deletions

diff --git a/jingle/glue/channel_socket_adapter.cc b/jingle/glue/channel_socket_adapter.cc
index 3e22a35..ae7150a 100644
--- a/jingle/glue/channel_socket_adapter.cc
+++ b/jingle/glue/channel_socket_adapter.cc
@@ -18,8 +18,6 @@ TransportChannelSocketAdapter::TransportChannelSocketAdapter(
     cricket::TransportChannel* channel)
     : message_loop_(MessageLoop::current()),
       channel_(channel),
-      old_read_callback_(NULL),
-      write_callback_(NULL),
       closed_error_code_(net::OK) {
   DCHECK(channel_);
 
@@ -35,30 +33,13 @@ TransportChannelSocketAdapter::~TransportChannelSocketAdapter() {
 }
 
 int TransportChannelSocketAdapter::Read(
-    net::IOBuffer* buf, int buffer_size, net::OldCompletionCallback* callback) {
-  DCHECK_EQ(MessageLoop::current(), message_loop_);
-  DCHECK(buf);
-  DCHECK(callback);
-  CHECK(!old_read_callback_ && read_callback_.is_null());
-
-  if (!channel_) {
-    DCHECK(closed_error_code_ != net::OK);
-    return closed_error_code_;
-  }
-
-  old_read_callback_ = callback;
-  read_buffer_ = buf;
-  read_buffer_size_ = buffer_size;
-
-  return net::ERR_IO_PENDING;
-}
-int TransportChannelSocketAdapter::Read(
-    net::IOBuffer* buf, int buffer_size,
+    net::IOBuffer* buf,
+    int buffer_size,
     const net::CompletionCallback& callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(buf);
   DCHECK(!callback.is_null());
-  CHECK(!old_read_callback_ && read_callback_.is_null());
+  CHECK(read_callback_.is_null());
 
   if (!channel_) {
     DCHECK(closed_error_code_ != net::OK);
@@ -73,11 +54,13 @@ int TransportChannelSocketAdapter::Read(
 }
 
 int TransportChannelSocketAdapter::Write(
-    net::IOBuffer* buffer, int buffer_size, net::OldCompletionCallback* callback) {
+    net::IOBuffer* buffer,
+    int buffer_size,
+    const net::CompletionCallback& callback) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(buffer);
-  DCHECK(callback);
-  CHECK(!write_callback_);
+  DCHECK(!callback.is_null());
+  CHECK(write_callback_.is_null());
 
   if (!channel_) {
     DCHECK(closed_error_code_ != net::OK);
@@ -129,23 +112,18 @@ void TransportChannelSocketAdapter::Close(int error_code) {
   channel_->SignalDestroyed.disconnect(this);
   channel_ = NULL;
 
-  if (old_read_callback_) {
-    net::OldCompletionCallback* callback = old_read_callback_;
-    old_read_callback_ = NULL;
-    read_buffer_ = NULL;
-    callback->Run(error_code);
-  } else if (!read_callback_.is_null()) {
+  if (!read_callback_.is_null()) {
     net::CompletionCallback callback = read_callback_;
     read_callback_.Reset();
     read_buffer_ = NULL;
     callback.Run(error_code);
   }
 
-  if (write_callback_) {
-    net::OldCompletionCallback* callback = write_callback_;
-    write_callback_ = NULL;
+  if (!write_callback_.is_null()) {
+    net::CompletionCallback callback = write_callback_;
+    write_callback_.Reset();
     write_buffer_ = NULL;
-    callback->Run(error_code);
+    callback.Run(error_code);
   }
 }
 
@@ -153,7 +131,7 @@ void TransportChannelSocketAdapter::OnNewPacket(
     cricket::TransportChannel* channel, const char* data, size_t data_size) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK_EQ(channel, channel_);
-  if (old_read_callback_ || !read_callback_.is_null()) {
+  if (!read_callback_.is_null()) {
     DCHECK(read_buffer_);
     CHECK_LT(data_size, static_cast<size_t>(std::numeric_limits<int>::max()));
 
@@ -165,17 +143,11 @@ void TransportChannelSocketAdapter::OnNewPacket(
 
     memcpy(read_buffer_->data(), data, data_size);
 
-    if (old_read_callback_) {
-      net::OldCompletionCallback* callback = old_read_callback_;
-      old_read_callback_ = NULL;
-      read_buffer_ = NULL;
-      callback->Run(data_size);
-    } else {
-      net::CompletionCallback callback = read_callback_;
-      read_callback_.Reset();
-      read_buffer_ = NULL;
-      callback.Run(data_size);
-    }
+    net::CompletionCallback callback = read_callback_;
+    read_callback_.Reset();
+    read_buffer_ = NULL;
+
+    callback.Run(data_size);
   } else {
     LOG(WARNING)
         << "Data was received without a callback. Dropping the packet.";
@@ -186,17 +158,17 @@ void TransportChannelSocketAdapter::OnWritableState(
     cricket::TransportChannel* channel) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   // Try to send the packet if there is a pending write.
-  if (write_callback_) {
+  if (!write_callback_.is_null()) {
     int result = channel_->SendPacket(write_buffer_->data(),
                                       write_buffer_size_);
     if (result < 0)
       result = net::MapSystemError(channel_->GetError());
 
     if (result != net::ERR_IO_PENDING) {
-      net::OldCompletionCallback* callback = write_callback_;
-      write_callback_ = NULL;
+      net::CompletionCallback callback = write_callback_;
+      write_callback_.Reset();
       write_buffer_ = NULL;
-      callback->Run(result);
+      callback.Run(result);
     }
   }
 }
diff --git a/jingle/glue/channel_socket_adapter.h b/jingle/glue/channel_socket_adapter.h
index 1f367e8..b90ad84 100644
--- a/jingle/glue/channel_socket_adapter.h
+++ b/jingle/glue/channel_socket_adapter.h
@@ -6,7 +6,6 @@
 #define JINGLE_GLUE_CHANNEL_SOCKET_ADAPTER_H_
 
 #include "base/compiler_specific.h"
-#include "net/base/completion_callback.h"
 #include "net/socket/socket.h"
 #include "third_party/libjingle/source/talk/base/socketaddress.h"
 #include "third_party/libjingle/source/talk/base/sigslot.h"
@@ -36,11 +35,9 @@ class TransportChannelSocketAdapter : public net::Socket,
 
   // Socket implementation.
   virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Read(net::IOBuffer* buf, int buf_len,
                    const net::CompletionCallback& callback) OVERRIDE;
   virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback) OVERRIDE;
+                    const net::CompletionCallback& callback) OVERRIDE;
 
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
@@ -55,12 +52,11 @@ class TransportChannelSocketAdapter : public net::Socket,
 
   cricket::TransportChannel* channel_;
 
-  net::OldCompletionCallback* old_read_callback_;  // Not owned.
   net::CompletionCallback read_callback_;
   scoped_refptr<net::IOBuffer> read_buffer_;
   int read_buffer_size_;
 
-  net::OldCompletionCallback* write_callback_;  // Not owned.
+  net::CompletionCallback write_callback_;
   scoped_refptr<net::IOBuffer> write_buffer_;
   int write_buffer_size_;
 
diff --git a/jingle/glue/channel_socket_adapter_unittest.cc b/jingle/glue/channel_socket_adapter_unittest.cc
index e8b34b5..7f5f3ee 100644
--- a/jingle/glue/channel_socket_adapter_unittest.cc
+++ b/jingle/glue/channel_socket_adapter_unittest.cc
@@ -44,7 +44,8 @@ class TransportChannelSocketAdapterTest : public testing::Test {
  public:
   TransportChannelSocketAdapterTest()
       : ALLOW_THIS_IN_INITIALIZER_LIST(
-          callback_(this, &TransportChannelSocketAdapterTest::Callback)),
+          callback_(base::Bind(&TransportChannelSocketAdapterTest::Callback,
+                               base::Unretained(this)))),
         callback_result_(0) {
   }
 
@@ -59,7 +60,7 @@ class TransportChannelSocketAdapterTest : public testing::Test {
 
   MockTransportChannel channel_;
   scoped_ptr<TransportChannelSocketAdapter> target_;
-  net::OldCompletionCallbackImpl<TransportChannelSocketAdapterTest> callback_;
+  net::CompletionCallback callback_;
   int callback_result_;
   MessageLoopForIO message_loop_;
 };
@@ -68,7 +69,7 @@ class TransportChannelSocketAdapterTest : public testing::Test {
 TEST_F(TransportChannelSocketAdapterTest, Read) {
   scoped_refptr<IOBuffer> buffer(new IOBuffer(kBufferSize));
 
-  int result = target_->Read(buffer, kBufferSize, &callback_);
+  int result = target_->Read(buffer, kBufferSize, callback_);
   ASSERT_EQ(net::ERR_IO_PENDING, result);
 
   channel_.SignalReadPacket(&channel_, kTestData, kTestDataSize);
@@ -79,14 +80,14 @@ TEST_F(TransportChannelSocketAdapterTest, Read) {
 TEST_F(TransportChannelSocketAdapterTest, ReadClose) {
   scoped_refptr<IOBuffer> buffer(new IOBuffer(kBufferSize));
 
-  int result = target_->Read(buffer, kBufferSize, &callback_);
+  int result = target_->Read(buffer, kBufferSize, callback_);
   ASSERT_EQ(net::ERR_IO_PENDING, result);
 
   target_->Close(kTestError);
   EXPECT_EQ(kTestError, callback_result_);
 
   // All Read() calls after Close() should return the error.
-  EXPECT_EQ(kTestError, target_->Read(buffer, kBufferSize, &callback_));
+  EXPECT_EQ(kTestError, target_->Read(buffer, kBufferSize, callback_));
 }
 
 // Verify that Write sends the packet and returns correct result.
@@ -96,7 +97,7 @@ TEST_F(TransportChannelSocketAdapterTest, Write) {
   EXPECT_CALL(channel_, SendPacket(buffer->data(), kTestDataSize))
       .WillOnce(Return(kTestDataSize));
 
-  int result = target_->Write(buffer, kTestDataSize, &callback_);
+  int result = target_->Write(buffer, kTestDataSize, callback_);
   EXPECT_EQ(kTestDataSize, result);
 }
 
@@ -112,7 +113,7 @@ TEST_F(TransportChannelSocketAdapterTest, WritePending) {
   EXPECT_CALL(channel_, GetError())
       .WillOnce(Return(EWOULDBLOCK));
 
-  int result = target_->Write(buffer, kTestDataSize, &callback_);
+  int result = target_->Write(buffer, kTestDataSize, callback_);
   ASSERT_EQ(net::OK, result);
 }
 
diff --git a/jingle/glue/pseudotcp_adapter.cc b/jingle/glue/pseudotcp_adapter.cc
index 7807eed..cb6ed91 100644
--- a/jingle/glue/pseudotcp_adapter.cc
+++ b/jingle/glue/pseudotcp_adapter.cc
@@ -30,12 +30,9 @@ class PseudoTcpAdapter::Core : public cricket::IPseudoTcpNotify,
 
   // Functions used to implement net::StreamSocket.
   int Read(net::IOBuffer* buffer, int buffer_size,
-           net::OldCompletionCallback* callback);
-  int Read(net::IOBuffer* buffer, int buffer_size,
            const net::CompletionCallback& callback);
   int Write(net::IOBuffer* buffer, int buffer_size,
-            net::OldCompletionCallback* callback);
-  int Connect(net::OldCompletionCallback* callback);
+            const net::CompletionCallback& callback);
   int Connect(const net::CompletionCallback& callback);
   void Disconnect();
   bool IsConnected() const;
@@ -71,11 +68,9 @@ class PseudoTcpAdapter::Core : public cricket::IPseudoTcpNotify,
   // This re-sets |timer| without triggering callbacks.
   void AdjustClock();
 
-  net::OldCompletionCallback* old_connect_callback_;
   net::CompletionCallback connect_callback_;
-  net::OldCompletionCallback* old_read_callback_;
   net::CompletionCallback read_callback_;
-  net::OldCompletionCallback* write_callback_;
+  net::CompletionCallback write_callback_;
 
   cricket::PseudoTcp pseudo_tcp_;
   scoped_ptr<net::Socket> socket_;
@@ -88,9 +83,6 @@ class PseudoTcpAdapter::Core : public cricket::IPseudoTcpNotify,
   bool socket_write_pending_;
   scoped_refptr<net::IOBuffer> socket_read_buffer_;
 
-  net::OldCompletionCallbackImpl<Core> socket_read_callback_;
-  net::OldCompletionCallbackImpl<Core> socket_write_callback_;
-
   base::OneShotTimer<Core> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
@@ -98,16 +90,9 @@ class PseudoTcpAdapter::Core : public cricket::IPseudoTcpNotify,
 
 
 PseudoTcpAdapter::Core::Core(net::Socket* socket)
-    : old_connect_callback_(NULL),
-      old_read_callback_(NULL),
-      write_callback_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(pseudo_tcp_(this, 0)),
+    : ALLOW_THIS_IN_INITIALIZER_LIST(pseudo_tcp_(this, 0)),
       socket_(socket),
-      socket_write_pending_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          socket_read_callback_(this, &PseudoTcpAdapter::Core::OnRead)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          socket_write_callback_(this, &PseudoTcpAdapter::Core::OnWritten)) {
+      socket_write_pending_(false) {
   // Doesn't trigger callbacks.
   pseudo_tcp_.NotifyMTU(kDefaultMtu);
 }
@@ -116,31 +101,8 @@ PseudoTcpAdapter::Core::~Core() {
 }
 
 int PseudoTcpAdapter::Core::Read(net::IOBuffer* buffer, int buffer_size,
-                                 net::OldCompletionCallback* callback) {
-  DCHECK(!old_read_callback_ && read_callback_.is_null());
-
-  // Reference the Core in case a callback deletes the adapter.
-  scoped_refptr<Core> core(this);
-
-  int result = pseudo_tcp_.Recv(buffer->data(), buffer_size);
-  if (result < 0) {
-    result = net::MapSystemError(pseudo_tcp_.GetError());
-    DCHECK(result < 0);
-  }
-
-  if (result == net::ERR_IO_PENDING) {
-    read_buffer_ = buffer;
-    read_buffer_size_ = buffer_size;
-    old_read_callback_ = callback;
-  }
-
-  AdjustClock();
-
-  return result;
-}
-int PseudoTcpAdapter::Core::Read(net::IOBuffer* buffer, int buffer_size,
                                  const net::CompletionCallback& callback) {
-  DCHECK(!old_read_callback_ && read_callback_.is_null());
+  DCHECK(read_callback_.is_null());
 
   // Reference the Core in case a callback deletes the adapter.
   scoped_refptr<Core> core(this);
@@ -163,8 +125,8 @@ int PseudoTcpAdapter::Core::Read(net::IOBuffer* buffer, int buffer_size,
 }
 
 int PseudoTcpAdapter::Core::Write(net::IOBuffer* buffer, int buffer_size,
-                                  net::OldCompletionCallback* callback) {
-  DCHECK(!write_callback_);
+                                  const net::CompletionCallback& callback) {
+  DCHECK(write_callback_.is_null());
 
   // Reference the Core in case a callback deletes the adapter.
   scoped_refptr<Core> core(this);
@@ -186,26 +148,6 @@ int PseudoTcpAdapter::Core::Write(net::IOBuffer* buffer, int buffer_size,
   return result;
 }
 
-int PseudoTcpAdapter::Core::Connect(net::OldCompletionCallback* callback) {
-  DCHECK_EQ(pseudo_tcp_.State(), cricket::PseudoTcp::TCP_LISTEN);
-
-  // Reference the Core in case a callback deletes the adapter.
-  scoped_refptr<Core> core(this);
-
-  // Start the connection attempt.
-  int result = pseudo_tcp_.Connect();
-  if (result < 0)
-    return net::ERR_FAILED;
-
-  AdjustClock();
-
-  old_connect_callback_ = callback;
-  connect_callback_.Reset();
-  DoReadFromSocket();
-
-  return net::ERR_IO_PENDING;
-}
-
 int PseudoTcpAdapter::Core::Connect(const net::CompletionCallback& callback) {
   DCHECK_EQ(pseudo_tcp_.State(), cricket::PseudoTcp::TCP_LISTEN);
 
@@ -219,7 +161,6 @@ int PseudoTcpAdapter::Core::Connect(const net::CompletionCallback& callback) {
 
   AdjustClock();
 
-  old_connect_callback_ = NULL;
   connect_callback_ = callback;
   DoReadFromSocket();
 
@@ -228,12 +169,10 @@ int PseudoTcpAdapter::Core::Connect(const net::CompletionCallback& callback) {
 
 void PseudoTcpAdapter::Core::Disconnect() {
   // Don't dispatch outstanding callbacks, as mandated by net::StreamSocket.
-  old_read_callback_ = NULL;
   read_callback_.Reset();
   read_buffer_ = NULL;
-  write_callback_ = NULL;
+  write_callback_.Reset();
   write_buffer_ = NULL;
-  old_connect_callback_ = NULL;
   connect_callback_.Reset();
 
   // TODO(wez): Connect should succeed if called after Disconnect, which
@@ -253,11 +192,7 @@ bool PseudoTcpAdapter::Core::IsConnected() const {
 void PseudoTcpAdapter::Core::OnTcpOpen(PseudoTcp* tcp) {
   DCHECK(tcp == &pseudo_tcp_);
 
-  if (old_connect_callback_) {
-    net::OldCompletionCallback* callback = old_connect_callback_;
-    old_connect_callback_ = NULL;
-    callback->Run(net::OK);
-  } else if (!connect_callback_.is_null()) {
+  if (!connect_callback_.is_null()) {
     net::CompletionCallback callback = connect_callback_;
     connect_callback_.Reset();
     callback.Run(net::OK);
@@ -269,7 +204,7 @@ void PseudoTcpAdapter::Core::OnTcpOpen(PseudoTcp* tcp) {
 
 void PseudoTcpAdapter::Core::OnTcpReadable(PseudoTcp* tcp) {
   DCHECK_EQ(tcp, &pseudo_tcp_);
-  if (!old_read_callback_ && read_callback_.is_null())
+  if (read_callback_.is_null())
     return;
 
   int result = pseudo_tcp_.Recv(read_buffer_->data(), read_buffer_size_);
@@ -282,22 +217,15 @@ void PseudoTcpAdapter::Core::OnTcpReadable(PseudoTcp* tcp) {
 
   AdjustClock();
 
-  if (old_read_callback_) {
-    net::OldCompletionCallback* callback = old_read_callback_;
-    old_read_callback_ = NULL;
-    read_buffer_ = NULL;
-    callback->Run(result);
-  } else {
-    net::CompletionCallback callback = read_callback_;
-    read_callback_.Reset();
-    read_buffer_ = NULL;
-    callback.Run(result);
-  }
+  net::CompletionCallback callback = read_callback_;
+  read_callback_.Reset();
+  read_buffer_ = NULL;
+  callback.Run(result);
 }
 
 void PseudoTcpAdapter::Core::OnTcpWriteable(PseudoTcp* tcp) {
   DCHECK_EQ(tcp, &pseudo_tcp_);
-  if (!write_callback_)
+  if (write_callback_.is_null())
     return;
 
   int result = pseudo_tcp_.Send(write_buffer_->data(), write_buffer_size_);
@@ -310,39 +238,31 @@ void PseudoTcpAdapter::Core::OnTcpWriteable(PseudoTcp* tcp) {
 
   AdjustClock();
 
-  net::OldCompletionCallback* callback = write_callback_;
-  write_callback_ = NULL;
+  net::CompletionCallback callback = write_callback_;
+  write_callback_.Reset();
   write_buffer_ = NULL;
-  callback->Run(result);
+  callback.Run(result);
 }
 
 void PseudoTcpAdapter::Core::OnTcpClosed(PseudoTcp* tcp, uint32 error) {
   DCHECK_EQ(tcp, &pseudo_tcp_);
 
-  if (old_connect_callback_) {
-    net::OldCompletionCallback* callback = old_connect_callback_;
-    old_connect_callback_ = NULL;
-    callback->Run(net::MapSystemError(error));
-  } else if (!connect_callback_.is_null()) {
+  if (!connect_callback_.is_null()) {
     net::CompletionCallback callback = connect_callback_;
     connect_callback_.Reset();
     callback.Run(net::MapSystemError(error));
   }
 
-  if (old_read_callback_) {
-    net::OldCompletionCallback* callback = old_read_callback_;
-    old_read_callback_ = NULL;
-    callback->Run(net::MapSystemError(error));
-  } else if (!read_callback_.is_null()) {
+  if (!read_callback_.is_null()) {
     net::CompletionCallback callback = read_callback_;
     read_callback_.Reset();
     callback.Run(net::MapSystemError(error));
   }
 
-  if (write_callback_) {
-    net::OldCompletionCallback* callback = write_callback_;
-    write_callback_ = NULL;
-    callback->Run(net::MapSystemError(error));
+  if (!write_callback_.is_null()) {
+    net::CompletionCallback callback = write_callback_;
+    write_callback_.Reset();
+    callback.Run(net::MapSystemError(error));
   }
 }
 
@@ -379,7 +299,9 @@ cricket::IPseudoTcpNotify::WriteResult PseudoTcpAdapter::Core::TcpWritePacket(
 
   // Our underlying socket is datagram-oriented, which means it should either
   // send exactly as many bytes as we requested, or fail.
-  int result = socket_->Write(write_buffer, len, &socket_write_callback_);
+  int result = socket_->Write(write_buffer, len,
+                              base::Bind(&PseudoTcpAdapter::Core::OnWritten,
+                                         base::Unretained(this)));
   if (result == net::ERR_IO_PENDING) {
     socket_write_pending_ = true;
     return IPseudoTcpNotify::WR_SUCCESS;
@@ -398,7 +320,8 @@ void PseudoTcpAdapter::Core::DoReadFromSocket() {
 
   while (true) {
     int result = socket_->Read(socket_read_buffer_, kReadBufferSize,
-                               &socket_read_callback_);
+                               base::Bind(&PseudoTcpAdapter::Core::OnRead,
+                                          base::Unretained(this)));
     if (result == net::ERR_IO_PENDING)
       break;
 
@@ -465,18 +388,13 @@ PseudoTcpAdapter::~PseudoTcpAdapter() {
 }
 
 int PseudoTcpAdapter::Read(net::IOBuffer* buffer, int buffer_size,
-                           net::OldCompletionCallback* callback) {
-  DCHECK(CalledOnValidThread());
-  return core_->Read(buffer, buffer_size, callback);
-}
-int PseudoTcpAdapter::Read(net::IOBuffer* buffer, int buffer_size,
                            const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   return core_->Read(buffer, buffer_size, callback);
 }
 
 int PseudoTcpAdapter::Write(net::IOBuffer* buffer, int buffer_size,
-                            net::OldCompletionCallback* callback) {
+                            const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   return core_->Write(buffer, buffer_size, callback);
 }
@@ -495,16 +413,6 @@ bool PseudoTcpAdapter::SetSendBufferSize(int32 size) {
   return false;
 }
 
-int PseudoTcpAdapter::Connect(net::OldCompletionCallback* callback) {
-  DCHECK(CalledOnValidThread());
-
-  // net::StreamSocket requires that Connect return OK if already connected.
-  if (IsConnected())
-    return net::OK;
-
-  return core_->Connect(callback);
-}
-
 int PseudoTcpAdapter::Connect(const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
 
diff --git a/jingle/glue/pseudotcp_adapter.h b/jingle/glue/pseudotcp_adapter.h
index f0d27ee..91811e9 100644
--- a/jingle/glue/pseudotcp_adapter.h
+++ b/jingle/glue/pseudotcp_adapter.h
@@ -31,16 +31,13 @@ class PseudoTcpAdapter : public net::StreamSocket, base::NonThreadSafe {
 
   // net::Socket implementation.
   virtual int Read(net::IOBuffer* buffer, int buffer_size,
-                   net::OldCompletionCallback* callback) OVERRIDE;
-  virtual int Read(net::IOBuffer* buffer, int buffer_size,
                    const net::CompletionCallback& callback) OVERRIDE;
   virtual int Write(net::IOBuffer* buffer, int buffer_size,
-                    net::OldCompletionCallback* callback) OVERRIDE;
+                    const net::CompletionCallback& callback) OVERRIDE;
   virtual bool SetReceiveBufferSize(int32 size) OVERRIDE;
   virtual bool SetSendBufferSize(int32 size) OVERRIDE;
 
   // net::StreamSocket implementation.
-  virtual int Connect(net::OldCompletionCallback* callback) OVERRIDE;
   virtual int Connect(const net::CompletionCallback& callback) OVERRIDE;
   virtual void Disconnect() OVERRIDE;
   virtual bool IsConnected() const OVERRIDE;
diff --git a/jingle/glue/pseudotcp_adapter_unittest.cc b/jingle/glue/pseudotcp_adapter_unittest.cc
index 6d803a5..7ee217a 100644
--- a/jingle/glue/pseudotcp_adapter_unittest.cc
+++ b/jingle/glue/pseudotcp_adapter_unittest.cc
@@ -10,7 +10,6 @@
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "jingle/glue/thread_wrapper.h"
-#include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ -81,8 +80,7 @@ class LeakyBucket : public RateLimiter {
 class FakeSocket : public net::Socket {
  public:
   FakeSocket()
-      : old_read_callback_(NULL),
-        rate_limiter_(NULL),
+      : rate_limiter_(NULL),
         latency_ms_(0) {
   }
   virtual ~FakeSocket() { }
@@ -91,20 +89,13 @@ class FakeSocket : public net::Socket {
     if (rate_limiter_ && rate_limiter_->DropNextPacket())
       return;  // Lose the packet.
 
-    if (old_read_callback_ || !read_callback_.is_null()) {
+    if (!read_callback_.is_null()) {
       int size = std::min(read_buffer_size_, static_cast<int>(data.size()));
       memcpy(read_buffer_->data(), &data[0], data.size());
-      if (old_read_callback_) {
-        net::OldCompletionCallback* cb = old_read_callback_;
-        old_read_callback_ = NULL;
-        read_buffer_ = NULL;
-        cb->Run(size);
-      } else {
-        net::CompletionCallback cb = read_callback_;
-        read_callback_.Reset();
-        read_buffer_ = NULL;
-        cb.Run(size);
-      }
+      net::CompletionCallback cb = read_callback_;
+      read_callback_.Reset();
+      read_buffer_ = NULL;
+      cb.Run(size);
     } else {
       incoming_packets_.push_back(data);
     }
@@ -120,29 +111,10 @@ class FakeSocket : public net::Socket {
 
   void set_latency(int latency_ms) { latency_ms_ = latency_ms; };
 
-  // net::Socket implementation.
-  virtual int Read(net::IOBuffer* buf, int buf_len,
-                   net::OldCompletionCallback* callback) {
-    CHECK(!old_read_callback_ && read_callback_.is_null());
-    CHECK(buf);
-
-    if (incoming_packets_.size() > 0) {
-      scoped_refptr<net::IOBuffer> buffer(buf);
-      int size = std::min(
-          static_cast<int>(incoming_packets_.front().size()), buf_len);
-      memcpy(buffer->data(), &*incoming_packets_.front().begin(), size);
-      incoming_packets_.pop_front();
-      return size;
-    } else {
-      old_read_callback_ = callback;
-      read_buffer_ = buf;
-      read_buffer_size_ = buf_len;
-      return net::ERR_IO_PENDING;
-    }
-  }
+  // net::Socket interface.
   virtual int Read(net::IOBuffer* buf, int buf_len,
                    const net::CompletionCallback& callback) {
-    CHECK(!old_read_callback_ && read_callback_.is_null());
+    CHECK(read_callback_.is_null());
     CHECK(buf);
 
     if (incoming_packets_.size() > 0) {
@@ -161,7 +133,7 @@ class FakeSocket : public net::Socket {
   }
 
   virtual int Write(net::IOBuffer* buf, int buf_len,
-                    net::OldCompletionCallback* callback) OVERRIDE {
+                    const net::CompletionCallback& callback) OVERRIDE {
     DCHECK(buf);
     if (peer_socket_) {
       MessageLoop::current()->PostDelayedTask(
@@ -187,7 +159,6 @@ class FakeSocket : public net::Socket {
  private:
   scoped_refptr<net::IOBuffer> read_buffer_;
   int read_buffer_size_;
-  net::OldCompletionCallback* old_read_callback_;
   net::CompletionCallback read_callback_;
 
   std::deque<std::vector<char> > incoming_packets_;
@@ -206,10 +177,6 @@ class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
         host_socket_(host_socket),
         client_socket_(client_socket),
         done_(false),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            write_cb_(this, &TCPChannelTester::OnWritten)),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            read_cb_(this, &TCPChannelTester::OnRead)),
         write_errors_(0),
         read_errors_(0) {
   }
@@ -264,8 +231,9 @@ class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
 
       int bytes_to_write = std::min(output_buffer_->BytesRemaining(),
                                     kMessageSize);
-      result = client_socket_->Write(output_buffer_, bytes_to_write,
-                                     &write_cb_);
+      result = client_socket_->Write(
+          output_buffer_, bytes_to_write,
+          base::Bind(&TCPChannelTester::OnWritten, base::Unretained(this)));
       HandleWriteResult(result);
     }
   }
@@ -290,7 +258,9 @@ class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
     while (result > 0) {
       input_buffer_->set_offset(input_buffer_->capacity() - kMessageSize);
 
-      result = host_socket_->Read(input_buffer_, kMessageSize, &read_cb_);
+      result = host_socket_->Read(input_buffer_, kMessageSize,
+                                  base::Bind(&TCPChannelTester::OnRead,
+                                             base::Unretained(this)));
       HandleReadResult(result);
     };
   }
@@ -324,8 +294,6 @@ class TCPChannelTester : public base::RefCountedThreadSafe<TCPChannelTester> {
   scoped_refptr<net::DrainableIOBuffer> output_buffer_;
   scoped_refptr<net::GrowableIOBuffer> input_buffer_;
 
-  net::OldCompletionCallbackImpl<TCPChannelTester> write_cb_;
-  net::OldCompletionCallbackImpl<TCPChannelTester> read_cb_;
   int write_errors_;
   int read_errors_;
 };
@@ -354,11 +322,11 @@ class PseudoTcpAdapterTest : public testing::Test {
 };
 
 TEST_F(PseudoTcpAdapterTest, DataTransfer) {
-  TestOldCompletionCallback host_connect_cb;
-  TestOldCompletionCallback client_connect_cb;
+  net::TestCompletionCallback host_connect_cb;
+  net::TestCompletionCallback client_connect_cb;
 
-  int rv1 = host_pseudotcp_->Connect(&host_connect_cb);
-  int rv2 = client_pseudotcp_->Connect(&client_connect_cb);
+  int rv1 = host_pseudotcp_->Connect(host_connect_cb.callback());
+  int rv2 = client_pseudotcp_->Connect(client_connect_cb.callback());
 
   if (rv1 == net::ERR_IO_PENDING)
     rv1 = host_connect_cb.WaitForResult();
@@ -389,11 +357,11 @@ TEST_F(PseudoTcpAdapterTest, LimitedChannel) {
   host_socket_->set_latency(kLatencyMs);
   client_socket_->set_rate_limiter(&client_limiter);
 
-  TestOldCompletionCallback host_connect_cb;
-  TestOldCompletionCallback client_connect_cb;
+  net::TestCompletionCallback host_connect_cb;
+  net::TestCompletionCallback client_connect_cb;
 
-  int rv1 = host_pseudotcp_->Connect(&host_connect_cb);
-  int rv2 = client_pseudotcp_->Connect(&client_connect_cb);
+  int rv1 = host_pseudotcp_->Connect(host_connect_cb.callback());
+  int rv2 = client_pseudotcp_->Connect(client_connect_cb.callback());
 
   if (rv1 == net::ERR_IO_PENDING)
     rv1 = host_connect_cb.WaitForResult();
@@ -428,13 +396,12 @@ TEST_F(PseudoTcpAdapterTest, DeleteOnConnected) {
   // This test verifies that deleting the adapter mid-callback doesn't lead
   // to deleted structures being touched as the stack unrolls, so the failure
   // mode is a crash rather than a normal test failure.
-  TestOldCompletionCallback client_connect_cb;
+  net::TestCompletionCallback client_connect_cb;
   DeleteOnConnected host_delete(&message_loop_, &host_pseudotcp_);
-  net::OldCompletionCallbackImpl<DeleteOnConnected>
-      host_connect_cb(&host_delete, &DeleteOnConnected::OnConnected);
 
-  host_pseudotcp_->Connect(&host_connect_cb);
-  client_pseudotcp_->Connect(&client_connect_cb);
+  host_pseudotcp_->Connect(base::Bind(&DeleteOnConnected::OnConnected,
+                                      base::Unretained(&host_delete)));
+  client_pseudotcp_->Connect(client_connect_cb.callback());
   message_loop_.Run();
 
   ASSERT_EQ(NULL, host_pseudotcp_.get());