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

net/ftp/ftp_network_transaction_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/ftp/ftp_network_transaction.h"
 
 #include "build/build_config.h"
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
@@ skipping 764 matching lines @@
       MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(mock_data.c_str()),
     };
     StaticSocketDataProvider data_socket(data_reads, arraysize(data_reads),
                                          NULL, 0);
     mock_socket_factory_.AddSocketDataProvider(ctrl_socket);
     mock_socket_factory_.AddSocketDataProvider(&data_socket);
     FtpRequestInfo request_info = GetRequestInfo(request);
     EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
     ASSERT_EQ(ERR_IO_PENDING,
-              transaction_.Start(&request_info, &callback_, BoundNetLog()));
+              transaction_.Start(&request_info, callback_.callback(),
+                                 BoundNetLog()));
     EXPECT_NE(LOAD_STATE_IDLE, transaction_.GetLoadState());
     ASSERT_EQ(expected_result, callback_.WaitForResult());
     if (expected_result == OK) {
       scoped_refptr<IOBuffer> io_buffer(new IOBuffer(kBufferSize));
       memset(io_buffer->data(), 0, kBufferSize);
       ASSERT_EQ(ERR_IO_PENDING,
-                transaction_.Read(io_buffer.get(), kBufferSize, &callback_));
+                transaction_.Read(io_buffer.get(), kBufferSize,
+                                  callback_.callback()));
       ASSERT_EQ(static_cast<int>(mock_data.length()),
                 callback_.WaitForResult());
       EXPECT_EQ(mock_data, std::string(io_buffer->data(), mock_data.length()));
 
       // Do another Read to detect that the data socket is now closed.
-      int rv = transaction_.Read(io_buffer.get(), kBufferSize, &callback_);
+      int rv = transaction_.Read(io_buffer.get(), kBufferSize,
+                                 callback_.callback());
       if (rv == ERR_IO_PENDING) {
         EXPECT_EQ(0, callback_.WaitForResult());
       } else {
         EXPECT_EQ(0, rv);
       }
     }
     EXPECT_EQ(FtpSocketDataProvider::QUIT, ctrl_socket->state());
     EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
   }
 
   void TransactionFailHelper(FtpSocketDataProvider* ctrl_socket,
                              const char* request,
                              FtpSocketDataProvider::State state,
                              FtpSocketDataProvider::State next_state,
                              const char* response,
                              int expected_result) {
     ctrl_socket->InjectFailure(state, next_state, response);
     ExecuteTransaction(ctrl_socket, request, expected_result);
   }
 
   scoped_ptr<MockHostResolver> host_resolver_;
   scoped_refptr<FtpNetworkSession> session_;
   MockClientSocketFactory mock_socket_factory_;
   FtpNetworkTransaction transaction_;
-  TestOldCompletionCallback callback_;
+  TestCompletionCallback callback_;
 };
 
 TEST_F(FtpNetworkTransactionTest, FailedLookup) {
   FtpRequestInfo request_info = GetRequestInfo("ftp://badhost");
   host_resolver_->rules()->AddSimulatedFailure("badhost");
   EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
   ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, &callback_, BoundNetLog()));
+            transaction_.Start(&request_info, callback_.callback(),
+                               BoundNetLog()));
   ASSERT_EQ(ERR_NAME_NOT_RESOLVED, callback_.WaitForResult());
   EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
 }
 
 // Check that when determining the host, the square brackets decorating IPv6
 // literals in URLs are stripped.
 TEST_F(FtpNetworkTransactionTest, StripBracketsFromIPv6Literals) {
   host_resolver_->rules()->AddSimulatedFailure("[::1]");
 
   // We start a transaction that is expected to fail with ERR_INVALID_RESPONSE.
@@ skipping 202 matching lines @@
     MockRead(mock_data.c_str()),
   };
   StaticSocketDataProvider data_socket1(data_reads, arraysize(data_reads),
                                         NULL, 0);
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket);
   mock_socket_factory_.AddSocketDataProvider(&data_socket1);
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   // Start the transaction.
   ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, &callback_, BoundNetLog()));
+            transaction_.Start(&request_info, callback_.callback(),
+                               BoundNetLog()));
   ASSERT_EQ(OK, callback_.WaitForResult());
 
   // The transaction fires the callback when we can start reading data. That
   // means that the data socket should be open.
   MockTCPClientSocket* data_socket =
       mock_socket_factory_.GetMockTCPClientSocket(1);
   ASSERT_TRUE(data_socket);
   ASSERT_TRUE(data_socket->IsConnected());
 
   // Even if the PASV response specified some other address, we connect
@@ skipping 103 matching lines @@
 TEST_F(FtpNetworkTransactionTest, EvilRestartUser) {
   FtpSocketDataProvider ctrl_socket1;
   ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD,
                              FtpSocketDataProvider::PRE_QUIT,
                              "530 Login authentication failed\r\n");
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1);
 
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, &callback_, BoundNetLog()));
+            transaction_.Start(&request_info, callback_.callback(),
+                               BoundNetLog()));
   ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult());
 
   MockRead ctrl_reads[] = {
     MockRead("220 host TestFTPd\r\n"),
     MockRead("221 Goodbye!\r\n"),
     MockRead(false, OK),
   };
   MockWrite ctrl_writes[] = {
     MockWrite("QUIT\r\n"),
   };
   StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads),
                                         ctrl_writes, arraysize(ctrl_writes));
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2);
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.RestartWithAuth(
                 AuthCredentials(
                     ASCIIToUTF16("foo\nownz0red"),
                     ASCIIToUTF16("innocent")),
-                &callback_));
+                callback_.callback()));
   EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult());
 }
 
 TEST_F(FtpNetworkTransactionTest, EvilRestartPassword) {
   FtpSocketDataProvider ctrl_socket1;
   ctrl_socket1.InjectFailure(FtpSocketDataProvider::PRE_PASSWD,
                              FtpSocketDataProvider::PRE_QUIT,
                              "530 Login authentication failed\r\n");
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket1);
 
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, &callback_, BoundNetLog()));
+            transaction_.Start(&request_info, callback_.callback(),
+                               BoundNetLog()));
   ASSERT_EQ(ERR_FTP_FAILED, callback_.WaitForResult());
 
   MockRead ctrl_reads[] = {
     MockRead("220 host TestFTPd\r\n"),
     MockRead("331 User okay, send password\r\n"),
     MockRead("221 Goodbye!\r\n"),
     MockRead(false, OK),
   };
   MockWrite ctrl_writes[] = {
     MockWrite("USER innocent\r\n"),
     MockWrite("QUIT\r\n"),
   };
   StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads),
                                         ctrl_writes, arraysize(ctrl_writes));
   mock_socket_factory_.AddSocketDataProvider(&ctrl_socket2);
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.RestartWithAuth(
                 AuthCredentials(ASCIIToUTF16("innocent"),
                                 ASCIIToUTF16("foo\nownz0red")),
-                &callback_));
+                callback_.callback()));
   EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult());
 }
 
 TEST_F(FtpNetworkTransactionTest, Escaping) {
   FtpSocketDataProviderEscaping ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host/%20%21%22%23%24%25%79%80%81",
                      OK);
 }
 
 // Test for http://crbug.com/23794.
@@ skipping 219 matching lines @@
   FtpSocketDataProviderFileDownload ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_PWD,
                         FtpSocketDataProvider::PRE_TYPE,
                         "257 \"\"\r\n",
                         OK);
 }
 
 }  // namespace net