Clang format slam.

net/http/http_stream_factory_impl_job.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_stream_factory_impl_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 122 matching lines @@
 }
 
 void HttpStreamFactoryImpl::Job::Start(Request* request) {
   DCHECK(request);
   request_ = request;
   StartInternal();
 }
 
 int HttpStreamFactoryImpl::Job::Preconnect(int num_streams) {
   DCHECK_GT(num_streams, 0);
-  HostPortPair origin_server =
-      HostPortPair(request_info_.url.HostNoBrackets(),
-                   request_info_.url.EffectiveIntPort());
+  HostPortPair origin_server = HostPortPair(
+      request_info_.url.HostNoBrackets(), request_info_.url.EffectiveIntPort());
   base::WeakPtr<HttpServerProperties> http_server_properties =
       session_->http_server_properties();
   if (http_server_properties &&
       http_server_properties->SupportsSpdy(origin_server)) {
     num_streams_ = 1;
   } else {
     num_streams_ = num_streams;
   }
   return StartInternal();
 }
@@ skipping 41 matching lines @@
 void HttpStreamFactoryImpl::Job::Resume(Job* job) {
   DCHECK_EQ(blocking_job_, job);
   blocking_job_ = NULL;
 
   // We know we're blocked if the next_state_ is STATE_WAIT_FOR_JOB_COMPLETE.
   // Unblock |this|.
   if (next_state_ == STATE_WAIT_FOR_JOB_COMPLETE) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&HttpStreamFactoryImpl::Job::OnIOComplete,
-                   ptr_factory_.GetWeakPtr(), OK));
+                   ptr_factory_.GetWeakPtr(),
+                   OK));
   }
 }
 
 void HttpStreamFactoryImpl::Job::Orphan(const Request* request) {
   DCHECK_EQ(request_, request);
   request_ = NULL;
   if (blocking_job_) {
     // We've been orphaned, but there's a job we're blocked on. Don't bother
     // racing, just cancel ourself.
     DCHECK(blocking_job_->waiting_job_);
     blocking_job_->waiting_job_ = NULL;
     blocking_job_ = NULL;
-    if (stream_factory_->for_websockets_ &&
-        connection_ && connection_->socket())
+    if (stream_factory_->for_websockets_ && connection_ &&
+        connection_->socket())
       connection_->socket()->Disconnect();
     stream_factory_->OnOrphanedJobComplete(this);
   } else if (stream_factory_->for_websockets_) {
     // We cancel this job because a WebSocketHandshakeStream can't be created
     // without a WebSocketHandshakeStreamBase::CreateHelper which is stored in
     // the Request class and isn't accessible from this job.
     if (connection_ && connection_->socket())
       connection_->socket()->Disconnect();
     stream_factory_->OnOrphanedJobComplete(this);
   }
@@ skipping 41 matching lines @@
 SpdySessionKey HttpStreamFactoryImpl::Job::GetSpdySessionKey() const {
   // In the case that we're using an HTTPS proxy for an HTTP url,
   // we look for a SPDY session *to* the proxy, instead of to the
   // origin server.
   PrivacyMode privacy_mode = request_info_.privacy_mode;
   if (IsHttpsProxyAndHttpUrl()) {
     return SpdySessionKey(proxy_info_.proxy_server().host_port_pair(),
                           ProxyServer::Direct(),
                           privacy_mode);
   } else {
-    return SpdySessionKey(origin_,
-                          proxy_info_.proxy_server(),
-                          privacy_mode);
+    return SpdySessionKey(origin_, proxy_info_.proxy_server(), privacy_mode);
   }
 }
 
 bool HttpStreamFactoryImpl::Job::CanUseExistingSpdySession() const {
   // We need to make sure that if a spdy session was created for
   // https://somehost/ that we don't use that session for http://somehost:443/.
   // The only time we can use an existing session is if the request URL is
   // https (the normal case) or if we're connection to a SPDY proxy, or
   // if we're running with force_spdy_always_.  crbug.com/133176
   // TODO(ricea): Add "wss" back to this list when SPDY WebSocket support is
   // working.
   return request_info_.url.SchemeIs("https") ||
-         proxy_info_.proxy_server().is_https() ||
-         force_spdy_always_;
+         proxy_info_.proxy_server().is_https() || force_spdy_always_;
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamReadyCallback() {
   DCHECK(stream_.get());
   DCHECK(!IsPreconnecting());
   DCHECK(!stream_factory_->for_websockets_);
   if (IsOrphaned()) {
     stream_factory_->OnOrphanedJobComplete(this);
   } else {
-    request_->Complete(was_npn_negotiated(),
-                       protocol_negotiated(),
-                       using_spdy(),
-                       net_log_);
-    request_->OnStreamReady(this, server_ssl_config_, proxy_info_,
-                            stream_.release());
+    request_->Complete(
+        was_npn_negotiated(), protocol_negotiated(), using_spdy(), net_log_);
+    request_->OnStreamReady(
+        this, server_ssl_config_, proxy_info_, stream_.release());
   }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnWebSocketHandshakeStreamReadyCallback() {
   DCHECK(websocket_stream_);
   DCHECK(!IsPreconnecting());
   DCHECK(stream_factory_->for_websockets_);
   // An orphaned WebSocket job will be closed immediately and
   // never be ready.
   DCHECK(!IsOrphaned());
-  request_->Complete(was_npn_negotiated(),
-                     protocol_negotiated(),
-                     using_spdy(),
-                     net_log_);
-  request_->OnWebSocketHandshakeStreamReady(this,
-                                            server_ssl_config_,
-                                            proxy_info_,
-                                            websocket_stream_.release());
+  request_->Complete(
+      was_npn_negotiated(), protocol_negotiated(), using_spdy(), net_log_);
+  request_->OnWebSocketHandshakeStreamReady(
+      this, server_ssl_config_, proxy_info_, websocket_stream_.release());
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnNewSpdySessionReadyCallback() {
   DCHECK(stream_.get());
   DCHECK(!IsPreconnecting());
   DCHECK(using_spdy());
   // Note: an event loop iteration has passed, so |new_spdy_session_| may be
   // NULL at this point if the SpdySession closed immediately after creation.
   base::WeakPtr<SpdySession> spdy_session = new_spdy_session_;
   new_spdy_session_.reset();
   if (IsOrphaned()) {
     if (spdy_session) {
-      stream_factory_->OnNewSpdySessionReady(
-          spdy_session, spdy_session_direct_, server_ssl_config_, proxy_info_,
-          was_npn_negotiated(), protocol_negotiated(), using_spdy(), net_log_);
+      stream_factory_->OnNewSpdySessionReady(spdy_session,
+                                             spdy_session_direct_,
+                                             server_ssl_config_,
+                                             proxy_info_,
+                                             was_npn_negotiated(),
+                                             protocol_negotiated(),
+                                             using_spdy(),
+                                             net_log_);
     }
     stream_factory_->OnOrphanedJobComplete(this);
   } else {
     request_->OnNewSpdySessionReady(
         this, stream_.Pass(), spdy_session, spdy_session_direct_);
   }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamFailedCallback(int result) {
   DCHECK(!IsPreconnecting());
   if (IsOrphaned())
     stream_factory_->OnOrphanedJobComplete(this);
   else
     request_->OnStreamFailed(this, result, server_ssl_config_);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnCertificateErrorCallback(
-    int result, const SSLInfo& ssl_info) {
+    int result,
+    const SSLInfo& ssl_info) {
   DCHECK(!IsPreconnecting());
   if (IsOrphaned())
     stream_factory_->OnOrphanedJobComplete(this);
   else
     request_->OnCertificateError(this, result, server_ssl_config_, ssl_info);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnNeedsProxyAuthCallback(
     const HttpResponseInfo& response,
@@ skipping 47 matching lines @@
 
 // static
 int HttpStreamFactoryImpl::Job::OnHostResolution(
     SpdySessionPool* spdy_session_pool,
     const SpdySessionKey& spdy_session_key,
     const AddressList& addresses,
     const BoundNetLog& net_log) {
   // It is OK to dereference spdy_session_pool, because the
   // ClientSocketPoolManager will be destroyed in the same callback that
   // destroys the SpdySessionPool.
-  return
-      spdy_session_pool->FindAvailableSession(spdy_session_key, net_log) ?
-      ERR_SPDY_SESSION_ALREADY_EXISTS : OK;
+  return spdy_session_pool->FindAvailableSession(spdy_session_key, net_log)
+             ? ERR_SPDY_SESSION_ALREADY_EXISTS
+             : OK;
 }
 
 void HttpStreamFactoryImpl::Job::OnIOComplete(int result) {
   RunLoop(result);
 }
 
 int HttpStreamFactoryImpl::Job::RunLoop(int result) {
   result = DoLoop(result);
 
   if (result == ERR_IO_PENDING)
@@ skipping 12 matching lines @@
   }
 
   if (IsCertificateError(result)) {
     // Retrieve SSL information from the socket.
     GetSSLInfo();
 
     next_state_ = STATE_WAITING_USER_ACTION;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&HttpStreamFactoryImpl::Job::OnCertificateErrorCallback,
-                   ptr_factory_.GetWeakPtr(), result, ssl_info_));
+                   ptr_factory_.GetWeakPtr(),
+                   result,
+                   ssl_info_));
     return ERR_IO_PENDING;
   }
 
   switch (result) {
     case ERR_PROXY_AUTH_REQUESTED: {
       DCHECK(connection_.get());
       DCHECK(connection_->socket());
       DCHECK(establishing_tunnel_);
 
       next_state_ = STATE_WAITING_USER_ACTION;
       ProxyClientSocket* proxy_socket =
           static_cast<ProxyClientSocket*>(connection_->socket());
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&Job::OnNeedsProxyAuthCallback, ptr_factory_.GetWeakPtr(),
+          base::Bind(&Job::OnNeedsProxyAuthCallback,
+                     ptr_factory_.GetWeakPtr(),
                      *proxy_socket->GetConnectResponseInfo(),
                      proxy_socket->GetAuthController()));
       return ERR_IO_PENDING;
     }
 
     case ERR_SSL_CLIENT_AUTH_CERT_NEEDED:
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&Job::OnNeedsClientAuthCallback, ptr_factory_.GetWeakPtr(),
+          base::Bind(&Job::OnNeedsClientAuthCallback,
+                     ptr_factory_.GetWeakPtr(),
                      connection_->ssl_error_response_info().cert_request_info));
       return ERR_IO_PENDING;
 
     case ERR_HTTPS_PROXY_TUNNEL_RESPONSE: {
       DCHECK(connection_.get());
       DCHECK(connection_->socket());
       DCHECK(establishing_tunnel_);
 
       ProxyClientSocket* proxy_socket =
           static_cast<ProxyClientSocket*>(connection_->socket());
@@ skipping 23 matching lines @@
         DCHECK(stream_.get());
         base::MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&Job::OnStreamReadyCallback, ptr_factory_.GetWeakPtr()));
       }
       return ERR_IO_PENDING;
 
     default:
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
-          base::Bind(&Job::OnStreamFailedCallback, ptr_factory_.GetWeakPtr(),
-                     result));
+          base::Bind(
+              &Job::OnStreamFailedCallback, ptr_factory_.GetWeakPtr(), result));
       return ERR_IO_PENDING;
   }
 }
 
 int HttpStreamFactoryImpl::Job::DoLoop(int result) {
   DCHECK_NE(next_state_, STATE_NONE);
   int rv = result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
@@ skipping 53 matching lines @@
   CHECK_EQ(STATE_NONE, next_state_);
   next_state_ = STATE_START;
   int rv = RunLoop(OK);
   DCHECK_EQ(ERR_IO_PENDING, rv);
   return rv;
 }
 
 int HttpStreamFactoryImpl::Job::DoStart() {
   int port = request_info_.url.EffectiveIntPort();
   origin_ = HostPortPair(request_info_.url.HostNoBrackets(), port);
-  origin_url_ = stream_factory_->ApplyHostMappingRules(
-      request_info_.url, &origin_);
+  origin_url_ =
+      stream_factory_->ApplyHostMappingRules(request_info_.url, &origin_);
   http_pipelining_key_.reset(new HttpPipelinedHost::Key(origin_));
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_JOB,
                       base::Bind(&NetLogHttpStreamJobCallback,
-                                 &request_info_.url, &origin_url_,
+                                 &request_info_.url,
+                                 &origin_url_,
                                  priority_));
 
   // Don't connect to restricted ports.
   bool is_port_allowed = IsPortAllowedByDefault(port);
   if (request_info_.url.SchemeIs("ftp")) {
     // Never share connection with other jobs for FTP requests.
     DCHECK(!waiting_job_);
 
     is_port_allowed = IsPortAllowedByFtp(port);
   }
@@ skipping 65 matching lines @@
   return rv && !HttpStreamFactory::HasSpdyExclusion(origin_);
 }
 
 bool HttpStreamFactoryImpl::Job::ShouldForceSpdyWithoutSSL() const {
   bool rv = force_spdy_always_ && !force_spdy_over_ssl_;
   return rv && !HttpStreamFactory::HasSpdyExclusion(origin_);
 }
 
 bool HttpStreamFactoryImpl::Job::ShouldForceQuic() const {
   return session_->params().enable_quic &&
-    session_->params().origin_to_force_quic_on.Equals(origin_) &&
-    proxy_info_.is_direct();
+         session_->params().origin_to_force_quic_on.Equals(origin_) &&
+         proxy_info_.is_direct();
 }
 
 int HttpStreamFactoryImpl::Job::DoWaitForJob() {
   DCHECK(blocking_job_);
   next_state_ = STATE_WAIT_FOR_JOB_COMPLETE;
   return ERR_IO_PENDING;
 }
 
 int HttpStreamFactoryImpl::Job::DoWaitForJobComplete(int result) {
   DCHECK(!blocking_job_);
   DCHECK_EQ(OK, result);
   next_state_ = STATE_INIT_CONNECTION;
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnection() {
   DCHECK(!blocking_job_);
   DCHECK(!connection_->is_initialized());
   DCHECK(proxy_info_.proxy_server().is_valid());
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
   using_ssl_ = request_info_.url.SchemeIs("https") ||
-      request_info_.url.SchemeIs("wss") || ShouldForceSpdySSL();
+               request_info_.url.SchemeIs("wss") || ShouldForceSpdySSL();
   using_spdy_ = false;
 
   if (ShouldForceQuic())
     using_quic_ = true;
 
   if (proxy_info_.is_quic())
     using_quic_ = true;
 
   if (using_quic_) {
     DCHECK(session_->params().enable_quic);
     if (proxy_info_.is_quic() && !request_info_.url.SchemeIs("http")) {
       NOTREACHED();
       // TODO(rch): support QUIC proxies for HTTPS urls.
       return ERR_NOT_IMPLEMENTED;
     }
-    HostPortPair destination = proxy_info_.is_quic() ?
-        proxy_info_.proxy_server().host_port_pair() : origin_;
+    HostPortPair destination = proxy_info_.is_quic()
+                                   ? proxy_info_.proxy_server().host_port_pair()
+                                   : origin_;
     next_state_ = STATE_INIT_CONNECTION_COMPLETE;
     bool secure_quic = using_ssl_ || proxy_info_.is_quic();
-    int rv = quic_request_.Request(
-        destination, secure_quic, request_info_.privacy_mode,
-        request_info_.method, net_log_, io_callback_);
+    int rv = quic_request_.Request(destination,
+                                   secure_quic,
+                                   request_info_.privacy_mode,
+                                   request_info_.method,
+                                   net_log_,
+                                   io_callback_);
     if (rv == OK) {
       using_existing_quic_session_ = true;
     } else {
       // OK, there's no available QUIC session. Let |waiting_job_| resume
       // if it's paused.
       if (waiting_job_) {
         waiting_job_->Resume(this);
         waiting_job_ = NULL;
       }
     }
     return rv;
   }
 
   // Check first if we have a spdy session for this group.  If so, then go
   // straight to using that.
   SpdySessionKey spdy_session_key = GetSpdySessionKey();
   base::WeakPtr<SpdySession> spdy_session =
-      session_->spdy_session_pool()->FindAvailableSession(
-          spdy_session_key, net_log_);
+      session_->spdy_session_pool()->FindAvailableSession(spdy_session_key,
+                                                          net_log_);
   if (spdy_session && CanUseExistingSpdySession()) {
     // If we're preconnecting, but we already have a SpdySession, we don't
     // actually need to preconnect any sockets, so we're done.
     if (IsPreconnecting())
       return OK;
     using_spdy_ = true;
     next_state_ = STATE_CREATE_STREAM;
     existing_spdy_session_ = spdy_session;
     return OK;
   } else if (request_ && (using_ssl_ || ShouldForceSpdyWithoutSSL())) {
     // Update the spdy session key for the request that launched this job.
     request_->SetSpdySessionKey(spdy_session_key);
   } else if (IsRequestEligibleForPipelining()) {
     // TODO(simonjam): With pipelining, we might be better off using fewer
     // connections and thus should make fewer preconnections. Explore
     // preconnecting fewer than the requested num_connections.
     //
     // Separate note: A forced pipeline is always available if one exists for
     // this key. This is different than normal pipelines, which may be
     // unavailable or unusable. So, there is no need to worry about a race
     // between when a pipeline becomes available and when this job blocks.
-    existing_available_pipeline_ = stream_factory_->http_pipelined_host_pool_.
-        IsExistingPipelineAvailableForKey(*http_pipelining_key_.get());
+    existing_available_pipeline_ =
+        stream_factory_->http_pipelined_host_pool_
+            .IsExistingPipelineAvailableForKey(*http_pipelining_key_.get());
     if (existing_available_pipeline_) {
       return OK;
     } else {
-      bool was_new_key = request_->SetHttpPipeliningKey(
-          *http_pipelining_key_.get());
+      bool was_new_key =
+          request_->SetHttpPipeliningKey(*http_pipelining_key_.get());
       if (!was_new_key && session_->force_http_pipelining()) {
         return ERR_IO_PENDING;
       }
     }
   }
 
   // OK, there's no available SPDY session. Let |waiting_job_| resume if it's
   // paused.
 
   if (waiting_job_) {
     waiting_job_->Resume(this);
     waiting_job_ = NULL;
   }
 
   if (proxy_info_.is_http() || proxy_info_.is_https())
     establishing_tunnel_ = using_ssl_;
 
   bool want_spdy_over_npn = original_url_ != NULL;
 
   if (proxy_info_.is_https()) {
     InitSSLConfig(proxy_info_.proxy_server().host_port_pair(),
                   &proxy_ssl_config_,
                   true /* is a proxy server */);
     // Disable revocation checking for HTTPS proxies since the revocation
     // requests are probably going to need to go through the proxy too.
     proxy_ssl_config_.rev_checking_enabled = false;
   }
   if (using_ssl_) {
-    InitSSLConfig(origin_, &server_ssl_config_,
-                  false /* not a proxy server */);
+    InitSSLConfig(origin_, &server_ssl_config_, false /* not a proxy server */);
   }
 
   if (IsPreconnecting()) {
     DCHECK(!stream_factory_->for_websockets_);
-    return PreconnectSocketsForHttpRequest(
-        origin_url_,
-        request_info_.extra_headers,
-        request_info_.load_flags,
-        priority_,
-        session_,
-        proxy_info_,
-        ShouldForceSpdySSL(),
-        want_spdy_over_npn,
-        server_ssl_config_,
-        proxy_ssl_config_,
-        request_info_.privacy_mode,
-        net_log_,
-        num_streams_);
+    return PreconnectSocketsForHttpRequest(origin_url_,
+                                           request_info_.extra_headers,
+                                           request_info_.load_flags,
+                                           priority_,
+                                           session_,
+                                           proxy_info_,
+                                           ShouldForceSpdySSL(),
+                                           want_spdy_over_npn,
+                                           server_ssl_config_,
+                                           proxy_ssl_config_,
+                                           request_info_.privacy_mode,
+                                           net_log_,
+                                           num_streams_);
   } else {
     // If we can't use a SPDY session, don't both checking for one after
     // the hostname is resolved.
-    OnHostResolutionCallback resolution_callback = CanUseExistingSpdySession() ?
-        base::Bind(&Job::OnHostResolution, session_->spdy_session_pool(),
-                   GetSpdySessionKey()) :
-        OnHostResolutionCallback();
+    OnHostResolutionCallback resolution_callback =
+        CanUseExistingSpdySession() ? base::Bind(&Job::OnHostResolution,
+                                                 session_->spdy_session_pool(),
+                                                 GetSpdySessionKey())
+                                    : OnHostResolutionCallback();
     if (stream_factory_->for_websockets_) {
       // TODO(ricea): Re-enable NPN when WebSockets over SPDY is supported.
       SSLConfig websocket_server_ssl_config = server_ssl_config_;
       websocket_server_ssl_config.next_protos.clear();
-      return InitSocketHandleForWebSocketRequest(
-          origin_url_, request_info_.extra_headers, request_info_.load_flags,
-          priority_, session_, proxy_info_, ShouldForceSpdySSL(),
-          want_spdy_over_npn, websocket_server_ssl_config, proxy_ssl_config_,
-          request_info_.privacy_mode, net_log_,
-          connection_.get(), resolution_callback, io_callback_);
+      return InitSocketHandleForWebSocketRequest(origin_url_,
+                                                 request_info_.extra_headers,
+                                                 request_info_.load_flags,
+                                                 priority_,
+                                                 session_,
+                                                 proxy_info_,
+                                                 ShouldForceSpdySSL(),
+                                                 want_spdy_over_npn,
+                                                 websocket_server_ssl_config,
+                                                 proxy_ssl_config_,
+                                                 request_info_.privacy_mode,
+                                                 net_log_,
+                                                 connection_.get(),
+                                                 resolution_callback,
+                                                 io_callback_);
     }
-    return InitSocketHandleForHttpRequest(
-        origin_url_, request_info_.extra_headers, request_info_.load_flags,
-        priority_, session_, proxy_info_, ShouldForceSpdySSL(),
-        want_spdy_over_npn, server_ssl_config_, proxy_ssl_config_,
-        request_info_.privacy_mode, net_log_,
-        connection_.get(), resolution_callback, io_callback_);
+    return InitSocketHandleForHttpRequest(origin_url_,
+                                          request_info_.extra_headers,
+                                          request_info_.load_flags,
+                                          priority_,
+                                          session_,
+                                          proxy_info_,
+                                          ShouldForceSpdySSL(),
+                                          want_spdy_over_npn,
+                                          server_ssl_config_,
+                                          proxy_ssl_config_,
+                                          request_info_.privacy_mode,
+                                          net_log_,
+                                          connection_.get(),
+                                          resolution_callback,
+                                          io_callback_);
   }
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnectionComplete(int result) {
   if (IsPreconnecting()) {
     if (using_quic_)
       return result;
     DCHECK_EQ(OK, result);
     return OK;
   }
 
   if (result == ERR_SPDY_SESSION_ALREADY_EXISTS) {
     // We found a SPDY connection after resolving the host.  This is
     // probably an IP pooled connection.
     SpdySessionKey spdy_session_key = GetSpdySessionKey();
     existing_spdy_session_ =
-        session_->spdy_session_pool()->FindAvailableSession(
-            spdy_session_key, net_log_);
+        session_->spdy_session_pool()->FindAvailableSession(spdy_session_key,
+                                                            net_log_);
     if (existing_spdy_session_) {
       using_spdy_ = true;
       next_state_ = STATE_CREATE_STREAM;
     } else {
       // It is possible that the spdy session no longer exists.
       ReturnToStateInitConnection(true /* close connection */);
     }
     return OK;
   }
 
@@ skipping 31 matching lines @@
           static_cast<SSLClientSocket*>(connection_->socket());
       if (ssl_socket->WasNpnNegotiated()) {
         was_npn_negotiated_ = true;
         std::string proto;
         std::string server_protos;
         SSLClientSocket::NextProtoStatus status =
             ssl_socket->GetNextProto(&proto, &server_protos);
         NextProto protocol_negotiated =
             SSLClientSocket::NextProtoFromString(proto);
         protocol_negotiated_ = protocol_negotiated;
-        net_log_.AddEvent(
-            NetLog::TYPE_HTTP_STREAM_REQUEST_PROTO,
-            base::Bind(&NetLogHttpStreamProtoCallback,
-                       status, &proto, &server_protos));
+        net_log_.AddEvent(NetLog::TYPE_HTTP_STREAM_REQUEST_PROTO,
+                          base::Bind(&NetLogHttpStreamProtoCallback,
+                                     status,
+                                     &proto,
+                                     &server_protos));
         if (ssl_socket->was_spdy_negotiated())
           SwitchToSpdyMode();
       }
       if (ShouldForceSpdySSL())
         SwitchToSpdyMode();
     }
-  } else if (proxy_info_.is_https() && connection_->socket() &&
-        result == OK) {
+  } else if (proxy_info_.is_https() && connection_->socket() && result == OK) {
     ProxyClientSocket* proxy_socket =
-      static_cast<ProxyClientSocket*>(connection_->socket());
+        static_cast<ProxyClientSocket*>(connection_->socket());
     if (proxy_socket->IsUsingSpdy()) {
       was_npn_negotiated_ = true;
       protocol_negotiated_ = proxy_socket->GetProtocolNegotiated();
       SwitchToSpdyMode();
     }
   }
 
   // We may be using spdy without SSL
   if (ShouldForceSpdyWithoutSSL())
     SwitchToSpdyMode();
@@ skipping 86 matching lines @@
   // this socket.  Is there a race for two SPDY requests?  We really
   // need to plumb this through to the connect level.
   if (connection_->socket() && !connection_->is_reused())
     SetSocketMotivation();
 
   if (!using_spdy_) {
     // We may get ftp scheme when fetching ftp resources through proxy.
     bool using_proxy = (proxy_info_.is_http() || proxy_info_.is_https()) &&
                        (request_info_.url.SchemeIs("http") ||
                         request_info_.url.SchemeIs("ftp"));
-    if (stream_factory_->http_pipelined_host_pool_.
-            IsExistingPipelineAvailableForKey(*http_pipelining_key_.get())) {
+    if (stream_factory_->http_pipelined_host_pool_
+            .IsExistingPipelineAvailableForKey(*http_pipelining_key_.get())) {
       DCHECK(!stream_factory_->for_websockets_);
-      stream_.reset(stream_factory_->http_pipelined_host_pool_.
-                    CreateStreamOnExistingPipeline(
-                        *http_pipelining_key_.get()));
+      stream_.reset(
+          stream_factory_->http_pipelined_host_pool_
+              .CreateStreamOnExistingPipeline(*http_pipelining_key_.get()));
       CHECK(stream_.get());
     } else if (stream_factory_->for_websockets_) {
       DCHECK(request_);
       DCHECK(request_->websocket_handshake_stream_create_helper());
       websocket_stream_.reset(
           request_->websocket_handshake_stream_create_helper()
               ->CreateBasicStream(connection_.Pass(), using_proxy));
     } else if (!using_proxy && IsRequestEligibleForPipelining()) {
       // TODO(simonjam): Support proxies.
       stream_.reset(
@@ skipping 183 matching lines @@
         fallback = FALLBACK_SSL3;
         break;
       case SSL_PROTOCOL_VERSION_TLS1:
         fallback = FALLBACK_TLS1;
         break;
       case SSL_PROTOCOL_VERSION_TLS1_1:
         fallback = FALLBACK_TLS1_1;
         break;
     }
   }
-  UMA_HISTOGRAM_ENUMERATION("Net.ConnectionUsedSSLVersionFallback",
-                            fallback, FALLBACK_MAX);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Net.ConnectionUsedSSLVersionFallback", fallback, FALLBACK_MAX);
 
   // We also wish to measure the amount of fallback connections for a host that
   // we know implements TLS up to 1.2. Ideally there would be no fallback here
   // but high numbers of SSLv3 would suggest that SSLv3 fallback is being
   // caused by network middleware rather than buggy HTTPS servers.
   const std::string& host = origin_server.host();
-  if (!is_proxy &&
-      host.size() >= 10 &&
+  if (!is_proxy && host.size() >= 10 &&
       host.compare(host.size() - 10, 10, "google.com") == 0 &&
-      (host.size() == 10 || host[host.size()-11] == '.')) {
-    UMA_HISTOGRAM_ENUMERATION("Net.GoogleConnectionUsedSSLVersionFallback",
-                              fallback, FALLBACK_MAX);
+      (host.size() == 10 || host[host.size() - 11] == '.')) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "Net.GoogleConnectionUsedSSLVersionFallback", fallback, FALLBACK_MAX);
   }
 
   if (request_info_.load_flags & LOAD_VERIFY_EV_CERT)
     ssl_config->verify_ev_cert = true;
 
   // Disable Channel ID if privacy mode is enabled.
   if (request_info_.privacy_mode == PRIVACY_MODE_ENABLED)
     ssl_config->channel_id_enabled = false;
 }
 
-
 int HttpStreamFactoryImpl::Job::ReconsiderProxyAfterError(int error) {
   DCHECK(!pac_request_);
 
   // A failure to resolve the hostname or any error related to establishing a
   // TCP connection could be grounds for trying a new proxy configuration.
   //
   // Why do this when a hostname cannot be resolved?  Some URLs only make sense
   // to proxy servers.  The hostname in those URLs might fail to resolve if we
   // are still using a non-proxy config.  We need to check if a proxy config
   // now exists that corresponds to a proxy server that could load the URL.
@@ skipping 99 matching lines @@
 }
 
 void HttpStreamFactoryImpl::Job::SwitchToSpdyMode() {
   if (HttpStreamFactory::spdy_enabled())
     using_spdy_ = true;
 }
 
 // static
 void HttpStreamFactoryImpl::Job::LogHttpConnectedMetrics(
     const ClientSocketHandle& handle) {
-  UMA_HISTOGRAM_ENUMERATION("Net.HttpSocketType", handle.reuse_type(),
-                            ClientSocketHandle::NUM_TYPES);
+  UMA_HISTOGRAM_ENUMERATION(
+      "Net.HttpSocketType", handle.reuse_type(), 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 52 matching lines @@
   }
   if (!session_->params().http_pipelining_enabled) {
     return false;
   }
   if (using_ssl_) {
     return false;
   }
   if (request_info_.method != "GET" && request_info_.method != "HEAD") {
     return false;
   }
-  if (request_info_.load_flags &
-      (net::LOAD_MAIN_FRAME | net::LOAD_SUB_FRAME | net::LOAD_PREFETCH |
-       net::LOAD_IS_DOWNLOAD)) {
+  if (request_info_.load_flags & (net::LOAD_MAIN_FRAME | net::LOAD_SUB_FRAME |
+                                  net::LOAD_PREFETCH | net::LOAD_IS_DOWNLOAD)) {
     // Avoid pipelining resources that may be streamed for a long time.
     return false;
   }
   return stream_factory_->http_pipelined_host_pool_.IsKeyEligibleForPipelining(
       *http_pipelining_key_.get());
 }
 
 }  // namespace net