Auto-format style pass over files.

net/http/http_stream_parser.cc

 // Copyright (c) 2010 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/compiler_specific.h"
 #include "base/histogram.h"
 #include "base/trace_event.h"
 #include "net/base/io_buffer.h"
@@ skipping 73 matching lines @@
     io_state_ = STATE_READ_HEADERS_COMPLETE;
 
   result = DoLoop(result);
   if (result == ERR_IO_PENDING)
     user_callback_ = callback;
 
   return result > 0 ? OK : result;
 }
 
 int HttpStreamParser::ReadResponseBody(IOBuffer* buf, int buf_len,
-                                      CompletionCallback* callback) {
+                                       CompletionCallback* callback) {
   DCHECK(io_state_ == STATE_BODY_PENDING || io_state_ == STATE_DONE);
   DCHECK(!user_callback_);
   DCHECK(callback);
   DCHECK_LE(buf_len, kMaxBufSize);
 
   if (io_state_ == STATE_DONE)
     return OK;
 
   user_read_buf_ = buf;
   user_read_buf_len_ = buf_len;
@@ skipping 92 matching lines @@
       // and otherwise we'll use an enum to tell why it won't help.
       enum COALESCE_POTENTIAL {
         NO_ADVANTAGE = 0,   // Coalescing won't reduce packet count.
         HEADER_ONLY = 1,    // There is only a header packet (can't coalesce).
         COALESCE_POTENTIAL_MAX = 30 // Various cases of coalasced savings.
       };
       size_t coalesce = HEADER_ONLY;
       if (request_body_ != NULL) {
         const size_t kBytesPerPacket = 1430;
         uint64 body_packets = (request_body_->size() + kBytesPerPacket - 1) /
-            kBytesPerPacket;
+                              kBytesPerPacket;
         uint64 header_packets = (bytes_remaining + kBytesPerPacket - 1) /
-            kBytesPerPacket;
+                                kBytesPerPacket;
         uint64 coalesced_packets = (request_body_->size() + bytes_remaining +
                                     kBytesPerPacket - 1) / kBytesPerPacket;
         if (coalesced_packets < header_packets + body_packets) {
           if (coalesced_packets > COALESCE_POTENTIAL_MAX)
             coalesce = COALESCE_POTENTIAL_MAX;
           else
             coalesce = static_cast<size_t>(header_packets + body_packets);
         } else {
           coalesce = NO_ADVANTAGE;
         }
@@ skipping 337 matching lines @@
 
 bool HttpStreamParser::CanFindEndOfResponse() const {
   return chunked_decoder_.get() || response_body_length_ >= 0;
 }
 
 bool HttpStreamParser::IsMoreDataBuffered() const {
   return read_buf_->offset() > read_buf_unused_offset_;
 }
 
 }  // namespace net