Clang format slam.

net/http/http_stream_factory_impl.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.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_pipelined_connection.h"
 #include "net/http/http_pipelined_host.h"
 #include "net/http/http_pipelined_stream.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/http/http_stream_factory_impl_request.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "url/gurl.h"
 
 namespace net {
 
 namespace {
 
 const PortAlternateProtocolPair kNoAlternateProtocol = {
-  0,  UNINITIALIZED_ALTERNATE_PROTOCOL
-};
+    0, UNINITIALIZED_ALTERNATE_PROTOCOL};
 
 GURL UpgradeUrlToHttps(const GURL& original_url, int port) {
   GURL::Replacements replacements;
   // new_sheme and new_port need to be in scope here because GURL::Replacements
   // references the memory contained by them directly.
   const std::string new_scheme = "https";
   const std::string new_port = base::IntToString(port);
   replacements.SetSchemeStr(new_scheme);
   replacements.SetPortStr(new_port);
   return original_url.ReplaceComponents(replacements);
 }
 
 }  // namespace
 
 HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session,
                                              bool for_websockets)
     : session_(session),
-      http_pipelined_host_pool_(this, NULL,
+      http_pipelined_host_pool_(this,
+                                NULL,
                                 session_->http_server_properties(),
                                 session_->force_http_pipelining()),
-      for_websockets_(for_websockets) {}
+      for_websockets_(for_websockets) {
+}
 
 HttpStreamFactoryImpl::~HttpStreamFactoryImpl() {
   DCHECK(request_map_.empty());
   DCHECK(spdy_session_request_map_.empty());
   DCHECK(http_pipelining_request_map_.empty());
 
   std::set<const Job*> tmp_job_set;
   tmp_job_set.swap(orphaned_job_set_);
   STLDeleteContainerPointers(tmp_job_set.begin(), tmp_job_set.end());
   DCHECK(orphaned_job_set_.empty());
@@ skipping 58 matching lines @@
   GURL alternate_url;
   PortAlternateProtocolPair alternate =
       GetAlternateProtocolRequestFor(request_info.url, &alternate_url);
   Job* alternate_job = NULL;
   if (alternate.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) {
     // Never share connection with other jobs for FTP requests.
     DCHECK(!request_info.url.SchemeIs("ftp"));
 
     HttpRequestInfo alternate_request_info = request_info;
     alternate_request_info.url = alternate_url;
-    alternate_job =
-        new Job(this, session_, alternate_request_info, priority,
-                server_ssl_config, proxy_ssl_config, net_log.net_log());
+    alternate_job = new Job(this,
+                            session_,
+                            alternate_request_info,
+                            priority,
+                            server_ssl_config,
+                            proxy_ssl_config,
+                            net_log.net_log());
     request->AttachJob(alternate_job);
     alternate_job->MarkAsAlternate(request_info.url, alternate);
   }
 
-  Job* job = new Job(this, session_, request_info, priority,
-                     server_ssl_config, proxy_ssl_config, net_log.net_log());
+  Job* job = new Job(this,
+                     session_,
+                     request_info,
+                     priority,
+                     server_ssl_config,
+                     proxy_ssl_config,
+                     net_log.net_log());
   request->AttachJob(job);
   if (alternate_job) {
     // Never share connection with other jobs for FTP requests.
     DCHECK(!request_info.url.SchemeIs("ftp"));
 
     job->WaitFor(alternate_job);
     // Make sure to wait until we call WaitFor(), before starting
     // |alternate_job|, otherwise |alternate_job| will not notify |job|
     // appropriately.
     alternate_job->Start(request);
@@ skipping 12 matching lines @@
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config) {
   DCHECK(!for_websockets_);
   GURL alternate_url;
   PortAlternateProtocolPair alternate =
       GetAlternateProtocolRequestFor(request_info.url, &alternate_url);
   Job* job = NULL;
   if (alternate.protocol != UNINITIALIZED_ALTERNATE_PROTOCOL) {
     HttpRequestInfo alternate_request_info = request_info;
     alternate_request_info.url = alternate_url;
-    job = new Job(this, session_, alternate_request_info, priority,
-                  server_ssl_config, proxy_ssl_config, session_->net_log());
+    job = new Job(this,
+                  session_,
+                  alternate_request_info,
+                  priority,
+                  server_ssl_config,
+                  proxy_ssl_config,
+                  session_->net_log());
     job->MarkAsAlternate(request_info.url, alternate);
   } else {
-    job = new Job(this, session_, request_info, priority,
-                  server_ssl_config, proxy_ssl_config, session_->net_log());
+    job = new Job(this,
+                  session_,
+                  request_info,
+                  priority,
+                  server_ssl_config,
+                  proxy_ssl_config,
+                  session_->net_log());
   }
   preconnect_job_set_.insert(job);
   job->Preconnect(num_streams);
 }
 
 base::Value* HttpStreamFactoryImpl::PipelineInfoToValue() const {
   return http_pipelined_host_pool_.PipelineInfoToValue();
 }
 
 const HostMappingRules* HttpStreamFactoryImpl::GetHostMappingRules() const {
@@ skipping 49 matching lines @@
 
     if (HttpStreamFactory::HasSpdyExclusion(origin))
       return kNoAlternateProtocol;
 
     *alternate_url = UpgradeUrlToHttps(original_url, alternate.port);
   } else {
     DCHECK_EQ(QUIC, alternate.protocol);
     if (!session_->params().enable_quic ||
         !(original_url.SchemeIs("http") ||
           session_->params().enable_quic_https)) {
-        return kNoAlternateProtocol;
+      return kNoAlternateProtocol;
     }
     // TODO(rch):  Figure out how to make QUIC iteract with PAC
     // scripts.  By not re-writing the URL, we will query the PAC script
     // for the proxy to use to reach the original URL via TCP.  But
     // the alternate request will be going via UDP to a different port.
     *alternate_url = original_url;
   }
   return alternate;
 }
 
@@ skipping 24 matching lines @@
     // Each iteration may empty out the RequestSet for |spdy_session_key| in
     // |spdy_session_request_map_|. So each time, check for RequestSet and use
     // the first one.
     //
     // TODO(willchan): If it's important, switch RequestSet out for a FIFO
     // queue (Order by priority first, then FIFO within same priority). Unclear
     // that it matters here.
     if (!ContainsKey(spdy_session_request_map_, spdy_session_key))
       break;
     Request* request = *spdy_session_request_map_[spdy_session_key].begin();
-    request->Complete(was_npn_negotiated,
-                      protocol_negotiated,
-                      using_spdy,
-                      net_log);
+    request->Complete(
+        was_npn_negotiated, protocol_negotiated, using_spdy, net_log);
     if (for_websockets_) {
       // TODO(ricea): Restore this code path when WebSocket over SPDY
       // implementation is ready.
       NOTREACHED();
     } else {
       bool use_relative_url = direct || request->url().SchemeIs("https");
       request->OnStreamReady(
           NULL,
           used_ssl_config,
           used_proxy_info,
@@ skipping 22 matching lines @@
             host->GetKey());
     if (!stream) {
       break;
     }
 
     Request* request = *http_pipelining_request_map_[host->GetKey()].begin();
     request->Complete(stream->was_npn_negotiated(),
                       stream->protocol_negotiated(),
                       false,  // not using_spdy
                       stream->net_log());
-    request->OnStreamReady(NULL,
-                           stream->used_ssl_config(),
-                           stream->used_proxy_info(),
-                           stream);
+    request->OnStreamReady(
+        NULL, stream->used_ssl_config(), stream->used_proxy_info(), stream);
   }
 }
 
 void HttpStreamFactoryImpl::AbortPipelinedRequestsWithKey(
-    const Job* job, const HttpPipelinedHost::Key& key, int status,
+    const Job* job,
+    const HttpPipelinedHost::Key& key,
+    int status,
     const SSLConfig& used_ssl_config) {
   RequestVector requests_to_fail = http_pipelining_request_map_[key];
   for (RequestVector::const_iterator it = requests_to_fail.begin();
-       it != requests_to_fail.end(); ++it) {
+       it != requests_to_fail.end();
+       ++it) {
     Request* request = *it;
     if (request == request_map_[job]) {
       continue;
     }
     request->OnStreamFailed(NULL, status, used_ssl_config);
   }
 }
 
 }  // namespace net