Auto-format style pass over files.

net/http/http_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/http/http_network_transaction.h"
 
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/format_macros.h"
 #include "base/histogram.h"
@@ skipping 43 matching lines @@
 // off to SSLv3 for.
 std::set<std::string>* g_tls_intolerant_servers = NULL;
 
 void BuildRequestHeaders(const HttpRequestInfo* request_info,
                          const HttpRequestHeaders& authorization_headers,
                          const UploadDataStream* upload_data_stream,
                          bool using_proxy,
                          std::string* request_line,
                          HttpRequestHeaders* request_headers) {
   const std::string path = using_proxy ?
-      HttpUtil::SpecForRequest(request_info->url) :
-      HttpUtil::PathForRequest(request_info->url);
+                           HttpUtil::SpecForRequest(request_info->url) :
+                           HttpUtil::PathForRequest(request_info->url);
   *request_line = StringPrintf(
       "%s %s HTTP/1.1\r\n", request_info->method.c_str(), path.c_str());
   request_headers->SetHeader(HttpRequestHeaders::kHost,
                              GetHostAndOptionalPort(request_info->url));
 
   // For compat with HTTP/1.0 servers and proxies:
   if (using_proxy) {
     request_headers->SetHeader(HttpRequestHeaders::kProxyConnection,
                                "keep-alive");
   } else {
@@ skipping 35 matching lines @@
   // e.g., plugins from overriding headers that are controlled using other
   // means. Otherwise a plugin could set a referrer although sending the
   // referrer is inhibited.
   // TODO(jochen): check whether also other headers should be stripped.
   static const char* const kExtraHeadersToBeStripped[] = {
     "Referer"
   };
 
   HttpRequestHeaders stripped_extra_headers;
   stripped_extra_headers.CopyFrom(request_info->extra_headers);
-    for (size_t i = 0; i < arraysize(kExtraHeadersToBeStripped); ++i)
-      stripped_extra_headers.RemoveHeader(kExtraHeadersToBeStripped[i]);
+  for (size_t i = 0; i < arraysize(kExtraHeadersToBeStripped); ++i)
+    stripped_extra_headers.RemoveHeader(kExtraHeadersToBeStripped[i]);
   request_headers->MergeFrom(stripped_extra_headers);
 }
 
 // The HTTP CONNECT method for establishing a tunnel connection is documented
 // in draft-luotonen-web-proxy-tunneling-01.txt and RFC 2817, Sections 5.2 and
 // 5.3.
 void BuildTunnelRequest(const HttpRequestInfo* request_info,
                         const HttpRequestHeaders& authorization_headers,
                         const HostPortPair& endpoint,
                         std::string* request_line,
@@ skipping 45 matching lines @@
   if (!StringToInt(port_protocol_vector[0], &port) ||
       port <= 0 || port >= 1 << 16) {
     DLOG(WARNING) << HttpAlternateProtocols::kHeader
                   << " header has unrecognizable port: "
                   << port_protocol_vector[0];
     return;
   }
 
   if (port_protocol_vector[1] !=
       HttpAlternateProtocols::kProtocolStrings[
-      HttpAlternateProtocols::NPN_SPDY_1]) {
+          HttpAlternateProtocols::NPN_SPDY_1]) {
     // Currently, we only recognize the npn-spdy protocol.
     DLOG(WARNING) << HttpAlternateProtocols::kHeader
                   << " header has unrecognized protocol: "
                   << port_protocol_vector[1];
     return;
   }
 
   if (alternate_protocols->HasAlternateProtocolFor(http_host_port_pair)) {
     const HttpAlternateProtocols::PortProtocolPair existing_alternate =
         alternate_protocols->GetAlternateProtocolFor(http_host_port_pair);
@@ skipping 551 matching lines @@
   if (session_->spdy_session_pool()->HasSession(endpoint_)) {
     using_spdy_ = true;
     return OK;
   }
 
   connection_group = endpoint_.ToString();
   DCHECK(!connection_group.empty());
 
   // If the user is refreshing the page, bypass the host cache.
   bool disable_resolver_cache = request_->load_flags & LOAD_BYPASS_CACHE ||
-    request_->load_flags & LOAD_DISABLE_CACHE;
+                                request_->load_flags & LOAD_DISABLE_CACHE;
 
   int rv;
   if (!proxy_info_.is_direct()) {
     ProxyServer proxy_server = proxy_info_.proxy_server();
     HostPortPair proxy_host_port_pair(proxy_server.HostNoBrackets(),
                                       proxy_server.port());
 
     TCPSocketParams tcp_params(proxy_host_port_pair, request_->priority,
                                request_->referrer, disable_resolver_cache);
 
@@ skipping 135 matching lines @@
     }
   }
 
   if (result == OK) {
     DCHECK(ssl_connect_start_time_ != base::TimeTicks());
     base::TimeDelta connect_duration =
         base::TimeTicks::Now() - ssl_connect_start_time_;
 
     if (using_spdy_) {
       UMA_HISTOGRAM_CUSTOM_TIMES("Net.SpdyConnectionLatency",
-          connect_duration,
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMinutes(10),
-          100);
+                                 connect_duration,
+                                 base::TimeDelta::FromMilliseconds(1),
+                                 base::TimeDelta::FromMinutes(10),
+                                 100);
 
       UpdateConnectionTypeHistograms(CONNECTION_SPDY);
       next_state_ = STATE_SPDY_SEND_REQUEST;
     } else {
       UMA_HISTOGRAM_CUSTOM_TIMES("Net.SSL_Connection_Latency",
-          connect_duration,
-          base::TimeDelta::FromMilliseconds(1),
-          base::TimeDelta::FromMinutes(10),
-          100);
+                                 connect_duration,
+                                 base::TimeDelta::FromMilliseconds(1),
+                                 base::TimeDelta::FromMinutes(10),
+                                 100);
 
       next_state_ = STATE_SEND_REQUEST;
     }
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
     result = HandleCertificateRequest(result);
   } else {
     result = HandleSSLHandshakeError(result);
   }
   return result;
 }
@@ skipping 163 matching lines @@
         next_state_ = STATE_SSL_CONNECT;
         // Reset for the real request and response headers.
         request_headers_.clear();
         http_stream_.reset(new HttpBasicStream(connection_.get(), net_log_));
         headers_valid_ = false;
         establishing_tunnel_ = false;
         // TODO(mbelshe): We should put in a test case to trip this code path.
         response_ = HttpResponseInfo();
         return OK;
 
-      // We aren't able to CONNECT to the remote host through the proxy.  We
-      // need to be very suspicious about the response because an active network
-      // attacker can force us into this state by masquerading as the proxy.
-      // The only safe thing to do here is to fail the connection because our
-      // client is expecting an SSL protected response.
-      // See http://crbug.com/7338.
+        // We aren't able to CONNECT to the remote host through the proxy.  We
+        // need to be very suspicious about the response because an active
+        // network attacker can force us into this state by masquerading as the
+        // proxy. The only safe thing to do here is to fail the connection
+        // because our client is expecting an SSL protected response.
+        // See http://crbug.com/7338.
       case 407:  // Proxy Authentication Required
         // We need this status code to allow proxy authentication.  Our
         // authentication code is smart enough to avoid being tricked by an
         // active network attacker.
         break;
       default:
         // For all other status codes, we conservatively fail the CONNECT
         // request.
         // We lose something by doing this.  We have seen proxy 403, 404, and
         // 501 response bodies that contain a useful error message.  For
@@ skipping 200 matching lines @@
 
   if (result <= 0)
     spdy_stream_ = NULL;
 
   return result;
 }
 
 void HttpNetworkTransaction::LogHttpConnectedMetrics(
     const ClientSocketHandle& handle) {
   UMA_HISTOGRAM_ENUMERATION("Net.HttpSocketType", handle.reuse_type(),
-      ClientSocketHandle::NUM_TYPES);
+                            ClientSocketHandle::NUM_TYPES);
 
   switch (handle.reuse_type()) {
     case ClientSocketHandle::UNUSED:
       UMA_HISTOGRAM_CUSTOM_TIMES("Net.HttpConnectionLatency",
                                  handle.setup_time(),
                                  base::TimeDelta::FromMilliseconds(1),
                                  base::TimeDelta::FromMinutes(10),
                                  100);
       break;
     case ClientSocketHandle::UNUSED_IDLE:
@@ skipping 12 matching lines @@
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void HttpNetworkTransaction::LogIOErrorMetrics(
     const ClientSocketHandle& handle) {
   UMA_HISTOGRAM_ENUMERATION("Net.IOError_SocketReuseType",
-       handle.reuse_type(), ClientSocketHandle::NUM_TYPES);
+                            handle.reuse_type(), ClientSocketHandle::NUM_TYPES);
 
   switch (handle.reuse_type()) {
     case ClientSocketHandle::UNUSED:
       break;
     case ClientSocketHandle::UNUSED_IDLE:
       UMA_HISTOGRAM_CUSTOM_TIMES(
           "Net.SocketIdleTimeOnIOError2_UnusedSocket",
           handle.idle_time(), base::TimeDelta::FromMilliseconds(1),
           base::TimeDelta::FromMinutes(6), 100);
       break;
@@ skipping 39 matching lines @@
     UMA_HISTOGRAM_CLIPPED_TIMES(
         "Net.Priority_Low_Latency",
         total_duration,
         base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10),
         100);
   }
 }
 
 void HttpNetworkTransaction::LogTransactionMetrics() const {
   base::TimeDelta duration = base::Time::Now() -
-      response_.request_time;
+                             response_.request_time;
   if (60 < duration.InMinutes())
     return;
 
   base::TimeDelta total_duration = base::Time::Now() - start_time_;
 
   UMA_HISTOGRAM_LONG_TIMES("Net.Transaction_Latency", duration);
   UMA_HISTOGRAM_CLIPPED_TIMES("Net.Transaction_Latency_Under_10", duration,
-      base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10),
-      100);
+                              base::TimeDelta::FromMilliseconds(1),
+                              base::TimeDelta::FromMinutes(10),
+                              100);
   UMA_HISTOGRAM_CLIPPED_TIMES("Net.Transaction_Latency_Total_Under_10",
-      total_duration, base::TimeDelta::FromMilliseconds(1),
-      base::TimeDelta::FromMinutes(10), 100);
+                              total_duration,
+                              base::TimeDelta::FromMilliseconds(1),
+                              base::TimeDelta::FromMinutes(10), 100);
   if (!reused_socket_) {
     UMA_HISTOGRAM_CLIPPED_TIMES(
         "Net.Transaction_Latency_Total_New_Connection_Under_10",
         total_duration, base::TimeDelta::FromMilliseconds(1),
         base::TimeDelta::FromMinutes(10), 100);
   }
 }
 
 void HttpNetworkTransaction::LogBlockedTunnelResponse(
     int response_code) const {
   LOG(WARNING) << "Blocked proxy response with status " << response_code
                << " to CONNECT request for "
                << GetHostAndPort(request_->url) << ".";
 }
 
 int HttpNetworkTransaction::HandleCertificateError(int error) {
   DCHECK(using_ssl_);
   DCHECK(IsCertificateError(error));
 
   SSLClientSocket* ssl_socket =
-    reinterpret_cast<SSLClientSocket*>(connection_->socket());
+      reinterpret_cast<SSLClientSocket*>(connection_->socket());
   ssl_socket->GetSSLInfo(&response_.ssl_info);
 
   // Add the bad certificate to the set of allowed certificates in the
   // SSL info object. This data structure will be consulted after calling
   // RestartIgnoringLastError(). And the user will be asked interactively
   // before RestartIgnoringLastError() is ever called.
   SSLConfig::CertAndStatus bad_cert;
   bad_cert.cert = response_.ssl_info.cert;
   bad_cert.cert_status = response_.ssl_info.cert_status;
   ssl_config_.allowed_bad_certs.push_back(bad_cert);
@@ skipping 41 matching lines @@
   ssl_socket->GetSSLCertRequestInfo(response_.cert_request_info);
 
   // Close the connection while the user is selecting a certificate to send
   // to the server.
   connection_->socket()->Disconnect();
   connection_->Reset();
 
   // If the user selected one of the certificate in client_certs for this
   // server before, use it automatically.
   X509Certificate* client_cert = session_->ssl_client_auth_cache()->
-      Lookup(GetHostAndPort(request_->url));
+                                 Lookup(GetHostAndPort(request_->url));
   if (client_cert) {
     const std::vector<scoped_refptr<X509Certificate> >& client_certs =
         response_.cert_request_info->client_certs;
     for (size_t i = 0; i < client_certs.size(); ++i) {
       if (client_cert->fingerprint().Equals(client_certs[i]->fingerprint())) {
         ssl_config_.client_cert = client_cert;
         ssl_config_.send_client_cert = true;
         next_state_ = STATE_INIT_CONNECTION;
         // Reset the other member variables.
         // Note: this is necessary only with SSL renegotiation.
         ResetStateForRestart();
         return OK;
       }
     }
   }
   return error;
 }
 
 int HttpNetworkTransaction::HandleSSLHandshakeError(int error) {
   if (ssl_config_.send_client_cert &&
-     (error == ERR_SSL_PROTOCOL_ERROR ||
-      error == ERR_BAD_SSL_CLIENT_AUTH_CERT)) {
+      (error == ERR_SSL_PROTOCOL_ERROR ||
+       error == ERR_BAD_SSL_CLIENT_AUTH_CERT)) {
     session_->ssl_client_auth_cache()->Remove(GetHostAndPort(request_->url));
   }
 
   switch (error) {
     case ERR_SSL_PROTOCOL_ERROR:
     case ERR_SSL_VERSION_OR_CIPHER_MISMATCH:
     case ERR_SSL_DECOMPRESSION_FAILURE_ALERT:
       if (ssl_config_.tls1_enabled) {
         // This could be a TLS-intolerant server or an SSL 3.0 server that
         // chose a TLS-only cipher suite.  Turn off TLS 1.0 and retry.
@@ skipping 331 matching lines @@
 }
 
 int HttpNetworkTransaction::HandleAuthChallenge() {
   scoped_refptr<HttpResponseHeaders> headers = GetResponseHeaders();
   DCHECK(headers);
 
   int status = headers->response_code();
   if (status != 401 && status != 407)
     return OK;
   HttpAuth::Target target = status == 407 ?
-      HttpAuth::AUTH_PROXY : HttpAuth::AUTH_SERVER;
+                            HttpAuth::AUTH_PROXY : HttpAuth::AUTH_SERVER;
   GURL auth_origin = AuthOrigin(target);
 
   LOG(INFO) << "The " << AuthTargetString(target) << " "
             << auth_origin << " requested auth"
             << AuthChallengeLogMessage();
 
   if (target == HttpAuth::AUTH_PROXY && proxy_info_.is_direct())
     return ERR_UNEXPECTED_PROXY_AUTH;
 
   // The auth we tried just failed, hence it can't be valid. Remove it from
@@ skipping 96 matching lines @@
       endpoint_);
 
   alternate_protocol_mode_ = kDoNotUseAlternateProtocol;
   if (connection_->socket())
     connection_->socket()->Disconnect();
   connection_->Reset();
   next_state_ = STATE_INIT_CONNECTION;
 }
 
 }  // namespace net