Clang format slam.

net/http/http_network_transaction.cc

Index: net/http/http_network_transaction.cc
diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc
index cf67b1d68131bc18710a182cd295efa6013a5f1d..13419a20969c488c0e1bc9df384192d3683de924 100644
--- a/net/http/http_network_transaction.cc
+++ b/net/http/http_network_transaction.cc
@@ -67,7 +67,6 @@
 #include "net/proxy/proxy_server.h"
 #endif
 
-
 using base::Time;
 using base::TimeDelta;
 
@@ -82,15 +81,14 @@ void ProcessAlternateProtocol(
     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.
@@ -155,10 +153,9 @@ HttpNetworkTransaction::~HttpNetworkTransaction() {
     // 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 {
@@ -196,7 +193,7 @@ int HttpNetworkTransaction::Start(const HttpRequestInfo* request_info,
 
   // 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;
@@ -221,15 +218,17 @@ int HttpNetworkTransaction::RestartIgnoringLastError(
 }
 
 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(
@@ -245,7 +244,8 @@ int HttpNetworkTransaction::RestartWithCertificate(
 }
 
 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();
@@ -286,8 +286,7 @@ void HttpNetworkTransaction::PrepareForAuthRestart(HttpAuth::Target target) {
   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()) {
@@ -338,10 +337,11 @@ void HttpNetworkTransaction::DidDrainBodyForAuthRestart(bool keep_alive) {
 
 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);
@@ -380,7 +380,8 @@ int HttpNetworkTransaction::Read(IOBuffer* buf, int buf_len,
   return rv;
 }
 
-void HttpNetworkTransaction::StopCaching() {}
+void HttpNetworkTransaction::StopCaching() {
+}
 
 bool HttpNetworkTransaction::GetFullRequestHeaders(
     HttpRequestHeaders* headers) const {
@@ -396,7 +397,8 @@ int64 HttpNetworkTransaction::GetTotalReceivedBytes() const {
   return total_received_bytes;
 }
 
-void HttpNetworkTransaction::DoneReading() {}
+void HttpNetworkTransaction::DoneReading() {
+}
 
 const HttpResponseInfo* HttpNetworkTransaction::GetResponseInfo() const {
   return ((headers_valid_ && response_.headers.get()) ||
@@ -435,7 +437,8 @@ UploadProgress HttpNetworkTransaction::GetUploadProgress() const {
 }
 
 void HttpNetworkTransaction::SetQuicServerInfo(
-    QuicServerInfo* quic_server_info) {}
+    QuicServerInfo* quic_server_info) {
+}
 
 bool HttpNetworkTransaction::GetLoadTimingInfo(
     LoadTimingInfo* load_timing_info) const {
@@ -553,9 +556,8 @@ void HttpNetworkTransaction::OnNeedsProxyAuth(
   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;
@@ -722,22 +724,21 @@ int HttpNetworkTransaction::DoCreateStream() {
     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;
@@ -779,7 +780,7 @@ int HttpNetworkTransaction::DoInitStreamComplete(int 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();
   }
 
@@ -797,9 +798,8 @@ int HttpNetworkTransaction::DoGenerateProxyAuthToken() {
                                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) {
@@ -823,9 +823,8 @@ int HttpNetworkTransaction::DoGenerateServerAuthToken() {
   }
   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) {
@@ -850,8 +849,8 @@ void HttpNetworkTransaction::BuildRequestHeaders(bool using_proxy) {
   // 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,
@@ -909,7 +908,7 @@ int HttpNetworkTransaction::DoBuildRequest() {
   // 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);
   }
 
@@ -1007,15 +1006,16 @@ int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
 
     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;
@@ -1024,11 +1024,11 @@ int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
           // 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(
@@ -1038,12 +1038,9 @@ int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
                 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;
           }
@@ -1057,7 +1054,7 @@ int HttpNetworkTransaction::DoReadHeadersComplete(int result) {
   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(
@@ -1209,61 +1206,63 @@ void HttpNetworkTransaction::LogTransactionConnectedMetrics() {
 
   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);
   }
 }
 
@@ -1310,7 +1309,7 @@ int HttpNetworkTransaction::HandleCertificateRequest(int error) {
         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;
   }
@@ -1318,8 +1317,9 @@ int HttpNetworkTransaction::HandleCertificateRequest(int 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;
@@ -1393,11 +1393,12 @@ int HttpNetworkTransaction::HandleSSLHandshakeError(int error) {
   }
 
   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;
@@ -1515,7 +1516,7 @@ void HttpNetworkTransaction::ResetConnectionAndRequestForResend() {
 
 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 {
@@ -1530,8 +1531,9 @@ int HttpNetworkTransaction::HandleAuthChallenge() {
   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;
 
@@ -1542,22 +1544,24 @@ int HttpNetworkTransaction::HandleAuthChallenge() {
     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 {
@@ -1574,7 +1578,7 @@ GURL HttpNetworkTransaction::AuthURL(HttpAuth::Target target) const {
     case HttpAuth::AUTH_SERVER:
       return request_->url;
     default:
-     return GURL();
+      return GURL();
   }
 }
 
@@ -1583,8 +1587,8 @@ bool HttpNetworkTransaction::ForWebSocketHandshake() const {
          request_->url.SchemeIsWSOrWSS();
 }
 
-#define STATE_CASE(s) \
-  case s: \
+#define STATE_CASE(s)                                       \
+  case s:                                                   \
     description = base::StringPrintf("%s (0x%08X)", #s, s); \
     break
 
@@ -1608,8 +1612,8 @@ std::string HttpNetworkTransaction::DescribeState(State state) {
     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;