Auto-format style pass over files.

net/http/partial_data.cc

 // Copyright (c) 2009 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/partial_data.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
@@ skipping 57 matching lines @@
   headers->CopyFrom(extra_headers_);
   if (byte_range_.IsValid())
     AddRangeHeader(current_range_start_, end, headers);
 }
 
 int PartialData::PrepareCacheValidation(disk_cache::Entry* entry,
                                         HttpRequestHeaders* headers) {
   DCHECK(current_range_start_ >= 0);
 
   // Scan the disk cache for the first cached portion within this range.
-  int64 range_len = byte_range_.HasLastBytePosition() ?
-      byte_range_.last_byte_position() - current_range_start_ + 1 : kint32max;
+  int64 range_len =
+      byte_range_.HasLastBytePosition() ?
+      byte_range_.last_byte_position() - current_range_start_ + 1 :
+      kint32max;
   if (range_len > kint32max)
     range_len = kint32max;
   int len = static_cast<int32>(range_len);
   if (!len)
     return 0;
   range_present_ = false;
 
   if (sparse_entry_) {
     cached_min_len_ = entry->GetAvailableRange(current_range_start_, len,
                                                &cached_start_);
@@ skipping 114 matching lines @@
   return rv;
 }
 
 bool PartialData::ResponseHeadersOK(const HttpResponseHeaders* headers) {
   if (headers->response_code() == 304) {
     if (!byte_range_.IsValid() || truncated_)
       return true;
 
     // We must have a complete range here.
     return byte_range_.HasFirstBytePosition() &&
-           byte_range_.HasLastBytePosition();
+        byte_range_.HasLastBytePosition();
   }
 
   int64 start, end, total_length;
   if (!headers->GetContentRange(&start, &end, &total_length))
     return false;
   if (total_length <= 0)
     return false;
 
   int64 content_length = headers->GetContentLength();
   if (content_length < 0 || content_length != end - start + 1)
@@ skipping 81 matching lines @@
     if (current_range_start_ > kint32max)
       return ERR_INVALID_ARGUMENT;
 
     rv = entry->ReadData(kDataStream, static_cast<int>(current_range_start_),
                          data, read_len, callback);
   }
   return rv;
 }
 
 int PartialData::CacheWrite(disk_cache::Entry* entry, IOBuffer* data,
-                           int data_len, CompletionCallback* callback) {
+                            int data_len, CompletionCallback* callback) {
   if (sparse_entry_) {
     return entry->WriteSparseData(current_range_start_, data, data_len,
                                   callback);
   } else  {
     if (current_range_start_ > kint32max)
       return ERR_INVALID_ARGUMENT;
 
     return entry->WriteData(kDataStream, static_cast<int>(current_range_start_),
                             data, data_len, callback, true);
   }
 }
 
 void PartialData::OnCacheReadCompleted(int result) {
   if (result > 0) {
     current_range_start_ += result;
     cached_min_len_ -= result;
     DCHECK(cached_min_len_ >= 0);
   }
 }
 
 void PartialData::OnNetworkReadCompleted(int result) {
   if (result > 0)
     current_range_start_ += result;
 }
 
 }  // namespace net