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

net/socket/socket_test_util.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/socket/socket_test_util.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 158 matching lines @@
 MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) {
   if (!writes_) {
     // Not using mock writes; succeed synchronously.
     return MockWriteResult(false, data.length());
   }
 
   DCHECK(!at_write_eof());
 
   // Check that what we are writing matches the expectation.
   // Then give the mocked return value.
-  net::MockWrite* w = &writes_[write_index_++];
+  MockWrite* w = &writes_[write_index_++];
   w->time_stamp = base::Time::Now();
   int result = w->result;
   if (w->data) {
     // Note - we can simulate a partial write here.  If the expected data
     // is a match, but shorter than the write actually written, that is legal.
     // Example:
     //   Application writes "foobarbaz" (9 bytes)
     //   Expected write was "foo" (3 bytes)
     //   This is a success, and we return 3 to the application.
     std::string expected_data(w->data, w->data_len);
     EXPECT_GE(data.length(), expected_data.length());
     std::string actual_data(data.substr(0, w->data_len));
     EXPECT_EQ(expected_data, actual_data);
     if (expected_data != actual_data)
-      return MockWriteResult(false, net::ERR_UNEXPECTED);
-    if (result == net::OK)
+      return MockWriteResult(false, ERR_UNEXPECTED);
+    if (result == OK)
       result = w->data_len;
   }
   return MockWriteResult(w->async, result);
 }
 
 void StaticSocketDataProvider::Reset() {
   read_index_ = 0;
   write_index_ = 0;
 }
 
@@ skipping 39 matching lines @@
 }
 
 SSLSocketDataProvider::~SSLSocketDataProvider() {
 }
 
 DelayedSocketData::DelayedSocketData(
     int write_delay, MockRead* reads, size_t reads_count,
     MockWrite* writes, size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       write_delay_(write_delay),
-      ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK_GE(write_delay_, 0);
 }
 
 DelayedSocketData::DelayedSocketData(
     const MockConnect& connect, int write_delay, MockRead* reads,
     size_t reads_count, MockWrite* writes, size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
       write_delay_(write_delay),
-      ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK_GE(write_delay_, 0);
   set_connect_data(connect);
 }
 
 DelayedSocketData::~DelayedSocketData() {
 }
 
 void DelayedSocketData::ForceNextRead() {
   write_delay_ = 0;
   CompleteRead();
 }
 
 MockRead DelayedSocketData::GetNextRead() {
   if (write_delay_ > 0)
     return MockRead(true, ERR_IO_PENDING);
   return StaticSocketDataProvider::GetNextRead();
 }
 
 MockWriteResult DelayedSocketData::OnWrite(const std::string& data) {
   MockWriteResult rv = StaticSocketDataProvider::OnWrite(data);
   // Now that our write has completed, we can allow reads to continue.
   if (!--write_delay_)
-    MessageLoop::current()->PostDelayedTask(FROM_HERE,
-      factory_.NewRunnableMethod(&DelayedSocketData::CompleteRead), 100);
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&DelayedSocketData::CompleteRead,
+                   weak_factory_.GetWeakPtr()),
+        100);
   return rv;
 }
 
 void DelayedSocketData::Reset() {
   set_socket(NULL);
-  factory_.RevokeAll();
+  weak_factory_.InvalidateWeakPtrs();
   StaticSocketDataProvider::Reset();
 }
 
 void DelayedSocketData::CompleteRead() {
   if (socket())
     socket()->OnReadComplete(GetNextRead());
 }
 
 OrderedSocketData::OrderedSocketData(
     MockRead* reads, size_t reads_count, MockWrite* writes, size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
-      sequence_number_(0), loop_stop_stage_(0), callback_(NULL),
-      blocked_(false), ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {
+      sequence_number_(0), loop_stop_stage_(0),
+      blocked_(false), ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 OrderedSocketData::OrderedSocketData(
     const MockConnect& connect,
     MockRead* reads, size_t reads_count,
     MockWrite* writes, size_t writes_count)
     : StaticSocketDataProvider(reads, reads_count, writes, writes_count),
-      sequence_number_(0), loop_stop_stage_(0), callback_(NULL),
-      blocked_(false), ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {
+      sequence_number_(0), loop_stop_stage_(0),
+      blocked_(false), ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   set_connect_data(connect);
 }
 
 void OrderedSocketData::EndLoop() {
   // If we've already stopped the loop, don't do it again until we've advanced
   // to the next sequence_number.
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ << ": EndLoop()";
   if (loop_stop_stage_ > 0) {
     const MockRead& next_read = StaticSocketDataProvider::PeekRead();
     if ((next_read.sequence_number & ~MockRead::STOPLOOP) >
         loop_stop_stage_) {
       NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                                 << ": Clearing stop index";
       loop_stop_stage_ = 0;
     } else {
       return;
     }
   }
   // Record the sequence_number at which we stopped the loop.
   NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_
                             << ": Posting Quit at read " << read_index();
   loop_stop_stage_ = sequence_number_;
-  if (callback_)
-    callback_->RunWithParams(Tuple1<int>(ERR_IO_PENDING));
+  if (!callback_.is_null())
+    callback_.Run(ERR_IO_PENDING);
 }
 
 MockRead OrderedSocketData::GetNextRead() {
-  factory_.RevokeAll();
+  weak_factory_.InvalidateWeakPtrs();
   blocked_ = false;
   const MockRead& next_read = StaticSocketDataProvider::PeekRead();
   if (next_read.sequence_number & MockRead::STOPLOOP)
     EndLoop();
   if ((next_read.sequence_number & ~MockRead::STOPLOOP) <=
       sequence_number_++) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_ - 1
                               << ": Read " << read_index();
     DumpMockRead(next_read);
     return StaticSocketDataProvider::GetNextRead();
@@ skipping 12 matching lines @@
   DumpMockRead(PeekWrite());
   ++sequence_number_;
   if (blocked_) {
     // TODO(willchan): This 100ms delay seems to work around some weirdness.  We
     // should probably fix the weirdness.  One example is in SpdyStream,
     // DoSendRequest() will return ERR_IO_PENDING, and there's a race.  If the
     // SYN_REPLY causes OnResponseReceived() to get called before
     // SpdyStream::ReadResponseHeaders() is called, we hit a NOTREACHED().
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
-        factory_.NewRunnableMethod(&OrderedSocketData::CompleteRead), 100);
+        base::Bind(&OrderedSocketData::CompleteRead,
+                   weak_factory_.GetWeakPtr()),
+        100);
   }
   return StaticSocketDataProvider::OnWrite(data);
 }
 
 void OrderedSocketData::Reset() {
   NET_TRACE(INFO, "  *** ") << "Stage "
                             << sequence_number_ << ": Reset()";
   sequence_number_ = 0;
   loop_stop_stage_ = 0;
   set_socket(NULL);
-  factory_.RevokeAll();
+  weak_factory_.InvalidateWeakPtrs();
   StaticSocketDataProvider::Reset();
 }
 
 void OrderedSocketData::CompleteRead() {
   if (socket()) {
     NET_TRACE(INFO, "  *** ") << "Stage " << sequence_number_;
     socket()->OnReadComplete(GetNextRead());
   }
 }
 
@@ skipping 187 matching lines @@
 
 MockSSLClientSocket* MockClientSocketFactory::GetMockSSLClientSocket(
     size_t index) const {
   DCHECK_LT(index, ssl_client_sockets_.size());
   return ssl_client_sockets_[index];
 }
 
 DatagramClientSocket* MockClientSocketFactory::CreateDatagramClientSocket(
     DatagramSocket::BindType bind_type,
     const RandIntCallback& rand_int_cb,
-    NetLog* net_log,
-    const NetLog::Source& source) {
+    net::NetLog* net_log,
+    const net::NetLog::Source& source) {
   SocketDataProvider* data_provider = mock_data_.GetNext();
   MockUDPClientSocket* socket = new MockUDPClientSocket(data_provider, net_log);
   data_provider->set_socket(socket);
   udp_client_sockets_.push_back(socket);
   return socket;
 }
 
 StreamSocket* MockClientSocketFactory::CreateTransportClientSocket(
     const AddressList& addresses,
     net::NetLog* net_log,
-    const NetLog::Source& source) {
+    const net::NetLog::Source& source) {
   SocketDataProvider* data_provider = mock_data_.GetNext();
   MockTCPClientSocket* socket =
       new MockTCPClientSocket(addresses, net_log, data_provider);
   data_provider->set_socket(socket);
   tcp_client_sockets_.push_back(socket);
   return socket;
 }
 
 SSLClientSocket* MockClientSocketFactory::CreateSSLClientSocket(
     ClientSocketHandle* transport_socket,
     const HostPortPair& host_and_port,
     const SSLConfig& ssl_config,
     SSLHostInfo* ssl_host_info,
     const SSLClientSocketContext& context) {
   MockSSLClientSocket* socket =
       new MockSSLClientSocket(transport_socket, host_and_port, ssl_config,
                               ssl_host_info, mock_ssl_data_.GetNext());
   ssl_client_sockets_.push_back(socket);
   return socket;
 }
 
 void MockClientSocketFactory::ClearSSLSessionCache() {
 }
 
 MockClientSocket::MockClientSocket(net::NetLog* net_log)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       connected_(false),
-      net_log_(NetLog::Source(), net_log) {
+      net_log_(net::NetLog::Source(), net_log) {
 }
 
 bool MockClientSocket::SetReceiveBufferSize(int32 size) {
   return true;
 }
 
 bool MockClientSocket::SetSendBufferSize(int32 size) {
   return true;
 }
 
@@ skipping 22 matching lines @@
   bool rv = ParseIPLiteralToNumber("192.0.2.33", &ip);
   CHECK(rv);
   *address = IPEndPoint(ip, 123);
   return OK;
 }
 
 const BoundNetLog& MockClientSocket::NetLog() const {
   return net_log_;
 }
 
-void MockClientSocket::GetSSLInfo(net::SSLInfo* ssl_info) {
+void MockClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   NOTREACHED();
 }
 
 void MockClientSocket::GetSSLCertRequestInfo(
-  net::SSLCertRequestInfo* cert_request_info) {
+  SSLCertRequestInfo* cert_request_info) {
 }
 
 int MockClientSocket::ExportKeyingMaterial(const base::StringPiece& label,
                                            const base::StringPiece& context,
                                            unsigned char *out,
                                            unsigned int outlen) {
   NOTREACHED();
   return ERR_NOT_IMPLEMENTED;
 }
 
 SSLClientSocket::NextProtoStatus
 MockClientSocket::GetNextProto(std::string* proto, std::string* server_protos) {
   proto->clear();
   server_protos->clear();
   return SSLClientSocket::kNextProtoUnsupported;
 }
 
 MockClientSocket::~MockClientSocket() {}
 
-void MockClientSocket::RunCallbackAsync(net::OldCompletionCallback* callback,
-                                        int result) {
-  MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&MockClientSocket::RunOldCallback, weak_factory_.GetWeakPtr(),
-                 callback, result));
-}
-void MockClientSocket::RunCallbackAsync(const net::CompletionCallback& callback,
+void MockClientSocket::RunCallbackAsync(const CompletionCallback& callback,
                                         int result) {
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&MockClientSocket::RunCallback, weak_factory_.GetWeakPtr(),
                  callback, result));
 }
 
-void MockClientSocket::RunOldCallback(net::OldCompletionCallback* callback,
-                                      int result) {
-  if (callback)
-    callback->Run(result);
-}
 void MockClientSocket::RunCallback(const net::CompletionCallback& callback,
                                    int result) {
   if (!callback.is_null())
     callback.Run(result);
 }
 
-MockTCPClientSocket::MockTCPClientSocket(const net::AddressList& addresses,
+MockTCPClientSocket::MockTCPClientSocket(const AddressList& addresses,
                                          net::NetLog* net_log,
-                                         net::SocketDataProvider* data)
+                                         SocketDataProvider* data)
     : MockClientSocket(net_log),
       addresses_(addresses),
       data_(data),
       read_offset_(0),
       num_bytes_read_(0),
-      read_data_(false, net::ERR_UNEXPECTED),
+      read_data_(false, ERR_UNEXPECTED),
       need_read_data_(true),
       peer_closed_connection_(false),
       pending_buf_(NULL),
       pending_buf_len_(0),
-      old_pending_callback_(NULL),
       was_used_to_convey_data_(false) {
   DCHECK(data_);
   data_->Reset();
 }
 
 MockTCPClientSocket::~MockTCPClientSocket() {}
 
-int MockTCPClientSocket::Read(net::IOBuffer* buf, int buf_len,
-                              net::OldCompletionCallback* callback) {
+int MockTCPClientSocket::Read(IOBuffer* buf, int buf_len,
+                              const CompletionCallback& callback) {
   if (!connected_)
-    return net::ERR_UNEXPECTED;
+    return ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
   DCHECK(pending_buf_ == NULL);
-
-  // Store our async IO data.
-  pending_buf_ = buf;
-  pending_buf_len_ = buf_len;
-  old_pending_callback_ = callback;
-
-  if (need_read_data_) {
-    read_data_ = data_->GetNextRead();
-    if (read_data_.result == ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) {
-      // This MockRead is just a marker to instruct us to set
-      // peer_closed_connection_.  Skip it and get the next one.
-      read_data_ = data_->GetNextRead();
-      peer_closed_connection_ = true;
-    }
-    // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
-    // to complete the async IO manually later (via OnReadComplete).
-    if (read_data_.result == ERR_IO_PENDING) {
-      DCHECK(callback);  // We need to be using async IO in this case.
-      return ERR_IO_PENDING;
-    }
-    need_read_data_ = false;
-  }
-
-  return CompleteRead();
-}
-int MockTCPClientSocket::Read(net::IOBuffer* buf, int buf_len,
-                              const net::CompletionCallback& callback) {
-  if (!connected_)
-    return net::ERR_UNEXPECTED;
-
-  // If the buffer is already in use, a read is already in progress!
-  DCHECK(pending_buf_ == NULL);
 
   // Store our async IO data.
   pending_buf_ = buf;
   pending_buf_len_ = buf_len;
   pending_callback_ = callback;
 
   if (need_read_data_) {
     read_data_ = data_->GetNextRead();
     if (read_data_.result == ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) {
       // This MockRead is just a marker to instruct us to set
       // peer_closed_connection_.  Skip it and get the next one.
       read_data_ = data_->GetNextRead();
       peer_closed_connection_ = true;
     }
     // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
     // to complete the async IO manually later (via OnReadComplete).
     if (read_data_.result == ERR_IO_PENDING) {
       // We need to be using async IO in this case.
       DCHECK(!callback.is_null());
       return ERR_IO_PENDING;
     }
     need_read_data_ = false;
   }
 
   return CompleteRead();
 }
 
-int MockTCPClientSocket::Write(net::IOBuffer* buf, int buf_len,
-                               net::OldCompletionCallback* callback) {
+int MockTCPClientSocket::Write(IOBuffer* buf, int buf_len,
+                               const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   if (!connected_)
-    return net::ERR_UNEXPECTED;
+    return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
-  net::MockWriteResult write_result = data_->OnWrite(data);
+  MockWriteResult write_result = data_->OnWrite(data);
 
   was_used_to_convey_data_ = true;
 
   if (write_result.async) {
     RunCallbackAsync(callback, write_result.result);
-    return net::ERR_IO_PENDING;
+    return ERR_IO_PENDING;
   }
 
   return write_result.result;
 }
 
-int MockTCPClientSocket::Connect(net::OldCompletionCallback* callback) {
+int MockTCPClientSocket::Connect(const CompletionCallback& callback) {
   if (connected_)
-    return net::OK;
+    return OK;
   connected_ = true;
   peer_closed_connection_ = false;
   if (data_->connect_data().async) {
     RunCallbackAsync(callback, data_->connect_data().result);
-    return net::ERR_IO_PENDING;
+    return ERR_IO_PENDING;
   }
   return data_->connect_data().result;
 }
-int MockTCPClientSocket::Connect(const net::CompletionCallback& callback) {
-  if (connected_)
-    return net::OK;
-
-  connected_ = true;
-  peer_closed_connection_ = false;
-  if (data_->connect_data().async) {
-    RunCallbackAsync(callback, data_->connect_data().result);
-    return net::ERR_IO_PENDING;
-  }
-
-  return data_->connect_data().result;
-}
 
 void MockTCPClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
-  old_pending_callback_ = NULL;
   pending_callback_.Reset();
 }
 
 bool MockTCPClientSocket::IsConnected() const {
   return connected_ && !peer_closed_connection_;
 }
 
 bool MockTCPClientSocket::IsConnectedAndIdle() const {
   return IsConnected();
 }
@@ skipping 31 matching lines @@
   // Since we've been waiting for data, need_read_data_ should be true.
   DCHECK(need_read_data_);
 
   read_data_ = data;
   need_read_data_ = false;
 
   // The caller is simulating that this IO completes right now.  Don't
   // let CompleteRead() schedule a callback.
   read_data_.async = false;
 
-  if (old_pending_callback_) {
-    net::OldCompletionCallback* callback = old_pending_callback_;
-    int rv = CompleteRead();
-    RunOldCallback(callback, rv);
-  } else {
-    net::CompletionCallback callback = pending_callback_;
-    int rv = CompleteRead();
-    RunCallback(callback, rv);
-  }
+  CompletionCallback callback = pending_callback_;
+  int rv = CompleteRead();
+  RunCallback(callback, rv);
 }
 
 int MockTCPClientSocket::CompleteRead() {
   DCHECK(pending_buf_);
   DCHECK(pending_buf_len_ > 0);
 
   was_used_to_convey_data_ = true;
 
   // Save the pending async IO data and reset our |pending_| state.
-  net::IOBuffer* buf = pending_buf_;
+  IOBuffer* buf = pending_buf_;
   int buf_len = pending_buf_len_;
-  net::OldCompletionCallback* old_callback = old_pending_callback_;
-  net::CompletionCallback callback = pending_callback_;
+  CompletionCallback callback = pending_callback_;
   pending_buf_ = NULL;
   pending_buf_len_ = 0;
-  old_pending_callback_ = NULL;
   pending_callback_.Reset();
 
   int result = read_data_.result;
   DCHECK(result != ERR_IO_PENDING);
 
   if (read_data_.data) {
     if (read_data_.data_len - read_offset_ > 0) {
       result = std::min(buf_len, read_data_.data_len - read_offset_);
       memcpy(buf->data(), read_data_.data + read_offset_, result);
       read_offset_ += result;
       num_bytes_read_ += result;
       if (read_offset_ == read_data_.data_len) {
         need_read_data_ = true;
         read_offset_ = 0;
       }
     } else {
       result = 0;  // EOF
     }
   }
 
   if (read_data_.async) {
-    DCHECK(old_callback || !callback.is_null());
-    if (old_callback)
-      RunCallbackAsync(old_callback, result);
-    else
-      RunCallbackAsync(callback, result);
-    return net::ERR_IO_PENDING;
+    DCHECK(!callback.is_null());
+    RunCallbackAsync(callback, result);
+    return ERR_IO_PENDING;
   }
   return result;
 }
 
 DeterministicMockTCPClientSocket::DeterministicMockTCPClientSocket(
-    net::NetLog* net_log, net::DeterministicSocketData* data)
+    net::NetLog* net_log, DeterministicSocketData* data)
     : MockClientSocket(net_log),
       write_pending_(false),
-      write_callback_(NULL),
       write_result_(0),
       read_data_(),
       read_buf_(NULL),
       read_buf_len_(0),
       read_pending_(false),
-      old_read_callback_(NULL),
       data_(data),
       was_used_to_convey_data_(false) {}
 
 DeterministicMockTCPClientSocket::~DeterministicMockTCPClientSocket() {}
 
 void DeterministicMockTCPClientSocket::CompleteWrite() {
   was_used_to_convey_data_ = true;
   write_pending_ = false;
-  write_callback_->Run(write_result_);
+  write_callback_.Run(write_result_);
 }
 
 int DeterministicMockTCPClientSocket::CompleteRead() {
   DCHECK_GT(read_buf_len_, 0);
   DCHECK_LE(read_data_.data_len, read_buf_len_);
   DCHECK(read_buf_);
 
   was_used_to_convey_data_ = true;
 
   if (read_data_.result == ERR_IO_PENDING)
     read_data_ = data_->GetNextRead();
   DCHECK_NE(ERR_IO_PENDING, read_data_.result);
   // If read_data_.async is true, we do not need to wait, since this is already
   // the callback. Therefore we don't even bother to check it.
   int result = read_data_.result;
 
   if (read_data_.data_len > 0) {
     DCHECK(read_data_.data);
     result = std::min(read_buf_len_, read_data_.data_len);
     memcpy(read_buf_->data(), read_data_.data, result);
   }
 
   if (read_pending_) {
     read_pending_ = false;
-    if (old_read_callback_)
-      old_read_callback_->Run(result);
-    else
-      read_callback_.Run(result);
+    read_callback_.Run(result);
   }
 
   return result;
 }
 
 int DeterministicMockTCPClientSocket::Write(
-    net::IOBuffer* buf, int buf_len, net::OldCompletionCallback* callback) {
+    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   if (!connected_)
-    return net::ERR_UNEXPECTED;
+    return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
-  net::MockWriteResult write_result = data_->OnWrite(data);
+  MockWriteResult write_result = data_->OnWrite(data);
 
   if (write_result.async) {
     write_callback_ = callback;
     write_result_ = write_result.result;
-    DCHECK(write_callback_ != NULL);
+    DCHECK(!write_callback_.is_null());
     write_pending_ = true;
-    return net::ERR_IO_PENDING;
+    return ERR_IO_PENDING;
   }
 
   was_used_to_convey_data_ = true;
   write_pending_ = false;
   return write_result.result;
 }
 
 int DeterministicMockTCPClientSocket::Read(
-    net::IOBuffer* buf, int buf_len, net::OldCompletionCallback* callback) {
+    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
   if (!connected_)
-    return net::ERR_UNEXPECTED;
+    return ERR_UNEXPECTED;
 
   read_data_ = data_->GetNextRead();
   // The buffer should always be big enough to contain all the MockRead data. To
-  // use small buffers, split the data into multiple MockReads.
-  DCHECK_LE(read_data_.data_len, buf_len);
-
-  read_buf_ = buf;
-  read_buf_len_ = buf_len;
-  old_read_callback_ = callback;
-
-  if (read_data_.async || (read_data_.result == ERR_IO_PENDING)) {
-    read_pending_ = true;
-    DCHECK(old_read_callback_);
-    return ERR_IO_PENDING;
-  }
-
-  was_used_to_convey_data_ = true;
-  return CompleteRead();
-}
-int DeterministicMockTCPClientSocket::Read(
-    net::IOBuffer* buf, int buf_len, const net::CompletionCallback& callback) {
-  if (!connected_)
-    return net::ERR_UNEXPECTED;
-
-  read_data_ = data_->GetNextRead();
-  // The buffer should always be big enough to contain all the MockRead data. To
   // use small buffers, split the data into multiple MockReads.
   DCHECK_LE(read_data_.data_len, buf_len);
 
   read_buf_ = buf;
   read_buf_len_ = buf_len;
   read_callback_ = callback;
 
   if (read_data_.async || (read_data_.result == ERR_IO_PENDING)) {
     read_pending_ = true;
     DCHECK(!read_callback_.is_null());
     return ERR_IO_PENDING;
   }
 
   was_used_to_convey_data_ = true;
   return CompleteRead();
 }
 
 // TODO(erikchen): Support connect sequencing.
 int DeterministicMockTCPClientSocket::Connect(
-    net::OldCompletionCallback* callback) {
+    const CompletionCallback& callback) {
   if (connected_)
-    return net::OK;
+    return OK;
   connected_ = true;
   if (data_->connect_data().async) {
     RunCallbackAsync(callback, data_->connect_data().result);
-    return net::ERR_IO_PENDING;
+    return ERR_IO_PENDING;
   }
   return data_->connect_data().result;
 }
-int DeterministicMockTCPClientSocket::Connect(
-    const net::CompletionCallback& callback) {
-  if (connected_)
-    return net::OK;
 
-  connected_ = true;
-  if (data_->connect_data().async) {
-    RunCallbackAsync(callback, data_->connect_data().result);
-    return net::ERR_IO_PENDING;
-  }
-
-  return data_->connect_data().result;
-}
-
 void DeterministicMockTCPClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
 }
 
 bool DeterministicMockTCPClientSocket::IsConnected() const {
   return connected_;
 }
 
 bool DeterministicMockTCPClientSocket::IsConnectedAndIdle() const {
   return IsConnected();
@@ skipping 10 matching lines @@
 int64 DeterministicMockTCPClientSocket::NumBytesRead() const {
   return -1;
 }
 
 base::TimeDelta DeterministicMockTCPClientSocket::GetConnectTimeMicros() const {
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
 void DeterministicMockTCPClientSocket::OnReadComplete(const MockRead& data) {}
 
-class MockSSLClientSocket::OldConnectCallback
-    : public net::OldCompletionCallbackImpl<
-          MockSSLClientSocket::OldConnectCallback> {
- public:
-  OldConnectCallback(MockSSLClientSocket *ssl_client_socket,
-                     net::OldCompletionCallback* user_callback,
-                     int rv)
-      : ALLOW_THIS_IN_INITIALIZER_LIST(
-          net::OldCompletionCallbackImpl<
-              MockSSLClientSocket::OldConnectCallback>(
-                  this, &OldConnectCallback::Wrapper)),
-        ssl_client_socket_(ssl_client_socket),
-        user_callback_(user_callback),
-        rv_(rv) {
-  }
-
- private:
-  void Wrapper(int rv) {
-    if (rv_ == net::OK)
-      ssl_client_socket_->connected_ = true;
-    user_callback_->Run(rv_);
-    delete this;
-  }
-
-  MockSSLClientSocket* ssl_client_socket_;
-  net::OldCompletionCallback* user_callback_;
-  int rv_;
-};
-class MockSSLClientSocket::ConnectCallback {
- public:
-  ConnectCallback(MockSSLClientSocket *ssl_client_socket,
-                  const CompletionCallback& user_callback,
-                  int rv)
-      : ALLOW_THIS_IN_INITIALIZER_LIST(callback_(
-          base::Bind(&ConnectCallback::Wrapper, base::Unretained(this)))),
-        ssl_client_socket_(ssl_client_socket),
-        user_callback_(user_callback),
-        rv_(rv) {
-  }
-
-  const CompletionCallback& callback() const { return callback_; }
-
- private:
-  void Wrapper(int rv) {
-    if (rv_ == net::OK)
-      ssl_client_socket_->connected_ = true;
-    user_callback_.Run(rv_);
-  }
-
-  CompletionCallback callback_;
-  MockSSLClientSocket* ssl_client_socket_;
-  CompletionCallback user_callback_;
-  int rv_;
-};
+// static
+void MockSSLClientSocket::ConnectCallback(
+    MockSSLClientSocket *ssl_client_socket,
+    const CompletionCallback& callback,
+    int rv) {
+  if (rv == OK)
+    ssl_client_socket->connected_ = true;
+  callback.Run(rv);
+}
 
 MockSSLClientSocket::MockSSLClientSocket(
-    net::ClientSocketHandle* transport_socket,
+    ClientSocketHandle* transport_socket,
     const HostPortPair& host_port_pair,
-    const net::SSLConfig& ssl_config,
+    const SSLConfig& ssl_config,
     SSLHostInfo* ssl_host_info,
-    net::SSLSocketDataProvider* data)
+    SSLSocketDataProvider* data)
     : MockClientSocket(transport_socket->socket()->NetLog().net_log()),
       transport_(transport_socket),
       data_(data),
       is_npn_state_set_(false),
       new_npn_value_(false) {
   DCHECK(data_);
   delete ssl_host_info;  // we take ownership but don't use it.
 }
 
 MockSSLClientSocket::~MockSSLClientSocket() {
   Disconnect();
 }
 
-int MockSSLClientSocket::Read(net::IOBuffer* buf, int buf_len,
-                              net::OldCompletionCallback* callback) {
-  return transport_->socket()->Read(buf, buf_len, callback);
-}
-int MockSSLClientSocket::Read(net::IOBuffer* buf, int buf_len,
-                              const net::CompletionCallback& callback) {
+int MockSSLClientSocket::Read(IOBuffer* buf, int buf_len,
+                              const CompletionCallback& callback) {
   return transport_->socket()->Read(buf, buf_len, callback);
 }
 
-int MockSSLClientSocket::Write(net::IOBuffer* buf, int buf_len,
-                               net::OldCompletionCallback* callback) {
+int MockSSLClientSocket::Write(IOBuffer* buf, int buf_len,
+                               const CompletionCallback& callback) {
   return transport_->socket()->Write(buf, buf_len, callback);
 }
 
-int MockSSLClientSocket::Connect(net::OldCompletionCallback* callback) {
-  OldConnectCallback* connect_callback = new OldConnectCallback(
-      this, callback, data_->connect.result);
-  int rv = transport_->socket()->Connect(connect_callback);
-  if (rv == net::OK) {
-    delete connect_callback;
-    if (data_->connect.result == net::OK)
+int MockSSLClientSocket::Connect(const CompletionCallback& callback) {
+  int rv = transport_->socket()->Connect(
+      base::Bind(&ConnectCallback, base::Unretained(this), callback));
+  if (rv == OK) {
+    if (data_->connect.result == OK)
       connected_ = true;
     if (data_->connect.async) {
       RunCallbackAsync(callback, data_->connect.result);
-      return net::ERR_IO_PENDING;
+      return ERR_IO_PENDING;
     }
     return data_->connect.result;
   }
-  return rv;
-}
-int MockSSLClientSocket::Connect(const net::CompletionCallback& callback) {
-  ConnectCallback connect_callback(this, callback, data_->connect.result);
-  int rv = transport_->socket()->Connect(connect_callback.callback());
-  if (rv == net::OK) {
-    if (data_->connect.result == net::OK)
-      connected_ = true;
-    if (data_->connect.async) {
-      RunCallbackAsync(callback, data_->connect.result);
-      return net::ERR_IO_PENDING;
-    }
-    return data_->connect.result;
-  }
   return rv;
 }
 
 void MockSSLClientSocket::Disconnect() {
   MockClientSocket::Disconnect();
   if (transport_->socket() != NULL)
     transport_->socket()->Disconnect();
 }
 
 bool MockSSLClientSocket::IsConnected() const {
   return transport_->socket()->IsConnected();
 }
 
 bool MockSSLClientSocket::WasEverUsed() const {
   return transport_->socket()->WasEverUsed();
 }
 
 bool MockSSLClientSocket::UsingTCPFastOpen() const {
   return transport_->socket()->UsingTCPFastOpen();
 }
 
 int64 MockSSLClientSocket::NumBytesRead() const {
   return -1;
 }
 
 base::TimeDelta MockSSLClientSocket::GetConnectTimeMicros() const {
   return base::TimeDelta::FromMicroseconds(-1);
 }
 
-void MockSSLClientSocket::GetSSLInfo(net::SSLInfo* ssl_info) {
+void MockSSLClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   ssl_info->Reset();
   ssl_info->cert = data_->cert;
   ssl_info->client_cert_sent = data_->client_cert_sent;
 }
 
 void MockSSLClientSocket::GetSSLCertRequestInfo(
-    net::SSLCertRequestInfo* cert_request_info) {
+    SSLCertRequestInfo* cert_request_info) {
   DCHECK(cert_request_info);
   if (data_->cert_request_info) {
     cert_request_info->host_and_port =
         data_->cert_request_info->host_and_port;
     cert_request_info->client_certs = data_->cert_request_info->client_certs;
   } else {
     cert_request_info->Reset();
   }
 }
 
@@ skipping 17 matching lines @@
 
 void MockSSLClientSocket::OnReadComplete(const MockRead& data) {
   NOTIMPLEMENTED();
 }
 
 MockUDPClientSocket::MockUDPClientSocket(SocketDataProvider* data,
                                          net::NetLog* net_log)
     : connected_(false),
       data_(data),
       read_offset_(0),
-      read_data_(false, net::ERR_UNEXPECTED),
+      read_data_(false, ERR_UNEXPECTED),
       need_read_data_(true),
       pending_buf_(NULL),
       pending_buf_len_(0),
-      old_pending_callback_(NULL),
-      net_log_(NetLog::Source(), net_log),
+      net_log_(net::NetLog::Source(), net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(data_);
   data_->Reset();
 }
 
 MockUDPClientSocket::~MockUDPClientSocket() {}
 
-int MockUDPClientSocket::Read(net::IOBuffer* buf, int buf_len,
-                              net::OldCompletionCallback* callback) {
+int MockUDPClientSocket::Read(IOBuffer* buf, int buf_len,
+                              const CompletionCallback& callback) {
   if (!connected_)
-    return net::ERR_UNEXPECTED;
+    return ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
   DCHECK(pending_buf_ == NULL);
-
-  // Store our async IO data.
-  pending_buf_ = buf;
-  pending_buf_len_ = buf_len;
-  old_pending_callback_ = callback;
-
-  if (need_read_data_) {
-    read_data_ = data_->GetNextRead();
-    // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
-    // to complete the async IO manually later (via OnReadComplete).
-    if (read_data_.result == ERR_IO_PENDING) {
-      DCHECK(callback);  // We need to be using async IO in this case.
-      return ERR_IO_PENDING;
-    }
-    need_read_data_ = false;
-  }
-
-  return CompleteRead();
-}
-int MockUDPClientSocket::Read(net::IOBuffer* buf, int buf_len,
-                              const net::CompletionCallback& callback) {
-  if (!connected_)
-    return net::ERR_UNEXPECTED;
-
-  // If the buffer is already in use, a read is already in progress!
-  DCHECK(pending_buf_ == NULL);
 
   // Store our async IO data.
   pending_buf_ = buf;
   pending_buf_len_ = buf_len;
   pending_callback_ = callback;
 
   if (need_read_data_) {
     read_data_ = data_->GetNextRead();
     // ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
     // to complete the async IO manually later (via OnReadComplete).
     if (read_data_.result == ERR_IO_PENDING) {
       // We need to be using async IO in this case.
       DCHECK(!callback.is_null());
       return ERR_IO_PENDING;
     }
     need_read_data_ = false;
   }
 
   return CompleteRead();
 }
 
-int MockUDPClientSocket::Write(net::IOBuffer* buf, int buf_len,
-                               net::OldCompletionCallback* callback) {
+int MockUDPClientSocket::Write(IOBuffer* buf, int buf_len,
+                               const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   if (!connected_)
     return ERR_UNEXPECTED;
 
   std::string data(buf->data(), buf_len);
   MockWriteResult write_result = data_->OnWrite(data);
 
   if (write_result.async) {
@@ skipping 42 matching lines @@
   // Since we've been waiting for data, need_read_data_ should be true.
   DCHECK(need_read_data_);
 
   read_data_ = data;
   need_read_data_ = false;
 
   // The caller is simulating that this IO completes right now.  Don't
   // let CompleteRead() schedule a callback.
   read_data_.async = false;
 
-  if (old_pending_callback_) {
-    net::OldCompletionCallback* callback = old_pending_callback_;
-    int rv = CompleteRead();
-    RunOldCallback(callback, rv);
-  } else {
-    net::CompletionCallback callback = pending_callback_;
-    int rv = CompleteRead();
-    RunCallback(callback, rv);
-  }
+  net::CompletionCallback callback = pending_callback_;
+  int rv = CompleteRead();
+  RunCallback(callback, rv);
 }
 
 int MockUDPClientSocket::CompleteRead() {
   DCHECK(pending_buf_);
   DCHECK(pending_buf_len_ > 0);
 
   // Save the pending async IO data and reset our |pending_| state.
-  net::IOBuffer* buf = pending_buf_;
+  IOBuffer* buf = pending_buf_;
   int buf_len = pending_buf_len_;
-  net::OldCompletionCallback* old_callback = old_pending_callback_;
-  net::CompletionCallback callback = pending_callback_;
+  CompletionCallback callback = pending_callback_;
   pending_buf_ = NULL;
   pending_buf_len_ = 0;
-  old_pending_callback_ = NULL;
-  pending_callback_.Reset();
   pending_callback_.Reset();
 
   int result = read_data_.result;
   DCHECK(result != ERR_IO_PENDING);
 
   if (read_data_.data) {
     if (read_data_.data_len - read_offset_ > 0) {
       result = std::min(buf_len, read_data_.data_len - read_offset_);
       memcpy(buf->data(), read_data_.data + read_offset_, result);
       read_offset_ += result;
       if (read_offset_ == read_data_.data_len) {
         need_read_data_ = true;
         read_offset_ = 0;
       }
     } else {
       result = 0;  // EOF
     }
   }
 
   if (read_data_.async) {
-    DCHECK(old_callback || !callback.is_null());
-    if (old_callback)
-      RunCallbackAsync(old_callback, result);
-    else
-      RunCallbackAsync(callback, result);
-    return net::ERR_IO_PENDING;
+    DCHECK(!callback.is_null());
+    RunCallbackAsync(callback, result);
+    return ERR_IO_PENDING;
   }
   return result;
 }
 
-void MockUDPClientSocket::RunCallbackAsync(net::OldCompletionCallback* callback,
+void MockUDPClientSocket::RunCallbackAsync(const CompletionCallback& callback,
                                            int result) {
-  MessageLoop::current()->PostTask(FROM_HERE,
-      base::Bind(&MockUDPClientSocket::RunOldCallback,
-                 weak_factory_.GetWeakPtr(), callback, result));
-}
-void MockUDPClientSocket::RunCallbackAsync(
-    const net::CompletionCallback& callback, int result) {
-  MessageLoop::current()->PostTask(FROM_HERE,
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
       base::Bind(&MockUDPClientSocket::RunCallback, weak_factory_.GetWeakPtr(),
                  callback, result));
 }
 
-void MockUDPClientSocket::RunOldCallback(net::OldCompletionCallback* callback,
-                                      int result) {
-  if (callback)
-    callback->Run(result);
-}
-void MockUDPClientSocket::RunCallback(const net::CompletionCallback& callback,
+void MockUDPClientSocket::RunCallback(const CompletionCallback& callback,
                                       int result) {
   if (!callback.is_null())
     callback.Run(result);
 }
 
 TestSocketRequest::TestSocketRequest(
     std::vector<TestSocketRequest*>* request_order,
     size_t* completion_count)
     : request_order_(request_order),
       completion_count_(completion_count) {
@@ skipping 52 matching lines @@
 void ClientSocketPoolTest::ReleaseAllConnections(KeepAlive keep_alive) {
   bool released_one;
   do {
     released_one = ReleaseOneConnection(keep_alive);
   } while (released_one);
 }
 
 MockTransportClientSocketPool::MockConnectJob::MockConnectJob(
     StreamSocket* socket,
     ClientSocketHandle* handle,
-    OldCompletionCallback* callback)
+    const CompletionCallback& callback)
     : socket_(socket),
       handle_(handle),
-      user_callback_(callback),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          connect_callback_(this, &MockConnectJob::OnConnect)) {
+      user_callback_(callback) {
 }
 
 MockTransportClientSocketPool::MockConnectJob::~MockConnectJob() {}
 
 int MockTransportClientSocketPool::MockConnectJob::Connect() {
-  int rv = socket_->Connect(&connect_callback_);
+  int rv = socket_->Connect(base::Bind(&MockConnectJob::OnConnect,
+                                       base::Unretained(this)));
   if (rv == OK) {
-    user_callback_ = NULL;
+    user_callback_.Reset();
     OnConnect(OK);
   }
   return rv;
 }
 
 bool MockTransportClientSocketPool::MockConnectJob::CancelHandle(
     const ClientSocketHandle* handle) {
   if (handle != handle_)
     return false;
   socket_.reset();
   handle_ = NULL;
-  user_callback_ = NULL;
+  user_callback_.Reset();
   return true;
 }
 
 void MockTransportClientSocketPool::MockConnectJob::OnConnect(int rv) {
   if (!socket_.get())
     return;
   if (rv == OK) {
     handle_->set_socket(socket_.release());
   } else {
     socket_.reset();
   }
 
   handle_ = NULL;
 
-  if (user_callback_) {
-    OldCompletionCallback* callback = user_callback_;
-    user_callback_ = NULL;
-    callback->Run(rv);
+  if (!user_callback_.is_null()) {
+    CompletionCallback callback = user_callback_;
+    user_callback_.Reset();
+    callback.Run(rv);
   }
 }
 
 MockTransportClientSocketPool::MockTransportClientSocketPool(
     int max_sockets,
     int max_sockets_per_group,
     ClientSocketPoolHistograms* histograms,
     ClientSocketFactory* socket_factory)
     : TransportClientSocketPool(max_sockets, max_sockets_per_group, histograms,
                                 NULL, NULL, NULL),
       client_socket_factory_(socket_factory),
       release_count_(0),
       cancel_count_(0) {
 }
 
 MockTransportClientSocketPool::~MockTransportClientSocketPool() {}
 
-int MockTransportClientSocketPool::RequestSocket(const std::string& group_name,
-                                           const void* socket_params,
-                                           RequestPriority priority,
-                                           ClientSocketHandle* handle,
-                                           OldCompletionCallback* callback,
-                                           const BoundNetLog& net_log) {
+int MockTransportClientSocketPool::RequestSocket(
+    const std::string& group_name,
+    const void* socket_params,
+    RequestPriority priority,
+    ClientSocketHandle* handle,
+    OldCompletionCallback* callback,
+    const BoundNetLog& net_log) {
   StreamSocket* socket = client_socket_factory_->CreateTransportClientSocket(
       AddressList(), net_log.net_log(), net::NetLog::Source());
-  MockConnectJob* job = new MockConnectJob(socket, handle, callback);
+  CompletionCallback cb;
+  if (callback) {
+    cb = base::Bind(&OldCompletionCallback::Run<int>,
+                    base::Unretained(callback));
+  }
+  MockConnectJob* job = new MockConnectJob(socket, handle, cb);
   job_list_.push_back(job);
   handle->set_pool_id(1);
   return job->Connect();
 }
 
 void MockTransportClientSocketPool::CancelRequest(const std::string& group_name,
                                             ClientSocketHandle* handle) {
   std::vector<MockConnectJob*>::iterator i;
   for (i = job_list_.begin(); i != job_list_.end(); ++i) {
     if ((*i)->CancelHandle(handle)) {
@@ skipping 32 matching lines @@
 MockSSLClientSocket* DeterministicMockClientSocketFactory::
     GetMockSSLClientSocket(size_t index) const {
   DCHECK_LT(index, ssl_client_sockets_.size());
   return ssl_client_sockets_[index];
 }
 
 DatagramClientSocket*
 DeterministicMockClientSocketFactory::CreateDatagramClientSocket(
     DatagramSocket::BindType bind_type,
     const RandIntCallback& rand_int_cb,
-    NetLog* net_log,
+    net::NetLog* net_log,
     const NetLog::Source& source) {
   NOTREACHED();
   return NULL;
 }
 
 StreamSocket* DeterministicMockClientSocketFactory::CreateTransportClientSocket(
     const AddressList& addresses,
     net::NetLog* net_log,
     const net::NetLog::Source& source) {
   DeterministicSocketData* data_provider = mock_data().GetNext();
@@ skipping 65 matching lines @@
 
 const char kSOCKS5OkRequest[] =
     { 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
 const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
 
 const char kSOCKS5OkResponse[] =
     { 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
 const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
 
 }  // namespace net