Clang format slam.

net/http/http_stream_factory_impl_request.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_request.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/http/http_stream_factory_impl_job.h"
@@ skipping 49 matching lines @@
   RequestSet& request_set =
       factory_->spdy_session_request_map_[spdy_session_key];
   DCHECK(!ContainsKey(request_set, this));
   request_set.insert(this);
 }
 
 bool HttpStreamFactoryImpl::Request::SetHttpPipeliningKey(
     const HttpPipelinedHost::Key& http_pipelining_key) {
   CHECK(!http_pipelining_key_.get());
   http_pipelining_key_.reset(new HttpPipelinedHost::Key(http_pipelining_key));
-  bool was_new_key = !ContainsKey(factory_->http_pipelining_request_map_,
-                                  http_pipelining_key);
+  bool was_new_key =
+      !ContainsKey(factory_->http_pipelining_request_map_, http_pipelining_key);
   RequestVector& request_vector =
       factory_->http_pipelining_request_map_[http_pipelining_key];
   request_vector.push_back(this);
   return was_new_key;
 }
 
 void HttpStreamFactoryImpl::Request::AttachJob(Job* job) {
   DCHECK(job);
   jobs_.insert(job);
   factory_->request_map_[job] = this;
 }
 
-void HttpStreamFactoryImpl::Request::Complete(
-    bool was_npn_negotiated,
-    NextProto protocol_negotiated,
-    bool using_spdy,
-    const BoundNetLog& job_net_log) {
+void HttpStreamFactoryImpl::Request::Complete(bool was_npn_negotiated,
+                                              NextProto protocol_negotiated,
+                                              bool using_spdy,
+                                              const BoundNetLog& job_net_log) {
   DCHECK(!completed_);
   completed_ = true;
   was_npn_negotiated_ = was_npn_negotiated;
   protocol_negotiated_ = protocol_negotiated;
   using_spdy_ = using_spdy;
-  net_log_.AddEvent(
-      NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB,
-      job_net_log.source().ToEventParametersCallback());
-  job_net_log.AddEvent(
-      NetLog::TYPE_HTTP_STREAM_JOB_BOUND_TO_REQUEST,
-      net_log_.source().ToEventParametersCallback());
+  net_log_.AddEvent(NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB,
+                    job_net_log.source().ToEventParametersCallback());
+  job_net_log.AddEvent(NetLog::TYPE_HTTP_STREAM_JOB_BOUND_TO_REQUEST,
+                       net_log_.source().ToEventParametersCallback());
 }
 
 void HttpStreamFactoryImpl::Request::OnStreamReady(
     Job* job,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     HttpStreamBase* stream) {
   DCHECK(!factory_->for_websockets_);
   DCHECK(stream);
   DCHECK(completed_);
@@ skipping 82 matching lines @@
     const SSLConfig& used_ssl_config,
     SSLCertRequestInfo* cert_info) {
   if (!bound_job_.get())
     OrphanJobsExcept(job);
   else
     DCHECK(jobs_.empty());
   delegate_->OnNeedsClientAuth(used_ssl_config, cert_info);
 }
 
 void HttpStreamFactoryImpl::Request::OnHttpsProxyTunnelResponse(
-    Job *job,
+    Job* job,
     const HttpResponseInfo& response_info,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     HttpStreamBase* stream) {
   if (!bound_job_.get())
     OrphanJobsExcept(job);
   else
     DCHECK(jobs_.empty());
   delegate_->OnHttpsProxyTunnelResponse(
       response_info, used_ssl_config, used_proxy_info, stream);
 }
 
 int HttpStreamFactoryImpl::Request::RestartTunnelWithProxyAuth(
     const AuthCredentials& credentials) {
   DCHECK(bound_job_.get());
   return bound_job_->RestartTunnelWithProxyAuth(credentials);
 }
 
 void HttpStreamFactoryImpl::Request::SetPriority(RequestPriority priority) {
   for (std::set<HttpStreamFactoryImpl::Job*>::const_iterator it = jobs_.begin();
-       it != jobs_.end(); ++it) {
+       it != jobs_.end();
+       ++it) {
     (*it)->SetPriority(priority);
   }
   if (bound_job_)
     bound_job_->SetPriority(priority);
 }
 
 LoadState HttpStreamFactoryImpl::Request::GetLoadState() const {
   if (bound_job_.get())
     return bound_job_->GetLoadState();
   DCHECK(!jobs_.empty());
 
   // Just pick the first one.
   return (*jobs_.begin())->GetLoadState();
 }
 
 bool HttpStreamFactoryImpl::Request::was_npn_negotiated() const {
   DCHECK(completed_);
   return was_npn_negotiated_;
 }
 
-NextProto HttpStreamFactoryImpl::Request::protocol_negotiated()
-    const {
+NextProto HttpStreamFactoryImpl::Request::protocol_negotiated() const {
   DCHECK(completed_);
   return protocol_negotiated_;
 }
 
 bool HttpStreamFactoryImpl::Request::using_spdy() const {
   DCHECK(completed_);
   return using_spdy_;
 }
 
-void
-HttpStreamFactoryImpl::Request::RemoveRequestFromSpdySessionRequestMap() {
+void HttpStreamFactoryImpl::Request::RemoveRequestFromSpdySessionRequestMap() {
   if (spdy_session_key_.get()) {
     SpdySessionRequestMap& spdy_session_request_map =
         factory_->spdy_session_request_map_;
     DCHECK(ContainsKey(spdy_session_request_map, *spdy_session_key_));
-    RequestSet& request_set =
-        spdy_session_request_map[*spdy_session_key_];
+    RequestSet& request_set = spdy_session_request_map[*spdy_session_key_];
     DCHECK(ContainsKey(request_set, this));
     request_set.erase(this);
     if (request_set.empty())
       spdy_session_request_map.erase(*spdy_session_key_);
     spdy_session_key_.reset();
   }
 }
 
 void
 HttpStreamFactoryImpl::Request::RemoveRequestFromHttpPipeliningRequestMap() {
   if (http_pipelining_key_.get()) {
     HttpPipeliningRequestMap& http_pipelining_request_map =
         factory_->http_pipelining_request_map_;
     DCHECK(ContainsKey(http_pipelining_request_map, *http_pipelining_key_));
     RequestVector& request_vector =
         http_pipelining_request_map[*http_pipelining_key_];
     for (RequestVector::iterator it = request_vector.begin();
-         it != request_vector.end(); ++it) {
+         it != request_vector.end();
+         ++it) {
       if (*it == this) {
         request_vector.erase(it);
         break;
       }
     }
     if (request_vector.empty())
       http_pipelining_request_map.erase(*http_pipelining_key_);
     http_pipelining_key_.reset();
   }
 }
@@ skipping 15 matching lines @@
     OrphanJobsExcept(job);
   } else {  // This is the case for HTTPS proxy tunneling.
     DCHECK_EQ(bound_job_.get(), job);
     DCHECK(jobs_.empty());
   }
 
   // Cache these values in case the job gets deleted.
   const SSLConfig used_ssl_config = job->server_ssl_config();
   const ProxyInfo used_proxy_info = job->proxy_info();
   const bool was_npn_negotiated = job->was_npn_negotiated();
-  const NextProto protocol_negotiated =
-      job->protocol_negotiated();
+  const NextProto protocol_negotiated = job->protocol_negotiated();
   const bool using_spdy = job->using_spdy();
   const BoundNetLog net_log = job->net_log();
 
   Complete(was_npn_negotiated, protocol_negotiated, using_spdy, net_log);
 
   // Cache this so we can still use it if the request is deleted.
   HttpStreamFactoryImpl* factory = factory_;
   if (factory->for_websockets_) {
     // TODO(ricea): Re-instate this code when WebSockets over SPDY is
     // implemented.
     NOTREACHED();
   } else {
-    delegate_->OnStreamReady(job->server_ssl_config(), job->proxy_info(),
-                             stream.release());
+    delegate_->OnStreamReady(
+        job->server_ssl_config(), job->proxy_info(), stream.release());
   }
   // |this| may be deleted after this point.
   if (spdy_session) {
     factory->OnNewSpdySessionReady(spdy_session,
                                    direct,
                                    used_ssl_config,
                                    used_proxy_info,
                                    was_npn_negotiated,
                                    protocol_negotiated,
                                    using_spdy,
@@ skipping 45 matching lines @@
       job->ReportJobSuccededForRequest();
     // We may have other jobs in |jobs_|. For example, if we start multiple jobs
     // for Alternate-Protocol.
     OrphanJobsExcept(job);
     return;
   }
   DCHECK(jobs_.empty());
 }
 
 }  // namespace net