Clang format slam.

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 50 matching lines @@
         use_epsv_(true),
         data_type_('I') {
     Init();
   }
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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);
-        }
+        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);
+      }
       case PRE_SYST:
         return Verify("SYST\r\n", data, PRE_PWD, "215 UNIX\r\n");
       case PRE_PWD:
-        return Verify("PWD\r\n", data, PRE_TYPE,
+        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,
+        return Verify(std::string("TYPE ") + data_type_ + "\r\n",
+                      data,
                       use_epsv_ ? PRE_EPSV : PRE_PASV,
                       "200 TYPE set successfully\r\n");
       case PRE_EPSV:
-        return Verify("EPSV\r\n", data, PRE_SIZE,
+        return Verify("EPSV\r\n",
+                      data,
+                      PRE_SIZE,
                       "227 Entering Extended Passive Mode (|||31744|)\r\n");
       case PRE_CWD_EPSV:
-        return Verify("EPSV\r\n", data, PRE_CWD,
+        return Verify("EPSV\r\n",
+                      data,
+                      PRE_CWD,
                       "227 Entering Extended Passive Mode (|||31744|)\r\n");
       case PRE_RETR_EPSV:
-        return Verify("EPSV\r\n", data, PRE_RETR,
+        return Verify("EPSV\r\n",
+                      data,
+                      PRE_RETR,
                       "227 Entering Extended Passive Mode (|||31744|)\r\n");
       case PRE_CWD_PASV:
-        return Verify("PASV\r\n", data, PRE_CWD,
+        return Verify("PASV\r\n",
+                      data,
+                      PRE_CWD,
                       "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
       case PRE_RETR_PASV:
-        return Verify("PASV\r\n", data, PRE_RETR,
+        return Verify("PASV\r\n",
+                      data,
+                      PRE_RETR,
                       "227 Entering Passive Mode 127,0,0,1,123,456\r\n");
       case PRE_PASV:
-        return Verify("PASV\r\n", data, PRE_SIZE,
+        return Verify("PASV\r\n",
+                      data,
+                      PRE_SIZE,
                       "227 Entering Passive Mode 127,0,0,1,123,456\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");
+        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(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;
     fault_response_ = response;
   }
 
-  State state() const {
-    return state_;
-  }
+  State state() const { return state_; }
 
   virtual void Reset() OVERRIDE {
     DynamicSocketDataProvider::Reset();
     Init();
   }
 
   void set_multiline_welcome(bool multiline) { multiline_welcome_ = multiline; }
 
   bool use_epsv() const { return use_epsv_; }
   void set_use_epsv(bool use_epsv) { use_epsv_ = use_epsv; }
@@ skipping 27 matching lines @@
       SimulateRead(next_read, next_read_length);
       return MockWriteResult(ASYNC, data.length());
     }
     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));
+    return Verify(
+        expected, data, next_state, next_read, std::strlen(next_read));
   }
 
-
  private:
   State state_;
   State failure_injection_state_;
   State failure_injection_next_state_;
   const char* fault_response_;
 
   // If true, we will send multiple 230 lines as response after PASS.
   bool multiline_welcome_;
 
   // If true, we will use EPSV command.
   bool use_epsv_;
 
   // Data type to be used for TYPE command.
   char data_type_;
 
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProvider);
 };
 
 class FtpSocketDataProviderDirectoryListing : public FtpSocketDataProvider {
  public:
-  FtpSocketDataProviderDirectoryListing() {
-  }
+  FtpSocketDataProviderDirectoryListing() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
-        return Verify("SIZE /\r\n", data,
+        return Verify("SIZE /\r\n",
+                      data,
                       use_epsv() ? PRE_CWD_EPSV : PRE_CWD_PASV,
                       "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 -l\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() {
-  }
+  FtpSocketDataProviderDirectoryListingWithPasvFallback() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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");
+        return Verify("EPSV\r\n", data, PRE_PASV, "500 no EPSV for you\r\n");
       case PRE_SIZE:
-        return Verify("SIZE /\r\n", data, PRE_CWD_PASV,
+        return Verify("SIZE /\r\n",
+                      data,
+                      PRE_CWD_PASV,
                       "550 I can only retrieve regular files\r\n");
       default:
         return FtpSocketDataProviderDirectoryListing::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       FtpSocketDataProviderDirectoryListingWithPasvFallback);
 };
 
 class FtpSocketDataProviderDirectoryListingZeroSize
     : public FtpSocketDataProviderDirectoryListing {
  public:
-  FtpSocketDataProviderDirectoryListingZeroSize() {
-  }
+  FtpSocketDataProviderDirectoryListingZeroSize() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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() {
-  }
+  FtpSocketDataProviderVMSDirectoryListing() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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");
+        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_SIZE:
-        return Verify("SIZE ANONYMOUS_ROOT:[000000]dir\r\n", data, PRE_CWD_PASV,
+        return Verify("SIZE ANONYMOUS_ROOT:[000000]dir\r\n",
+                      data,
+                      PRE_CWD_PASV,
                       "550 I can only retrieve regular files\r\n");
       case PRE_CWD:
-        return Verify("CWD ANONYMOUS_ROOT:[dir]\r\n", data, PRE_LIST,
-                      "200 OK\r\n");
+        return Verify(
+            "CWD ANONYMOUS_ROOT:[dir]\r\n", data, PRE_LIST, "200 OK\r\n");
       case PRE_LIST:
         return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderVMSDirectoryListing);
 };
 
 class FtpSocketDataProviderVMSDirectoryListingRootDirectory
     : public FtpSocketDataProvider {
  public:
-  FtpSocketDataProviderVMSDirectoryListingRootDirectory() {
-  }
+  FtpSocketDataProviderVMSDirectoryListingRootDirectory() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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");
+        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");
+        return Verify(
+            "EPSV\r\n", data, PRE_PASV, "500 EPSV command unknown\r\n");
       case PRE_SIZE:
-        return Verify("SIZE ANONYMOUS_ROOT\r\n", data, PRE_CWD_PASV,
+        return Verify("SIZE ANONYMOUS_ROOT\r\n",
+                      data,
+                      PRE_CWD_PASV,
                       "550 I can only retrieve regular files\r\n");
       case PRE_CWD:
-        return Verify("CWD ANONYMOUS_ROOT:[000000]\r\n", data, PRE_LIST,
-                      "200 OK\r\n");
+        return Verify(
+            "CWD ANONYMOUS_ROOT:[000000]\r\n", data, PRE_LIST, "200 OK\r\n");
       case PRE_LIST:
         return Verify("LIST *.*;0\r\n", data, PRE_QUIT, "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(
       FtpSocketDataProviderVMSDirectoryListingRootDirectory);
 };
 
 class FtpSocketDataProviderFileDownloadWithFileTypecode
     : public FtpSocketDataProvider {
  public:
-  FtpSocketDataProviderFileDownloadWithFileTypecode() {
-  }
+  FtpSocketDataProviderFileDownloadWithFileTypecode() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
-        return Verify("SIZE /file\r\n", data, PRE_RETR,
-                      "213 18\r\n");
+        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() {
-  }
+  FtpSocketDataProviderFileDownload() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
-        return Verify("SIZE /file\r\n", data, PRE_CWD,
-                      "213 18\r\n");
+        return Verify("SIZE /file\r\n", data, PRE_CWD, "213 18\r\n");
       case PRE_CWD:
-        return Verify("CWD /file\r\n", data,
+        return Verify("CWD /file\r\n",
+                      data,
                       use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV,
                       "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() {
-  }
+  FtpSocketDataProviderFileNotFound() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
-        return Verify("SIZE /file\r\n", data,
+        return Verify("SIZE /file\r\n",
+                      data,
                       use_epsv() ? PRE_CWD_EPSV : PRE_CWD_PASV,
                       "550 File Not Found\r\n");
       case PRE_CWD:
-        return Verify("CWD /file\r\n", data,
+        return Verify("CWD /file\r\n",
+                      data,
                       use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV,
                       "550 File Not Found\r\n");
       case PRE_RETR:
-        return Verify("RETR /file\r\n", data, PRE_QUIT,
-                      "550 File Not Found\r\n");
+        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() {
-  }
+  FtpSocketDataProviderFileDownloadWithPasvFallback() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_EPSV:
-        return Verify("EPSV\r\n", data, PRE_PASV,
-                      "500 No can do\r\n");
+        return Verify("EPSV\r\n", data, PRE_PASV, "500 No can do\r\n");
       case PRE_CWD:
-        return Verify("CWD /file\r\n", data, PRE_RETR_PASV,
-                      "550 Not a directory\r\n");
+        return Verify(
+            "CWD /file\r\n", data, PRE_RETR_PASV, "550 Not a directory\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadWithPasvFallback);
 };
 
 class FtpSocketDataProviderFileDownloadZeroSize
     : public FtpSocketDataProviderFileDownload {
  public:
-  FtpSocketDataProviderFileDownloadZeroSize() {
-  }
+  FtpSocketDataProviderFileDownloadZeroSize() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_SIZE:
-        return Verify("SIZE /file\r\n", data, PRE_CWD,
-                      "213 0\r\n");
+        return Verify("SIZE /file\r\n", data, PRE_CWD, "213 0\r\n");
       case PRE_CWD:
-        return Verify("CWD /file\r\n", data,
+        return Verify("CWD /file\r\n",
+                      data,
                       use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV,
                       "550 not a directory\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadZeroSize);
 };
 
 class FtpSocketDataProviderFileDownloadCWD451
     : public FtpSocketDataProviderFileDownload {
  public:
-  FtpSocketDataProviderFileDownloadCWD451() {
-  }
+  FtpSocketDataProviderFileDownloadCWD451() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_CWD:
-        return Verify("CWD /file\r\n", data,
+        return Verify("CWD /file\r\n",
+                      data,
                       use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV,
                       "451 not a directory\r\n");
       default:
         return FtpSocketDataProviderFileDownload::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderFileDownloadCWD451);
 };
 
 class FtpSocketDataProviderVMSFileDownload : public FtpSocketDataProvider {
  public:
-  FtpSocketDataProviderVMSFileDownload() {
-  }
+  FtpSocketDataProviderVMSFileDownload() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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");
+        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");
+        return Verify(
+            "EPSV\r\n", data, PRE_PASV, "500 EPSV command unknown\r\n");
       case PRE_SIZE:
-        return Verify("SIZE ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_CWD,
+        return Verify("SIZE ANONYMOUS_ROOT:[000000]file\r\n",
+                      data,
+                      PRE_CWD,
                       "213 18\r\n");
       case PRE_CWD:
-        return Verify("CWD ANONYMOUS_ROOT:[file]\r\n", data, PRE_RETR_PASV,
+        return Verify("CWD ANONYMOUS_ROOT:[file]\r\n",
+                      data,
+                      PRE_RETR_PASV,
                       "550 Not a directory\r\n");
       case PRE_RETR:
-        return Verify("RETR ANONYMOUS_ROOT:[000000]file\r\n", data, PRE_QUIT,
+        return Verify("RETR ANONYMOUS_ROOT:[000000]file\r\n",
+                      data,
+                      PRE_QUIT,
                       "200 OK\r\n");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderVMSFileDownload);
 };
 
 class FtpSocketDataProviderEscaping : public FtpSocketDataProviderFileDownload {
  public:
-  FtpSocketDataProviderEscaping() {
-  }
+  FtpSocketDataProviderEscaping() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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");
+        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,
+        return Verify("CWD / !\"#$%y\200\201\r\n",
+                      data,
                       use_epsv() ? PRE_RETR_EPSV : PRE_RETR_PASV,
                       "550 Not a directory\r\n");
       case PRE_RETR:
-        return Verify("RETR / !\"#$%y\200\201\r\n", data, PRE_QUIT,
-                      "200 OK\r\n");
+        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() {
-  }
+  FtpSocketDataProviderFileDownloadTransferStarting() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_RETR:
-        return Verify("RETR /file\r\n", data, PRE_QUIT,
+        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() {
-  }
+  FtpSocketDataProviderDirectoryListingTransferStarting() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_LIST:
-        return Verify("LIST -l\r\n", data, PRE_QUIT,
+        return Verify("LIST -l\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() {
-  }
+  FtpSocketDataProviderFileDownloadInvalidResponse() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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,
+        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);
 };
 
 class FtpSocketDataProviderEvilEpsv : public FtpSocketDataProviderFileDownload {
  public:
-  FtpSocketDataProviderEvilEpsv(const char* epsv_response,
-                                State expected_state)
+  FtpSocketDataProviderEvilEpsv(const char* epsv_response, State expected_state)
       : epsv_response_(epsv_response),
         epsv_response_length_(std::strlen(epsv_response)),
         expected_state_(expected_state) {}
 
   FtpSocketDataProviderEvilEpsv(const char* epsv_response,
-                               size_t epsv_response_length,
-                               State expected_state)
+                                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(ASYNC, data.length());
     switch (state()) {
       case PRE_EPSV:
-        return Verify("EPSV\r\n", data, expected_state_,
-                      epsv_response_, epsv_response_length_);
+        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) {
-  }
+      : pasv_response_(pasv_response), expected_state_(expected_state) {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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) {
-  }
+      : size_response_(size_response), expected_state_(expected_state) {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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) {
-  }
+                                 const char* expected_password)
+      : expected_user_(expected_user), expected_password_(expected_password) {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       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");
+        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");
+        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() {
-  }
+  FtpSocketDataProviderCloseConnection() {}
 
   virtual MockWriteResult OnWrite(const std::string& data) OVERRIDE {
     if (InjectFault())
       return MockWriteResult(ASYNC, data.length());
     switch (state()) {
       case PRE_USER:
-        return Verify("USER anonymous\r\n", data,
-                      PRE_QUIT, "");
+        return Verify("USER anonymous\r\n", data, PRE_QUIT, "");
       default:
         return FtpSocketDataProvider::OnWrite(data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FtpSocketDataProviderCloseConnection);
 };
 
-class FtpNetworkTransactionTest
-    : public PlatformTest,
-      public ::testing::WithParamInterface<int> {
+class FtpNetworkTransactionTest : public PlatformTest,
+                                  public ::testing::WithParamInterface<int> {
  public:
   FtpNetworkTransactionTest()
       : host_resolver_(new MockHostResolver),
         session_(new FtpNetworkSession(host_resolver_.get())),
         transaction_(session_.get(), &mock_socket_factory_) {
     scoped_refptr<RuleBasedHostResolverProc> rules(
         new RuleBasedHostResolverProc(NULL));
     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());
   }
 
  protected:
   // Accessor to make code refactoring-friendly, e.g. when we change the way
   // parameters are passed (like more parameters).
-  int GetFamily() {
-    return GetParam();
-  }
+  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 data_socket,
                           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);
 
     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()),
+        // 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()),
     };
 
     ScopedVector<StaticSocketDataProvider> data_sockets;
     data_sockets.reserve(data_socket);
     for (int i = 0; i < data_socket + 1; i++) {
       // We only read from one data socket, other ones are dummy.
       if (i == data_socket) {
         data_sockets.push_back(new StaticSocketDataProvider(
-                                   data_reads, arraysize(data_reads), NULL, 0));
+            data_reads, arraysize(data_reads), NULL, 0));
       } else {
         data_sockets.push_back(new StaticSocketDataProvider);
       }
       mock_socket_factory_.AddSocketDataProvider(data_sockets[i]);
     }
 
     FtpRequestInfo request_info = GetRequestInfo(request);
     EXPECT_EQ(LOAD_STATE_IDLE, transaction_.GetLoadState());
-    ASSERT_EQ(ERR_IO_PENDING,
-              transaction_.Start(&request_info, callback_.callback(),
-                                 BoundNetLog()));
+    ASSERT_EQ(
+        ERR_IO_PENDING,
+        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_.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_.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());
   }
 
@@ skipping 15 matching lines @@
 };
 
 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());
-  ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, callback_.callback(),
-                               BoundNetLog()));
+  ASSERT_EQ(
+      ERR_IO_PENDING,
+      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_P(FtpNetworkTransactionTest, StripBracketsFromIPv6Literals) {
   // This test only makes sense for IPv6 connections.
   if (GetFamily() != AF_INET6)
     return;
@@ skipping 197 matching lines @@
                                             FtpSocketDataProvider::PRE_QUIT);
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_UNSAFE_PORT);
 }
 
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilPasvUnsafeHost) {
   FtpSocketDataProviderEvilPasv ctrl_socket(
       "227 Portscan (10,1,2,3,123,456)\r\n", FtpSocketDataProvider::PRE_SIZE);
   ctrl_socket.set_use_epsv(GetFamily() != AF_INET);
   std::string mock_data("mock-data");
   MockRead data_reads[] = {
-    MockRead(mock_data.c_str()),
+      MockRead(mock_data.c_str()),
   };
   StaticSocketDataProvider data_socket1;
-  StaticSocketDataProvider data_socket2(data_reads, arraysize(data_reads),
-                                        NULL, 0);
+  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);
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
   // Start the transaction.
-  ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, callback_.callback(),
-                               BoundNetLog()));
+  ASSERT_EQ(
+      ERR_IO_PENDING,
+      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 =
       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) {
+       it != data_socket->addresses().end();
+       ++it) {
     EXPECT_NE("10.1.2.3", it->ToStringWithoutPort());
   }
 }
 
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat1) {
   // This test makes no sense for IPv4 connections (we don't use EPSV there).
   if (GetFamily() == AF_INET)
     return;
 
   FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||22)\r\n",
@@ skipping 30 matching lines @@
                                             FtpSocketDataProvider::PRE_QUIT);
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE);
 }
 
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvReallyBadFormat5) {
   // This test makes no sense for IPv4 connections (we don't use EPSV there).
   if (GetFamily() == AF_INET)
     return;
 
   const char response[] = "227 Portscan (\0\0\031773\0)\r\n";
-  FtpSocketDataProviderEvilEpsv ctrl_socket(response, sizeof(response)-1,
-                                            FtpSocketDataProvider::PRE_QUIT);
+  FtpSocketDataProviderEvilEpsv ctrl_socket(
+      response, sizeof(response) - 1, FtpSocketDataProvider::PRE_QUIT);
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, ERR_INVALID_RESPONSE);
 }
 
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilEpsvUnsafePort1) {
   // This test makes no sense for IPv4 connections (we don't use EPSV there).
   if (GetFamily() == AF_INET)
     return;
 
   FtpSocketDataProviderEvilEpsv ctrl_socket("227 Portscan (|||22|)\r\n",
                                             FtpSocketDataProvider::PRE_QUIT);
@@ skipping 83 matching lines @@
 
 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);
 
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, callback_.callback(),
-                               BoundNetLog()));
+  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(SYNCHRONOUS, OK),
+      MockRead("220 host TestFTPd\r\n"), MockRead("221 Goodbye!\r\n"),
+      MockRead(SYNCHRONOUS, OK),
   };
   MockWrite ctrl_writes[] = {
-    MockWrite("QUIT\r\n"),
+      MockWrite("QUIT\r\n"),
   };
-  StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads),
-                                        ctrl_writes, arraysize(ctrl_writes));
+  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(
-                    base::ASCIIToUTF16("foo\nownz0red"),
-                    base::ASCIIToUTF16("innocent")),
+                AuthCredentials(base::ASCIIToUTF16("foo\nownz0red"),
+                                base::ASCIIToUTF16("innocent")),
                 callback_.callback()));
   EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult());
 }
 
 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);
 
   FtpRequestInfo request_info = GetRequestInfo("ftp://host/file");
 
-  ASSERT_EQ(ERR_IO_PENDING,
-            transaction_.Start(&request_info, callback_.callback(),
-                               BoundNetLog()));
+  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(SYNCHRONOUS, OK),
+      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"),
+      MockWrite("USER innocent\r\n"), MockWrite("QUIT\r\n"),
   };
-  StaticSocketDataProvider ctrl_socket2(ctrl_reads, arraysize(ctrl_reads),
-                                        ctrl_writes, arraysize(ctrl_writes));
+  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(base::ASCIIToUTF16("innocent"),
                                 base::ASCIIToUTF16("foo\nownz0red")),
                 callback_.callback()));
   EXPECT_EQ(ERR_MALFORMED_IDENTITY, callback_.WaitForResult());
 }
 
 TEST_P(FtpNetworkTransactionTest, Escaping) {
   FtpSocketDataProviderEscaping ctrl_socket;
-  ExecuteTransaction(&ctrl_socket, "ftp://host/%20%21%22%23%24%25%79%80%81",
-                     1, OK);
+  ExecuteTransaction(
+      &ctrl_socket, "ftp://host/%20%21%22%23%24%25%79%80%81", 1, OK);
 }
 
 // Test for http://crbug.com/23794.
 TEST_P(FtpNetworkTransactionTest, DownloadTransactionEvilSize) {
   // Try to overflow int64 in the response.
   FtpSocketDataProviderEvilSize ctrl_socket(
       "213 99999999999999999999999999999999\r\n",
       FtpSocketDataProvider::PRE_QUIT);
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, 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);
+  FtpSocketDataProviderEvilSize ctrl_socket("213 3204427776\r\n",
+                                            FtpSocketDataProvider::PRE_CWD);
   ExecuteTransaction(&ctrl_socket, "ftp://host/file", 1, OK);
   EXPECT_EQ(3204427776LL,
             transaction_.GetResponseInfo()->expected_content_size);
 }
 
 // Regression test for http://crbug.com/25023.
 TEST_P(FtpNetworkTransactionTest, CloseConnection) {
   FtpSocketDataProviderCloseConnection ctrl_socket;
   ExecuteTransaction(&ctrl_socket, "ftp://host", 1, ERR_EMPTY_RESPONSE);
 }
@@ skipping 207 matching lines @@
                         FtpSocketDataProvider::PRE_TYPE,
                         "257 \"\"\r\n",
                         OK);
 }
 
 INSTANTIATE_TEST_CASE_P(FTP,
                         FtpNetworkTransactionTest,
                         ::testing::Values(AF_INET, AF_INET6));
 
 }  // namespace net