Clang format slam.

net/http/http_pipelined_connection_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_pipelined_connection_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 41 matching lines @@
 HttpPipelinedConnection*
 HttpPipelinedConnectionImpl::Factory::CreateNewPipeline(
     ClientSocketHandle* connection,
     HttpPipelinedConnection::Delegate* delegate,
     const HostPortPair& origin,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     const BoundNetLog& net_log,
     bool was_npn_negotiated,
     NextProto protocol_negotiated) {
-  return new HttpPipelinedConnectionImpl(connection, delegate, origin,
-                                         used_ssl_config, used_proxy_info,
-                                         net_log, was_npn_negotiated,
+  return new HttpPipelinedConnectionImpl(connection,
+                                         delegate,
+                                         origin,
+                                         used_ssl_config,
+                                         used_proxy_info,
+                                         net_log,
+                                         was_npn_negotiated,
                                          protocol_negotiated);
 }
 
 HttpPipelinedConnectionImpl::HttpPipelinedConnectionImpl(
     ClientSocketHandle* connection,
     HttpPipelinedConnection::Delegate* delegate,
     const HostPortPair& origin,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     const BoundNetLog& net_log,
@@ skipping 12 matching lines @@
       active_(false),
       usable_(true),
       completed_one_request_(false),
       weak_factory_(this),
       send_next_state_(SEND_STATE_NONE),
       send_still_on_call_stack_(false),
       read_next_state_(READ_STATE_NONE),
       active_read_id_(0),
       read_still_on_call_stack_(false) {
   CHECK(connection_.get());
-  net_log_.BeginEvent(
-      NetLog::TYPE_HTTP_PIPELINED_CONNECTION,
-      base::Bind(&NetLogHostPortPairCallback, &origin));
+  net_log_.BeginEvent(NetLog::TYPE_HTTP_PIPELINED_CONNECTION,
+                      base::Bind(&NetLogHostPortPairCallback, &origin));
 }
 
 HttpPipelinedConnectionImpl::~HttpPipelinedConnectionImpl() {
   CHECK_EQ(depth(), 0);
   CHECK(stream_info_map_.empty());
   CHECK(pending_send_request_queue_.empty());
   CHECK(request_order_.empty());
   CHECK_EQ(send_next_state_, SEND_STATE_NONE);
   CHECK_EQ(read_next_state_, READ_STATE_NONE);
   CHECK(!active_send_request_.get());
@@ skipping 152 matching lines @@
       return OK;
     }
   }
 
   send_next_state_ = SEND_STATE_NONE;
   return OK;
 }
 
 int HttpPipelinedConnectionImpl::DoSendActiveRequest(int result) {
   CHECK(stream_info_map_[active_send_request_->pipeline_id].parser.get());
-  int rv = stream_info_map_[active_send_request_->pipeline_id].parser->
-      SendRequest(active_send_request_->request_line,
-                  active_send_request_->headers,
-                  active_send_request_->response,
-                  base::Bind(&HttpPipelinedConnectionImpl::OnSendIOCallback,
-                             base::Unretained(this)));
+  int rv =
+      stream_info_map_[active_send_request_->pipeline_id].parser->SendRequest(
+          active_send_request_->request_line,
+          active_send_request_->headers,
+          active_send_request_->response,
+          base::Bind(&HttpPipelinedConnectionImpl::OnSendIOCallback,
+                     base::Unretained(this)));
   stream_info_map_[active_send_request_->pipeline_id].state = STREAM_SENDING;
   send_next_state_ = SEND_STATE_COMPLETE;
   return rv;
 }
 
 int HttpPipelinedConnectionImpl::DoSendComplete(int result) {
   CHECK(active_send_request_.get());
   CHECK_EQ(STREAM_SENDING,
            stream_info_map_[active_send_request_->pipeline_id].state);
 
   request_order_.push(active_send_request_->pipeline_id);
   stream_info_map_[active_send_request_->pipeline_id].state = STREAM_SENT;
-  net_log_.AddEvent(
-      NetLog::TYPE_HTTP_PIPELINED_CONNECTION_SENT_REQUEST,
-      stream_info_map_[active_send_request_->pipeline_id].source.
-          ToEventParametersCallback());
+  net_log_.AddEvent(NetLog::TYPE_HTTP_PIPELINED_CONNECTION_SENT_REQUEST,
+                    stream_info_map_[active_send_request_->pipeline_id]
+                        .source.ToEventParametersCallback());
 
   if (result == ERR_SOCKET_NOT_CONNECTED && completed_one_request_) {
     result = ERR_PIPELINE_EVICTION;
   }
   if (result < OK) {
     usable_ = false;
   }
 
   if (!send_still_on_call_stack_) {
     QueueUserCallback(active_send_request_->pipeline_id,
-                      active_send_request_->callback, result, FROM_HERE);
+                      active_send_request_->callback,
+                      result,
+                      FROM_HERE);
   }
 
   active_send_request_.reset();
 
   if (send_still_on_call_stack_) {
     // It should be impossible for another request to appear on the queue while
     // this send was on the call stack.
     CHECK(pending_send_request_queue_.empty());
     send_next_state_ = SEND_STATE_NONE;
   } else if (!usable_) {
@@ skipping 13 matching lines @@
     if (ContainsKey(stream_info_map_, evicted_send->pipeline_id) &&
         stream_info_map_[evicted_send->pipeline_id].state != STREAM_CLOSED) {
       evicted_send->callback.Run(ERR_PIPELINE_EVICTION);
     }
   }
   send_next_state_ = SEND_STATE_NONE;
   return result;
 }
 
 int HttpPipelinedConnectionImpl::ReadResponseHeaders(
-    int pipeline_id, const CompletionCallback& callback) {
+    int pipeline_id,
+    const CompletionCallback& callback) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK_EQ(STREAM_SENT, stream_info_map_[pipeline_id].state);
   CHECK(stream_info_map_[pipeline_id].read_headers_callback.is_null());
 
   if (!usable_)
     return ERR_PIPELINE_EVICTION;
 
   stream_info_map_[pipeline_id].state = STREAM_READ_PENDING;
   stream_info_map_[pipeline_id].read_headers_callback = callback;
   if (read_next_state_ == READ_STATE_NONE &&
@@ skipping 121 matching lines @@
 }
 
 int HttpPipelinedConnectionImpl::DoReadHeadersComplete(int result) {
   CHECK(active_read_id_);
   CHECK(ContainsKey(stream_info_map_, active_read_id_));
   CHECK_EQ(STREAM_ACTIVE, stream_info_map_[active_read_id_].state);
 
   read_next_state_ = READ_STATE_WAITING_FOR_CLOSE;
   if (result < OK) {
     if (completed_one_request_ &&
-        (result == ERR_CONNECTION_CLOSED ||
-         result == ERR_EMPTY_RESPONSE ||
+        (result == ERR_CONNECTION_CLOSED || result == ERR_EMPTY_RESPONSE ||
          result == ERR_SOCKET_NOT_CONNECTED)) {
       // These usually indicate that pipelining failed on the server side. In
       // that case, we should retry without pipelining.
       result = ERR_PIPELINE_EVICTION;
     }
     usable_ = false;
   }
 
   CheckHeadersForPipelineCompatibility(active_read_id_, result);
 
   if (!read_still_on_call_stack_) {
     QueueUserCallback(active_read_id_,
                       stream_info_map_[active_read_id_].read_headers_callback,
-                      result, FROM_HERE);
+                      result,
+                      FROM_HERE);
   }
 
   return result;
 }
 
 int HttpPipelinedConnectionImpl::DoReadWaitForClose(int result) {
   read_next_state_ = READ_STATE_WAITING_FOR_CLOSE;
   return result;
 }
 
@@ skipping 26 matching lines @@
     if (stream_info_map_[evicted_id].state == STREAM_READ_PENDING) {
       stream_info_map_[evicted_id].state = STREAM_READ_EVICTED;
       stream_info_map_[evicted_id].read_headers_callback.Run(
           ERR_PIPELINE_EVICTION);
     }
   }
   read_next_state_ = READ_STATE_NONE;
   return result;
 }
 
-void HttpPipelinedConnectionImpl::Close(int pipeline_id,
-                                        bool not_reusable) {
+void HttpPipelinedConnectionImpl::Close(int pipeline_id, bool not_reusable) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
-  net_log_.AddEvent(
-      NetLog::TYPE_HTTP_PIPELINED_CONNECTION_STREAM_CLOSED,
-      base::Bind(&NetLogStreamClosedCallback,
-                 stream_info_map_[pipeline_id].source, not_reusable));
+  net_log_.AddEvent(NetLog::TYPE_HTTP_PIPELINED_CONNECTION_STREAM_CLOSED,
+                    base::Bind(&NetLogStreamClosedCallback,
+                               stream_info_map_[pipeline_id].source,
+                               not_reusable));
   switch (stream_info_map_[pipeline_id].state) {
     case STREAM_CREATED:
       stream_info_map_[pipeline_id].state = STREAM_UNUSED;
       break;
 
     case STREAM_BOUND:
       stream_info_map_[pipeline_id].state = STREAM_CLOSED;
       break;
 
     case STREAM_SENDING:
       usable_ = false;
       stream_info_map_[pipeline_id].state = STREAM_CLOSED;
       active_send_request_.reset();
       send_next_state_ = SEND_STATE_EVICT_PENDING_REQUESTS;
       DoSendRequestLoop(OK);
       break;
 
     case STREAM_SENT:
     case STREAM_READ_PENDING:
       usable_ = false;
       stream_info_map_[pipeline_id].state = STREAM_CLOSED;
-      if (!request_order_.empty() &&
-          pipeline_id == request_order_.front() &&
+      if (!request_order_.empty() && pipeline_id == request_order_.front() &&
           read_next_state_ == READ_STATE_NONE) {
         read_next_state_ = READ_STATE_EVICT_PENDING_READS;
         DoReadHeadersLoop(OK);
       }
       break;
 
     case STREAM_ACTIVE:
       stream_info_map_[pipeline_id].state = STREAM_CLOSED;
       if (not_reusable) {
         usable_ = false;
@@ skipping 11 matching lines @@
       // TODO(simonjam): Why is Close() sometimes called twice?
       break;
 
     default:
       CHECK(false);
       break;
   }
 }
 
 int HttpPipelinedConnectionImpl::ReadResponseBody(
-    int pipeline_id, IOBuffer* buf, int buf_len,
+    int pipeline_id,
+    IOBuffer* buf,
+    int buf_len,
     const CompletionCallback& callback) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK_EQ(active_read_id_, pipeline_id);
   CHECK(stream_info_map_[pipeline_id].parser.get());
   return stream_info_map_[pipeline_id].parser->ReadResponseBody(
       buf, buf_len, callback);
 }
 
 UploadProgress HttpPipelinedConnectionImpl::GetUploadProgress(
     int pipeline_id) const {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK(stream_info_map_.find(pipeline_id)->second.parser.get());
   return stream_info_map_.find(pipeline_id)->second.parser->GetUploadProgress();
 }
 
 HttpResponseInfo* HttpPipelinedConnectionImpl::GetResponseInfo(
     int pipeline_id) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK(stream_info_map_.find(pipeline_id)->second.parser.get());
   return stream_info_map_.find(pipeline_id)->second.parser->GetResponseInfo();
 }
 
 bool HttpPipelinedConnectionImpl::IsResponseBodyComplete(
     int pipeline_id) const {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK(stream_info_map_.find(pipeline_id)->second.parser.get());
-  return stream_info_map_.find(pipeline_id)->second.parser->
-      IsResponseBodyComplete();
+  return stream_info_map_.find(pipeline_id)
+      ->second.parser->IsResponseBodyComplete();
 }
 
 bool HttpPipelinedConnectionImpl::CanFindEndOfResponse(int pipeline_id) const {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK(stream_info_map_.find(pipeline_id)->second.parser.get());
-  return stream_info_map_.find(pipeline_id)->second.parser->
-      CanFindEndOfResponse();
+  return stream_info_map_.find(pipeline_id)
+      ->second.parser->CanFindEndOfResponse();
 }
 
 bool HttpPipelinedConnectionImpl::IsConnectionReused(int pipeline_id) const {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   if (pipeline_id > 1) {
     return true;
   }
   ClientSocketHandle::SocketReuseType reuse_type = connection_->reuse_type();
   return connection_->is_reused() ||
          reuse_type == ClientSocketHandle::UNUSED_IDLE;
 }
 
 void HttpPipelinedConnectionImpl::SetConnectionReused(int pipeline_id) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   connection_->set_reuse_type(ClientSocketHandle::REUSED_IDLE);
 }
 
 int64 HttpPipelinedConnectionImpl::GetTotalReceivedBytes(
     int pipeline_id) const {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   if (stream_info_map_.find(pipeline_id)->second.parser.get())
     return stream_info_map_.find(pipeline_id)->second.parser->received_bytes();
   return 0;
 }
 
 bool HttpPipelinedConnectionImpl::GetLoadTimingInfo(
-    int pipeline_id, LoadTimingInfo* load_timing_info) const {
+    int pipeline_id,
+    LoadTimingInfo* load_timing_info) const {
   return connection_->GetLoadTimingInfo(IsConnectionReused(pipeline_id),
                                         load_timing_info);
 }
 
 void HttpPipelinedConnectionImpl::GetSSLInfo(int pipeline_id,
                                              SSLInfo* ssl_info) {
   CHECK(ContainsKey(stream_info_map_, pipeline_id));
   CHECK(stream_info_map_[pipeline_id].parser.get());
   stream_info_map_[pipeline_id].parser->GetSSLInfo(ssl_info);
 }
@@ skipping 47 matching lines @@
   if (info->headers->GetParsedHttpVersion() < required_version) {
     ReportPipelineFeedback(pipeline_id, OLD_HTTP_VERSION);
     return;
   }
   if (!info->headers->IsKeepAlive() || !CanFindEndOfResponse(pipeline_id)) {
     usable_ = false;
     ReportPipelineFeedback(pipeline_id, MUST_CLOSE_CONNECTION);
     return;
   }
   if (info->headers->HasHeader(
-      HttpAuth::GetChallengeHeaderName(HttpAuth::AUTH_SERVER))) {
+          HttpAuth::GetChallengeHeaderName(HttpAuth::AUTH_SERVER))) {
     ReportPipelineFeedback(pipeline_id, AUTHENTICATION_REQUIRED);
     return;
   }
   ReportPipelineFeedback(pipeline_id, OK);
 }
 
 void HttpPipelinedConnectionImpl::ReportPipelineFeedback(int pipeline_id,
                                                          Feedback feedback) {
   std::string feedback_str;
   switch (feedback) {
@@ skipping 15 matching lines @@
 
     case AUTHENTICATION_REQUIRED:
       feedback_str = "AUTHENTICATION_REQUIRED";
       break;
 
     default:
       NOTREACHED();
       feedback_str = "UNKNOWN";
       break;
   }
-  net_log_.AddEvent(
-      NetLog::TYPE_HTTP_PIPELINED_CONNECTION_RECEIVED_HEADERS,
-      base::Bind(&NetLogReceivedHeadersCallback,
-                 stream_info_map_[pipeline_id].source, &feedback_str));
+  net_log_.AddEvent(NetLog::TYPE_HTTP_PIPELINED_CONNECTION_RECEIVED_HEADERS,
+                    base::Bind(&NetLogReceivedHeadersCallback,
+                               stream_info_map_[pipeline_id].source,
+                               &feedback_str));
   delegate_->OnPipelineFeedback(this, feedback);
 }
 
 void HttpPipelinedConnectionImpl::QueueUserCallback(
-    int pipeline_id, const CompletionCallback& callback, int rv,
+    int pipeline_id,
+    const CompletionCallback& callback,
+    int rv,
     const tracked_objects::Location& from_here) {
   CHECK(stream_info_map_[pipeline_id].pending_user_callback.is_null());
   stream_info_map_[pipeline_id].pending_user_callback = callback;
   base::MessageLoop::current()->PostTask(
       from_here,
       base::Bind(&HttpPipelinedConnectionImpl::FireUserCallback,
-                 weak_factory_.GetWeakPtr(), pipeline_id, rv));
+                 weak_factory_.GetWeakPtr(),
+                 pipeline_id,
+                 rv));
 }
 
 void HttpPipelinedConnectionImpl::FireUserCallback(int pipeline_id,
                                                    int result) {
   if (ContainsKey(stream_info_map_, pipeline_id)) {
     CHECK(!stream_info_map_[pipeline_id].pending_user_callback.is_null());
     CompletionCallback callback =
         stream_info_map_[pipeline_id].pending_user_callback;
     stream_info_map_[pipeline_id].pending_user_callback.Reset();
     callback.Run(result);
@@ skipping 21 matching lines @@
 }
 
 const BoundNetLog& HttpPipelinedConnectionImpl::net_log() const {
   return net_log_;
 }
 
 bool HttpPipelinedConnectionImpl::was_npn_negotiated() const {
   return was_npn_negotiated_;
 }
 
-NextProto HttpPipelinedConnectionImpl::protocol_negotiated()
-    const {
+NextProto HttpPipelinedConnectionImpl::protocol_negotiated() const {
   return protocol_negotiated_;
 }
 
 HttpPipelinedConnectionImpl::PendingSendRequest::PendingSendRequest()
-    : pipeline_id(0),
-      response(NULL) {
+    : pipeline_id(0), response(NULL) {
 }
 
 HttpPipelinedConnectionImpl::PendingSendRequest::~PendingSendRequest() {
 }
 
-HttpPipelinedConnectionImpl::StreamInfo::StreamInfo()
-    : state(STREAM_CREATED) {
+HttpPipelinedConnectionImpl::StreamInfo::StreamInfo() : state(STREAM_CREATED) {
 }
 
 HttpPipelinedConnectionImpl::StreamInfo::~StreamInfo() {
 }
 
 }  // namespace net