Fix some FTP DCHECKs on 1xx responses.

net/ftp/ftp_network_transaction_unittest.cc

 // Copyright (c) 2012 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/macros.h"
@@ skipping 823 matching lines @@
                       PRE_QUIT, "");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderCloseConnection);
 };
 
+class BorkedFtpSocketDataProvider : public FtpSocketDataProvider {
+ public:
+  BorkedFtpSocketDataProvider() {}
+  ~BorkedFtpSocketDataProvider() override {}
+
+  MockWriteResult OnWrite(const std::string& data) override {
+    switch (state()) {
+      case PRE_USER:
+        return Verify("USER anonymous\r\n", data, PRE_PASSWD, "957 Spam\r\n");
+      default:
+        return FtpSocketDataProvider::OnWrite(data);
+    }
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BorkedFtpSocketDataProvider);
+};
+
 class FtpNetworkTransactionTest
     : public PlatformTest,
       public ::testing::WithParamInterface<int> {
  public:
-  FtpNetworkTransactionTest()
-      : host_resolver_(new MockHostResolver),
-        transaction_(host_resolver_.get(), &mock_socket_factory_) {
+  FtpNetworkTransactionTest() : host_resolver_(new MockHostResolver) {
+    SetUpTransaction();
+
     scoped_refptr<RuleBasedHostResolverProc> rules(
-        new RuleBasedHostResolverProc(NULL));
+        new RuleBasedHostResolverProc(nullptr));
     if (GetFamily() == AF_INET) {
       rules->AddIPLiteralRule("*", "127.0.0.1", "127.0.0.1");
     } else if (GetFamily() == AF_INET6) {
       rules->AddIPLiteralRule("*", "::1", "::1");
     } else {
       NOTREACHED();
     }
     host_resolver_->set_rules(rules.get());
   }
 
+  // Sets up an FtpNetworkTransaction and MocketClientSocketFactory, replacing
+  // the default one. Only needs to be called if a test runs multiple
+  // transactions.
+  void SetUpTransaction() {
+    mock_socket_factory_.reset(new MockClientSocketFactory());
+    transaction_.reset(new FtpNetworkTransaction(host_resolver_.get(),
+                                                 mock_socket_factory_.get()));
+  }
+
  protected:
   // Accessor to make code refactoring-friendly, e.g. when we change the way
   // parameters are passed (like more parameters).
   int GetFamily() {
     return GetParam();
   }
 
   FtpRequestInfo GetRequestInfo(const std::string& url) {
     FtpRequestInfo info;
     info.url = GURL(url);
     return info;
   }
 
   void ExecuteTransaction(FtpSocketDataProvider* ctrl_socket,
                           const char* request,
                           int expected_result) {
     // Expect EPSV usage for non-IPv4 control connections.
     ctrl_socket->set_use_epsv((GetFamily() != AF_INET));
 
-    mock_socket_factory_.AddSocketDataProvider(ctrl_socket);
+    mock_socket_factory_->AddSocketDataProvider(ctrl_socket);
 
     std::string mock_data("mock-data");
     MockRead data_reads[] = {
       // Usually FTP servers close the data connection after the entire data has
       // been received.
       MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
       MockRead(mock_data.c_str()),
     };
 
     std::unique_ptr<StaticSocketDataProvider> data_socket(
         new StaticSocketDataProvider(data_reads, arraysize(data_reads), NULL,
                                      0));
-    mock_socket_factory_.AddSocketDataProvider(data_socket.get());
+    mock_socket_factory_->AddSocketDataProvider(data_socket.get());
     FtpRequestInfo request_info = GetRequestInfo(request);
-    EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
+    EXPECT_EQ(LOAD_STATE_IDLE, transaction_->GetLoadState());
     ASSERT_EQ(ERR_IO_PENDING,
-              transaction_.Start(&request_info, callback_.callback(),
-                                 NetLogWithSource()));
-    EXPECT_NE(LOAD_STATE_IDLE, transaction_.GetLoadState());
+              transaction_->Start(&request_info, callback_.callback(),
+                                  NetLogWithSource()));
+    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_.callback()));
+      ASSERT_EQ(ERR_IO_PENDING, 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_.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());
+    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);
   }
 
   std::unique_ptr<MockHostResolver> host_resolver_;
-  MockClientSocketFactory mock_socket_factory_;
-  FtpNetworkTransaction transaction_;
+  std::unique_ptr<MockClientSocketFactory> mock_socket_factory_;
+  std::unique_ptr<FtpNetworkTransaction> transaction_;
   TestCompletionCallback callback_;
 };
 
 TEST_P(FtpNetworkTransactionTest, FailedLookup) {
   FtpRequestInfo request_info = GetRequestInfo("ftp://badhost");
   scoped_refptr<RuleBasedHostResolverProc> rules(
       new RuleBasedHostResolverProc(NULL));
   rules->AddSimulatedFailure("badhost");
   host_resolver_->set_rules(rules.get());
 
-  EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
+  EXPECT_EQ(LOAD_STATE_IDLE, transaction_->GetLoadState());
   ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, callback_.callback(),
-                               NetLogWithSource()));
+            transaction_->Start(&request_info, callback_.callback(),
+                                NetLogWithSource()));
   ASSERT_THAT(callback_.WaitForResult(), IsError(ERR_NAME_NOT_RESOLVED));
-  EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
+  EXPECT_EQ(LOAD_STATE_IDLE, transaction_->GetLoadState());
 }
 
 // Check that when determining the host, the square brackets decorating IPv6
 // literals in URLs are stripped.
 TEST_P(FtpNetworkTransactionTest, StripBracketsFromIPv6Literals) {
   // This test only makes sense for IPv6 connections.
   if (GetFamily() != AF_INET6)
     return;
 
   host_resolver_->rules()->AddSimulatedFailure("[::1]");
 
   // We start a transaction that is expected to fail with ERR_INVALID_RESPONSE.
   // The important part of this test is to make sure that we don't fail with
   // ERR_NAME_NOT_RESOLVED, since that would mean the decorated hostname
   // was used.
   FtpSocketDataProviderEvilSize ctrl_socket(
       "213 99999999999999999999999999999999\r\n",
       FtpSocketDataProvider::PRE_QUIT);
   ExecuteTransaction(&ctrl_socket, "ftp://[::1]/file", ERR_INVALID_RESPONSE);
 }
 
 TEST_P(FtpNetworkTransactionTest, DirectoryTransaction) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host", OK);
 
-  EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing);
-  EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size);
+  EXPECT_TRUE(transaction_->GetResponseInfo()->is_directory_listing);
+  EXPECT_EQ(-1, transaction_->GetResponseInfo()->expected_content_size);
   EXPECT_EQ((GetFamily() == AF_INET) ? "127.0.0.1" : "::1",
-            transaction_.GetResponseInfo()->socket_address.host());
-  EXPECT_EQ(21, transaction_.GetResponseInfo()->socket_address.port());
+            transaction_->GetResponseInfo()->socket_address.host());
+  EXPECT_EQ(21, transaction_->GetResponseInfo()->socket_address.port());
 }
 
 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionWithPasvFallback) {
   FtpSocketDataProviderDirectoryListingWithPasvFallback ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host", OK);
 
-  EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing);
-  EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size);
+  EXPECT_TRUE(transaction_->GetResponseInfo()->is_directory_listing);
+  EXPECT_EQ(-1, transaction_->GetResponseInfo()->expected_content_size);
 }
 
 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionWithTypecode) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host/;type=d", OK);
 
-  EXPECT_TRUE(transaction_.GetResponseInfo()->is_directory_listing);
-  EXPECT_EQ(-1, transaction_.GetResponseInfo()->expected_content_size);
+  EXPECT_TRUE(transaction_->GetResponseInfo()->is_directory_listing);
+  EXPECT_EQ(-1, transaction_->GetResponseInfo()->expected_content_size);
 }
 
 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionMultilineWelcome) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
   ctrl_socket.set_multiline_welcome(true);
   ExecuteTransaction(&ctrl_socket, "ftp://host", OK);
 }
 
 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionShortReads2) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
@@ skipping 36 matching lines @@
 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionTransferStarting) {
   FtpSocketDataProviderDirectoryListingTransferStarting ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host", OK);
 }
 
 TEST_P(FtpNetworkTransactionTest, DownloadTransaction) {
   FtpSocketDataProviderFileDownload ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK);
 
   // We pass an artificial value of 18 as a response to the SIZE command.
-  EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size);
+  EXPECT_EQ(18, transaction_->GetResponseInfo()->expected_content_size);
   EXPECT_EQ((GetFamily() == AF_INET) ? "127.0.0.1" : "::1",
-            transaction_.GetResponseInfo()->socket_address.host());
-  EXPECT_EQ(21, transaction_.GetResponseInfo()->socket_address.port());
+            transaction_->GetResponseInfo()->socket_address.host());
+  EXPECT_EQ(21, transaction_->GetResponseInfo()->socket_address.port());
 }
 
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionWithPasvFallback) {
   FtpSocketDataProviderFileDownloadWithPasvFallback ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK);
 
   // We pass an artificial value of 18 as a response to the SIZE command.
-  EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size);
+  EXPECT_EQ(18, transaction_->GetResponseInfo()->expected_content_size);
 }
 
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionWithTypecodeA) {
   FtpSocketDataProviderFileDownloadWithFileTypecode ctrl_socket;
   ctrl_socket.set_data_type('A');
   ExecuteTransaction(&ctrl_socket, "ftp://host/file;type=a", OK);
 
   // We pass an artificial value of 18 as a response to the SIZE command.
-  EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size);
+  EXPECT_EQ(18, transaction_->GetResponseInfo()->expected_content_size);
 }
 
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionWithTypecodeI) {
   FtpSocketDataProviderFileDownloadWithFileTypecode ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host/file;type=i", OK);
 
   // We pass an artificial value of 18 as a response to the SIZE command.
-  EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size);
+  EXPECT_EQ(18, transaction_->GetResponseInfo()->expected_content_size);
 }
 
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionMultilineWelcome) {
   FtpSocketDataProviderFileDownload ctrl_socket;
   ctrl_socket.set_multiline_welcome(true);
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK);
 }
 
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionShortReads2) {
   FtpSocketDataProviderFileDownload ctrl_socket;
@@ skipping 69 matching lines @@
   FtpSocketDataProviderEvilPasv ctrl_socket(
       "227 Portscan (10,1,2,3,123,456)\r\n", FtpSocketDataProvider::PRE_RETR);
   ctrl_socket.set_use_epsv(GetFamily() != AF_INET);
   std::string mock_data("mock-data");
   MockRead data_reads[] = {
     MockRead(mock_data.c_str()),
   };
   StaticSocketDataProvider data_socket1;
   StaticSocketDataProvider data_socket2(data_reads, arraysize(data_reads),
                                         NULL, 0);
-  mock_socket_factory_.AddSocketDataProvider(&ctrl_socket);
-  mock_socket_factory_.AddSocketDataProvider(&data_socket1);
-  mock_socket_factory_.AddSocketDataProvider(&data_socket2);
+  mock_socket_factory_->AddSocketDataProvider(&ctrl_socket);
+  mock_socket_factory_->AddSocketDataProvider(&data_socket1);
+  mock_socket_factory_->AddSocketDataProvider(&data_socket2);
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   // Start the transaction.
   ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, callback_.callback(),
-                               NetLogWithSource()));
+            transaction_->Start(&request_info, callback_.callback(),
+                                NetLogWithSource()));
   ASSERT_THAT(callback_.WaitForResult(), IsOk());
 
   // The transaction fires the callback when we can start reading data. That
   // means that the data socket should be open.
   MockTCPClientSocket* data_socket =
-      static_cast<MockTCPClientSocket*>(transaction_.data_socket_.get());
+      static_cast<MockTCPClientSocket*>(transaction_->data_socket_.get());
   ASSERT_TRUE(data_socket);
   ASSERT_TRUE(data_socket->IsConnected());
 
   // Even if the PASV response specified some other address, we connect
   // to the address we used for control connection (which could be 127.0.0.1
   // or ::1 depending on whether we use IPv6).
   for (AddressList::const_iterator it = data_socket->addresses().begin();
       it != data_socket->addresses().end(); ++it) {
     EXPECT_NE("10.1.2.3", it->ToStringWithoutPort());
   }
@@ skipping 144 matching lines @@
 
 // Make sure FtpNetworkTransaction doesn't request paths like
 // "/foo/../bar".  Doing so wouldn't be a security issue, client side, but just
 // doesn't seem like a good idea.
 TEST_P(FtpNetworkTransactionTest,
        DownloadTransactionPathSeparatorsNotUnescaped) {
   FtpSocketDataProviderPathSeparatorsNotUnescaped ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host/foo%2f..%2fbar%5c", OK);
 
   // We pass an artificial value of 18 as a response to the SIZE command.
-  EXPECT_EQ(18, transaction_.GetResponseInfo()->expected_content_size);
+  EXPECT_EQ(18, transaction_->GetResponseInfo()->expected_content_size);
 }
 
 TEST_P(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);
+  mock_socket_factory_->AddSocketDataProvider(&ctrl_socket1);
 
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, callback_.callback(),
-                               NetLogWithSource()));
+            transaction_->Start(&request_info, callback_.callback(),
+                                NetLogWithSource()));
   ASSERT_THAT(callback_.WaitForResult(), IsError(ERR_FTP_FAILED));
 
   MockRead ctrl_reads[] = {
     MockRead("220 host TestFTPd\r\n"),
     MockRead("221 Goodbye!\r\n"),
     MockRead(SYNCHRONOUS, 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);
+  mock_socket_factory_->AddSocketDataProvider(&ctrl_socket2);
   ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.RestartWithAuth(
-                AuthCredentials(
-                    base::ASCIIToUTF16("foo\nownz0red"),
-                    base::ASCIIToUTF16("innocent")),
+            transaction_->RestartWithAuth(
+                AuthCredentials(base::ASCIIToUTF16("foo\nownz0red"),
+                                base::ASCIIToUTF16("innocent")),
                 callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_MALFORMED_IDENTITY));
 }
 
 TEST_P(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);
+  mock_socket_factory_->AddSocketDataProvider(&ctrl_socket1);
 
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, callback_.callback(),
-                               NetLogWithSource()));
+            transaction_->Start(&request_info, callback_.callback(),
+                                NetLogWithSource()));
   ASSERT_THAT(callback_.WaitForResult(), IsError(ERR_FTP_FAILED));
 
   MockRead ctrl_reads[] = {
     MockRead("220 host TestFTPd\r\n"),
     MockRead("331 User okay, send password\r\n"),
     MockRead("221 Goodbye!\r\n"),
     MockRead(SYNCHRONOUS, 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);
+  mock_socket_factory_->AddSocketDataProvider(&ctrl_socket2);
   ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.RestartWithAuth(
+            transaction_->RestartWithAuth(
                 AuthCredentials(base::ASCIIToUTF16("innocent"),
                                 base::ASCIIToUTF16("foo\nownz0red")),
                 callback_.callback()));
   EXPECT_THAT(callback_.WaitForResult(), IsError(ERR_MALFORMED_IDENTITY));
 }
 
 TEST_P(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.
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilSize) {
   // Try to overflow int64_t in the response.
   FtpSocketDataProviderEvilSize ctrl_socket(
       "213 99999999999999999999999999999999\r\n",
       FtpSocketDataProvider::PRE_QUIT);
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE);
 }
 
 // Test for http://crbug.com/36360.
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionBigSize) {
   // Pass a valid, but large file size. The transaction should not fail.
   FtpSocketDataProviderEvilSize ctrl_socket(
       "213 3204427776\r\n",
       FtpSocketDataProvider::PRE_CWD);
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", OK);
   EXPECT_EQ(3204427776LL,
-            transaction_.GetResponseInfo()->expected_content_size);
+            transaction_->GetResponseInfo()->expected_content_size);
 }
 
 // Regression test for http://crbug.com/25023.
 TEST_P(FtpNetworkTransactionTest, CloseConnection) {
   FtpSocketDataProviderCloseConnection ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host", ERR_EMPTY_RESPONSE);
 }
 
 TEST_P(FtpNetworkTransactionTest, DirectoryTransactionFailUser) {
   FtpSocketDataProviderDirectoryListing ctrl_socket;
@@ skipping 193 matching lines @@
 TEST_P(FtpNetworkTransactionTest, ZeroLengthDirInPWD) {
   FtpSocketDataProviderFileDownload ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_PWD,
                         FtpSocketDataProvider::PRE_TYPE,
                         "257 \"\"\r\n",
                         OK);
 }
 
+TEST_P(FtpNetworkTransactionTest, UnexpectedInitiatedResponseForDirectory) {
+  // The states for a directory listing where an initiated response will cause
+  // an error.  Includes all commands sent on the directory listing path, except
+  // CWD, SIZE, LIST, and QUIT commands.
+  FtpSocketDataProvider::State kFailingStates[] = {
+      FtpSocketDataProvider::PRE_USER, FtpSocketDataProvider::PRE_PASSWD,
+      FtpSocketDataProvider::PRE_SYST, FtpSocketDataProvider::PRE_PWD,
+      FtpSocketDataProvider::PRE_TYPE,
+      GetFamily() != AF_INET ? FtpSocketDataProvider::PRE_LIST_EPSV
+                             : FtpSocketDataProvider::PRE_LIST_PASV,
+      FtpSocketDataProvider::PRE_CWD,
+  };
+
+  for (FtpSocketDataProvider::State state : kFailingStates) {
+    SetUpTransaction();
+    FtpSocketDataProviderDirectoryListing ctrl_socket;
+    ctrl_socket.InjectFailure(state, FtpSocketDataProvider::PRE_QUIT,
+                              "157 Foo\r\n");
+    ExecuteTransaction(&ctrl_socket, "ftp://host/", ERR_INVALID_RESPONSE);
+  }
+}
+
+TEST_P(FtpNetworkTransactionTest, UnexpectedInitiatedResponseForFile) {
+  // The states for a download where an initiated response will cause an error.
+  // Includes all commands sent on the file download path, except CWD, SIZE, and
+  // QUIT commands.
+  const FtpSocketDataProvider::State kFailingStates[] = {
+      FtpSocketDataProvider::PRE_USER, FtpSocketDataProvider::PRE_PASSWD,
+      FtpSocketDataProvider::PRE_SYST, FtpSocketDataProvider::PRE_PWD,
+      FtpSocketDataProvider::PRE_TYPE,
+      GetFamily() != AF_INET ? FtpSocketDataProvider::PRE_RETR_EPSV
+                             : FtpSocketDataProvider::PRE_RETR_PASV,
+      FtpSocketDataProvider::PRE_CWD};
+
+  for (FtpSocketDataProvider::State state : kFailingStates) {
+    LOG(ERROR) << "??: " << state;
+    SetUpTransaction();
+    FtpSocketDataProviderFileDownload ctrl_socket;
+    ctrl_socket.InjectFailure(state, FtpSocketDataProvider::PRE_QUIT,
+                              "157 Foo\r\n");
+    ExecuteTransaction(&ctrl_socket, "ftp://host/file", ERR_INVALID_RESPONSE);
+  }
+}
+
 INSTANTIATE_TEST_CASE_P(FTP,
                         FtpNetworkTransactionTest,
                         ::testing::Values(AF_INET, AF_INET6));
 
 }  // namespace net