More net/ method ordering.

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.
 
 #include "net/ftp/ftp_network_transaction.h"
 
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 186 matching lines @@
       resource_type_(RESOURCE_TYPE_UNKNOWN),
       use_epsv_(true),
       data_connection_port_(0),
       socket_factory_(socket_factory),
       next_state_(STATE_NONE) {
 }
 
 FtpNetworkTransaction::~FtpNetworkTransaction() {
 }
 
+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::RestartIgnoringLastError(
+    CompletionCallback* callback) {
+  return ERR_NOT_IMPLEMENTED;
+}
+
 int FtpNetworkTransaction::Start(const FtpRequestInfo* request_info,
                                  CompletionCallback* callback,
                                  const BoundNetLog& net_log) {
   net_log_ = net_log;
   request_ = request_info;
 
   if (request_->url.has_username()) {
     GetIdentityFromURL(request_->url, &username_, &password_);
   } else {
     username_ = ASCIIToUTF16("anonymous");
     password_ = ASCIIToUTF16("chrome@example.com");
   }
 
   DetectTypecode();
 
   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 string16& username,
                                            const string16& password,
                                            CompletionCallback* callback) {
   ResetStateForRestart();
 
   username_ = username;
   password_ = password;
 
   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_NOT_IMPLEMENTED;
-}
-
 int FtpNetworkTransaction::Read(IOBuffer* buf,
                                 int buf_len,
                                 CompletionCallback* callback) {
   DCHECK(buf);
   DCHECK_GT(buf_len, 0);
 
   read_data_buf_ = buf;
   read_data_buf_len_ = buf_len;
 
   next_state_ = STATE_DATA_READ;
@@ skipping 27 matching lines @@
   if (command_sent_ != COMMAND_NONE)
     return LOAD_STATE_SENDING_REQUEST;
 
   return LOAD_STATE_IDLE;
 }
 
 uint64 FtpNetworkTransaction::GetUploadProgress() const {
   return 0;
 }
 
-// Used to prepare and send FTP command.
-int FtpNetworkTransaction::SendFtpCommand(const std::string& command,
-                                          Command cmd) {
-  // If we send a new command when we still have unprocessed responses
-  // for previous commands, the response receiving code will have no way to know
-  // which responses are for which command.
-  DCHECK(!ctrl_response_buffer_->ResponseAvailable());
+void FtpNetworkTransaction::ResetStateForRestart() {
+  command_sent_ = COMMAND_NONE;
+  user_callback_ = NULL;
+  response_ = FtpResponseInfo();
+  read_ctrl_buf_ = new IOBuffer(kCtrlBufLen);
+  ctrl_response_buffer_.reset(new FtpCtrlResponseBuffer());
+  read_data_buf_ = NULL;
+  read_data_buf_len_ = 0;
+  if (write_buf_)
+    write_buf_->SetOffset(0);
+  last_error_ = OK;
+  data_connection_port_ = 0;
+  ctrl_socket_.reset();
+  data_socket_.reset();
+  next_state_ = STATE_NONE;
+}
 
-  DCHECK(!write_command_buf_);
-  DCHECK(!write_buf_);
+void FtpNetworkTransaction::DoCallback(int rv) {
+  DCHECK(rv != ERR_IO_PENDING);
+  DCHECK(user_callback_);
 
-  if (!IsValidFTPCommandString(command)) {
-    // Callers should validate the command themselves and return a more specific
-    // error code.
-    NOTREACHED();
-    return Stop(ERR_UNEXPECTED);
-  }
+  // Since Run may result in Read being called, clear callback_ up front.
+  CompletionCallback* c = user_callback_;
+  user_callback_ = NULL;
+  c->Run(rv);
+}
 
-  command_sent_ = cmd;
-
-  write_command_buf_ = new IOBufferWithSize(command.length() + 2);
-  write_buf_ = new DrainableIOBuffer(write_command_buf_,
-                                     write_command_buf_->size());
-  memcpy(write_command_buf_->data(), command.data(), command.length());
-  memcpy(write_command_buf_->data() + command.length(), kCRLF, 2);
-
-  next_state_ = STATE_CTRL_WRITE;
-  return OK;
+void FtpNetworkTransaction::OnIOComplete(int result) {
+  int rv = DoLoop(result);
+  if (rv != ERR_IO_PENDING)
+    DoCallback(rv);
 }
 
 int FtpNetworkTransaction::ProcessCtrlResponse() {
   FtpCtrlResponse response = ctrl_response_buffer_->PopResponse();
 
   int rv = OK;
   switch (command_sent_) {
     case COMMAND_NONE:
       // TODO(phajdan.jr): Check for errors in the welcome message.
       next_state_ = STATE_CTRL_WRITE_USER;
@@ skipping 53 matching lines @@
         break;
       default:
         // Multiple responses for other commands are invalid.
         return Stop(ERR_INVALID_RESPONSE);
     }
   }
 
   return rv;
 }
 
-void FtpNetworkTransaction::ResetStateForRestart() {
-  command_sent_ = COMMAND_NONE;
-  user_callback_ = NULL;
-  response_ = FtpResponseInfo();
-  read_ctrl_buf_ = new IOBuffer(kCtrlBufLen);
-  ctrl_response_buffer_.reset(new FtpCtrlResponseBuffer());
-  read_data_buf_ = NULL;
-  read_data_buf_len_ = 0;
-  if (write_buf_)
-    write_buf_->SetOffset(0);
-  last_error_ = OK;
-  data_connection_port_ = 0;
-  ctrl_socket_.reset();
-  data_socket_.reset();
-  next_state_ = STATE_NONE;
-}
+// Used to prepare and send FTP command.
+int FtpNetworkTransaction::SendFtpCommand(const std::string& command,
+                                          Command cmd) {
+  // If we send a new command when we still have unprocessed responses
+  // for previous commands, the response receiving code will have no way to know
+  // which responses are for which command.
+  DCHECK(!ctrl_response_buffer_->ResponseAvailable());
 
-void FtpNetworkTransaction::DoCallback(int rv) {
-  DCHECK(rv != ERR_IO_PENDING);
-  DCHECK(user_callback_);
+  DCHECK(!write_command_buf_);
+  DCHECK(!write_buf_);
 
-  // Since Run may result in Read being called, clear callback_ up front.
-  CompletionCallback* c = user_callback_;
-  user_callback_ = NULL;
-  c->Run(rv);
-}
+  if (!IsValidFTPCommandString(command)) {
+    // Callers should validate the command themselves and return a more specific
+    // error code.
+    NOTREACHED();
+    return Stop(ERR_UNEXPECTED);
+  }
 
-void FtpNetworkTransaction::OnIOComplete(int result) {
-  int rv = DoLoop(result);
-  if (rv != ERR_IO_PENDING)
-    DoCallback(rv);
+  command_sent_ = cmd;
+
+  write_command_buf_ = new IOBufferWithSize(command.length() + 2);
+  write_buf_ = new DrainableIOBuffer(write_command_buf_,
+                                     write_command_buf_->size());
+  memcpy(write_command_buf_->data(), command.data(), command.length());
+  memcpy(write_command_buf_->data() + command.length(), kCRLF, 2);
+
+  next_state_ = STATE_CTRL_WRITE;
+  return OK;
 }
 
 std::string FtpNetworkTransaction::GetRequestPathForFtpCommand(
     bool is_directory) const {
   std::string path(current_remote_directory_);
   if (request_->url.has_path()) {
     std::string gurl_path(request_->url.path());
 
     // Get rid of the typecode, see RFC 1738 section 3.2.2. FTP url-path.
     std::string::size_type pos = gurl_path.rfind(';');
@@ skipping 493 matching lines @@
       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     case ERROR_CLASS_PERMANENT_ERROR:
       return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
     default:
       NOTREACHED();
       return Stop(ERR_UNEXPECTED);
   }
   return OK;
 }
 
-// SIZE command
-int FtpNetworkTransaction::DoCtrlWriteSIZE() {
-  std::string command = "SIZE " + GetRequestPathForFtpCommand(false);
-  next_state_ = STATE_CTRL_READ;
-  return SendFtpCommand(command, COMMAND_SIZE);
-}
-
-int FtpNetworkTransaction::ProcessResponseSIZE(
-    const FtpCtrlResponse& response) {
-  switch (GetErrorClass(response.status_code)) {
-    case ERROR_CLASS_INITIATED:
-      break;
-    case ERROR_CLASS_OK:
-      if (response.lines.size() != 1)
-        return Stop(ERR_INVALID_RESPONSE);
-      int64 size;
-      if (!base::StringToInt64(response.lines[0], &size))
-        return Stop(ERR_INVALID_RESPONSE);
-      if (size < 0)
-        return Stop(ERR_INVALID_RESPONSE);
-
-      // A successful response to SIZE does not mean the resource is a file.
-      // Some FTP servers (for example, the qnx one) send a SIZE even for
-      // directories.
-      response_.expected_content_size = size;
-      break;
-    case ERROR_CLASS_INFO_NEEDED:
-      break;
-    case ERROR_CLASS_TRANSIENT_ERROR:
-      break;
-    case ERROR_CLASS_PERMANENT_ERROR:
-      // It's possible that SIZE failed because the path is a directory.
-      if (resource_type_ == RESOURCE_TYPE_UNKNOWN &&
-          response.status_code != 550) {
-        return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
-      }
-      break;
-    default:
-      NOTREACHED();
-      return Stop(ERR_UNEXPECTED);
-  }
-
-  if (resource_type_ == RESOURCE_TYPE_FILE)
-    next_state_ = STATE_CTRL_WRITE_RETR;
-  else
-    next_state_ = STATE_CTRL_WRITE_CWD;
-
-  return OK;
-}
-
 // RETR command
 int FtpNetworkTransaction::DoCtrlWriteRETR() {
   std::string command = "RETR " + GetRequestPathForFtpCommand(false);
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_RETR);
 }
 
 int FtpNetworkTransaction::ProcessResponseRETR(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
@@ skipping 31 matching lines @@
       return Stop(ERR_UNEXPECTED);
   }
 
   // We should be sure about our resource type now. Otherwise we risk
   // an infinite loop (RETR can later send CWD, and CWD can later send RETR).
   DCHECK_NE(RESOURCE_TYPE_UNKNOWN, resource_type_);
 
   return OK;
 }
 
+// SIZE command
+int FtpNetworkTransaction::DoCtrlWriteSIZE() {
+  std::string command = "SIZE " + GetRequestPathForFtpCommand(false);
+  next_state_ = STATE_CTRL_READ;
+  return SendFtpCommand(command, COMMAND_SIZE);
+}
+
+int FtpNetworkTransaction::ProcessResponseSIZE(
+    const FtpCtrlResponse& response) {
+  switch (GetErrorClass(response.status_code)) {
+    case ERROR_CLASS_INITIATED:
+      break;
+    case ERROR_CLASS_OK:
+      if (response.lines.size() != 1)
+        return Stop(ERR_INVALID_RESPONSE);
+      int64 size;
+      if (!base::StringToInt64(response.lines[0], &size))
+        return Stop(ERR_INVALID_RESPONSE);
+      if (size < 0)
+        return Stop(ERR_INVALID_RESPONSE);
+
+      // A successful response to SIZE does not mean the resource is a file.
+      // Some FTP servers (for example, the qnx one) send a SIZE even for
+      // directories.
+      response_.expected_content_size = size;
+      break;
+    case ERROR_CLASS_INFO_NEEDED:
+      break;
+    case ERROR_CLASS_TRANSIENT_ERROR:
+      break;
+    case ERROR_CLASS_PERMANENT_ERROR:
+      // It's possible that SIZE failed because the path is a directory.
+      if (resource_type_ == RESOURCE_TYPE_UNKNOWN &&
+          response.status_code != 550) {
+        return Stop(GetNetErrorCodeForFtpResponseCode(response.status_code));
+      }
+      break;
+    default:
+      NOTREACHED();
+      return Stop(ERR_UNEXPECTED);
+  }
+
+  if (resource_type_ == RESOURCE_TYPE_FILE)
+    next_state_ = STATE_CTRL_WRITE_RETR;
+  else
+    next_state_ = STATE_CTRL_WRITE_CWD;
+
+  return OK;
+}
+
 // CWD command
 int FtpNetworkTransaction::DoCtrlWriteCWD() {
   std::string command = "CWD " + GetRequestPathForFtpCommand(true);
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, COMMAND_CWD);
 }
 
 int FtpNetworkTransaction::ProcessResponseCWD(const FtpCtrlResponse& response) {
   // We should never issue CWD if we know the target resource is a file.
   DCHECK_NE(RESOURCE_TYPE_FILE, resource_type_);
@@ skipping 230 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