Clang format slam.

net/http/http_stream_parser.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_parser.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
@@ skipping 92 matching lines @@
 // // data() points to the end of the consumed bytes (exclusive).
 //
 // // If you want to reuse the buffer, be sure to clear the buffer.
 // buf->Clear();
 // // size() == BytesRemaining() == BytesConsumed() == 0.
 // // data() points to the beginning of the buffer.
 //
 class HttpStreamParser::SeekableIOBuffer : public IOBuffer {
  public:
   explicit SeekableIOBuffer(int capacity)
-    : IOBuffer(capacity),
-      real_data_(data_),
-      capacity_(capacity),
-      size_(0),
-      used_(0) {
-  }
+      : IOBuffer(capacity),
+        real_data_(data_),
+        capacity_(capacity),
+        size_(0),
+        used_(0) {}
 
   // DidConsume() changes the |data_| pointer so that |data_| always points
   // to the first unconsumed byte.
-  void DidConsume(int bytes) {
-    SetOffset(used_ + bytes);
-  }
+  void DidConsume(int bytes) { SetOffset(used_ + bytes); }
 
   // Returns the number of unconsumed bytes.
-  int BytesRemaining() const {
-    return size_ - used_;
-  }
+  int BytesRemaining() const { return size_ - used_; }
 
   // Seeks to an arbitrary point in the buffer. The notion of bytes consumed
   // and remaining are updated appropriately.
   void SetOffset(int bytes) {
     DCHECK_GE(bytes, 0);
     DCHECK_LE(bytes, size_);
     used_ = bytes;
     data_ = real_data_ + used_;
   }
 
@@ skipping 11 matching lines @@
     size_ = 0;
     SetOffset(0);
   }
 
   // Returns the logical size of the buffer (i.e the number of bytes of data
   // in the buffer).
   int size() const { return size_; }
 
   // Returns the capacity of the buffer. The capacity is the size used when
   // the object is created.
-  int capacity() const { return capacity_; };
+  int capacity() const {
+    return capacity_;
+  };
 
  private:
   virtual ~SeekableIOBuffer() {
     // data_ will be deleted in IOBuffer::~IOBuffer().
     data_ = real_data_;
   }
 
   char* real_data_;
   const int capacity_;
   int size_;
@@ skipping 33 matching lines @@
 
 int HttpStreamParser::SendRequest(const std::string& request_line,
                                   const HttpRequestHeaders& headers,
                                   HttpResponseInfo* response,
                                   const CompletionCallback& callback) {
   DCHECK_EQ(STATE_NONE, io_state_);
   DCHECK(callback_.is_null());
   DCHECK(!callback.is_null());
   DCHECK(response);
 
-  net_log_.AddEvent(
-      NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
-      base::Bind(&HttpRequestHeaders::NetLogCallback,
-                 base::Unretained(&headers),
-                 &request_line));
+  net_log_.AddEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS,
+                    base::Bind(&HttpRequestHeaders::NetLogCallback,
+                               base::Unretained(&headers),
+                               &request_line));
 
   DVLOG(1) << __FUNCTION__ << "()"
            << " request_line = \"" << request_line << "\""
            << " headers = \"" << headers.ToString() << "\"";
   response_ = response;
 
   // Put the peer's IP address and port into the response.
   IPEndPoint ip_endpoint;
   int result = connection_->socket()->GetPeerAddress(&ip_endpoint);
   if (result != OK)
@@ skipping 29 matching lines @@
     // We'll repurpose |request_headers_| to store the merged headers and
     // body.
     request_headers_ = new DrainableIOBuffer(
         merged_request_headers_and_body.get(), merged_size);
 
     memcpy(request_headers_->data(), request.data(), request_headers_length_);
     request_headers_->DidConsume(request_headers_length_);
 
     size_t todo = request_->upload_data_stream->size();
     while (todo) {
-      int consumed = request_->upload_data_stream
-          ->Read(request_headers_.get(), todo, CompletionCallback());
+      int consumed = request_->upload_data_stream->Read(
+          request_headers_.get(), todo, CompletionCallback());
       DCHECK_GT(consumed, 0);  // Read() won't fail if not chunked.
       request_headers_->DidConsume(consumed);
       todo -= consumed;
     }
     DCHECK(request_->upload_data_stream->IsEOF());
     // Reset the offset, so the buffer can be read from the beginning.
     request_headers_->SetOffset(0);
     did_merge = true;
 
-    net_log_.AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
-        base::Bind(&NetLogSendRequestBodyCallback,
-                   request_->upload_data_stream->size(),
-                   false, /* not chunked */
-                   true /* merged */));
+    net_log_.AddEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
+                      base::Bind(&NetLogSendRequestBodyCallback,
+                                 request_->upload_data_stream->size(),
+                                 false, /* not chunked */
+                                 true /* merged */));
   }
 
   if (!did_merge) {
     // If we didn't merge the body with the headers, then |request_headers_|
     // contains just the HTTP headers.
     scoped_refptr<StringIOBuffer> headers_io_buf(new StringIOBuffer(request));
     request_headers_ =
         new DrainableIOBuffer(headers_io_buf.get(), headers_io_buf->size());
   }
 
@@ skipping 32 matching lines @@
 
   return result > 0 ? OK : result;
 }
 
 void HttpStreamParser::Close(bool not_reusable) {
   if (not_reusable && connection_->socket())
     connection_->socket()->Disconnect();
   connection_->Reset();
 }
 
-int HttpStreamParser::ReadResponseBody(IOBuffer* buf, int buf_len,
+int HttpStreamParser::ReadResponseBody(IOBuffer* buf,
+                                       int buf_len,
                                        const CompletionCallback& callback) {
   DCHECK(io_state_ == STATE_NONE || io_state_ == STATE_DONE);
   DCHECK(callback_.is_null());
   DCHECK(!callback.is_null());
   DCHECK_LE(buf_len, kMaxBufSize);
 
   if (io_state_ == STATE_DONE)
     return OK;
 
   // Must have response headers with a non-1xx error code.
@@ skipping 77 matching lines @@
 int HttpStreamParser::DoSendHeaders() {
   int bytes_remaining = request_headers_->BytesRemaining();
   DCHECK_GT(bytes_remaining, 0);
 
   // Record our best estimate of the 'request time' as the time when we send
   // out the first bytes of the request headers.
   if (bytes_remaining == request_headers_->size())
     response_->request_time = base::Time::Now();
 
   io_state_ = STATE_SEND_HEADERS_COMPLETE;
-  return connection_->socket()
-      ->Write(request_headers_.get(), bytes_remaining, io_callback_);
+  return connection_->socket()->Write(
+      request_headers_.get(), bytes_remaining, io_callback_);
 }
 
 int HttpStreamParser::DoSendHeadersComplete(int result) {
   if (result < 0) {
     // In the unlikely case that the headers and body were merged, all the
     // the headers were sent, but not all of the body way, and |result| is
     // an error that this should try reading after, stash the error for now and
     // act like the request was successfully sent.
     if (request_headers_->BytesConsumed() >= request_headers_length_ &&
         ShouldTryReadingOnUploadError(result)) {
       upload_error_ = result;
       return OK;
     }
     return result;
   }
 
   request_headers_->DidConsume(result);
   if (request_headers_->BytesRemaining() > 0) {
     io_state_ = STATE_SEND_HEADERS;
     return OK;
   }
 
   if (request_->upload_data_stream != NULL &&
       (request_->upload_data_stream->is_chunked() ||
-      // !IsEOF() indicates that the body wasn't merged.
-      (request_->upload_data_stream->size() > 0 &&
+       // !IsEOF() indicates that the body wasn't merged.
+       (request_->upload_data_stream->size() > 0 &&
         !request_->upload_data_stream->IsEOF()))) {
-    net_log_.AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
-        base::Bind(&NetLogSendRequestBodyCallback,
-                   request_->upload_data_stream->size(),
-                   request_->upload_data_stream->is_chunked(),
-                   false /* not merged */));
+    net_log_.AddEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
+                      base::Bind(&NetLogSendRequestBodyCallback,
+                                 request_->upload_data_stream->size(),
+                                 request_->upload_data_stream->is_chunked(),
+                                 false /* not merged */));
     io_state_ = STATE_SEND_BODY;
     return OK;
   }
 
   // Finished sending the request.
   return OK;
 }
 
 int HttpStreamParser::DoSendBody() {
   if (request_body_send_buf_->BytesRemaining() > 0) {
     io_state_ = STATE_SEND_BODY_COMPLETE;
-    return connection_->socket()
-        ->Write(request_body_send_buf_.get(),
-                request_body_send_buf_->BytesRemaining(),
-                io_callback_);
+    return connection_->socket()->Write(
+        request_body_send_buf_.get(),
+        request_body_send_buf_->BytesRemaining(),
+        io_callback_);
   }
 
   if (request_->upload_data_stream->is_chunked() && sent_last_chunk_) {
     // Finished sending the request.
     return OK;
   }
 
   request_body_read_buf_->Clear();
   io_state_ = STATE_SEND_REQUEST_READ_BODY_COMPLETE;
   return request_->upload_data_stream->Read(request_body_read_buf_.get(),
@@ skipping 55 matching lines @@
   io_state_ = STATE_READ_HEADERS_COMPLETE;
 
   // Grow the read buffer if necessary.
   if (read_buf_->RemainingCapacity() == 0)
     read_buf_->SetCapacity(read_buf_->capacity() + kHeaderBufInitialSize);
 
   // http://crbug.com/16371: We're seeing |user_buf_->data()| return NULL.
   // See if the user is passing in an IOBuffer with a NULL |data_|.
   CHECK(read_buf_->data());
 
-  return connection_->socket()
-      ->Read(read_buf_.get(), read_buf_->RemainingCapacity(), io_callback_);
+  return connection_->socket()->Read(
+      read_buf_.get(), read_buf_->RemainingCapacity(), io_callback_);
 }
 
 int HttpStreamParser::DoReadHeadersComplete(int result) {
   result = HandleReadHeaderResult(result);
 
   // TODO(mmenke):  The code below is ugly and hacky.  A much better and more
   // flexible long term solution would be to separate out the read and write
   // loops, though this would involve significant changes, both here and
   // elsewhere (WebSockets, for instance).
 
@@ skipping 58 matching lines @@
       read_buf_->SetCapacity(0);
       read_buf_unused_offset_ = 0;
     }
   }
 
   // Check to see if we're done reading.
   if (IsResponseBodyComplete())
     return 0;
 
   DCHECK_EQ(0, read_buf_->offset());
-  return connection_->socket()
-      ->Read(user_read_buf_.get(), user_read_buf_len_, io_callback_);
+  return connection_->socket()->Read(
+      user_read_buf_.get(), user_read_buf_len_, io_callback_);
 }
 
 int HttpStreamParser::DoReadBodyComplete(int result) {
   // When the connection is closed, there are numerous ways to interpret it.
   //
   //  - If a Content-Length header is present and the body contains exactly that
   //    number of bytes at connection close, the response is successful.
   //
   //  - If a Content-Length header is present and the body contains fewer bytes
   //    than promised by the header at connection close, it may indicate that
@@ skipping 63 matching lines @@
       }
     }
 
     CHECK_LE(save_amount + additional_save_amount, kMaxBufSize);
     if (read_buf_->capacity() < save_amount + additional_save_amount) {
       read_buf_->SetCapacity(save_amount + additional_save_amount);
     }
 
     if (save_amount) {
       received_bytes_ -= save_amount;
-      memcpy(read_buf_->StartOfBuffer(), user_read_buf_->data() + result,
+      memcpy(read_buf_->StartOfBuffer(),
+             user_read_buf_->data() + result,
              save_amount);
     }
     read_buf_->set_offset(save_amount);
     if (additional_save_amount) {
       memmove(read_buf_->data(),
               read_buf_->StartOfBuffer() + read_buf_unused_offset_,
               additional_save_amount);
       read_buf_->set_offset(save_amount + additional_save_amount);
     }
     read_buf_unused_offset_ = 0;
@@ skipping 53 matching lines @@
       end_offset = 0;
     }
     int rv = DoParseResponseHeaders(end_offset);
     if (rv < 0)
       return rv;
     return result;
   }
 
   read_buf_->set_offset(read_buf_->offset() + result);
   DCHECK_LE(read_buf_->offset(), read_buf_->capacity());
-  DCHECK_GE(result,  0);
+  DCHECK_GE(result, 0);
 
   int end_of_header_offset = ParseResponseHeaders();
 
   // Note: -1 is special, it indicates we haven't found the end of headers.
   // Anything less than -1 is a net::Error, so we bail out.
   if (end_of_header_offset < -1)
     return end_of_header_offset;
 
   if (end_of_header_offset == -1) {
     io_state_ = STATE_READ_HEADERS;
@@ skipping 67 matching lines @@
     return rv;
   return end_offset;
 }
 
 int HttpStreamParser::DoParseResponseHeaders(int end_offset) {
   scoped_refptr<HttpResponseHeaders> headers;
   DCHECK_EQ(0, read_buf_unused_offset_);
 
   if (response_header_start_offset_ >= 0) {
     received_bytes_ += end_offset;
-    headers = new HttpResponseHeaders(HttpUtil::AssembleRawHeaders(
-        read_buf_->StartOfBuffer(), end_offset));
+    headers = new HttpResponseHeaders(
+        HttpUtil::AssembleRawHeaders(read_buf_->StartOfBuffer(), end_offset));
   } else {
     // Enough data was read -- there is no status line.
     headers = new HttpResponseHeaders(std::string("HTTP/0.9 200 OK"));
   }
 
   // Check for multiple Content-Length headers with no Transfer-Encoding header.
   // If they exist, and have distinct values, it's a potential response
   // smuggling attack.
   if (!headers->HasHeader("Transfer-Encoding")) {
     if (HeadersContainMultipleCopiesOfField(*headers.get(), "Content-Length"))
@@ skipping 120 matching lines @@
 }
 
 int HttpStreamParser::EncodeChunk(const base::StringPiece& payload,
                                   char* output,
                                   size_t output_size) {
   if (output_size < payload.size() + kChunkHeaderFooterSize)
     return ERR_INVALID_ARGUMENT;
 
   char* cursor = output;
   // Add the header.
-  const int num_chars = base::snprintf(output, output_size,
-                                       "%X\r\n",
-                                       static_cast<int>(payload.size()));
+  const int num_chars = base::snprintf(
+      output, output_size, "%X\r\n", static_cast<int>(payload.size()));
   cursor += num_chars;
   // Add the payload if any.
   if (payload.size() > 0) {
     memcpy(cursor, payload.data(), payload.size());
     cursor += payload.size();
   }
   // Add the trailing CRLF.
   memcpy(cursor, "\r\n", 2);
   cursor += 2;
 
   return cursor - output;
 }
 
 // static
 bool HttpStreamParser::ShouldMergeRequestHeadersAndBody(
     const std::string& request_headers,
     const UploadDataStream* request_body) {
   if (request_body != NULL &&
       // IsInMemory() ensures that the request body is not chunked.
       request_body->IsInMemory() &&
       request_body->size() > 0) {
     size_t merged_size = request_headers.size() + request_body->size();
     if (merged_size <= kMaxMergedHeaderAndBodySize)
       return true;
   }
   return false;
 }
 
 }  // namespace net