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

net/socket/socks_client_socket_unittest.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/socks_client_socket.h"
 
 #include "net/base/address_list.h"
 #include "net/base/net_log.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/mock_host_resolver.h"
@@ skipping 20 matching lines @@
                                      MockWrite writes[], size_t writes_count,
                                      HostResolver* host_resolver,
                                      const std::string& hostname, int port,
                                      NetLog* net_log);
   virtual void SetUp();
 
  protected:
   scoped_ptr<SOCKSClientSocket> user_sock_;
   AddressList address_list_;
   StreamSocket* tcp_sock_;
-  TestOldCompletionCallback callback_;
+  TestCompletionCallback callback_;
   scoped_ptr<MockHostResolver> host_resolver_;
   scoped_ptr<SocketDataProvider> data_;
 };
 
 SOCKSClientSocketTest::SOCKSClientSocketTest()
   : host_resolver_(new MockHostResolver) {
 }
 
 // Set up platform before every test case
 void SOCKSClientSocketTest::SetUp() {
   PlatformTest::SetUp();
 }
 
 SOCKSClientSocket* SOCKSClientSocketTest::BuildMockSocket(
     MockRead reads[],
     size_t reads_count,
     MockWrite writes[],
     size_t writes_count,
     HostResolver* host_resolver,
     const std::string& hostname,
     int port,
     NetLog* net_log) {
 
-  TestOldCompletionCallback callback;
+  TestCompletionCallback callback;
   data_.reset(new StaticSocketDataProvider(reads, reads_count,
                                            writes, writes_count));
   tcp_sock_ = new MockTCPClientSocket(address_list_, net_log, data_.get());
 
-  int rv = tcp_sock_->Connect(&callback);
+  int rv = tcp_sock_->Connect(callback.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(tcp_sock_->IsConnected());
 
   return new SOCKSClientSocket(tcp_sock_,
       HostResolver::RequestInfo(HostPortPair(hostname, port)),
       host_resolver);
 }
 
@@ skipping 56 matching lines @@
   user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes),
                                    host_resolver_.get(),
                                    "localhost", 80,
                                    &log));
 
   // At this state the TCP connection is completed but not the SOCKS handshake.
   EXPECT_TRUE(tcp_sock_->IsConnected());
   EXPECT_FALSE(user_sock_->IsConnected());
 
-  int rv = user_sock_->Connect(&callback_);
+  int rv = user_sock_->Connect(callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   EXPECT_TRUE(
       LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKS_CONNECT));
   EXPECT_FALSE(user_sock_->IsConnected());
 
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
   log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEndEvent(
       entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 
   scoped_refptr<IOBuffer> buffer(new IOBuffer(payload_write.size()));
   memcpy(buffer->data(), payload_write.data(), payload_write.size());
-  rv = user_sock_->Write(buffer, payload_write.size(), &callback_);
+  rv = user_sock_->Write(buffer, payload_write.size(), callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback_.WaitForResult();
   EXPECT_EQ(static_cast<int>(payload_write.size()), rv);
 
   buffer = new IOBuffer(payload_read.size());
-  rv = user_sock_->Read(buffer, payload_read.size(), &callback_);
+  rv = user_sock_->Read(buffer, payload_read.size(), callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback_.WaitForResult();
   EXPECT_EQ(static_cast<int>(payload_read.size()), rv);
   EXPECT_EQ(payload_read, std::string(buffer->data(), payload_read.size()));
 
   user_sock_->Disconnect();
   EXPECT_FALSE(tcp_sock_->IsConnected());
   EXPECT_FALSE(user_sock_->IsConnected());
 }
 
@@ skipping 24 matching lines @@
     MockRead data_reads[] = {
         MockRead(false, tests[i].fail_reply, arraysize(tests[i].fail_reply)) };
     CapturingNetLog log(CapturingNetLog::kUnbounded);
 
     user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                      data_writes, arraysize(data_writes),
                                      host_resolver_.get(),
                                      "localhost", 80,
                                      &log));
 
-    int rv = user_sock_->Connect(&callback_);
+    int rv = user_sock_->Connect(callback_.callback());
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     net::CapturingNetLog::EntryList entries;
     log.GetEntries(&entries);
     EXPECT_TRUE(LogContainsBeginEvent(
         entries, 0, NetLog::TYPE_SOCKS_CONNECT));
 
     rv = callback_.WaitForResult();
     EXPECT_EQ(tests[i].fail_code, rv);
     EXPECT_FALSE(user_sock_->IsConnected());
@@ skipping 16 matching lines @@
       MockRead(true, kSOCKSPartialReply1, arraysize(kSOCKSPartialReply1)),
       MockRead(true, kSOCKSPartialReply2, arraysize(kSOCKSPartialReply2)) };
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes),
                                    host_resolver_.get(),
                                    "localhost", 80,
                                    &log));
 
-  int rv = user_sock_->Connect(&callback_);
+  int rv = user_sock_->Connect(callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_SOCKS_CONNECT));
 
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
   log.GetEntries(&entries);
@@ skipping 17 matching lines @@
   MockRead data_reads[] = {
       MockRead(true, kSOCKSOkReply, arraysize(kSOCKSOkReply)) };
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes),
                                    host_resolver_.get(),
                                    "localhost", 80,
                                    &log));
 
-  int rv = user_sock_->Connect(&callback_);
+  int rv = user_sock_->Connect(callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_SOCKS_CONNECT));
 
   rv = callback_.WaitForResult();
   EXPECT_EQ(OK, rv);
   EXPECT_TRUE(user_sock_->IsConnected());
   log.GetEntries(&entries);
@@ skipping 11 matching lines @@
       // close connection unexpectedly
       MockRead(false, 0) };
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes),
                                    host_resolver_.get(),
                                    "localhost", 80,
                                    &log));
 
-  int rv = user_sock_->Connect(&callback_);
+  int rv = user_sock_->Connect(callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_SOCKS_CONNECT));
 
   rv = callback_.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
   EXPECT_FALSE(user_sock_->IsConnected());
   log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsEndEvent(
       entries, -1, NetLog::TYPE_SOCKS_CONNECT));
 }
 
 // Tries to connect to an unknown hostname. Should fail rather than
 // falling back to SOCKS4a.
 TEST_F(SOCKSClientSocketTest, FailedDNS) {
   const char hostname[] = "unresolved.ipv4.address";
 
   host_resolver_->rules()->AddSimulatedFailure(hostname);
 
   CapturingNetLog log(CapturingNetLog::kUnbounded);
 
   user_sock_.reset(BuildMockSocket(NULL, 0,
                                    NULL, 0,
                                    host_resolver_.get(),
                                    hostname, 80,
                                    &log));
 
-  int rv = user_sock_->Connect(&callback_);
+  int rv = user_sock_->Connect(callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   net::CapturingNetLog::EntryList entries;
   log.GetEntries(&entries);
   EXPECT_TRUE(LogContainsBeginEvent(
       entries, 0, NetLog::TYPE_SOCKS_CONNECT));
 
   rv = callback_.WaitForResult();
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
   EXPECT_FALSE(user_sock_->IsConnected());
   log.GetEntries(&entries);
@@ skipping 11 matching lines @@
   MockWrite data_writes[] = { MockWrite(false, "", 0) };
   MockRead data_reads[] = { MockRead(false, "", 0) };
 
   user_sock_.reset(BuildMockSocket(data_reads, arraysize(data_reads),
                                    data_writes, arraysize(data_writes),
                                    hanging_resolver.get(),
                                    "foo", 80,
                                    NULL));
 
   // Start connecting (will get stuck waiting for the host to resolve).
-  int rv = user_sock_->Connect(&callback_);
+  int rv = user_sock_->Connect(callback_.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   EXPECT_FALSE(user_sock_->IsConnected());
   EXPECT_FALSE(user_sock_->IsConnectedAndIdle());
 
   // The host resolver should have received the resolve request.
   EXPECT_TRUE(hanging_resolver->HasOutstandingRequest());
 
   // Disconnect the SOCKS socket -- this should cancel the outstanding resolve.
   user_sock_->Disconnect();
 
   EXPECT_FALSE(hanging_resolver->HasOutstandingRequest());
 
   EXPECT_FALSE(user_sock_->IsConnected());
   EXPECT_FALSE(user_sock_->IsConnectedAndIdle());
 }
 
 }  // namespace net