Clang format slam.

net/http/partial_data.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/partial_data.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
 const char kRangeHeader[] = "Content-Range";
 const int kDataStream = 1;
 
 }  // namespace
 
 // A core object that can be detached from the Partialdata object at destruction
 // so that asynchronous operations cleanup can be performed.
 class PartialData::Core {
  public:
   // Build a new core object. Lifetime management is automatic.
-  static Core* CreateCore(PartialData* owner) {
-    return new Core(owner);
-  }
+  static Core* CreateCore(PartialData* owner) { return new Core(owner); }
 
   // Wrapper for Entry::GetAvailableRange. If this method returns ERR_IO_PENDING
   // PartialData::GetAvailableRangeCompleted() will be invoked on the owner
   // object when finished (unless Cancel() is called first).
-  int GetAvailableRange(disk_cache::Entry* entry, int64 offset, int len,
+  int GetAvailableRange(disk_cache::Entry* entry,
+                        int64 offset,
+                        int len,
                         int64* start);
 
   // Cancels a pending operation. It is a mistake to call this method if there
   // is no operation in progress; in fact, there will be no object to do so.
   void Cancel();
 
  private:
   explicit Core(PartialData* owner);
   ~Core();
 
   // Pending io completion routine.
   void OnIOComplete(int result);
 
   PartialData* owner_;
   int64 start_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
-PartialData::Core::Core(PartialData* owner)
-    : owner_(owner), start_(0) {
+PartialData::Core::Core(PartialData* owner) : owner_(owner), start_(0) {
   DCHECK(!owner_->core_);
   owner_->core_ = this;
 }
 
 PartialData::Core::~Core() {
   if (owner_)
     owner_->core_ = NULL;
 }
 
 void PartialData::Core::Cancel() {
   DCHECK(owner_);
   owner_ = NULL;
 }
 
-int PartialData::Core::GetAvailableRange(disk_cache::Entry* entry, int64 offset,
-                                         int len, int64* start) {
+int PartialData::Core::GetAvailableRange(disk_cache::Entry* entry,
+                                         int64 offset,
+                                         int len,
+                                         int64* start) {
   int rv = entry->GetAvailableRange(
-      offset, len, &start_, base::Bind(&PartialData::Core::OnIOComplete,
-                                       base::Unretained(this)));
+      offset,
+      len,
+      &start_,
+      base::Bind(&PartialData::Core::OnIOComplete, base::Unretained(this)));
   if (rv != net::ERR_IO_PENDING) {
     // The callback will not be invoked. Lets cleanup.
     *start = start_;
     delete this;
   }
   return rv;
 }
 
 void PartialData::Core::OnIOComplete(int result) {
   if (owner_)
@@ skipping 27 matching lines @@
     return false;
 
   // We can handle this range request.
   byte_range_ = ranges[0];
   if (!byte_range_.IsValid())
     return false;
 
   resource_size_ = 0;
   current_range_start_ = byte_range_.first_byte_position();
 
-  DVLOG(1) << "Range start: " << current_range_start_ << " end: " <<
-               byte_range_.last_byte_position();
+  DVLOG(1) << "Range start: " << current_range_start_
+           << " end: " << byte_range_.last_byte_position();
   return true;
 }
 
 void PartialData::SetHeaders(const HttpRequestHeaders& headers) {
   DCHECK(extra_headers_.IsEmpty());
   extra_headers_.CopyFrom(headers);
 }
 
 void PartialData::RestoreHeaders(HttpRequestHeaders* headers) const {
   DCHECK(current_range_start_ >= 0 || byte_range_.IsSuffixByteRange());
-  int64 end = byte_range_.IsSuffixByteRange() ?
-              byte_range_.suffix_length() : byte_range_.last_byte_position();
+  int64 end = byte_range_.IsSuffixByteRange()
+                  ? byte_range_.suffix_length()
+                  : byte_range_.last_byte_position();
 
   headers->CopyFrom(extra_headers_);
   if (truncated_ || !byte_range_.IsValid())
     return;
 
   if (current_range_start_ < 0) {
     headers->SetHeader(HttpRequestHeaders::kRange,
                        HttpByteRange::Suffix(end).GetHeaderValue());
   } else {
-    headers->SetHeader(HttpRequestHeaders::kRange,
-                       HttpByteRange::Bounded(
-                           current_range_start_, end).GetHeaderValue());
+    headers->SetHeader(
+        HttpRequestHeaders::kRange,
+        HttpByteRange::Bounded(current_range_start_, end).GetHeaderValue());
   }
 }
 
 int PartialData::ShouldValidateCache(disk_cache::Entry* entry,
                                      const CompletionCallback& callback) {
   DCHECK_GE(current_range_start_, 0);
 
   // Scan the disk cache for the first cached portion within this range.
   int len = GetNextRangeLen();
   if (!len)
     return 0;
 
   DVLOG(3) << "ShouldValidateCache len: " << len;
 
   if (sparse_entry_) {
     DCHECK(callback_.is_null());
     Core* core = Core::CreateCore(this);
-    cached_min_len_ = core->GetAvailableRange(entry, current_range_start_, len,
-                                              &cached_start_);
+    cached_min_len_ = core->GetAvailableRange(
+        entry, current_range_start_, len, &cached_start_);
 
     if (cached_min_len_ == ERR_IO_PENDING) {
       callback_ = callback;
       return ERR_IO_PENDING;
     }
   } else if (!truncated_) {
     if (byte_range_.HasFirstBytePosition() &&
         byte_range_.first_byte_position() >= resource_size_) {
       // The caller should take care of this condition because we should have
       // failed IsRequestedRangeOK(), but it's better to be consistent here.
@@ skipping 18 matching lines @@
   int len = GetNextRangeLen();
   DCHECK_NE(0, len);
   range_present_ = false;
 
   headers->CopyFrom(extra_headers_);
 
   if (!cached_min_len_) {
     // We don't have anything else stored.
     final_range_ = true;
     cached_start_ =
-        byte_range_.HasLastBytePosition() ? current_range_start_  + len : 0;
+        byte_range_.HasLastBytePosition() ? current_range_start_ + len : 0;
   }
 
   if (current_range_start_ == cached_start_) {
     // The data lives in the cache.
     range_present_ = true;
     if (len == cached_min_len_)
       final_range_ = true;
     headers->SetHeader(
         HttpRequestHeaders::kRange,
-        net::HttpByteRange::Bounded(
-            current_range_start_,
-            cached_start_ + cached_min_len_ - 1).GetHeaderValue());
+        net::HttpByteRange::Bounded(current_range_start_,
+                                    cached_start_ + cached_min_len_ - 1)
+            .GetHeaderValue());
   } else {
     // This range is not in the cache.
     headers->SetHeader(
         HttpRequestHeaders::kRange,
-        net::HttpByteRange::Bounded(
-            current_range_start_, cached_start_ - 1).GetHeaderValue());
+        net::HttpByteRange::Bounded(current_range_start_, cached_start_ - 1)
+            .GetHeaderValue());
   }
 }
 
 bool PartialData::IsCurrentRangeCached() const {
   return range_present_;
 }
 
 bool PartialData::IsLastRange() const {
   return final_range_;
 }
@@ skipping 81 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;
 
   DCHECK_EQ(headers->response_code(), 206);
 
@@ skipping 41 matching lines @@
   if (byte_range_.IsValid() && success) {
     headers->UpdateWithNewRange(byte_range_, resource_size_, !sparse_entry_);
     return;
   }
 
   headers->RemoveHeader(kLengthHeader);
   headers->RemoveHeader(kRangeHeader);
 
   if (byte_range_.IsValid()) {
     headers->ReplaceStatusLine("HTTP/1.1 416 Requested Range Not Satisfiable");
-    headers->AddHeader(base::StringPrintf("%s: bytes 0-0/%" PRId64,
-                                          kRangeHeader, resource_size_));
+    headers->AddHeader(base::StringPrintf(
+        "%s: bytes 0-0/%" PRId64, kRangeHeader, resource_size_));
     headers->AddHeader(base::StringPrintf("%s: 0", kLengthHeader));
   } else {
     // TODO(rvargas): Is it safe to change the protocol version?
     headers->ReplaceStatusLine("HTTP/1.1 200 OK");
     DCHECK_NE(resource_size_, 0);
-    headers->AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader,
-                                          resource_size_));
+    headers->AddHeader(
+        base::StringPrintf("%s: %" PRId64, kLengthHeader, resource_size_));
   }
 }
 
 void PartialData::FixContentLength(HttpResponseHeaders* headers) {
   headers->RemoveHeader(kLengthHeader);
-  headers->AddHeader(base::StringPrintf("%s: %" PRId64, kLengthHeader,
-                                        resource_size_));
+  headers->AddHeader(
+      base::StringPrintf("%s: %" PRId64, kLengthHeader, resource_size_));
 }
 
-int PartialData::CacheRead(
-    disk_cache::Entry* entry, IOBuffer* data, int data_len,
-    const net::CompletionCallback& callback) {
+int PartialData::CacheRead(disk_cache::Entry* entry,
+                           IOBuffer* data,
+                           int data_len,
+                           const net::CompletionCallback& callback) {
   int read_len = std::min(data_len, cached_min_len_);
   if (!read_len)
     return 0;
 
   int rv = 0;
   if (sparse_entry_) {
-    rv = entry->ReadSparseData(current_range_start_, data, read_len,
-                               callback);
+    rv = entry->ReadSparseData(current_range_start_, data, read_len, callback);
   } else {
     if (current_range_start_ > kint32max)
       return ERR_INVALID_ARGUMENT;
 
-    rv = entry->ReadData(kDataStream, static_cast<int>(current_range_start_),
-                         data, read_len, callback);
+    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,
-    const net::CompletionCallback& callback) {
+int PartialData::CacheWrite(disk_cache::Entry* entry,
+                            IOBuffer* data,
+                            int data_len,
+                            const net::CompletionCallback& callback) {
   DVLOG(3) << "To write: " << data_len;
   if (sparse_entry_) {
     return entry->WriteSparseData(
         current_range_start_, data, data_len, callback);
-  } else  {
+  } 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);
+    return entry->WriteData(kDataStream,
+                            static_cast<int>(current_range_start_),
+                            data,
+                            data_len,
+                            callback,
+                            true);
   }
 }
 
 void PartialData::OnCacheReadCompleted(int result) {
   DVLOG(3) << "Read: " << result;
   if (result > 0) {
     current_range_start_ += result;
     cached_min_len_ -= result;
     DCHECK_GE(cached_min_len_, 0);
   }
 }
 
 void PartialData::OnNetworkReadCompleted(int result) {
   if (result > 0)
     current_range_start_ += result;
 }
 
 int PartialData::GetNextRangeLen() {
   int64 range_len =
-      byte_range_.HasLastBytePosition() ?
-      byte_range_.last_byte_position() - current_range_start_ + 1 :
-      kint32max;
+      byte_range_.HasLastBytePosition()
+          ? byte_range_.last_byte_position() - current_range_start_ + 1
+          : kint32max;
   if (range_len > kint32max)
     range_len = kint32max;
   return static_cast<int32>(range_len);
 }
 
 void PartialData::GetAvailableRangeCompleted(int result, int64 start) {
   DCHECK(!callback_.is_null());
   DCHECK_NE(ERR_IO_PENDING, result);
 
   cached_start_ = start;
   cached_min_len_ = result;
   if (result >= 0)
     result = 1;  // Return success, go ahead and validate the entry.
 
   CompletionCallback cb = callback_;
   callback_.Reset();
   cb.Run(result);
 }
 
 }  // namespace net