Change MockRead and MockWrite (et. al.) to take an IoMode enum, instead

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/memory/ref_counted.h"
@@ skipping 42 matching lines @@
 
   FtpSocketDataProvider()
       : failure_injection_state_(NONE),
         multiline_welcome_(false),
         data_type_('I') {
     Init();
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_USER:
         return Verify("USER anonymous\r\n", data, PRE_PASSWD,
                       "331 Password needed\r\n");
       case PRE_PASSWD:
         {
           const char* response_one = "230 Welcome\r\n";
           const char* response_multi = "230- One\r\n230- Two\r\n230 Three\r\n";
           return Verify("PASS chrome@example.com\r\n", data, PRE_SYST,
                         multiline_welcome_ ? response_multi : response_one);
@@ skipping 11 matching lines @@
                       "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);
+        return MockWriteResult(ASYNC, ERR_UNEXPECTED);
     }
   }
 
   void InjectFailure(State state, State next_state, const char* response) {
     DCHECK_EQ(NONE, failure_injection_state_);
     DCHECK_NE(NONE, state);
     DCHECK_NE(NONE, next_state);
     DCHECK_NE(state, next_state);
     failure_injection_state_ = state;
     failure_injection_next_state_ = next_state;
@@ skipping 35 matching lines @@
 
   MockWriteResult Verify(const std::string& expected,
                          const std::string& data,
                          State next_state,
                          const char* next_read,
                          const size_t next_read_length) {
     EXPECT_EQ(expected, data);
     if (expected == data) {
       state_ = next_state;
       SimulateRead(next_read, next_read_length);
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     }
-    return MockWriteResult(true, ERR_UNEXPECTED);
+    return MockWriteResult(ASYNC, ERR_UNEXPECTED);
   }
 
   MockWriteResult Verify(const std::string& expected,
                          const std::string& data,
                          State next_state,
                          const char* next_read) {
     return Verify(expected, data, next_state,
                   next_read, std::strlen(next_read));
   }
 
@@ skipping 13 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProvider);
 };
 
 class FtpSocketDataProviderDirectoryListing : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderDirectoryListing() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
         return Verify("SIZE /\r\n", data, PRE_CWD,
                       "550 I can only retrieve regular files\r\n");
       case PRE_CWD:
         return Verify("CWD /\r\n", data, PRE_LIST, "200 OK\r\n");
       case PRE_LIST:
         return Verify("LIST\r\n", data, PRE_QUIT, "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListing);
 };
 
 class FtpSocketDataProviderDirectoryListingWithPasvFallback
     : public FtpSocketDataProviderDirectoryListing {
  public:
   FtpSocketDataProviderDirectoryListingWithPasvFallback() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, PRE_PASV,
                       "500 no EPSV for you\r\n");
       case PRE_PASV:
         return Verify("PASV\r\n", data, PRE_SIZE,
                       "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
       default:
         return FtpSocketDataProviderDirectoryListing::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       FtpSocketDataProviderDirectoryListingWithPasvFallback);
 };
 
 class FtpSocketDataProviderDirectoryListingZeroSize
     : public FtpSocketDataProviderDirectoryListing {
  public:
   FtpSocketDataProviderDirectoryListingZeroSize() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
         return Verify("SIZE /\r\n", data, PRE_CWD, "213 0\r\n");
       default:
         return FtpSocketDataProviderDirectoryListing::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderDirectoryListingZeroSize);
 };
 
 class FtpSocketDataProviderVMSDirectoryListing : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderVMSDirectoryListing() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SYST:
         return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n");
       case PRE_PWD:
         return Verify("PWD\r\n", data, PRE_TYPE,
                       "257 \"ANONYMOUS_ROOT:[000000]\"\r\n");
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, PRE_PASV, "500 Invalid command\r\n");
       case PRE_PASV:
         return Verify("PASV\r\n", data, PRE_SIZE,
@@ skipping 16 matching lines @@
 };
 
 class FtpSocketDataProviderVMSDirectoryListingRootDirectory
     : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderVMSDirectoryListingRootDirectory() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SYST:
         return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n");
       case PRE_PWD:
         return Verify("PWD\r\n", data, PRE_TYPE,
                       "257 \"ANONYMOUS_ROOT:[000000]\"\r\n");
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, PRE_PASV,
                       "500 EPSV command unknown\r\n");
       case PRE_PASV:
@@ skipping 18 matching lines @@
 };
 
 class FtpSocketDataProviderFileDownloadWithFileTypecode
     : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderFileDownloadWithFileTypecode() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
         return Verify("SIZE /file\r\n", data, PRE_RETR,
                       "213 18\r\n");
       case PRE_RETR:
         return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithFileTypecode);
 };
 
 class FtpSocketDataProviderFileDownload : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderFileDownload() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
         return Verify("SIZE /file\r\n", data, PRE_CWD,
                       "213 18\r\n");
       case PRE_CWD:
         return Verify("CWD /file\r\n", data, PRE_RETR,
                       "550 Not a directory\r\n");
       case PRE_RETR:
         return Verify("RETR /file\r\n", data, PRE_QUIT, "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownload);
 };
 
 class FtpSocketDataProviderFileNotFound : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderFileNotFound() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
         return Verify("SIZE /file\r\n", data, PRE_CWD,
                       "550 File Not Found\r\n");
       case PRE_CWD:
         return Verify("CWD /file\r\n", data, PRE_RETR,
                       "550 File Not Found\r\n");
       case PRE_RETR:
         return Verify("RETR /file\r\n", data, PRE_QUIT,
                       "550 File Not Found\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileNotFound);
 };
 
 class FtpSocketDataProviderFileDownloadWithPasvFallback
     : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderFileDownloadWithPasvFallback() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, PRE_PASV,
                       "500 No can do\r\n");
       case PRE_PASV:
         return Verify("PASV\r\n", data, PRE_SIZE,
                       "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithPasvFallback);
 };
 
 class FtpSocketDataProviderFileDownloadZeroSize
     : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderFileDownloadZeroSize() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
         return Verify("SIZE /file\r\n", data, PRE_CWD,
                       "213 0\r\n");
       case PRE_CWD:
         return Verify("CWD /file\r\n", data, PRE_RETR,
                       "550 not a directory\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadZeroSize);
 };
 
 class FtpSocketDataProviderFileDownloadCWD451
     : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderFileDownloadCWD451() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_CWD:
         return Verify("CWD /file\r\n", data, PRE_RETR,
                       "451 not a directory\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadCWD451);
 };
 
 class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderVMSFileDownload() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SYST:
         return Verify("SYST\r\n", data, PRE_PWD, "215 VMS\r\n");
       case PRE_PWD:
         return Verify("PWD\r\n", data, PRE_TYPE,
                       "257 \"ANONYMOUS_ROOT:[000000]\"\r\n");
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, PRE_PASV,
                       "500 EPSV command unknown\r\n");
       case PRE_PASV:
@@ skipping 17 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderVMSFileDownload);
 };
 
 class FtpSocketDataProviderEscaping : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderEscaping() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
         return Verify("SIZE / !\"#$%y\200\201\r\n", data, PRE_CWD,
                       "213 18\r\n");
       case PRE_CWD:
         return Verify("CWD / !\"#$%y\200\201\r\n", data, PRE_RETR,
                       "550 Not a directory\r\n");
       case PRE_RETR:
         return Verify("RETR / !\"#$%y\200\201\r\n", data, PRE_QUIT,
                       "200 OK\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEscaping);
 };
 
 class FtpSocketDataProviderFileDownloadTransferStarting
     : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderFileDownloadTransferStarting() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_RETR:
         return Verify("RETR /file\r\n", data, PRE_QUIT,
                       "125-Data connection already open.\r\n"
                       "125  Transfer starting.\r\n"
                       "226 Transfer complete.\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadTransferStarting);
 };
 
 class FtpSocketDataProviderDirectoryListingTransferStarting
     : public FtpSocketDataProviderDirectoryListing {
  public:
   FtpSocketDataProviderDirectoryListingTransferStarting() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_LIST:
         return Verify("LIST\r\n", data, PRE_QUIT,
                       "125-Data connection already open.\r\n"
                       "125  Transfer starting.\r\n"
                       "226 Transfer complete.\r\n");
       default:
         return FtpSocketDataProviderDirectoryListing::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       FtpSocketDataProviderDirectoryListingTransferStarting);
 };
 
 class FtpSocketDataProviderFileDownloadInvalidResponse
     : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderFileDownloadInvalidResponse() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, 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);
     }
@@ skipping 13 matching lines @@
 
   FtpSocketDataProviderEvilEpsv(const char* epsv_response,
                                size_t epsv_response_length,
                                State expected_state)
       : epsv_response_(epsv_response),
         epsv_response_length_(epsv_response_length),
         expected_state_(expected_state) {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_EPSV:
         return Verify("EPSV\r\n", data, expected_state_,
                       epsv_response_, epsv_response_length_);
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   const char* epsv_response_;
   const size_t epsv_response_length_;
   const State expected_state_;
 
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilEpsv);
 };
 
 class FtpSocketDataProviderEvilPasv
     : public FtpSocketDataProviderFileDownloadWithPasvFallback {
  public:
   FtpSocketDataProviderEvilPasv(const char* pasv_response, State expected_state)
       : pasv_response_(pasv_response),
         expected_state_(expected_state) {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_PASV:
         return Verify("PASV\r\n", data, expected_state_, pasv_response_);
       default:
         return FtpSocketDataProviderFileDownloadWithPasvFallback::OnWrite(data);
     }
   }
 
  private:
   const char* pasv_response_;
   const State expected_state_;
 
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilPasv);
 };
 
 class FtpSocketDataProviderEvilSize : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderEvilSize(const char* size_response, State expected_state)
       : size_response_(size_response),
         expected_state_(expected_state) {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
         return Verify("SIZE /file\r\n", data, expected_state_, size_response_);
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   const char* size_response_;
   const State expected_state_;
 
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilSize);
 };
 
 class FtpSocketDataProviderEvilLogin
     : public FtpSocketDataProviderFileDownload {
  public:
   FtpSocketDataProviderEvilLogin(const char* expected_user,
                                 const char* expected_password)
       : expected_user_(expected_user),
         expected_password_(expected_password) {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_USER:
         return Verify(std::string("USER ") + expected_user_ + "\r\n", data,
                       PRE_PASSWD, "331 Password needed\r\n");
       case PRE_PASSWD:
         return Verify(std::string("PASS ") + expected_password_ + "\r\n", data,
                       PRE_SYST, "230 Welcome\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   const char* expected_user_;
   const char* expected_password_;
 
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderEvilLogin);
 };
 
 class FtpSocketDataProviderCloseConnection : public FtpSocketDataProvider {
  public:
   FtpSocketDataProviderCloseConnection() {
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
-      return MockWriteResult(true, data.length());
+      return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_USER:
         return Verify("USER anonymous\r\n", data,
                       PRE_QUIT, "");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
@@ skipping 15 matching lines @@
     return info;
   }
 
   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(SYNCHRONOUS, 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_.callback(),
@@ skipping 394 matching lines @@
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   ASSERT_EQ(ERR_IO_PENDING,
             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),
+    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);
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.RestartWithAuth(
                 AuthCredentials(
@@ skipping 14 matching lines @@
 
   ASSERT_EQ(ERR_IO_PENDING,
             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),
+    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);
   ASSERT_EQ(ERR_IO_PENDING,
             transaction_.RestartWithAuth(
@@ skipping 232 matching lines @@
   FtpSocketDataProviderFileDownload ctrl_socket;
   TransactionFailHelper(&ctrl_socket,
                         "ftp://host/file",
                         FtpSocketDataProvider::PRE_PWD,
                         FtpSocketDataProvider::PRE_TYPE,
                         "257 \"\"\r\n",
                         OK);
 }
 
 }  // namespace net