Clang format slam.

net/http/http_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/http/http_network_transaction.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 49 matching lines @@
 #include "net/spdy/spdy_session_pool.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "url/gurl.h"
 
 #if defined(SPDY_PROXY_AUTH_ORIGIN)
 #include <algorithm>
 #include "net/proxy/proxy_server.h"
 #endif
 
-
 using base::Time;
 using base::TimeDelta;
 
 namespace net {
 
 namespace {
 
 void ProcessAlternateProtocol(
     HttpStreamFactory* factory,
     const base::WeakPtr<HttpServerProperties>& http_server_properties,
     const HttpResponseHeaders& headers,
     const HostPortPair& http_host_port_pair) {
   std::string alternate_protocol_str;
 
-  if (!headers.EnumerateHeader(NULL, kAlternateProtocolHeader,
-                               &alternate_protocol_str)) {
+  if (!headers.EnumerateHeader(
+          NULL, kAlternateProtocolHeader, &alternate_protocol_str)) {
     // Header is not present.
     return;
   }
 
-  factory->ProcessAlternateProtocol(http_server_properties,
-                                    alternate_protocol_str,
-                                    http_host_port_pair);
+  factory->ProcessAlternateProtocol(
+      http_server_properties, alternate_protocol_str, http_host_port_pair);
 }
 
 // Returns true if |error| is a client certificate authentication error.
 bool IsClientCertificateError(int error) {
   switch (error) {
     case ERR_BAD_SSL_CLIENT_AUTH_CERT:
     case ERR_SSL_CLIENT_AUTH_PRIVATE_KEY_ACCESS_DENIED:
     case ERR_SSL_CLIENT_AUTH_CERT_NO_PRIVATE_KEY:
     case ERR_SSL_CLIENT_AUTH_SIGNATURE_FAILED:
       return true;
@@ skipping 44 matching lines @@
   }
   proxy_ssl_config_ = server_ssl_config_;
 }
 
 HttpNetworkTransaction::~HttpNetworkTransaction() {
   if (stream_.get()) {
     HttpResponseHeaders* headers = GetResponseHeaders();
     // TODO(mbelshe): The stream_ should be able to compute whether or not the
     //                stream should be kept alive.  No reason to compute here
     //                and pass it in.
-    bool try_to_keep_alive =
-        next_state_ == STATE_NONE &&
-        stream_->CanFindEndOfResponse() &&
-        (!headers || headers->IsKeepAlive());
+    bool try_to_keep_alive = next_state_ == STATE_NONE &&
+                             stream_->CanFindEndOfResponse() &&
+                             (!headers || headers->IsKeepAlive());
     if (!try_to_keep_alive) {
       stream_->Close(true /* not reusable */);
     } else {
       if (stream_->IsResponseBodyComplete()) {
         // If the response body is complete, we can just reuse the socket.
         stream_->Close(false /* reusable */);
       } else if (stream_->IsSpdyHttpStream()) {
         // Doesn't really matter for SpdyHttpStream. Just close it.
         stream_->Close(true /* not reusable */);
       } else {
@@ skipping 17 matching lines @@
   request_ = request_info;
   start_time_ = base::Time::Now();
 
   if (request_->load_flags & LOAD_DISABLE_CERT_REVOCATION_CHECKING) {
     server_ssl_config_.rev_checking_enabled = false;
     proxy_ssl_config_.rev_checking_enabled = false;
   }
 
   // Channel ID is disabled if privacy mode is enabled for this request.
   bool channel_id_enabled = server_ssl_config_.channel_id_enabled &&
-      (request_->privacy_mode == PRIVACY_MODE_DISABLED);
+                            (request_->privacy_mode == PRIVACY_MODE_DISABLED);
   server_ssl_config_.channel_id_enabled = channel_id_enabled;
 
   next_state_ = STATE_NOTIFY_BEFORE_CREATE_STREAM;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
   return rv;
 }
 
 int HttpNetworkTransaction::RestartIgnoringLastError(
     const CompletionCallback& callback) {
   DCHECK(!stream_.get());
   DCHECK(!stream_request_.get());
   DCHECK_EQ(STATE_NONE, next_state_);
 
   next_state_ = STATE_CREATE_STREAM;
 
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
   return rv;
 }
 
 int HttpNetworkTransaction::RestartWithCertificate(
-    X509Certificate* client_cert, const CompletionCallback& callback) {
+    X509Certificate* client_cert,
+    const CompletionCallback& callback) {
   // In HandleCertificateRequest(), we always tear down existing stream
   // requests to force a new connection.  So we shouldn't have one here.
   DCHECK(!stream_request_.get());
   DCHECK(!stream_.get());
   DCHECK_EQ(STATE_NONE, next_state_);
 
-  SSLConfig* ssl_config = response_.cert_request_info->is_proxy ?
-      &proxy_ssl_config_ : &server_ssl_config_;
+  SSLConfig* ssl_config = response_.cert_request_info->is_proxy
+                              ? &proxy_ssl_config_
+                              : &server_ssl_config_;
   ssl_config->send_client_cert = true;
   ssl_config->client_cert = client_cert;
   session_->ssl_client_auth_cache()->Add(
       response_.cert_request_info->host_and_port, client_cert);
   // Reset the other member variables.
   // Note: this is necessary only with SSL renegotiation.
   ResetStateForRestart();
   next_state_ = STATE_CREATE_STREAM;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
   return rv;
 }
 
 int HttpNetworkTransaction::RestartWithAuth(
-    const AuthCredentials& credentials, const CompletionCallback& callback) {
+    const AuthCredentials& credentials,
+    const CompletionCallback& callback) {
   HttpAuth::Target target = pending_auth_target_;
   if (target == HttpAuth::AUTH_NONE) {
     NOTREACHED();
     return ERR_UNEXPECTED;
   }
   pending_auth_target_ = HttpAuth::AUTH_NONE;
 
   auth_controllers_[target]->ResetAuth(credentials);
 
   DCHECK(callback_.is_null());
@@ skipping 20 matching lines @@
   return rv;
 }
 
 void HttpNetworkTransaction::PrepareForAuthRestart(HttpAuth::Target target) {
   DCHECK(HaveAuth(target));
   DCHECK(!stream_request_.get());
 
   bool keep_alive = false;
   // Even if the server says the connection is keep-alive, we have to be
   // able to find the end of each response in order to reuse the connection.
-  if (GetResponseHeaders()->IsKeepAlive() &&
-      stream_->CanFindEndOfResponse()) {
+  if (GetResponseHeaders()->IsKeepAlive() && stream_->CanFindEndOfResponse()) {
     // If the response body hasn't been completely read, we need to drain
     // it first.
     if (!stream_->IsResponseBodyComplete()) {
       next_state_ = STATE_DRAIN_BODY_FOR_AUTH_RESTART;
       read_buf_ = new IOBuffer(kDrainBodyBufferSize);  // A bit bucket.
       read_buf_len_ = kDrainBodyBufferSize;
       return;
     }
     keep_alive = true;
   }
@@ skipping 30 matching lines @@
     }
     stream_.reset(new_stream);
   }
 
   // Reset the other member variables.
   ResetStateForAuthRestart();
 }
 
 bool HttpNetworkTransaction::IsReadyToRestartForAuth() {
   return pending_auth_target_ != HttpAuth::AUTH_NONE &&
-      HaveAuth(pending_auth_target_);
+         HaveAuth(pending_auth_target_);
 }
 
-int HttpNetworkTransaction::Read(IOBuffer* buf, int buf_len,
+int HttpNetworkTransaction::Read(IOBuffer* buf,
+                                 int buf_len,
                                  const CompletionCallback& callback) {
   DCHECK(buf);
   DCHECK_LT(0, buf_len);
 
   State next_state = STATE_NONE;
 
   scoped_refptr<HttpResponseHeaders> headers(GetResponseHeaders());
   if (headers_valid_ && headers.get() && stream_request_.get()) {
     // We're trying to read the body of the response but we're still trying
     // to establish an SSL tunnel through an HTTP proxy.  We can't read these
@@ skipping 18 matching lines @@
   read_buf_ = buf;
   read_buf_len_ = buf_len;
 
   next_state_ = next_state;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
   return rv;
 }
 
-void HttpNetworkTransaction::StopCaching() {}
+void HttpNetworkTransaction::StopCaching() {
+}
 
 bool HttpNetworkTransaction::GetFullRequestHeaders(
     HttpRequestHeaders* headers) const {
   // TODO(ttuttle): Make sure we've populated request_headers_.
   *headers = request_headers_;
   return true;
 }
 
 int64 HttpNetworkTransaction::GetTotalReceivedBytes() const {
   int64 total_received_bytes = total_received_bytes_;
   if (stream_)
     total_received_bytes += stream_->GetTotalReceivedBytes();
   return total_received_bytes;
 }
 
-void HttpNetworkTransaction::DoneReading() {}
+void HttpNetworkTransaction::DoneReading() {
+}
 
 const HttpResponseInfo* HttpNetworkTransaction::GetResponseInfo() const {
   return ((headers_valid_ && response_.headers.get()) ||
           response_.ssl_info.cert.get() || response_.cert_request_info.get())
              ? &response_
              : NULL;
 }
 
 LoadState HttpNetworkTransaction::GetLoadState() const {
   // TODO(wtc): Define a new LoadState value for the
@@ skipping 18 matching lines @@
 
 UploadProgress HttpNetworkTransaction::GetUploadProgress() const {
   if (!stream_.get())
     return UploadProgress();
 
   // TODO(bashi): This cast is temporary. Remove later.
   return static_cast<HttpStream*>(stream_.get())->GetUploadProgress();
 }
 
 void HttpNetworkTransaction::SetQuicServerInfo(
-    QuicServerInfo* quic_server_info) {}
+    QuicServerInfo* quic_server_info) {
+}
 
 bool HttpNetworkTransaction::GetLoadTimingInfo(
     LoadTimingInfo* load_timing_info) const {
   if (!stream_ || !stream_->GetLoadTimingInfo(load_timing_info))
     return false;
 
   load_timing_info->proxy_resolve_start =
       proxy_info_.proxy_resolve_start_time();
   load_timing_info->proxy_resolve_end = proxy_info_.proxy_resolve_end_time();
   load_timing_info->send_start = send_start_time_;
@@ skipping 97 matching lines @@
   headers_valid_ = true;
   server_ssl_config_ = used_ssl_config;
   proxy_info_ = used_proxy_info;
 
   auth_controllers_[HttpAuth::AUTH_PROXY] = auth_controller;
   pending_auth_target_ = HttpAuth::AUTH_PROXY;
 
   DoCallback(OK);
 }
 
-void HttpNetworkTransaction::OnNeedsClientAuth(
-    const SSLConfig& used_ssl_config,
-    SSLCertRequestInfo* cert_info) {
+void HttpNetworkTransaction::OnNeedsClientAuth(const SSLConfig& used_ssl_config,
+                                               SSLCertRequestInfo* cert_info) {
   DCHECK_EQ(STATE_CREATE_STREAM_COMPLETE, next_state_);
 
   server_ssl_config_ = used_ssl_config;
   response_.cert_request_info = cert_info;
   OnIOComplete(ERR_SSL_CLIENT_AUTH_CERT_NEEDED);
 }
 
 void HttpNetworkTransaction::OnHttpsProxyTunnelResponse(
     const HttpResponseInfo& response_info,
     const SSLConfig& used_ssl_config,
@@ skipping 146 matching lines @@
     return OK;
   return ERR_IO_PENDING;
 }
 
 int HttpNetworkTransaction::DoCreateStream() {
   next_state_ = STATE_CREATE_STREAM_COMPLETE;
   if (ForWebSocketHandshake()) {
     stream_request_.reset(
         session_->http_stream_factory_for_websocket()
             ->RequestWebSocketHandshakeStream(
-                  *request_,
-                  priority_,
-                  server_ssl_config_,
-                  proxy_ssl_config_,
-                  this,
-                  websocket_handshake_stream_base_create_helper_,
-                  net_log_));
+                *request_,
+                priority_,
+                server_ssl_config_,
+                proxy_ssl_config_,
+                this,
+                websocket_handshake_stream_base_create_helper_,
+                net_log_));
   } else {
     stream_request_.reset(
-        session_->http_stream_factory()->RequestStream(
-            *request_,
-            priority_,
-            server_ssl_config_,
-            proxy_ssl_config_,
-            this,
-            net_log_));
+        session_->http_stream_factory()->RequestStream(*request_,
+                                                       priority_,
+                                                       server_ssl_config_,
+                                                       proxy_ssl_config_,
+                                                       this,
+                                                       net_log_));
   }
   DCHECK(stream_request_.get());
   return ERR_IO_PENDING;
 }
 
 int HttpNetworkTransaction::DoCreateStreamComplete(int result) {
   if (result == OK) {
     next_state_ = STATE_INIT_STREAM;
     DCHECK(stream_.get());
   } else if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) {
@@ skipping 21 matching lines @@
 
 int HttpNetworkTransaction::DoInitStreamComplete(int result) {
   if (result == OK) {
     next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN;
   } else {
     if (result < 0)
       result = HandleIOError(result);
 
     // The stream initialization failed, so this stream will never be useful.
     if (stream_)
-        total_received_bytes_ += stream_->GetTotalReceivedBytes();
+      total_received_bytes_ += stream_->GetTotalReceivedBytes();
     stream_.reset();
   }
 
   return result;
 }
 
 int HttpNetworkTransaction::DoGenerateProxyAuthToken() {
   next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE;
   if (!ShouldApplyProxyAuth())
     return OK;
   HttpAuth::Target target = HttpAuth::AUTH_PROXY;
   if (!auth_controllers_[target].get())
     auth_controllers_[target] =
         new HttpAuthController(target,
                                AuthURL(target),
                                session_->http_auth_cache(),
                                session_->http_auth_handler_factory());
-  return auth_controllers_[target]->MaybeGenerateAuthToken(request_,
-                                                           io_callback_,
-                                                           net_log_);
+  return auth_controllers_[target]->MaybeGenerateAuthToken(
+      request_, io_callback_, net_log_);
 }
 
 int HttpNetworkTransaction::DoGenerateProxyAuthTokenComplete(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   if (rv == OK)
     next_state_ = STATE_GENERATE_SERVER_AUTH_TOKEN;
   return rv;
 }
 
 int HttpNetworkTransaction::DoGenerateServerAuthToken() {
   next_state_ = STATE_GENERATE_SERVER_AUTH_TOKEN_COMPLETE;
   HttpAuth::Target target = HttpAuth::AUTH_SERVER;
   if (!auth_controllers_[target].get()) {
     auth_controllers_[target] =
         new HttpAuthController(target,
                                AuthURL(target),
                                session_->http_auth_cache(),
                                session_->http_auth_handler_factory());
     if (request_->load_flags & LOAD_DO_NOT_USE_EMBEDDED_IDENTITY)
       auth_controllers_[target]->DisableEmbeddedIdentity();
   }
   if (!ShouldApplyServerAuth())
     return OK;
-  return auth_controllers_[target]->MaybeGenerateAuthToken(request_,
-                                                           io_callback_,
-                                                           net_log_);
+  return auth_controllers_[target]->MaybeGenerateAuthToken(
+      request_, io_callback_, net_log_);
 }
 
 int HttpNetworkTransaction::DoGenerateServerAuthTokenComplete(int rv) {
   DCHECK_NE(ERR_IO_PENDING, rv);
   if (rv == OK)
     next_state_ = STATE_INIT_REQUEST_BODY;
   return rv;
 }
 
 void HttpNetworkTransaction::BuildRequestHeaders(bool using_proxy) {
   request_headers_.SetHeader(HttpRequestHeaders::kHost,
                              GetHostAndOptionalPort(request_->url));
 
   // For compat with HTTP/1.0 servers and proxies:
   if (using_proxy) {
     request_headers_.SetHeader(HttpRequestHeaders::kProxyConnection,
                                "keep-alive");
   } else {
     request_headers_.SetHeader(HttpRequestHeaders::kConnection, "keep-alive");
   }
 
   // Add a content length header?
   if (request_->upload_data_stream) {
     if (request_->upload_data_stream->is_chunked()) {
-      request_headers_.SetHeader(
-          HttpRequestHeaders::kTransferEncoding, "chunked");
+      request_headers_.SetHeader(HttpRequestHeaders::kTransferEncoding,
+                                 "chunked");
     } else {
       request_headers_.SetHeader(
           HttpRequestHeaders::kContentLength,
           base::Uint64ToString(request_->upload_data_stream->size()));
     }
   } else if (request_->method == "POST" || request_->method == "PUT" ||
              request_->method == "HEAD") {
     // An empty POST/PUT request still needs a content length.  As for HEAD,
     // IE and Safari also add a content length header.  Presumably it is to
     // support sending a HEAD request to an URL that only expects to be sent a
@@ skipping 37 matching lines @@
 }
 
 int HttpNetworkTransaction::DoBuildRequest() {
   next_state_ = STATE_BUILD_REQUEST_COMPLETE;
   headers_valid_ = false;
 
   // This is constructed lazily (instead of within our Start method), so that
   // we have proxy info available.
   if (request_headers_.IsEmpty()) {
     bool using_proxy = (proxy_info_.is_http() || proxy_info_.is_https()) &&
-                        !is_https_request();
+                       !is_https_request();
     BuildRequestHeaders(using_proxy);
   }
 
   return OK;
 }
 
 int HttpNetworkTransaction::DoBuildRequestComplete(int result) {
   if (result == OK)
     next_state_ = STATE_SEND_REQUEST;
   return result;
@@ skipping 77 matching lines @@
     bool data_reduction_fallback_proxy_used = false;
 #if defined(DATA_REDUCTION_FALLBACK_HOST)
     if (!data_reduction_proxy_used) {
       data_reduction_fallback_proxy_used =
           proxy_info_.proxy_server().isDataReductionProxyFallback();
     }
 #endif
 
     if (data_reduction_proxy_used || data_reduction_fallback_proxy_used) {
       net::HttpResponseHeaders::DataReductionProxyInfo
-      data_reduction_proxy_info;
-      proxy_bypass_event
-          = response_.headers->GetDataReductionProxyBypassEventType(
+          data_reduction_proxy_info;
+      proxy_bypass_event =
+          response_.headers->GetDataReductionProxyBypassEventType(
               &data_reduction_proxy_info);
       if (proxy_bypass_event < ProxyService::BYPASS_EVENT_TYPE_MAX) {
         ProxyService* proxy_service = session_->proxy_service();
 
         proxy_service->RecordDataReductionProxyBypassInfo(
-            data_reduction_proxy_used, proxy_info_.proxy_server(),
+            data_reduction_proxy_used,
+            proxy_info_.proxy_server(),
             proxy_bypass_event);
 
         ProxyServer proxy_server;
 #if defined(DATA_REDUCTION_FALLBACK_HOST)
         if (data_reduction_proxy_used && data_reduction_proxy_info.bypass_all) {
           // TODO(bengr): Rename as DATA_REDUCTION_FALLBACK_ORIGIN.
           GURL proxy_url(DATA_REDUCTION_FALLBACK_HOST);
           if (proxy_url.SchemeIsHTTPOrHTTPS()) {
-            proxy_server = ProxyServer(proxy_url.SchemeIs("http") ?
-                                           ProxyServer::SCHEME_HTTP :
-                                           ProxyServer::SCHEME_HTTPS,
+            proxy_server = ProxyServer(proxy_url.SchemeIs("http")
+                                           ? ProxyServer::SCHEME_HTTP
+                                           : ProxyServer::SCHEME_HTTPS,
                                        HostPortPair::FromURL(proxy_url));
-            }
+          }
         }
 #endif
         if (proxy_service->MarkProxiesAsBadUntil(
                 proxy_info_,
                 data_reduction_proxy_info.bypass_duration,
                 proxy_server,
                 net_log_)) {
           // Only retry idempotent methods. We don't want to resubmit a POST
           // if the proxy took some action.
-          if (request_->method == "GET" ||
-              request_->method == "OPTIONS" ||
-              request_->method == "HEAD" ||
-              request_->method == "PUT" ||
-              request_->method == "DELETE" ||
-              request_->method == "TRACE") {
+          if (request_->method == "GET" || request_->method == "OPTIONS" ||
+              request_->method == "HEAD" || request_->method == "PUT" ||
+              request_->method == "DELETE" || request_->method == "TRACE") {
             ResetConnectionAndRequestForResend();
             return OK;
           }
         }
       }
     }
   }
 #endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
 
   // Like Net.HttpResponseCode, but only for MAIN_FRAME loads.
   if (request_->load_flags & LOAD_MAIN_FRAME) {
     const int response_code = response_.headers->response_code();
     UMA_HISTOGRAM_ENUMERATION(
-        "Net.HttpResponseCode_Nxx_MainFrame", response_code/100, 10);
+        "Net.HttpResponseCode_Nxx_MainFrame", response_code / 100, 10);
   }
 
   net_log_.AddEvent(
       NetLog::TYPE_HTTP_TRANSACTION_READ_RESPONSE_HEADERS,
       base::Bind(&HttpResponseHeaders::NetLogCallback, response_.headers));
 
   if (response_.headers->GetParsedHttpVersion() < HttpVersion(1, 0)) {
     // HTTP/0.9 doesn't support the PUT method, so lack of response headers
     // indicates a buggy server.  See:
     // https://bugzilla.mozilla.org/show_bug.cgi?id=193921
@@ skipping 131 matching lines @@
 }
 
 void HttpNetworkTransaction::LogTransactionConnectedMetrics() {
   if (logged_response_time_)
     return;
 
   logged_response_time_ = true;
 
   base::TimeDelta total_duration = response_.response_time - start_time_;
 
-  UMA_HISTOGRAM_CUSTOM_TIMES(
-      "Net.Transaction_Connected",
-      total_duration,
-      base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10),
-      100);
+  UMA_HISTOGRAM_CUSTOM_TIMES("Net.Transaction_Connected",
+                             total_duration,
+                             base::TimeDelta::FromMilliseconds(1),
+                             base::TimeDelta::FromMinutes(10),
+                             100);
 
   bool reused_socket = stream_->IsConnectionReused();
   if (!reused_socket) {
-    UMA_HISTOGRAM_CUSTOM_TIMES(
-        "Net.Transaction_Connected_New_b",
-        total_duration,
-        base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10),
-        100);
+    UMA_HISTOGRAM_CUSTOM_TIMES("Net.Transaction_Connected_New_b",
+                               total_duration,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromMinutes(10),
+                               100);
   }
 
   // Currently, non-HIGHEST priority requests are frame or sub-frame resource
   // types.  This will change when we also prioritize certain subresources like
   // css, js, etc.
   if (priority_ != HIGHEST) {
-    UMA_HISTOGRAM_CUSTOM_TIMES(
-        "Net.Priority_High_Latency_b",
-        total_duration,
-        base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10),
-        100);
+    UMA_HISTOGRAM_CUSTOM_TIMES("Net.Priority_High_Latency_b",
+                               total_duration,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromMinutes(10),
+                               100);
   } else {
-    UMA_HISTOGRAM_CUSTOM_TIMES(
-        "Net.Priority_Low_Latency_b",
-        total_duration,
-        base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromMinutes(10),
-        100);
+    UMA_HISTOGRAM_CUSTOM_TIMES("Net.Priority_Low_Latency_b",
+                               total_duration,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromMinutes(10),
+                               100);
   }
 }
 
 void HttpNetworkTransaction::LogTransactionMetrics() const {
-  base::TimeDelta duration = base::Time::Now() -
-                             response_.request_time;
+  base::TimeDelta duration = base::Time::Now() - response_.request_time;
   if (60 < duration.InMinutes())
     return;
 
   base::TimeDelta total_duration = base::Time::Now() - start_time_;
 
-  UMA_HISTOGRAM_CUSTOM_TIMES("Net.Transaction_Latency_b", duration,
+  UMA_HISTOGRAM_CUSTOM_TIMES("Net.Transaction_Latency_b",
+                             duration,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(10),
                              100);
   UMA_HISTOGRAM_CUSTOM_TIMES("Net.Transaction_Latency_Total",
                              total_duration,
                              base::TimeDelta::FromMilliseconds(1),
-                             base::TimeDelta::FromMinutes(10), 100);
+                             base::TimeDelta::FromMinutes(10),
+                             100);
 
   if (!stream_->IsConnectionReused()) {
-    UMA_HISTOGRAM_CUSTOM_TIMES(
-        "Net.Transaction_Latency_Total_New_Connection",
-        total_duration, base::TimeDelta::FromMilliseconds(1),
-        base::TimeDelta::FromMinutes(10), 100);
+    UMA_HISTOGRAM_CUSTOM_TIMES("Net.Transaction_Latency_Total_New_Connection",
+                               total_duration,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromMinutes(10),
+                               100);
   }
 }
 
 int HttpNetworkTransaction::HandleCertificateRequest(int error) {
   // There are two paths through which the server can request a certificate
   // from us.  The first is during the initial handshake, the second is
   // during SSL renegotiation.
   //
   // In both cases, we want to close the connection before proceeding.
   // We do this for two reasons:
@@ skipping 26 matching lines @@
     return error;
 
   // Check that the certificate selected is still a certificate the server
   // is likely to accept, based on the criteria supplied in the
   // CertificateRequest message.
   if (client_cert.get()) {
     const std::vector<std::string>& cert_authorities =
         response_.cert_request_info->cert_authorities;
 
     bool cert_still_valid = cert_authorities.empty() ||
-        client_cert->IsIssuedByEncoded(cert_authorities);
+                            client_cert->IsIssuedByEncoded(cert_authorities);
     if (!cert_still_valid)
       return error;
   }
 
   // TODO(davidben): Add a unit test which covers this path; we need to be
   // able to send a legitimate certificate and also bypass/clear the
   // SSL session cache.
-  SSLConfig* ssl_config = response_.cert_request_info->is_proxy ?
-      &proxy_ssl_config_ : &server_ssl_config_;
+  SSLConfig* ssl_config = response_.cert_request_info->is_proxy
+                              ? &proxy_ssl_config_
+                              : &server_ssl_config_;
   ssl_config->send_client_cert = true;
   ssl_config->client_cert = client_cert;
   next_state_ = STATE_CREATE_STREAM;
   // Reset the other member variables.
   // Note: this is necessary only with SSL renegotiation.
   ResetStateForRestart();
   return OK;
 }
 
 void HttpNetworkTransaction::HandleClientAuthError(int error) {
@@ skipping 53 matching lines @@
     case ERR_SSL_INAPPROPRIATE_FALLBACK:
       // The server told us that we should not have fallen back. A buggy server
       // could trigger ERR_SSL_INAPPROPRIATE_FALLBACK with the initial
       // connection. |fallback_error_code_| is initialised to
       // ERR_SSL_INAPPROPRIATE_FALLBACK to catch this case.
       error = fallback_error_code_;
       break;
   }
 
   if (should_fallback) {
-    net_log_.AddEvent(
-        NetLog::TYPE_SSL_VERSION_FALLBACK,
-        base::Bind(&NetLogSSLVersionFallbackCallback,
-                   &request_->url, error, server_ssl_config_.version_max,
-                   version_max));
+    net_log_.AddEvent(NetLog::TYPE_SSL_VERSION_FALLBACK,
+                      base::Bind(&NetLogSSLVersionFallbackCallback,
+                                 &request_->url,
+                                 error,
+                                 server_ssl_config_.version_max,
+                                 version_max));
     fallback_error_code_ = error;
     server_ssl_config_.version_max = version_max;
     server_ssl_config_.version_fallback = true;
     ResetConnectionAndRequestForResend();
     error = OK;
   }
 
   return error;
 }
 
@@ skipping 97 matching lines @@
 
   // We need to clear request_headers_ because it contains the real request
   // headers, but we may need to resend the CONNECT request first to recreate
   // the SSL tunnel.
   request_headers_.Clear();
   next_state_ = STATE_CREATE_STREAM;  // Resend the request.
 }
 
 bool HttpNetworkTransaction::ShouldApplyProxyAuth() const {
   return !is_https_request() &&
-      (proxy_info_.is_https() || proxy_info_.is_http());
+         (proxy_info_.is_https() || proxy_info_.is_http());
 }
 
 bool HttpNetworkTransaction::ShouldApplyServerAuth() const {
   return !(request_->load_flags & LOAD_DO_NOT_SEND_AUTH_DATA);
 }
 
 int HttpNetworkTransaction::HandleAuthChallenge() {
   scoped_refptr<HttpResponseHeaders> headers(GetResponseHeaders());
   DCHECK(headers.get());
 
   int status = headers->response_code();
   if (status != HTTP_UNAUTHORIZED &&
       status != HTTP_PROXY_AUTHENTICATION_REQUIRED)
     return OK;
-  HttpAuth::Target target = status == HTTP_PROXY_AUTHENTICATION_REQUIRED ?
-                            HttpAuth::AUTH_PROXY : HttpAuth::AUTH_SERVER;
+  HttpAuth::Target target = status == HTTP_PROXY_AUTHENTICATION_REQUIRED
+                                ? HttpAuth::AUTH_PROXY
+                                : HttpAuth::AUTH_SERVER;
   if (target == HttpAuth::AUTH_PROXY && proxy_info_.is_direct())
     return ERR_UNEXPECTED_PROXY_AUTH;
 
   // This case can trigger when an HTTPS server responds with a "Proxy
   // authentication required" status code through a non-authenticating
   // proxy.
   if (!auth_controllers_[target].get())
     return ERR_UNEXPECTED_PROXY_AUTH;
 
   int rv = auth_controllers_[target]->HandleAuthChallenge(
-      headers, (request_->load_flags & LOAD_DO_NOT_SEND_AUTH_DATA) != 0, false,
+      headers,
+      (request_->load_flags & LOAD_DO_NOT_SEND_AUTH_DATA) != 0,
+      false,
       net_log_);
   if (auth_controllers_[target]->HaveAuthHandler())
-      pending_auth_target_ = target;
+    pending_auth_target_ = target;
 
   scoped_refptr<AuthChallengeInfo> auth_info =
       auth_controllers_[target]->auth_info();
   if (auth_info.get())
-      response_.auth_challenge = auth_info;
+    response_.auth_challenge = auth_info;
 
   return rv;
 }
 
 bool HttpNetworkTransaction::HaveAuth(HttpAuth::Target target) const {
   return auth_controllers_[target].get() &&
-      auth_controllers_[target]->HaveAuth();
+         auth_controllers_[target]->HaveAuth();
 }
 
 GURL HttpNetworkTransaction::AuthURL(HttpAuth::Target target) const {
   switch (target) {
     case HttpAuth::AUTH_PROXY: {
       if (!proxy_info_.proxy_server().is_valid() ||
           proxy_info_.proxy_server().is_direct()) {
         return GURL();  // There is no proxy server.
       }
       const char* scheme = proxy_info_.is_https() ? "https://" : "http://";
       return GURL(scheme +
                   proxy_info_.proxy_server().host_port_pair().ToString());
     }
     case HttpAuth::AUTH_SERVER:
       return request_->url;
     default:
-     return GURL();
+      return GURL();
   }
 }
 
 bool HttpNetworkTransaction::ForWebSocketHandshake() const {
   return websocket_handshake_stream_base_create_helper_ &&
          request_->url.SchemeIsWSOrWSS();
 }
 
-#define STATE_CASE(s) \
-  case s: \
+#define STATE_CASE(s)                                       \
+  case s:                                                   \
     description = base::StringPrintf("%s (0x%08X)", #s, s); \
     break
 
 std::string HttpNetworkTransaction::DescribeState(State state) {
   std::string description;
   switch (state) {
     STATE_CASE(STATE_NOTIFY_BEFORE_CREATE_STREAM);
     STATE_CASE(STATE_CREATE_STREAM);
     STATE_CASE(STATE_CREATE_STREAM_COMPLETE);
     STATE_CASE(STATE_INIT_REQUEST_BODY);
     STATE_CASE(STATE_INIT_REQUEST_BODY_COMPLETE);
     STATE_CASE(STATE_BUILD_REQUEST);
     STATE_CASE(STATE_BUILD_REQUEST_COMPLETE);
     STATE_CASE(STATE_SEND_REQUEST);
     STATE_CASE(STATE_SEND_REQUEST_COMPLETE);
     STATE_CASE(STATE_READ_HEADERS);
     STATE_CASE(STATE_READ_HEADERS_COMPLETE);
     STATE_CASE(STATE_READ_BODY);
     STATE_CASE(STATE_READ_BODY_COMPLETE);
     STATE_CASE(STATE_DRAIN_BODY_FOR_AUTH_RESTART);
     STATE_CASE(STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE);
     STATE_CASE(STATE_NONE);
     default:
-      description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
-                                       state);
+      description =
+          base::StringPrintf("Unknown state 0x%08X (%u)", state, state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net