Clang format slam.

net/disk_cache/blockfile/sparse_control.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/disk_cache/blockfile/sparse_control.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 24 matching lines @@
 const int kMaxEntrySize = 0x100000;
 
 // The size of each data block (tracked by the child allocation bitmap).
 const int kBlockSize = 1024;
 
 // Returns the name of a child entry given the base_name and signature of the
 // parent and the child_id.
 // If the entry is called entry_name, child entries will be named something
 // like Range_entry_name:XXX:YYY where XXX is the entry signature and YYY is the
 // number of the particular child.
-std::string GenerateChildName(const std::string& base_name, int64 signature,
+std::string GenerateChildName(const std::string& base_name,
+                              int64 signature,
                               int64 child_id) {
-  return base::StringPrintf("Range_%s:%" PRIx64 ":%" PRIx64, base_name.c_str(),
-                            signature, child_id);
+  return base::StringPrintf(
+      "Range_%s:%" PRIx64 ":%" PRIx64, base_name.c_str(), signature, child_id);
 }
 
 // This class deletes the children of a sparse entry.
-class ChildrenDeleter
-    : public base::RefCounted<ChildrenDeleter>,
-      public disk_cache::FileIOCallback {
+class ChildrenDeleter : public base::RefCounted<ChildrenDeleter>,
+                        public disk_cache::FileIOCallback {
  public:
   ChildrenDeleter(disk_cache::BackendImpl* backend, const std::string& name)
       : backend_(backend->GetWeakPtr()), name_(name), signature_(0) {}
 
   virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
 
   // Two ways of deleting the children: if we have the children map, use Start()
   // directly, otherwise pass the data address to ReadData().
   void Start(char* buffer, int len);
   void ReadData(disk_cache::Addr address, int len);
@@ skipping 169 matching lines @@
 bool SparseControl::CouldBeSparse() const {
   DCHECK(!init_);
 
   if (entry_->GetDataSize(kSparseData))
     return false;
 
   // We don't verify the data, just see if it could be there.
   return (entry_->GetDataSize(kSparseIndex) != 0);
 }
 
-int SparseControl::StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf,
-                           int buf_len, const CompletionCallback& callback) {
+int SparseControl::StartIO(SparseOperation op,
+                           int64 offset,
+                           net::IOBuffer* buf,
+                           int buf_len,
+                           const CompletionCallback& callback) {
   DCHECK(init_);
   // We don't support simultaneous IO for sparse data.
   if (operation_ != kNoOperation)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   // We only support up to 64 GB.
   if (static_cast<uint64>(offset) + static_cast<unsigned int>(buf_len) >=
@@ skipping 39 matching lines @@
 
 int SparseControl::GetAvailableRange(int64 offset, int len, int64* start) {
   DCHECK(init_);
   // We don't support simultaneous IO for sparse data.
   if (operation_ != kNoOperation)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   DCHECK(start);
 
   range_found_ = false;
-  int result = StartIO(
-      kGetRangeOperation, offset, NULL, len, CompletionCallback());
+  int result =
+      StartIO(kGetRangeOperation, offset, NULL, len, CompletionCallback());
   if (range_found_) {
     *start = offset_;
     return result;
   }
 
   // This is a failure. We want to return a valid start value in any case.
   *start = offset;
   return result < 0 ? result : 0;  // Don't mask error codes to the caller.
 }
 
@@ skipping 29 matching lines @@
 
   char* buffer;
   Addr address;
   entry->GetData(kSparseIndex, &buffer, &address);
   if (!buffer && !address.is_initialized())
     return;
 
   entry->net_log().AddEvent(net::NetLog::TYPE_SPARSE_DELETE_CHILDREN);
 
   DCHECK(entry->backend_.get());
-  ChildrenDeleter* deleter = new ChildrenDeleter(entry->backend_.get(),
-                                                 entry->GetKey());
+  ChildrenDeleter* deleter =
+      new ChildrenDeleter(entry->backend_.get(), entry->GetKey());
   // The object will self destruct when finished.
   deleter->AddRef();
 
   if (buffer) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ChildrenDeleter::Start, deleter, buffer, data_len));
   } else {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
@@ skipping 10 matching lines @@
   memset(&sparse_header_, 0, sizeof(sparse_header_));
   sparse_header_.signature = Time::Now().ToInternalValue();
   sparse_header_.magic = kIndexMagic;
   sparse_header_.parent_key_len = entry_->GetKey().size();
   children_map_.Resize(kNumSparseBits, true);
 
   // Save the header. The bitmap is saved in the destructor.
   scoped_refptr<net::IOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
 
-  int rv = entry_->WriteData(kSparseIndex, 0, buf.get(), sizeof(sparse_header_),
-                             CompletionCallback(), false);
+  int rv = entry_->WriteData(kSparseIndex,
+                             0,
+                             buf.get(),
+                             sizeof(sparse_header_),
+                             CompletionCallback(),
+                             false);
   if (rv != sizeof(sparse_header_)) {
     DLOG(ERROR) << "Unable to save sparse_header_";
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
   }
 
   entry_->SetEntryFlags(PARENT_ENTRY);
   return net::OK;
 }
 
 // We are opening an entry from disk. Make sure that our control data is there.
 int SparseControl::OpenSparseEntry(int data_len) {
   if (data_len < static_cast<int>(sizeof(SparseData)))
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (entry_->GetDataSize(kSparseData))
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (!(PARENT_ENTRY & entry_->GetEntryFlags()))
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   // Dont't go over board with the bitmap. 8 KB gives us offsets up to 64 GB.
   int map_len = data_len - sizeof(sparse_header_);
   if (map_len > kMaxMapSize || map_len % 4)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   scoped_refptr<net::IOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&sparse_header_)));
 
   // Read header.
-  int rv = entry_->ReadData(kSparseIndex, 0, buf.get(), sizeof(sparse_header_),
-                            CompletionCallback());
+  int rv = entry_->ReadData(
+      kSparseIndex, 0, buf.get(), sizeof(sparse_header_), CompletionCallback());
   if (rv != static_cast<int>(sizeof(sparse_header_)))
     return net::ERR_CACHE_READ_FAILURE;
 
   // The real validation should be performed by the caller. This is just to
   // double check.
   if (sparse_header_.magic != kIndexMagic ||
       sparse_header_.parent_key_len !=
           static_cast<int>(entry_->GetKey().size()))
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   // Read the actual bitmap.
   buf = new net::IOBuffer(map_len);
-  rv = entry_->ReadData(kSparseIndex, sizeof(sparse_header_), buf.get(),
-                        map_len, CompletionCallback());
+  rv = entry_->ReadData(kSparseIndex,
+                        sizeof(sparse_header_),
+                        buf.get(),
+                        map_len,
+                        CompletionCallback());
   if (rv != map_len)
     return net::ERR_CACHE_READ_FAILURE;
 
   // Grow the bitmap to the current size and copy the bits.
   children_map_.Resize(map_len * 8, false);
   children_map_.SetMap(reinterpret_cast<uint32*>(buf->data()), map_len);
   return net::OK;
 }
 
 bool SparseControl::OpenChild() {
@@ skipping 13 matching lines @@
 
   if (!entry_->backend_.get())
     return false;
 
   child_ = entry_->backend_->OpenEntryImpl(key);
   if (!child_)
     return ContinueWithoutChild(key);
 
   EntryImpl* child = static_cast<EntryImpl*>(child_);
   if (!(CHILD_ENTRY & child->GetEntryFlags()) ||
-      child->GetDataSize(kSparseIndex) <
-          static_cast<int>(sizeof(child_data_)))
+      child->GetDataSize(kSparseIndex) < static_cast<int>(sizeof(child_data_)))
     return KillChildAndContinue(key, false);
 
   scoped_refptr<net::WrappedIOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
   // Read signature.
-  int rv = child_->ReadData(kSparseIndex, 0, buf.get(), sizeof(child_data_),
-                            CompletionCallback());
+  int rv = child_->ReadData(
+      kSparseIndex, 0, buf.get(), sizeof(child_data_), CompletionCallback());
   if (rv != sizeof(child_data_))
     return KillChildAndContinue(key, true);  // This is a fatal failure.
 
   if (child_data_.header.signature != sparse_header_.signature ||
       child_data_.header.magic != kIndexMagic)
     return KillChildAndContinue(key, false);
 
   if (child_data_.header.last_block_len < 0 ||
       child_data_.header.last_block_len > kBlockSize) {
     // Make sure these values are always within range.
     child_data_.header.last_block_len = 0;
     child_data_.header.last_block = -1;
   }
 
   return true;
 }
 
 void SparseControl::CloseChild() {
   scoped_refptr<net::WrappedIOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
   // Save the allocation bitmap before closing the child entry.
-  int rv = child_->WriteData(kSparseIndex, 0, buf.get(), sizeof(child_data_),
-                             CompletionCallback(), false);
+  int rv = child_->WriteData(kSparseIndex,
+                             0,
+                             buf.get(),
+                             sizeof(child_data_),
+                             CompletionCallback(),
+                             false);
   if (rv != sizeof(child_data_))
     DLOG(ERROR) << "Failed to save child data";
   child_->Release();
   child_ = NULL;
 }
 
 std::string SparseControl::GenerateChildKey() {
-  return GenerateChildName(entry_->GetKey(), sparse_header_.signature,
-                           offset_ >> 20);
+  return GenerateChildName(
+      entry_->GetKey(), sparse_header_.signature, offset_ >> 20);
 }
 
 // We are deleting the child because something went wrong.
 bool SparseControl::KillChildAndContinue(const std::string& key, bool fatal) {
   SetChildBit(false);
   child_->DoomImpl();
   child_->Release();
   child_ = NULL;
   if (fatal) {
     result_ = net::ERR_CACHE_READ_FAILURE;
@@ skipping 39 matching lines @@
     children_map_.Resize(Bitmap::RequiredArraySize(child_bit + 1) * 32, true);
 
   children_map_.Set(child_bit, value);
 }
 
 void SparseControl::WriteSparseData() {
   scoped_refptr<net::IOBuffer> buf(new net::WrappedIOBuffer(
       reinterpret_cast<const char*>(children_map_.GetMap())));
 
   int len = children_map_.ArraySize() * 4;
-  int rv = entry_->WriteData(kSparseIndex, sizeof(sparse_header_), buf.get(),
-                             len, CompletionCallback(), false);
+  int rv = entry_->WriteData(kSparseIndex,
+                             sizeof(sparse_header_),
+                             buf.get(),
+                             len,
+                             CompletionCallback(),
+                             false);
   if (rv != len) {
     DLOG(ERROR) << "Unable to save sparse map";
   }
 }
 
 bool SparseControl::VerifyRange() {
   DCHECK_GE(result_, 0);
 
   child_offset_ = static_cast<int>(offset_) & (kMaxEntrySize - 1);
   child_len_ = std::min(buf_len_, kMaxEntrySize - child_offset_);
@@ skipping 82 matching lines @@
   // We know the real type of child_.
   EntryImpl* child = static_cast<EntryImpl*>(child_);
   child->SetEntryFlags(CHILD_ENTRY);
 
   memset(&child_data_, 0, sizeof(child_data_));
   child_data_.header = sparse_header_;
 
   scoped_refptr<net::WrappedIOBuffer> buf(
       new net::WrappedIOBuffer(reinterpret_cast<char*>(&child_data_)));
 
-  int rv = child_->WriteData(kSparseIndex, 0, buf.get(), sizeof(child_data_),
-                             CompletionCallback(), false);
+  int rv = child_->WriteData(kSparseIndex,
+                             0,
+                             buf.get(),
+                             sizeof(child_data_),
+                             CompletionCallback(),
+                             false);
   if (rv != sizeof(child_data_))
     DLOG(ERROR) << "Failed to save child data";
   SetChildBit(true);
 }
 
 void SparseControl::DoChildrenIO() {
-  while (DoChildIO()) continue;
+  while (DoChildIO())
+    continue;
 
   // Range operations are finished synchronously, often without setting
   // |finished_| to true.
-  if (kGetRangeOperation == operation_ &&
-      entry_->net_log().IsLogging()) {
+  if (kGetRangeOperation == operation_ && entry_->net_log().IsLogging()) {
     entry_->net_log().EndEvent(
         net::NetLog::TYPE_SPARSE_GET_RANGE,
         CreateNetLogGetAvailableRangeResultCallback(offset_, result_));
   }
   if (finished_) {
-    if (kGetRangeOperation != operation_ &&
-        entry_->net_log().IsLogging()) {
+    if (kGetRangeOperation != operation_ && entry_->net_log().IsLogging()) {
       entry_->net_log().EndEvent(GetSparseEventType(operation_));
     }
     if (pending_)
       DoUserCallback();  // Don't touch this object after this point.
   }
 }
 
 bool SparseControl::DoChildIO() {
   finished_ = true;
   if (!buf_len_ || result_ < 0)
@@ skipping 15 matching lines @@
 
   int rv = 0;
   switch (operation_) {
     case kReadOperation:
       if (entry_->net_log().IsLogging()) {
         entry_->net_log().BeginEvent(
             net::NetLog::TYPE_SPARSE_READ_CHILD_DATA,
             CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
                                                 child_len_));
       }
-      rv = child_->ReadDataImpl(kSparseData, child_offset_, user_buf_.get(),
-                                child_len_, callback);
+      rv = child_->ReadDataImpl(
+          kSparseData, child_offset_, user_buf_.get(), child_len_, callback);
       break;
     case kWriteOperation:
       if (entry_->net_log().IsLogging()) {
         entry_->net_log().BeginEvent(
             net::NetLog::TYPE_SPARSE_WRITE_CHILD_DATA,
             CreateNetLogSparseReadWriteCallback(child_->net_log().source(),
                                                 child_len_));
       }
-      rv = child_->WriteDataImpl(kSparseData, child_offset_, user_buf_.get(),
-                                 child_len_, callback, false);
+      rv = child_->WriteDataImpl(kSparseData,
+                                 child_offset_,
+                                 user_buf_.get(),
+                                 child_len_,
+                                 callback,
+                                 false);
       break;
     case kGetRangeOperation:
       rv = DoGetAvailableRange();
       break;
     default:
       NOTREACHED();
   }
 
   if (rv == net::ERR_IO_PENDING) {
     if (!pending_) {
@@ skipping 125 matching lines @@
     CompletionCallback cb = abort_callbacks_[i];
     if (i == abort_callbacks_.size() - 1)
       abort_callbacks_.clear();
 
     entry_->Release();  // Don't touch object after this line.
     cb.Run(net::OK);
   }
 }
 
 }  // namespace disk_cache