Clang format slam.

net/quic/quic_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/quic/quic_http_stream.h"
 
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
@@ skipping 39 matching lines @@
   if (session_)
     session_->RemoveObserver(this);
 }
 
 int QuicHttpStream::InitializeStream(const HttpRequestInfo* request_info,
                                      RequestPriority priority,
                                      const BoundNetLog& stream_net_log,
                                      const CompletionCallback& callback) {
   DCHECK(!stream_);
   if (!session_)
-    return was_handshake_confirmed_ ? ERR_CONNECTION_CLOSED :
-        ERR_QUIC_HANDSHAKE_FAILED;
+    return was_handshake_confirmed_ ? ERR_CONNECTION_CLOSED
+                                    : ERR_QUIC_HANDSHAKE_FAILED;
 
   if (request_info->url.SchemeIsSecure()) {
     SSLInfo ssl_info;
     bool secure_session = session_->GetSSLInfo(&ssl_info) && ssl_info.cert;
     UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.SecureResourceSecureSession",
                           secure_session);
     if (!secure_session)
       return ERR_REQUEST_FOR_SECURE_RESOURCE_OVER_INSECURE_QUIC;
   }
 
   stream_net_log_ = stream_net_log;
   request_info_ = request_info;
   priority_ = priority;
 
   int rv = stream_request_.StartRequest(
-      session_, &stream_, base::Bind(&QuicHttpStream::OnStreamReady,
-                                     weak_factory_.GetWeakPtr()));
+      session_,
+      &stream_,
+      base::Bind(&QuicHttpStream::OnStreamReady, weak_factory_.GetWeakPtr()));
   if (rv == ERR_IO_PENDING) {
     callback_ = callback;
   } else if (rv == OK) {
     stream_->SetDelegate(this);
   } else if (!was_handshake_confirmed_) {
     rv = ERR_QUIC_HANDSHAKE_FAILED;
   }
 
   return rv;
 }
@@ skipping 14 matching lines @@
                                 const CompletionCallback& callback) {
   CHECK(stream_);
   CHECK(!request_body_stream_);
   CHECK(!response_info_);
   CHECK(!callback.is_null());
   CHECK(response);
 
   QuicPriority priority = ConvertRequestPriorityToQuicPriority(priority_);
   stream_->set_priority(priority);
   // Store the serialized request headers.
-  CreateSpdyHeadersFromHttpRequest(*request_info_, request_headers,
-                                   &request_headers_, SPDY3, /*direct=*/true);
+  CreateSpdyHeadersFromHttpRequest(*request_info_,
+                                   request_headers,
+                                   &request_headers_,
+                                   SPDY3,
+                                   /*direct=*/true);
 
   // Store the request body.
   request_body_stream_ = request_info_->upload_data_stream;
   if (request_body_stream_) {
     // TODO(rch): Can we be more precise about when to allocate
     // raw_request_body_buf_. Removed the following check. DoReadRequestBody()
     // was being called even if we didn't yet allocate raw_request_body_buf_.
     //   && (request_body_stream_->size() ||
     //       request_body_stream_->is_chunked()))
     //
@@ skipping 38 matching lines @@
   // Still waiting for the response, return IO_PENDING.
   CHECK(callback_.is_null());
   callback_ = callback;
   return ERR_IO_PENDING;
 }
 
 const HttpResponseInfo* QuicHttpStream::GetResponseInfo() const {
   return response_info_;
 }
 
-int QuicHttpStream::ReadResponseBody(
-    IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
+int QuicHttpStream::ReadResponseBody(IOBuffer* buf,
+                                     int buf_len,
+                                     const CompletionCallback& callback) {
   CHECK(buf);
   CHECK(buf_len);
   CHECK(!callback.is_null());
 
   // If we have data buffered, complete the IO immediately.
   if (!response_body_.empty()) {
     int bytes_read = 0;
     while (!response_body_.empty() && buf_len > 0) {
       scoped_refptr<IOBufferWithSize> data = response_body_.front();
       const int bytes_to_copy = std::min(buf_len, data->size());
       memcpy(&(buf->data()[bytes_read]), data->data(), bytes_to_copy);
       buf_len -= bytes_to_copy;
       if (bytes_to_copy == data->size()) {
         response_body_.pop_front();
       } else {
         const int bytes_remaining = data->size() - bytes_to_copy;
         IOBufferWithSize* new_buffer = new IOBufferWithSize(bytes_remaining);
-        memcpy(new_buffer->data(), &(data->data()[bytes_to_copy]),
+        memcpy(new_buffer->data(),
+               &(data->data()[bytes_to_copy]),
                bytes_remaining);
         response_body_.pop_front();
         response_body_.push_front(make_scoped_refptr(new_buffer));
       }
       bytes_read += bytes_to_copy;
     }
     return bytes_read;
   }
 
   if (!stream_) {
@@ skipping 119 matching lines @@
   }
 
   user_buffer_ = NULL;
   user_buffer_len_ = 0;
   DoCallback(length);
   return OK;
 }
 
 void QuicHttpStream::OnClose(QuicErrorCode error) {
   if (error != QUIC_NO_ERROR) {
-    response_status_ = was_handshake_confirmed_ ?
-        ERR_QUIC_PROTOCOL_ERROR : ERR_QUIC_HANDSHAKE_FAILED;
+    response_status_ = was_handshake_confirmed_ ? ERR_QUIC_PROTOCOL_ERROR
+                                                : ERR_QUIC_HANDSHAKE_FAILED;
   } else if (!response_headers_received_) {
     response_status_ = ERR_ABORTED;
   }
 
   closed_stream_received_bytes_ = stream_->stream_bytes_read();
   stream_ = NULL;
   if (!callback_.is_null())
     DoCallback(response_status_);
 }
 
 void QuicHttpStream::OnError(int error) {
   stream_ = NULL;
-  response_status_ = was_handshake_confirmed_ ?
-      error : ERR_QUIC_HANDSHAKE_FAILED;
+  response_status_ =
+      was_handshake_confirmed_ ? error : ERR_QUIC_HANDSHAKE_FAILED;
   if (!callback_.is_null())
     DoCallback(response_status_);
 }
 
 bool QuicHttpStream::HasSendHeadersComplete() {
   return next_state_ > STATE_SEND_HEADERS_COMPLETE;
 }
 
 void QuicHttpStream::OnCryptoHandshakeConfirmed() {
   was_handshake_confirmed_ = true;
@@ skipping 60 matching lines @@
   return rv;
 }
 
 int QuicHttpStream::DoSendHeaders() {
   if (!stream_)
     return ERR_UNEXPECTED;
 
   // Log the actual request with the URL Request's net log.
   stream_net_log_.AddEvent(
       NetLog::TYPE_HTTP_TRANSACTION_QUIC_SEND_REQUEST_HEADERS,
-      base::Bind(&QuicRequestNetLogCallback, stream_->id(), &request_headers_,
+      base::Bind(&QuicRequestNetLogCallback,
+                 stream_->id(),
+                 &request_headers_,
                  priority_));
   // Also log to the QuicSession's net log.
   stream_->net_log().AddEvent(
       NetLog::TYPE_QUIC_HTTP_STREAM_SEND_REQUEST_HEADERS,
-      base::Bind(&QuicRequestNetLogCallback, stream_->id(), &request_headers_,
+      base::Bind(&QuicRequestNetLogCallback,
+                 stream_->id(),
+                 &request_headers_,
                  priority_));
 
   bool has_upload_data = request_body_stream_ != NULL;
 
   next_state_ = STATE_SEND_HEADERS_COMPLETE;
   int rv = stream_->WriteHeaders(request_headers_, !has_upload_data, NULL);
   request_headers_.clear();
   return rv;
 }
 
 int QuicHttpStream::DoSendHeadersComplete(int rv) {
   if (rv < 0)
     return rv;
 
-  next_state_ = request_body_stream_ ?
-      STATE_READ_REQUEST_BODY : STATE_OPEN;
+  next_state_ = request_body_stream_ ? STATE_READ_REQUEST_BODY : STATE_OPEN;
 
   return OK;
 }
 
 int QuicHttpStream::DoReadRequestBody() {
   next_state_ = STATE_READ_REQUEST_BODY_COMPLETE;
   return request_body_stream_->Read(
       raw_request_body_buf_.get(),
       raw_request_body_buf_->size(),
       base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
@@ skipping 19 matching lines @@
     return ERR_UNEXPECTED;
 
   CHECK(request_body_stream_);
   CHECK(request_body_buf_.get());
   const bool eof = request_body_stream_->IsEOF();
   int len = request_body_buf_->BytesRemaining();
   if (len > 0 || eof) {
     next_state_ = STATE_SEND_BODY_COMPLETE;
     base::StringPiece data(request_body_buf_->data(), len);
     return stream_->WriteStreamData(
-        data, eof,
+        data,
+        eof,
         base::Bind(&QuicHttpStream::OnIOComplete, weak_factory_.GetWeakPtr()));
   }
 
   next_state_ = STATE_OPEN;
   return OK;
 }
 
 int QuicHttpStream::DoSendBodyComplete(int rv) {
   if (rv < 0)
     return rv;
 
   request_body_buf_->DidConsume(request_body_buf_->BytesRemaining());
 
   if (!request_body_stream_->IsEOF()) {
     next_state_ = STATE_READ_REQUEST_BODY;
     return OK;
   }
 
   next_state_ = STATE_OPEN;
   return OK;
 }
 
 int QuicHttpStream::ParseResponseHeaders() {
   size_t read_buf_len = static_cast<size_t>(read_buf_->offset());
   SpdyFramer framer(SPDY3);
   SpdyHeaderBlock headers;
   char* data = read_buf_->StartOfBuffer();
-  size_t len = framer.ParseHeaderBlockInBuffer(data, read_buf_->offset(),
-                                               &headers);
+  size_t len =
+      framer.ParseHeaderBlockInBuffer(data, read_buf_->offset(), &headers);
 
   if (len == 0) {
     return ERR_IO_PENDING;
   }
 
   // Save the remaining received data.
   size_t delta = read_buf_len - len;
   if (delta > 0) {
     BufferResponseBody(data + len, delta);
   }
 
   // The URLRequest logs these headers, so only log to the QuicSession's
   // net log.
   stream_->net_log().AddEvent(
       NetLog::TYPE_QUIC_HTTP_STREAM_READ_RESPONSE_HEADERS,
       base::Bind(&SpdyHeaderBlockNetLogCallback, &headers));
 
   if (!SpdyHeadersToHttpResponse(headers, SPDY3, response_info_)) {
     DLOG(WARNING) << "Invalid headers";
     return ERR_QUIC_PROTOCOL_ERROR;
   }
   // Put the peer's IP address and port into the response.
   IPEndPoint address = stream_->GetPeerAddress();
   response_info_->socket_address = HostPortPair::FromIPEndPoint(address);
   response_info_->connection_info =
       HttpResponseInfo::CONNECTION_INFO_QUIC1_SPDY3;
-  response_info_->vary_data
-      .Init(*request_info_, *response_info_->headers.get());
+  response_info_->vary_data.Init(*request_info_,
+                                 *response_info_->headers.get());
   response_info_->was_npn_negotiated = true;
   response_info_->npn_negotiated_protocol = "quic/1+spdy/3";
   response_headers_received_ = true;
 
   return OK;
 }
 
 void QuicHttpStream::BufferResponseBody(const char* data, int length) {
   if (length == 0)
     return;
   IOBufferWithSize* io_buffer = new IOBufferWithSize(length);
   memcpy(io_buffer->data(), data, length);
   response_body_.push_back(make_scoped_refptr(io_buffer));
 }
 
 }  // namespace net