Clean up FTP code a bit:

net/ftp/ftp_network_transaction.cc

-// Copyright (c) 2010 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.
+// Copyright (c) 2010 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 "base/compiler_specific.h"
 #include "base/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
@@ skipping 129 matching lines @@
 
   if (request_->url.has_username()) {
     GetIdentityFromURL(request_->url, &username_, &password_);
   } else {
     username_ = L"anonymous";
     password_ = L"chrome@example.com";
   }
 
   DetectTypecode();
 
-  next_state_ = STATE_CTRL_INIT;
+  next_state_ = STATE_CTRL_RESOLVE_HOST;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
 int FtpNetworkTransaction::Stop(int error) {
   if (command_sent_ == COMMAND_QUIT)
     return error;
 
   next_state_ = STATE_CTRL_WRITE_QUIT;
   last_error_ = error;
   return OK;
 }
 
 int FtpNetworkTransaction::RestartWithAuth(const std::wstring& username,
                                            const std::wstring& password,
                                            CompletionCallback* callback) {
   ResetStateForRestart();
 
   username_ = username;
   password_ = password;
 
-  next_state_ = STATE_CTRL_INIT;
+  next_state_ = STATE_CTRL_RESOLVE_HOST;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
 int FtpNetworkTransaction::RestartIgnoringLastError(
     CompletionCallback* callback) {
   return ERR_FAILED;
 }
@@ skipping 106 matching lines @@
     case COMMAND_NONE:
       // TODO(phajdan.jr): Check for errors in the welcome message.
       next_state_ = STATE_CTRL_WRITE_USER;
       break;
     case COMMAND_USER:
       rv = ProcessResponseUSER(response);
       break;
     case COMMAND_PASS:
       rv = ProcessResponsePASS(response);
       break;
-    case COMMAND_ACCT:
-      rv = ProcessResponseACCT(response);
-      break;
     case COMMAND_SYST:
       rv = ProcessResponseSYST(response);
       break;
     case COMMAND_PWD:
       rv = ProcessResponsePWD(response);
       break;
     case COMMAND_TYPE:
       rv = ProcessResponseTYPE(response);
       break;
     case COMMAND_EPSV:
@@ skipping 138 matching lines @@
 }
 
 int FtpNetworkTransaction::DoLoop(int result) {
   DCHECK(next_state_ != STATE_NONE);
 
   int rv = result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
-      case STATE_CTRL_INIT:
-        DCHECK(rv == OK);
-        rv = DoCtrlInit();
-        break;
-      case STATE_CTRL_INIT_COMPLETE:
-        rv = DoCtrlInitComplete(rv);
-        break;
       case STATE_CTRL_RESOLVE_HOST:
         DCHECK(rv == OK);
         rv = DoCtrlResolveHost();
         break;
       case STATE_CTRL_RESOLVE_HOST_COMPLETE:
         rv = DoCtrlResolveHostComplete(rv);
         break;
       case STATE_CTRL_CONNECT:
         DCHECK(rv == OK);
         rv = DoCtrlConnect();
@@ skipping 20 matching lines @@
         rv = DoCtrlWriteUSER();
         break;
       case STATE_CTRL_WRITE_PASS:
         DCHECK(rv == OK);
         rv = DoCtrlWritePASS();
         break;
       case STATE_CTRL_WRITE_SYST:
         DCHECK(rv == OK);
         rv = DoCtrlWriteSYST();
         break;
-      case STATE_CTRL_WRITE_ACCT:
-        DCHECK(rv == OK);
-        rv = DoCtrlWriteACCT();
-        break;
       case STATE_CTRL_WRITE_PWD:
         DCHECK(rv == OK);
         rv = DoCtrlWritePWD();
         break;
       case STATE_CTRL_WRITE_TYPE:
         DCHECK(rv == OK);
         rv = DoCtrlWriteTYPE();
         break;
       case STATE_CTRL_WRITE_EPSV:
         DCHECK(rv == OK);
@@ skipping 43 matching lines @@
         break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_UNEXPECTED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
   return rv;
 }
 
-// TODO(ibrar): Yet to see if we need any intialization
-int FtpNetworkTransaction::DoCtrlInit() {
-  next_state_ = STATE_CTRL_INIT_COMPLETE;
-  return OK;
-}
-
-int FtpNetworkTransaction::DoCtrlInitComplete(int result) {
-  next_state_ = STATE_CTRL_RESOLVE_HOST;
-  return OK;
-}
-
 int FtpNetworkTransaction::DoCtrlResolveHost() {
   next_state_ = STATE_CTRL_RESOLVE_HOST_COMPLETE;
 
   std::string host;
   int port;
 
   host = request_->url.HostNoBrackets();
   port = request_->url.EffectiveIntPort();
 
   HostResolver::RequestInfo info(host, port);
@@ skipping 121 matching lines @@
   return SendFtpCommand(command, COMMAND_PASS);
 }
 
 int FtpNetworkTransaction::ProcessResponsePASS(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_OK:
       next_state_ = STATE_CTRL_WRITE_SYST;
       break;
     case ERROR_CLASS_INFO_NEEDED:
-      next_state_ = STATE_CTRL_WRITE_ACCT;
-      break;
+      return Stop(ERR_FAILED);
     case ERROR_CLASS_TRANSIENT_ERROR:
       return Stop(ERR_FAILED);
     case ERROR_CLASS_PERMANENT_ERROR:
       response_.needs_auth = true;
       return Stop(ERR_FAILED);
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
@@ skipping 126 matching lines @@
       return Stop(ERR_FAILED);
     case ERROR_CLASS_PERMANENT_ERROR:
       return Stop(ERR_FAILED);
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
-// ACCT command.
-int FtpNetworkTransaction::DoCtrlWriteACCT() {
-  std::string command = "ACCT noaccount";
-  next_state_ = STATE_CTRL_READ;
-  return SendFtpCommand(command, COMMAND_ACCT);
-}
-
-int FtpNetworkTransaction::ProcessResponseACCT(
-    const FtpCtrlResponse& response) {
-  switch (GetErrorClass(response.status_code)) {
-    case ERROR_CLASS_INITIATED:
-      return Stop(ERR_INVALID_RESPONSE);
-    case ERROR_CLASS_OK:
-      next_state_ = STATE_CTRL_WRITE_SYST;
-      break;
-    case ERROR_CLASS_INFO_NEEDED:
-      return Stop(ERR_INVALID_RESPONSE);
-    case ERROR_CLASS_TRANSIENT_ERROR:
-      return Stop(ERR_FAILED);
-    case ERROR_CLASS_PERMANENT_ERROR:
-      return Stop(ERR_FAILED);
-    default:
-      NOTREACHED();
-      return Stop(ERR_UNEXPECTED);
-  }
-  return OK;
-}
-
 // EPSV command
 int FtpNetworkTransaction::DoCtrlWriteEPSV() {
   const std::string command = "EPSV";
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_EPSV);
 }
 
 int FtpNetworkTransaction::ProcessResponseEPSV(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
@@ skipping 115 matching lines @@
     case ERROR_CLASS_INITIATED:
       // We want the client to start reading the response at this point.
       // It got here either through Start or RestartWithAuth. We want that
       // method to complete. Not setting next state here will make DoLoop exit
       // and in turn make Start/RestartWithAuth complete.
       break;
     case ERROR_CLASS_OK:
       next_state_ = STATE_CTRL_WRITE_QUIT;
       break;
     case ERROR_CLASS_INFO_NEEDED:
-      next_state_ = use_epsv_ ? STATE_CTRL_WRITE_EPSV : STATE_CTRL_WRITE_PASV;
-      break;
+      return Stop(ERR_FAILED);
     case ERROR_CLASS_TRANSIENT_ERROR:
-      if (response.status_code == 421 || response.status_code == 425 ||
-          response.status_code == 426)
-        return Stop(ERR_FAILED);
-      return ERR_FAILED;  // TODO(ibrar): Retry here.
+      return Stop(ERR_FAILED);
     case ERROR_CLASS_PERMANENT_ERROR:
       // Code 550 means "Failed to open file". Other codes are unrelated,
       // like "Not logged in" etc.
       if (response.status_code != 550)
         return Stop(ERR_FAILED);
 
       // It's possible that RETR failed because the path is a directory.
       resource_type_ = RESOURCE_TYPE_DIRECTORY;
 
       // We're going to try CWD next, but first send a PASV one more time,
@@ skipping 257 matching lines @@
   if (!had_error_type[type]) {
     had_error_type[type] = true;
     UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorHappened",
         type, NUM_OF_NET_ERROR_TYPES);
   }
   UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorCount",
       type, NUM_OF_NET_ERROR_TYPES);
 }
 
 }  // namespace net