Clang format slam.

net/http/http_pipelined_host_pool.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_pipelined_host_pool.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "net/http/http_pipelined_host_capability.h"
@@ skipping 49 matching lines @@
     ClientSocketHandle* connection,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     const BoundNetLog& net_log,
     bool was_npn_negotiated,
     NextProto protocol_negotiated) {
   HttpPipelinedHost* host = GetPipelinedHost(key, true);
   if (!host) {
     return NULL;
   }
-  return host->CreateStreamOnNewPipeline(connection, used_ssl_config,
-                                         used_proxy_info, net_log,
+  return host->CreateStreamOnNewPipeline(connection,
+                                         used_ssl_config,
+                                         used_proxy_info,
+                                         net_log,
                                          was_npn_negotiated,
                                          protocol_negotiated);
 }
 
 HttpPipelinedStream* HttpPipelinedHostPool::CreateStreamOnExistingPipeline(
     const HttpPipelinedHost::Key& key) {
   HttpPipelinedHost* host = GetPipelinedHost(key, false);
   if (!host) {
     return NULL;
   }
   return host->CreateStreamOnExistingPipeline();
 }
 
 bool HttpPipelinedHostPool::IsExistingPipelineAvailableForKey(
     const HttpPipelinedHost::Key& key) {
   HttpPipelinedHost* host = GetPipelinedHost(key, false);
   if (!host) {
     return false;
   }
   return host->IsExistingPipelineAvailable();
 }
 
 HttpPipelinedHost* HttpPipelinedHostPool::GetPipelinedHost(
-    const HttpPipelinedHost::Key& key, bool create_if_not_found) {
+    const HttpPipelinedHost::Key& key,
+    bool create_if_not_found) {
   HostMap::iterator host_it = host_map_.find(key);
   if (host_it != host_map_.end()) {
     CHECK(host_it->second);
     return host_it->second;
   } else if (!create_if_not_found) {
     return NULL;
   }
 
   HttpPipelinedHostCapability capability =
       http_server_properties_->GetPipelineCapability(key.origin());
   if (capability == PIPELINE_INCAPABLE) {
     return NULL;
   }
 
-  HttpPipelinedHost* host = factory_->CreateNewHost(
-      this, key, NULL, capability, force_pipelining_);
+  HttpPipelinedHost* host =
+      factory_->CreateNewHost(this, key, NULL, capability, force_pipelining_);
   host_map_[key] = host;
   return host;
 }
 
 void HttpPipelinedHostPool::OnHostIdle(HttpPipelinedHost* host) {
   const HttpPipelinedHost::Key& key = host->GetKey();
   CHECK(ContainsKey(host_map_, key));
   host_map_.erase(key);
   delete host;
 }
 
 void HttpPipelinedHostPool::OnHostHasAdditionalCapacity(
     HttpPipelinedHost* host) {
   delegate_->OnHttpPipelinedHostHasAdditionalCapacity(host);
 }
 
 void HttpPipelinedHostPool::OnHostDeterminedCapability(
     HttpPipelinedHost* host,
     HttpPipelinedHostCapability capability) {
   http_server_properties_->SetPipelineCapability(host->GetKey().origin(),
                                                  capability);
 }
 
 base::Value* HttpPipelinedHostPool::PipelineInfoToValue() const {
   base::ListValue* list = new base::ListValue();
-  for (HostMap::const_iterator it = host_map_.begin();
-       it != host_map_.end(); ++it) {
+  for (HostMap::const_iterator it = host_map_.begin(); it != host_map_.end();
+       ++it) {
     base::Value* value = it->second->PipelineInfoToValue();
     list->Append(value);
   }
   return list;
 }
 
 }  // namespace net