Clang format slam.

net/spdy/spdy_http_stream.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/spdy/spdy_http_stream.h"
 
 #include <algorithm>
 #include <list>
 
 #include "base/bind.h"
@@ skipping 44 matching lines @@
 int SpdyHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const BoundNetLog& stream_net_log,
                                      const CompletionCallback& callback) {
   DCHECK(!stream_);
   if (!spdy_session_)
     return ERR_CONNECTION_CLOSED;
 
   request_info_ = request_info;
   if (request_info_->method == "GET") {
-    int error = spdy_session_->GetPushStream(request_info_->url, &stream_,
-                                             stream_net_log);
+    int error = spdy_session_->GetPushStream(
+        request_info_->url, &stream_, stream_net_log);
     if (error != OK)
       return error;
 
     // |stream_| may be NULL even if OK was returned.
     if (stream_.get()) {
       DCHECK_EQ(stream_->type(), SPDY_PUSH_STREAM);
       stream_->SetDelegate(this);
       return OK;
     }
   }
 
-  int rv = stream_request_.StartRequest(
-      SPDY_REQUEST_RESPONSE_STREAM, spdy_session_, request_info_->url,
-      priority, stream_net_log,
-      base::Bind(&SpdyHttpStream::OnStreamCreated,
-                 weak_factory_.GetWeakPtr(), callback));
+  int rv =
+      stream_request_.StartRequest(SPDY_REQUEST_RESPONSE_STREAM,
+                                   spdy_session_,
+                                   request_info_->url,
+                                   priority,
+                                   stream_net_log,
+                                   base::Bind(&SpdyHttpStream::OnStreamCreated,
+                                              weak_factory_.GetWeakPtr(),
+                                              callback));
 
   if (rv == OK) {
     stream_ = stream_request_.ReleaseStream();
     stream_->SetDelegate(this);
   }
 
   return rv;
 }
 
 const HttpResponseInfo* SpdyHttpStream::GetResponseInfo() const {
@@ skipping 20 matching lines @@
     CHECK(!stream_->IsIdle());
     return OK;
   }
 
   // Still waiting for the response, return IO_PENDING.
   CHECK(callback_.is_null());
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
-int SpdyHttpStream::ReadResponseBody(
-    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
+int SpdyHttpStream::ReadResponseBody(IOBuffer* buf,
+                                     int buf_len,
+                                     const CompletionCallback& callback) {
   if (stream_.get())
     CHECK(!stream_->IsIdle());
 
   CHECK(buf);
   CHECK(buf_len);
   CHECK(!callback.is_null());
 
   // If we have data buffered, complete the IO immediately.
   if (!response_body_queue_.IsEmpty()) {
     return response_body_queue_.Dequeue(buf->data(), buf_len);
@@ skipping 123 matching lines @@
   response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
 
   if (stream_->type() == SPDY_PUSH_STREAM) {
     // Pushed streams do not send any data, and should always be
     // idle. However, we still want to return ERR_IO_PENDING to mimic
     // non-push behavior. The callback will be called when the
     // response is received.
     result = ERR_IO_PENDING;
   } else {
     scoped_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock);
-    CreateSpdyHeadersFromHttpRequest(
-        *request_info_, request_headers,
-        headers.get(), stream_->GetProtocolVersion(),
-        direct_);
+    CreateSpdyHeadersFromHttpRequest(*request_info_,
+                                     request_headers,
+                                     headers.get(),
+                                     stream_->GetProtocolVersion(),
+                                     direct_);
     stream_->net_log().AddEvent(
         NetLog::TYPE_HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS,
         base::Bind(&SpdyHeaderBlockNetLogCallback, headers.get()));
-    result =
-        stream_->SendRequestHeaders(
-            headers.Pass(),
-            HasUploadData() ? MORE_DATA_TO_SEND : NO_MORE_DATA_TO_SEND);
+    result = stream_->SendRequestHeaders(
+        headers.Pass(),
+        HasUploadData() ? MORE_DATA_TO_SEND : NO_MORE_DATA_TO_SEND);
   }
 
   if (result == ERR_IO_PENDING) {
     CHECK(callback_.is_null());
     callback_ = callback;
   }
   return result;
 }
 
 void SpdyHttpStream::Cancel() {
@@ skipping 29 matching lines @@
     // We do not have complete headers yet.
     return RESPONSE_HEADERS_ARE_INCOMPLETE;
   }
 
   response_info_->response_time = stream_->response_time();
   response_headers_status_ = RESPONSE_HEADERS_ARE_COMPLETE;
   // Don't store the SSLInfo in the response here, HttpNetworkTransaction
   // will take care of that part.
   SSLInfo ssl_info;
   NextProto protocol_negotiated = kProtoUnknown;
-  stream_->GetSSLInfo(&ssl_info,
-                      &response_info_->was_npn_negotiated,
-                      &protocol_negotiated);
+  stream_->GetSSLInfo(
+      &ssl_info, &response_info_->was_npn_negotiated, &protocol_negotiated);
   response_info_->npn_negotiated_protocol =
       SSLClientSocket::NextProtoToString(protocol_negotiated);
   response_info_->request_time = stream_->GetRequestTime();
   response_info_->connection_info =
       HttpResponseInfo::ConnectionInfoFromNextProto(stream_->GetProtocol());
-  response_info_->vary_data
-      .Init(*request_info_, *response_info_->headers.get());
+  response_info_->vary_data.Init(*request_info_,
+                                 *response_info_->headers.get());
 
   if (!callback_.is_null())
     DoCallback(OK);
 
   return RESPONSE_HEADERS_ARE_COMPLETE;
 }
 
 void SpdyHttpStream::OnDataReceived(scoped_ptr<SpdyBuffer> buffer) {
   CHECK_EQ(response_headers_status_, RESPONSE_HEADERS_ARE_COMPLETE);
 
@@ skipping 32 matching lines @@
   if (status == net::OK) {
     // We need to complete any pending buffered read now.
     invoked_callback = DoBufferedReadCallback();
   }
   if (!invoked_callback && !callback_.is_null())
     DoCallback(status);
 }
 
 bool SpdyHttpStream::HasUploadData() const {
   CHECK(request_info_);
-  return
-      request_info_->upload_data_stream &&
-      ((request_info_->upload_data_stream->size() > 0) ||
-       request_info_->upload_data_stream->is_chunked());
+  return request_info_->upload_data_stream &&
+         ((request_info_->upload_data_stream->size() > 0) ||
+          request_info_->upload_data_stream->is_chunked());
 }
 
-void SpdyHttpStream::OnStreamCreated(
-    const CompletionCallback& callback,
-    int rv) {
+void SpdyHttpStream::OnStreamCreated(const CompletionCallback& callback,
+                                     int rv) {
   if (rv == OK) {
     stream_ = stream_request_.ReleaseStream();
     stream_->SetDelegate(this);
   }
   callback.Run(rv);
 }
 
 void SpdyHttpStream::ReadAndSendRequestBodyData() {
   CHECK(HasUploadData());
   CHECK_EQ(request_body_buf_size_, 0);
 
   if (request_info_->upload_data_stream->IsEOF())
     return;
 
   // Read the data from the request body stream.
-  const int rv = request_info_->upload_data_stream
-      ->Read(request_body_buf_.get(),
-             request_body_buf_->size(),
-             base::Bind(&SpdyHttpStream::OnRequestBodyReadCompleted,
-                        weak_factory_.GetWeakPtr()));
+  const int rv = request_info_->upload_data_stream->Read(
+      request_body_buf_.get(),
+      request_body_buf_->size(),
+      base::Bind(&SpdyHttpStream::OnRequestBodyReadCompleted,
+                 weak_factory_.GetWeakPtr()));
 
   if (rv != ERR_IO_PENDING) {
     // ERR_IO_PENDING is the only possible error.
     CHECK_GE(rv, 0);
     OnRequestBodyReadCompleted(rv);
   }
 }
 
 void SpdyHttpStream::OnRequestBodyReadCompleted(int status) {
   CHECK_GE(status, 0);
@@ skipping 29 matching lines @@
 
 // Checks to see if we should wait for more buffered data before notifying
 // the caller.  Returns true if we should wait, false otherwise.
 bool SpdyHttpStream::ShouldWaitForMoreBufferedData() const {
   // If the response is complete, there is no point in waiting.
   if (stream_closed_)
     return false;
 
   DCHECK_GT(user_buffer_len_, 0);
   return response_body_queue_.GetTotalSize() <
-      static_cast<size_t>(user_buffer_len_);
+         static_cast<size_t>(user_buffer_len_);
 }
 
 bool SpdyHttpStream::DoBufferedReadCallback() {
   buffered_read_callback_pending_ = false;
 
   // If the transaction is cancelled or errored out, we don't need to complete
   // the read.
   if (!stream_.get() && !stream_closed_)
     return false;
 
@@ skipping 53 matching lines @@
   Close(false);
   delete this;
 }
 
 void SpdyHttpStream::SetPriority(RequestPriority priority) {
   // TODO(akalin): Plumb this through to |stream_request_| and
   // |stream_|.
 }
 
 }  // namespace net