FTP: minor cleanups to the unit tests:

net/ftp/ftp_network_transaction_unittest.cc

 // Copyright (c) 2009 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/ref_counted.h"
 #include "net/base/io_buffer.h"
@@ skipping 63 matching lines @@
       case PRE_PWD:
         return Verify("PWD\r\n", data, PRE_TYPE,
                       "257 \"/\" is your current location\r\n");
       case PRE_TYPE:
         return Verify(std::string("TYPE ") + data_type_ + "\r\n", data,
                       PRE_EPSV, "200 TYPE set successfully\r\n");
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, PRE_SIZE,
                       "227 Entering Extended Passive Mode (|||31744|)\r\n");
       case PRE_NOPASV:
+        // Use unallocated 599 FTP error code to make sure it falls into the generic
+        // ERR_FTP_FAILED bucket.
         return Verify("PASV\r\n", data, PRE_QUIT,
                       "599 fail\r\n");
       case PRE_QUIT:
         return Verify("QUIT\r\n", data, QUIT, "221 Goodbye.\r\n");
       default:
         NOTREACHED() << "State not handled " << state();
         return MockWriteResult(true, ERR_UNEXPECTED);
     }
   }
 
@@ skipping 372 matching lines @@
     : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderFileDownloadInvalidResponse() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) {
     if (InjectFault())
       return MockWriteResult(true, data.length());
     switch (state()) {
       case PRE_SIZE:
+        // Use unallocated 599 FTP error code to make sure it falls into the
+        // generic ERR_FTP_FAILED bucket.
         return Verify("SIZE /file\r\n", data, PRE_QUIT,
                       "599 Evil Response\r\n"
                       "599 More Evil\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadInvalidResponse);
@@ skipping 156 matching lines @@
   void ExecuteTransaction(FtpSocketDataProvider* ctrl_socket,
                           const char* request,
                           int expected_result) {
     std::string mock_data("mock-data");
     MockRead data_reads[] = {
       // Usually FTP servers close the data connection after the entire data has
       // been received.
       MockRead(false, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(mock_data.c_str()),
     };
-    // For compatibility with FileZilla, the transaction code will use two data
-    // sockets for directory requests. For more info see http://crbug.com/25316.
-    StaticSocketDataProvider data1(data_reads, arraysize(data_reads), NULL, 0);
-    StaticSocketDataProvider data2(data_reads, arraysize(data_reads), NULL, 0);
+    StaticSocketDataProvider data_socket(data_reads, arraysize(data_reads),
+                                         NULL, 0);
     mock_socket_factory_.AddSocketDataProvider(ctrl_socket);
-    mock_socket_factory_.AddSocketDataProvider(&data1);
-    mock_socket_factory_.AddSocketDataProvider(&data2);
+    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()));
     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,
@@ skipping 440 matching lines @@
 }
 
 // Regression test for http://crbug.com/25023.
 TEST_F(FtpNetworkTransactionTest, CloseConnection) {
   FtpSocketDataProviderCloseConnection ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host", ERR_EMPTY_RESPONSE);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailUser) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host",
                         FtpSocketDataProvider::PRE_USER,
                         FtpSocketDataProvider::PRE_QUIT,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailPass) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
@@ skipping 11 matching lines @@
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host",
                         FtpSocketDataProvider::PRE_PASSWD,
                         FtpSocketDataProvider::PRE_QUIT,
                         "503 Bad sequence of commands\r\n",
                         ERR_FTP_BAD_COMMAND_SEQUENCE);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailSyst) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host",
                         FtpSocketDataProvider::PRE_SYST,
                         FtpSocketDataProvider::PRE_PWD,
                         "599 fail\r\n",
                         OK);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailPwd) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host",
                         FtpSocketDataProvider::PRE_PWD,
                         FtpSocketDataProvider::PRE_QUIT,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailType) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host",
                         FtpSocketDataProvider::PRE_TYPE,
                         FtpSocketDataProvider::PRE_QUIT,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailEpsv) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host",
                         FtpSocketDataProvider::PRE_EPSV,
                         FtpSocketDataProvider::PRE_NOPASV,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailCwd) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host",
                         FtpSocketDataProvider::PRE_CWD,
                         FtpSocketDataProvider::PRE_QUIT,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFileNotFound) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
@@ skipping 10 matching lines @@
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host",
                         FtpSocketDataProvider::PRE_MLSD,
                         FtpSocketDataProvider::PRE_LIST,
                         "500 Unrecognized command\r\n",
                         OK);
 }
 
 TEST_F(FtpNetworkTransactionTest, DirectoryTransactionFailList) {
   FtpSocketDataProviderVMSDirectoryListing ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/dir",
                         FtpSocketDataProvider::PRE_LIST,
                         FtpSocketDataProvider::PRE_QUIT,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailUser) {
   FtpSocketDataProviderFileDownload ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_USER,
                         FtpSocketDataProvider::PRE_QUIT,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailPass) {
   FtpSocketDataProviderFileDownload ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_PASSWD,
                         FtpSocketDataProvider::PRE_QUIT,
                         "530 Login authentication failed\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailSyst) {
   FtpSocketDataProviderFileDownload ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_SYST,
                         FtpSocketDataProvider::PRE_PWD,
                         "599 fail\r\n",
                         OK);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailPwd) {
   FtpSocketDataProviderFileDownload ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_PWD,
                         FtpSocketDataProvider::PRE_QUIT,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailType) {
   FtpSocketDataProviderFileDownload ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_TYPE,
                         FtpSocketDataProvider::PRE_QUIT,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailEpsv) {
   FtpSocketDataProviderFileDownload ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_EPSV,
                         FtpSocketDataProvider::PRE_NOPASV,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFailRetr) {
   FtpSocketDataProviderFileDownload ctrl_socket;
+  // Use unallocated 599 FTP error code to make sure it falls into the generic
+  // ERR_FTP_FAILED bucket.
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_RETR,
                         FtpSocketDataProvider::PRE_QUIT,
                         "599 fail\r\n",
                         ERR_FTP_FAILED);
 }
 
 TEST_F(FtpNetworkTransactionTest, DownloadTransactionFileNotFound) {
   FtpSocketDataProviderFileDownload ctrl_socket;
@@ skipping 10 matching lines @@
   FtpSocketDataProviderFileDownload ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_PWD,
                         FtpSocketDataProvider::PRE_TYPE,
                         "257 \"\"\r\n",
                         OK);
 }
 
 }  // namespace net