Clang format slam.

net/ftp/ftp_network_transaction.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
@@ skipping 205 matching lines @@
       last_error_(OK),
       system_type_(SYSTEM_TYPE_UNKNOWN),
       // Use image (binary) transfer by default. It should always work,
       // whereas the ascii transfer may damage binary data.
       data_type_(DATA_TYPE_IMAGE),
       resource_type_(RESOURCE_TYPE_UNKNOWN),
       use_epsv_(true),
       data_connection_port_(0),
       socket_factory_(socket_factory),
       next_state_(STATE_NONE),
-      state_after_data_connect_complete_(STATE_CTRL_WRITE_SIZE) {}
+      state_after_data_connect_complete_(STATE_CTRL_WRITE_SIZE) {
+}
 
 FtpNetworkTransaction::~FtpNetworkTransaction() {
 }
 
 int FtpNetworkTransaction::Stop(int error) {
   if (command_sent_ == COMMAND_QUIT)
     return error;
 
   next_state_ = STATE_CTRL_WRITE_QUIT;
   last_error_ = error;
@@ skipping 255 matching lines @@
     std::string::size_type pos = gurl_path.rfind(';');
     if (pos != std::string::npos)
       gurl_path.resize(pos);
 
     path.append(gurl_path);
   }
   // Make sure that if the path is expected to be a file, it won't end
   // with a trailing slash.
   if (!is_directory && path.length() > 1 && path[path.length() - 1] == '/')
     path.erase(path.length() - 1);
-  UnescapeRule::Type unescape_rules = UnescapeRule::SPACES |
-                                      UnescapeRule::URL_SPECIAL_CHARS;
+  UnescapeRule::Type unescape_rules =
+      UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS;
   // This may unescape to non-ASCII characters, but we allow that. See the
   // comment for IsValidFTPCommandString.
   path = net::UnescapeURLComponent(path, unescape_rules);
 
   if (system_type_ == SYSTEM_TYPE_VMS) {
     if (is_directory)
       path = FtpUtil::UnixDirectoryPathToVMS(path);
     else
       path = FtpUtil::UnixFilePathToVMS(path);
   }
@@ skipping 445 matching lines @@
   next_state_ = STATE_CTRL_READ;
   return SendFtpCommand(command, command, COMMAND_EPSV);
 }
 
 int FtpNetworkTransaction::ProcessResponseEPSV(
     const FtpCtrlResponse& response) {
   switch (GetErrorClass(response.status_code)) {
     case ERROR_CLASS_INITIATED:
       return Stop(ERR_INVALID_RESPONSE);
     case ERROR_CLASS_OK:
-      if (!ExtractPortFromEPSVResponse( response, &data_connection_port_))
+      if (!ExtractPortFromEPSVResponse(response, &data_connection_port_))
         return Stop(ERR_INVALID_RESPONSE);
       if (data_connection_port_ < 1024 ||
           !IsPortAllowedByFtp(data_connection_port_))
         return Stop(ERR_UNSAFE_PORT);
       next_state_ = STATE_DATA_CONNECT;
       break;
     case ERROR_CLASS_INFO_NEEDED:
       return Stop(ERR_INVALID_RESPONSE);
     case ERROR_CLASS_TRANSIENT_ERROR:
     case ERROR_CLASS_PERMANENT_ERROR:
@@ skipping 262 matching lines @@
 
 int FtpNetworkTransaction::DoDataConnect() {
   next_state_ = STATE_DATA_CONNECT_COMPLETE;
   IPEndPoint ip_endpoint;
   AddressList data_address;
   // Connect to the same host as the control socket to prevent PASV port
   // scanning attacks.
   int rv = ctrl_socket_->GetPeerAddress(&ip_endpoint);
   if (rv != OK)
     return Stop(rv);
-  data_address = AddressList::CreateFromIPAddress(
-      ip_endpoint.address(), data_connection_port_);
+  data_address = AddressList::CreateFromIPAddress(ip_endpoint.address(),
+                                                  data_connection_port_);
   data_socket_ = socket_factory_->CreateTransportClientSocket(
-        data_address, net_log_.net_log(), net_log_.source());
+      data_address, net_log_.net_log(), net_log_.source());
   net_log_.AddEvent(
       NetLog::TYPE_FTP_DATA_CONNECTION,
       data_socket_->NetLog().source().ToEventParametersCallback());
   return data_socket_->Connect(io_callback_);
 }
 
 int FtpNetworkTransaction::DoDataConnectComplete(int result) {
   if (result != OK && use_epsv_) {
     // It's possible we hit a broken server, sadly. They can break in different
     // ways. Some time out, some reset a connection. Fall back to PASV.
@@ skipping 77 matching lines @@
     NET_ERROR_INTERNET_DISCONNECTED = 5,
 
     // Could not reach the destination address.
     NET_ERROR_ADDRESS_UNREACHABLE = 6,
 
     // A programming error in our network stack.
     NET_ERROR_UNEXPECTED = 7,
 
     // Other kind of error.
     NET_ERROR_OTHER = 20,
-
     NUM_OF_NET_ERROR_TYPES
   } type;
   switch (result) {
     case OK:
       type = NET_ERROR_OK;
       break;
     case ERR_ACCESS_DENIED:
     case ERR_NETWORK_ACCESS_DENIED:
       type = NET_ERROR_ACCESS_DENIED;
       break;
@@ skipping 21 matching lines @@
       break;
     default:
       type = NET_ERROR_OTHER;
       break;
   };
   static bool had_error_type[NUM_OF_NET_ERROR_TYPES];
 
   DCHECK(type >= 0 && type < NUM_OF_NET_ERROR_TYPES);
   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.FtpDataConnectionErrorHappened", type, NUM_OF_NET_ERROR_TYPES);
   }
-  UMA_HISTOGRAM_ENUMERATION("Net.FtpDataConnectionErrorCount",
-      type, NUM_OF_NET_ERROR_TYPES);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Net.FtpDataConnectionErrorCount", type, NUM_OF_NET_ERROR_TYPES);
 }
 
 }  // namespace net