Clang format slam.

net/disk_cache/blockfile/entry_impl.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/entry_impl.h"
 
 #include "base/hash.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
@@ skipping 14 matching lines @@
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace {
 
 // Index for the file used to store the key, if any (files_[kKeyFileIndex]).
 const int kKeyFileIndex = 3;
 
 // This class implements FileIOCallback to buffer the callback from a file IO
 // operation from the actual net class.
-class SyncCallback: public disk_cache::FileIOCallback {
+class SyncCallback : public disk_cache::FileIOCallback {
  public:
   // |end_event_type| is the event type to log on completion.  Logs nothing on
   // discard, or when the NetLog is not set to log all events.
-  SyncCallback(disk_cache::EntryImpl* entry, net::IOBuffer* buffer,
+  SyncCallback(disk_cache::EntryImpl* entry,
+               net::IOBuffer* buffer,
                const net::CompletionCallback& callback,
                net::NetLog::EventType end_event_type)
-      : entry_(entry), callback_(callback), buf_(buffer),
-        start_(TimeTicks::Now()), end_event_type_(end_event_type) {
+      : entry_(entry),
+        callback_(callback),
+        buf_(buffer),
+        start_(TimeTicks::Now()),
+        end_event_type_(end_event_type) {
     entry->AddRef();
     entry->IncrementIoCount();
   }
   virtual ~SyncCallback() {}
 
   virtual void OnFileIOComplete(int bytes_copied) OVERRIDE;
   void Discard();
 
  private:
   disk_cache::EntryImpl* entry_;
@@ skipping 235 matching lines @@
 
   DVLOG(3) << "Buffer grow to " << required;
 
   buffer_.reserve(required);
   return true;
 }
 
 // ------------------------------------------------------------------------
 
 EntryImpl::EntryImpl(BackendImpl* backend, Addr address, bool read_only)
-    : entry_(NULL, Addr(0)), node_(NULL, Addr(0)),
-      backend_(backend->GetWeakPtr()), doomed_(false), read_only_(read_only),
+    : entry_(NULL, Addr(0)),
+      node_(NULL, Addr(0)),
+      backend_(backend->GetWeakPtr()),
+      doomed_(false),
+      read_only_(read_only),
       dirty_(false) {
   entry_.LazyInit(backend->File(address), address);
   for (int i = 0; i < kNumStreams; i++) {
     unreported_size_[i] = 0;
   }
 }
 
 void EntryImpl::DoomImpl() {
   if (doomed_ || !backend_.get())
     return;
 
   SetPointerForInvalidEntry(backend_->GetCurrentEntryId());
   backend_->InternalDoomEntry(this);
 }
 
-int EntryImpl::ReadDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
+int EntryImpl::ReadDataImpl(int index,
+                            int offset,
+                            IOBuffer* buf,
+                            int buf_len,
                             const CompletionCallback& callback) {
   if (net_log_.IsLogging()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_READ_DATA,
         CreateNetLogReadWriteDataCallback(index, offset, buf_len, false));
   }
 
   int result = InternalReadData(index, offset, buf, buf_len, callback);
 
   if (result != net::ERR_IO_PENDING && net_log_.IsLogging()) {
-    net_log_.EndEvent(
-        net::NetLog::TYPE_ENTRY_READ_DATA,
-        CreateNetLogReadWriteCompleteCallback(result));
+    net_log_.EndEvent(net::NetLog::TYPE_ENTRY_READ_DATA,
+                      CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
 
-int EntryImpl::WriteDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
+int EntryImpl::WriteDataImpl(int index,
+                             int offset,
+                             IOBuffer* buf,
+                             int buf_len,
                              const CompletionCallback& callback,
                              bool truncate) {
   if (net_log_.IsLogging()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_WRITE_DATA,
         CreateNetLogReadWriteDataCallback(index, offset, buf_len, truncate));
   }
 
-  int result = InternalWriteData(index, offset, buf, buf_len, callback,
-                                 truncate);
+  int result =
+      InternalWriteData(index, offset, buf, buf_len, callback, truncate);
 
   if (result != net::ERR_IO_PENDING && net_log_.IsLogging()) {
-    net_log_.EndEvent(
-        net::NetLog::TYPE_ENTRY_WRITE_DATA,
-        CreateNetLogReadWriteCompleteCallback(result));
+    net_log_.EndEvent(net::NetLog::TYPE_ENTRY_WRITE_DATA,
+                      CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
 
-int EntryImpl::ReadSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImpl::ReadSparseDataImpl(int64 offset,
+                                  IOBuffer* buf,
+                                  int buf_len,
                                   const CompletionCallback& callback) {
   DCHECK(node_.Data()->dirty || read_only_);
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
   TimeTicks start = TimeTicks::Now();
-  result = sparse_->StartIO(SparseControl::kReadOperation, offset, buf, buf_len,
-                            callback);
+  result = sparse_->StartIO(
+      SparseControl::kReadOperation, offset, buf, buf_len, callback);
   ReportIOTime(kSparseRead, start);
   return result;
 }
 
-int EntryImpl::WriteSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImpl::WriteSparseDataImpl(int64 offset,
+                                   IOBuffer* buf,
+                                   int buf_len,
                                    const CompletionCallback& callback) {
   DCHECK(node_.Data()->dirty || read_only_);
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
   TimeTicks start = TimeTicks::Now();
-  result = sparse_->StartIO(SparseControl::kWriteOperation, offset, buf,
-                            buf_len, callback);
+  result = sparse_->StartIO(
+      SparseControl::kWriteOperation, offset, buf, buf_len, callback);
   ReportIOTime(kSparseWrite, start);
   return result;
 }
 
 int EntryImpl::GetAvailableRangeImpl(int64 offset, int len, int64* start) {
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
   return sparse_->GetAvailableRange(offset, len, start);
 }
 
 void EntryImpl::CancelSparseIOImpl() {
   if (!sparse_.get())
     return;
 
   sparse_->CancelIO();
 }
 
 int EntryImpl::ReadyForSparseIOImpl(const CompletionCallback& callback) {
   DCHECK(sparse_.get());
   return sparse_->ReadyToUse(callback);
 }
 
 uint32 EntryImpl::GetHash() {
   return entry_.Data()->hash;
 }
 
-bool EntryImpl::CreateEntry(Addr node_address, const std::string& key,
+bool EntryImpl::CreateEntry(Addr node_address,
+                            const std::string& key,
                             uint32 hash) {
   Trace("Create entry In");
   EntryStore* entry_store = entry_.Data();
   RankingsNode* node = node_.Data();
   memset(entry_store, 0, sizeof(EntryStore) * entry_.address().num_blocks());
   memset(node, 0, sizeof(RankingsNode));
   if (!node_.LazyInit(backend_->File(node_address), node_address))
     return false;
 
   entry_store->rankings_node = node_address.value();
@@ skipping 59 matching lines @@
     SparseControl::DeleteChildren(this);
   }
 
   if (GetDataSize(0))
     CACHE_UMA(COUNTS, "DeleteHeader", 0, GetDataSize(0));
   if (GetDataSize(1))
     CACHE_UMA(COUNTS, "DeleteData", 0, GetDataSize(1));
   for (int index = 0; index < kNumStreams; index++) {
     Addr address(entry_.Data()->data_addr[index]);
     if (address.is_initialized()) {
-      backend_->ModifyStorageSize(entry_.Data()->data_size[index] -
-                                      unreported_size_[index], 0);
+      backend_->ModifyStorageSize(
+          entry_.Data()->data_size[index] - unreported_size_[index], 0);
       entry_.Data()->data_addr[index] = 0;
       entry_.Data()->data_size[index] = 0;
       entry_.Store();
       DeleteData(address, index);
     }
   }
 
   if (!everything)
     return;
 
@@ skipping 219 matching lines @@
     case kWriteAsync1:
       CACHE_UMA(AGE_MS, "AsyncWriteDispatchTime", 0, start);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void EntryImpl::BeginLogging(net::NetLog* net_log, bool created) {
   DCHECK(!net_log_.net_log());
-  net_log_ = net::BoundNetLog::Make(
-      net_log, net::NetLog::SOURCE_DISK_CACHE_ENTRY);
-  net_log_.BeginEvent(
-      net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL,
-      CreateNetLogEntryCreationCallback(this, created));
+  net_log_ =
+      net::BoundNetLog::Make(net_log, net::NetLog::SOURCE_DISK_CACHE_ENTRY);
+  net_log_.BeginEvent(net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL,
+                      CreateNetLogEntryCreationCallback(this, created));
 }
 
 const net::BoundNetLog& EntryImpl::net_log() const {
   return net_log_;
 }
 
 // static
 int EntryImpl::NumBlocksForEntry(int key_size) {
   // The longest key that can be stored using one block.
   int key1_len =
@@ skipping 28 matching lines @@
   if (!key_.empty())
     return key_;
 
   Addr address(entry->Data()->long_key);
   DCHECK(address.is_initialized());
   size_t offset = 0;
   if (address.is_block_file())
     offset = address.start_block() * address.BlockSize() + kBlockHeaderSize;
 
   COMPILE_ASSERT(kNumStreams == kKeyFileIndex, invalid_key_index);
-  File* key_file = const_cast<EntryImpl*>(this)->GetBackingFile(address,
-                                                                kKeyFileIndex);
+  File* key_file =
+      const_cast<EntryImpl*>(this)->GetBackingFile(address, kKeyFileIndex);
   if (!key_file)
     return std::string();
 
   ++key_len;  // We store a trailing \0 on disk that we read back below.
   if (!offset && key_file->GetLength() != static_cast<size_t>(key_len))
     return std::string();
 
   if (!key_file->Read(WriteInto(&key_, key_len), key_len, offset))
     key_.clear();
   return key_;
@@ skipping 10 matching lines @@
 }
 
 int32 EntryImpl::GetDataSize(int index) const {
   if (index < 0 || index >= kNumStreams)
     return 0;
 
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   return entry->Data()->data_size[index];
 }
 
-int EntryImpl::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
+int EntryImpl::ReadData(int index,
+                        int offset,
+                        IOBuffer* buf,
+                        int buf_len,
                         const CompletionCallback& callback) {
   if (callback.is_null())
     return ReadDataImpl(index, offset, buf, buf_len, callback);
 
   DCHECK(node_.Data()->dirty || read_only_);
   if (index < 0 || index >= kNumStreams)
     return net::ERR_INVALID_ARGUMENT;
 
   int entry_size = entry_.Data()->data_size[index];
   if (offset >= entry_size || offset < 0 || !buf_len)
     return 0;
 
   if (buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   if (!background_queue_.get())
     return net::ERR_UNEXPECTED;
 
   background_queue_->ReadData(this, index, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
-int EntryImpl::WriteData(int index, int offset, IOBuffer* buf, int buf_len,
-                         const CompletionCallback& callback, bool truncate) {
+int EntryImpl::WriteData(int index,
+                         int offset,
+                         IOBuffer* buf,
+                         int buf_len,
+                         const CompletionCallback& callback,
+                         bool truncate) {
   if (callback.is_null())
     return WriteDataImpl(index, offset, buf, buf_len, callback, truncate);
 
   DCHECK(node_.Data()->dirty || read_only_);
   if (index < 0 || index >= kNumStreams)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   if (!background_queue_.get())
     return net::ERR_UNEXPECTED;
 
-  background_queue_->WriteData(this, index, offset, buf, buf_len, truncate,
-                               callback);
+  background_queue_->WriteData(
+      this, index, offset, buf, buf_len, truncate, callback);
   return net::ERR_IO_PENDING;
 }
 
-int EntryImpl::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImpl::ReadSparseData(int64 offset,
+                              IOBuffer* buf,
+                              int buf_len,
                               const CompletionCallback& callback) {
   if (callback.is_null())
     return ReadSparseDataImpl(offset, buf, buf_len, callback);
 
   if (!background_queue_.get())
     return net::ERR_UNEXPECTED;
 
   background_queue_->ReadSparseData(this, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
-int EntryImpl::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImpl::WriteSparseData(int64 offset,
+                               IOBuffer* buf,
+                               int buf_len,
                                const CompletionCallback& callback) {
   if (callback.is_null())
     return WriteSparseDataImpl(offset, buf, buf_len, callback);
 
   if (!background_queue_.get())
     return net::ERR_UNEXPECTED;
 
   background_queue_->WriteSparseData(this, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
-int EntryImpl::GetAvailableRange(int64 offset, int len, int64* start,
+int EntryImpl::GetAvailableRange(int64 offset,
+                                 int len,
+                                 int64* start,
                                  const CompletionCallback& callback) {
   if (!background_queue_.get())
     return net::ERR_UNEXPECTED;
 
   background_queue_->GetAvailableRange(this, offset, len, start, callback);
   return net::ERR_IO_PENDING;
 }
 
 bool EntryImpl::CouldBeSparse() const {
   if (sparse_.get())
@@ skipping 73 matching lines @@
     }
   }
 
   Trace("~EntryImpl out 0x%p", reinterpret_cast<void*>(this));
   net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_ENTRY_IMPL);
   backend_->OnEntryDestroyEnd();
 }
 
 // ------------------------------------------------------------------------
 
-int EntryImpl::InternalReadData(int index, int offset,
-                                IOBuffer* buf, int buf_len,
+int EntryImpl::InternalReadData(int index,
+                                int offset,
+                                IOBuffer* buf,
+                                int buf_len,
                                 const CompletionCallback& callback) {
   DCHECK(node_.Data()->dirty || read_only_);
   DVLOG(2) << "Read from " << index << " at " << offset << " : " << buf_len;
   if (index < 0 || index >= kNumStreams)
     return net::ERR_INVALID_ARGUMENT;
 
   int entry_size = entry_.Data()->data_size[index];
   if (offset >= entry_size || offset < 0 || !buf_len)
     return 0;
 
@@ skipping 33 matching lines @@
   File* file = GetBackingFile(address, index);
   if (!file) {
     DoomImpl();
     LOG(ERROR) << "No file for " << std::hex << address.value();
     return net::ERR_FILE_NOT_FOUND;
   }
 
   size_t file_offset = offset;
   if (address.is_block_file()) {
     DCHECK_LE(offset + buf_len, kMaxBlockSize);
-    file_offset += address.start_block() * address.BlockSize() +
-                   kBlockHeaderSize;
+    file_offset +=
+        address.start_block() * address.BlockSize() + kBlockHeaderSize;
   }
 
   SyncCallback* io_callback = NULL;
   if (!callback.is_null()) {
-    io_callback = new SyncCallback(this, buf, callback,
-                                   net::NetLog::TYPE_ENTRY_READ_DATA);
+    io_callback = new SyncCallback(
+        this, buf, callback, net::NetLog::TYPE_ENTRY_READ_DATA);
   }
 
   TimeTicks start_async = TimeTicks::Now();
 
   bool completed;
   if (!file->Read(buf->data(), buf_len, file_offset, io_callback, &completed)) {
     if (io_callback)
       io_callback->Discard();
     DoomImpl();
     return net::ERR_CACHE_READ_FAILURE;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
   if (io_callback)
     ReportIOTime(kReadAsync1, start_async);
 
   ReportIOTime(kRead, start);
   return (completed || callback.is_null()) ? buf_len : net::ERR_IO_PENDING;
 }
 
-int EntryImpl::InternalWriteData(int index, int offset,
-                                 IOBuffer* buf, int buf_len,
+int EntryImpl::InternalWriteData(int index,
+                                 int offset,
+                                 IOBuffer* buf,
+                                 int buf_len,
                                  const CompletionCallback& callback,
                                  bool truncate) {
   DCHECK(node_.Data()->dirty || read_only_);
   DVLOG(2) << "Write to " << index << " at " << offset << " : " << buf_len;
   if (index < 0 || index >= kNumStreams)
     return net::ERR_INVALID_ARGUMENT;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
@@ skipping 46 matching lines @@
     return 0;
   }
 
   File* file = GetBackingFile(address, index);
   if (!file)
     return net::ERR_FILE_NOT_FOUND;
 
   size_t file_offset = offset;
   if (address.is_block_file()) {
     DCHECK_LE(offset + buf_len, kMaxBlockSize);
-    file_offset += address.start_block() * address.BlockSize() +
-                   kBlockHeaderSize;
+    file_offset +=
+        address.start_block() * address.BlockSize() + kBlockHeaderSize;
   } else if (truncate || (extending && !buf_len)) {
     if (!file->SetLength(offset + buf_len))
       return net::ERR_FAILED;
   }
 
   if (!buf_len)
     return 0;
 
   SyncCallback* io_callback = NULL;
   if (!callback.is_null()) {
-    io_callback = new SyncCallback(this, buf, callback,
-                                   net::NetLog::TYPE_ENTRY_WRITE_DATA);
+    io_callback = new SyncCallback(
+        this, buf, callback, net::NetLog::TYPE_ENTRY_WRITE_DATA);
   }
 
   TimeTicks start_async = TimeTicks::Now();
 
   bool completed;
-  if (!file->Write(buf->data(), buf_len, file_offset, io_callback,
-                   &completed)) {
+  if (!file->Write(
+          buf->data(), buf_len, file_offset, io_callback, &completed)) {
     if (io_callback)
       io_callback->Discard();
     return net::ERR_CACHE_WRITE_FAILURE;
   }
 
   if (io_callback && completed)
     io_callback->Discard();
 
   if (io_callback)
     ReportIOTime(kWriteAsync1, start_async);
@@ skipping 43 matching lines @@
 // important that the entry doesn't keep a reference to this address, or we'll
 // end up deleting the contents of |address| once again.
 void EntryImpl::DeleteData(Addr address, int index) {
   DCHECK(backend_.get());
   if (!address.is_initialized())
     return;
   if (address.is_separate_file()) {
     int failure = !DeleteCacheFile(backend_->GetFileName(address));
     CACHE_UMA(COUNTS, "DeleteFailed", 0, failure);
     if (failure) {
-      LOG(ERROR) << "Failed to delete " <<
-          backend_->GetFileName(address).value() << " from the cache.";
+      LOG(ERROR) << "Failed to delete " << backend_->GetFileName(address)
+                                               .value() << " from the cache.";
     }
     if (files_[index].get())
       files_[index] = NULL;  // Releases the object.
   } else {
     backend_->DeleteBlock(address, true);
   }
 }
 
 void EntryImpl::UpdateRank(bool modified) {
   if (!backend_.get())
@@ skipping 41 matching lines @@
 // buffer and / or the files needed to store the data.
 //
 // In general, a buffer may overlap data already stored on disk, and in that
 // case, the contents of the buffer are the most accurate. It may also extend
 // the file, but we don't want to read from disk just to keep the buffer up to
 // date. This means that as soon as there is a chance to get confused about what
 // is the most recent version of some part of a file, we'll flush the buffer and
 // reuse it for the new data. Keep in mind that the normal use pattern is quite
 // simple (write sequentially from the beginning), so we optimize for handling
 // that case.
-bool EntryImpl::PrepareTarget(int index, int offset, int buf_len,
+bool EntryImpl::PrepareTarget(int index,
+                              int offset,
+                              int buf_len,
                               bool truncate) {
   if (truncate)
     return HandleTruncation(index, offset, buf_len);
 
   if (!offset && !buf_len)
     return true;
 
   Addr address(entry_.Data()->data_addr[index]);
   if (address.is_initialized()) {
     if (address.is_block_file() && !MoveToLocalBuffer(index))
@@ skipping 237 matching lines @@
       return;
     }
   }
 
   // Bad news: we'd have to read the info from disk so instead we'll just tell
   // the caller where to read from.
   *buffer = NULL;
   address->set_value(entry_.Data()->data_addr[index]);
   if (address->is_initialized()) {
     // Prevent us from deleting the block from the backing store.
-    backend_->ModifyStorageSize(entry_.Data()->data_size[index] -
-                                    unreported_size_[index], 0);
+    backend_->ModifyStorageSize(
+        entry_.Data()->data_size[index] - unreported_size_[index], 0);
     entry_.Data()->data_addr[index] = 0;
     entry_.Data()->data_size[index] = 0;
   }
 }
 
 void EntryImpl::Log(const char* msg) {
   int dirty = 0;
   if (node_.HasData()) {
     dirty = node_.Data()->dirty;
   }
 
-  Trace("%s 0x%p 0x%x 0x%x", msg, reinterpret_cast<void*>(this),
-        entry_.address().value(), node_.address().value());
+  Trace("%s 0x%p 0x%x 0x%x",
+        msg,
+        reinterpret_cast<void*>(this),
+        entry_.address().value(),
+        node_.address().value());
 
-  Trace("  data: 0x%x 0x%x 0x%x", entry_.Data()->data_addr[0],
-        entry_.Data()->data_addr[1], entry_.Data()->long_key);
+  Trace("  data: 0x%x 0x%x 0x%x",
+        entry_.Data()->data_addr[0],
+        entry_.Data()->data_addr[1],
+        entry_.Data()->long_key);
 
   Trace("  doomed: %d 0x%x", doomed_, dirty);
 }
 
 }  // namespace disk_cache