Clang format slam.

net/disk_cache/blockfile/backend_impl_v3.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/backend_impl_v3.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 72 matching lines @@
   DCHECK(!init_);
   if (init_)
     return net::ERR_FAILED;
 
   return net::ERR_IO_PENDING;
 }
 
 // ------------------------------------------------------------------------
 
 #if defined(V3_NOT_JUST_YET_READY)
-int BackendImplV3::OpenPrevEntry(void** iter, Entry** prev_entry,
+int BackendImplV3::OpenPrevEntry(void** iter,
+                                 Entry** prev_entry,
                                  const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   return OpenFollowingEntry(true, iter, prev_entry, callback);
 }
 #endif  // defined(V3_NOT_JUST_YET_READY).
 
 bool BackendImplV3::SetMaxSize(int max_bytes) {
   COMPILE_ASSERT(sizeof(max_bytes) == sizeof(max_size_), unsupported_int_model);
   if (max_bytes < 0)
     return false;
 
   // Zero size means use the default.
   if (!max_bytes)
     return true;
 
   // Avoid a DCHECK later on.
   if (max_bytes >= kint32max - kint32max / 10)
     max_bytes = kint32max - kint32max / 10 - 1;
 
   user_flags_ |= MAX_SIZE;
   max_size_ = max_bytes;
   return true;
 }
 
 void BackendImplV3::SetType(net::CacheType type) {
   DCHECK_NE(net::MEMORY_CACHE, type);
   cache_type_ = type;
 }
 
-bool BackendImplV3::CreateBlock(FileType block_type, int block_count,
+bool BackendImplV3::CreateBlock(FileType block_type,
+                                int block_count,
                                 Addr* block_address) {
   return block_files_.CreateBlock(block_type, block_count, block_address);
 }
 
 #if defined(V3_NOT_JUST_YET_READY)
 void BackendImplV3::UpdateRank(EntryImplV3* entry, bool modified) {
   if (read_only_ || (!modified && cache_type() == net::SHADER_CACHE))
     return;
   eviction_.UpdateRank(entry, modified);
 }
@@ skipping 95 matching lines @@
 }
 
 bool BackendImplV3::IsLoaded() const {
   if (user_flags_ & NO_LOAD_PROTECTION)
     return false;
 
   return user_load_;
 }
 
 std::string BackendImplV3::HistogramName(const char* name) const {
-  static const char* names[] = { "Http", "", "Media", "AppCache", "Shader" };
+  static const char* names[] = {"Http", "", "Media", "AppCache", "Shader"};
   DCHECK_NE(cache_type_, net::MEMORY_CACHE);
   return base::StringPrintf("DiskCache3.%s_%s", name, names[cache_type_]);
 }
 
 base::WeakPtr<BackendImplV3> BackendImplV3::GetWeakPtr() {
   return ptr_factory_.GetWeakPtr();
 }
 
 #if defined(V3_NOT_JUST_YET_READY)
 // We want to remove biases from some histograms so we only send data once per
@@ skipping 22 matching lines @@
 
   Time create_time = Time::FromInternalValue(header->create_time);
   CACHE_UMA(AGE, "FillupAge", create_time);
 
   int64 use_time = stats_.GetCounter(Stats::TIMER);
   CACHE_UMA(HOURS, "FillupTime", static_cast<int>(use_time / 120));
   CACHE_UMA(PERCENTAGE, "FirstHitRatio", stats_.GetHitRatio());
 
   if (!use_time)
     use_time = 1;
-  CACHE_UMA(COUNTS_10000, "FirstEntryAccessRate",
+  CACHE_UMA(COUNTS_10000,
+            "FirstEntryAccessRate",
             static_cast<int>(header->num_entries / use_time));
-  CACHE_UMA(COUNTS, "FirstByteIORate",
+  CACHE_UMA(COUNTS,
+            "FirstByteIORate",
             static_cast<int>((header->num_bytes / 1024) / use_time));
 
   int avg_size = header->num_bytes / GetEntryCount();
   CACHE_UMA(COUNTS, "FirstEntrySize", avg_size);
 
   int large_entries_bytes = stats_.GetLargeEntriesSize();
   int large_ratio = large_entries_bytes * 100 / header->num_bytes;
   CACHE_UMA(PERCENTAGE, "FirstLargeEntriesRatio", large_ratio);
 
   if (!lru_eviction_) {
     CACHE_UMA(PERCENTAGE, "FirstResurrectRatio", stats_.GetResurrectRatio());
-    CACHE_UMA(PERCENTAGE, "FirstNoUseRatio",
+    CACHE_UMA(PERCENTAGE,
+              "FirstNoUseRatio",
               header->num_no_use_entries * 100 / header->num_entries);
-    CACHE_UMA(PERCENTAGE, "FirstLowUseRatio",
+    CACHE_UMA(PERCENTAGE,
+              "FirstLowUseRatio",
               header->num_low_use_entries * 100 / header->num_entries);
-    CACHE_UMA(PERCENTAGE, "FirstHighUseRatio",
+    CACHE_UMA(PERCENTAGE,
+              "FirstHighUseRatio",
               header->num_high_use_entries * 100 / header->num_entries);
   }
 
   stats_.ResetRatios();
 }
 
 void BackendImplV3::OnEvent(Stats::Counters an_event) {
   stats_.OnEvent(an_event);
 }
 
@@ skipping 112 matching lines @@
   return cache_type_;
 }
 
 int32 BackendImplV3::GetEntryCount() const {
   if (disabled_)
     return 0;
   DCHECK(init_);
   return index_.header()->num_entries;
 }
 
-int BackendImplV3::OpenEntry(const std::string& key, Entry** entry,
+int BackendImplV3::OpenEntry(const std::string& key,
+                             Entry** entry,
                              const CompletionCallback& callback) {
   if (disabled_)
     return NULL;
 
   TimeTicks start = TimeTicks::Now();
   uint32 hash = base::Hash(key);
   Trace("Open hash 0x%x", hash);
 
   bool error;
   EntryImpl* cache_entry = MatchEntry(key, hash, false, Addr(), &error);
@@ skipping 13 matching lines @@
     CACHE_UMA(COUNTS_10000, "AllOpenBySize.Miss", 0, current_size);
     CACHE_UMA(HOURS, "AllOpenByTotalHours.Miss", 0, total_hours);
     CACHE_UMA(HOURS, "AllOpenByUseHours.Miss", 0, use_hours);
     stats_.OnEvent(Stats::OPEN_MISS);
     return NULL;
   }
 
   eviction_.OnOpenEntry(cache_entry);
   entry_count_++;
 
-  Trace("Open hash 0x%x end: 0x%x", hash,
+  Trace("Open hash 0x%x end: 0x%x",
+        hash,
         cache_entry->entry()->address().value());
   CACHE_UMA(AGE_MS, "OpenTime", 0, start);
   CACHE_UMA(COUNTS_10000, "AllOpenBySize.Hit", 0, current_size);
   CACHE_UMA(HOURS, "AllOpenByTotalHours.Hit", 0, total_hours);
   CACHE_UMA(HOURS, "AllOpenByUseHours.Hit", 0, use_hours);
   stats_.OnEvent(Stats::OPEN_HIT);
   SIMPLE_STATS_COUNTER("disk_cache.hit");
   return cache_entry;
 }
 
-int BackendImplV3::CreateEntry(const std::string& key, Entry** entry,
+int BackendImplV3::CreateEntry(const std::string& key,
+                               Entry** entry,
                                const CompletionCallback& callback) {
   if (disabled_ || key.empty())
     return NULL;
 
   TimeTicks start = TimeTicks::Now();
   Trace("Create hash 0x%x", hash);
 
   scoped_refptr<EntryImpl> parent;
   Addr entry_address(data_->table[hash & mask_]);
   if (entry_address.is_initialized()) {
@@ skipping 130 matching lines @@
   EntryImpl* node;
   void* iter = NULL;
   EntryImpl* next = OpenNextEntryImpl(&iter);
   if (!next)
     return net::OK;
 
   while (next) {
     node = next;
     next = OpenNextEntryImpl(&iter);
 
-    if (node->GetLastUsed() >= initial_time &&
-        node->GetLastUsed() < end_time) {
+    if (node->GetLastUsed() >= initial_time && node->GetLastUsed() < end_time) {
       node->DoomImpl();
     } else if (node->GetLastUsed() < initial_time) {
       if (next)
         next->Release();
       next = NULL;
       SyncEndEnumeration(iter);
     }
 
     node->Release();
   }
@@ skipping 19 matching lines @@
       SyncEndEnumeration(iter);
       return net::OK;
     }
 
     entry->DoomImpl();
     entry->Release();
     SyncEndEnumeration(iter);  // Dooming the entry invalidates the iterator.
   }
 }
 
-int BackendImplV3::OpenNextEntry(void** iter, Entry** next_entry,
+int BackendImplV3::OpenNextEntry(void** iter,
+                                 Entry** next_entry,
                                  const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.OpenNextEntry(iter, next_entry, callback);
   return net::ERR_IO_PENDING;
 }
 
 void BackendImplV3::EndEnumeration(void** iter) {
-  scoped_ptr<IndexIterator> iterator(
-      reinterpret_cast<IndexIterator*>(*iter));
+  scoped_ptr<IndexIterator> iterator(reinterpret_cast<IndexIterator*>(*iter));
   *iter = NULL;
 }
 
 void BackendImplV3::GetStats(StatsItems* stats) {
   if (disabled_)
     return;
 
   std::pair<std::string, std::string> item;
 
   item.first = "Entries";
@@ skipping 61 matching lines @@
   // of bigger caches. TODO(rvargas): remove this limit.
   if (max_size_ > kDefaultCacheSize * 4)
     max_size_ = kDefaultCacheSize * 4;
 
   if (!table_len)
     return;
 
   // If we already have a table, adjust the size to it.
   int current_max_size = MaxStorageSizeForTable(table_len);
   if (max_size_ > current_max_size)
-    max_size_= current_max_size;
+    max_size_ = current_max_size;
 }
 
 bool BackendImplV3::InitStats() {
   Addr address(data_->header.stats);
   int size = stats_.StorageSize();
 
   if (!address.is_initialized()) {
     FileType file_type = Addr::RequiredFileType(size);
     DCHECK_NE(file_type, EXTERNAL);
     int num_blocks = Addr::RequiredBlocks(size, file_type);
 
     if (!CreateBlock(file_type, num_blocks, &address))
       return false;
     return stats_.Init(NULL, 0, address);
   }
 
   if (!address.is_block_file()) {
     NOTREACHED();
     return false;
   }
 
   // Load the required data.
   size = address.num_blocks() * address.BlockSize();
   MappedFile* file = File(address);
   if (!file)
     return false;
 
   scoped_ptr<char[]> data(new char[size]);
-  size_t offset = address.start_block() * address.BlockSize() +
-                  kBlockHeaderSize;
+  size_t offset =
+      address.start_block() * address.BlockSize() + kBlockHeaderSize;
   if (!file->Read(data.get(), size, offset))
     return false;
 
   if (!stats_.Init(data.get(), size, address))
     return false;
   if (cache_type_ == net::DISK_CACHE && ShouldReportAgain())
     stats_.InitSizeHistogram();
   return true;
 }
 
 void BackendImplV3::StoreStats() {
   int size = stats_.StorageSize();
   scoped_ptr<char[]> data(new char[size]);
   Addr address;
   size = stats_.SerializeStats(data.get(), size, &address);
   DCHECK(size);
   if (!address.is_initialized())
     return;
 
   MappedFile* file = File(address);
   if (!file)
     return;
 
-  size_t offset = address.start_block() * address.BlockSize() +
-                  kBlockHeaderSize;
+  size_t offset =
+      address.start_block() * address.BlockSize() + kBlockHeaderSize;
   file->Write(data.get(), size, offset);  // ignore result.
 }
 
 void BackendImplV3::RestartCache(bool failure) {
   int64 errors = stats_.GetCounter(Stats::FATAL_ERROR);
   int64 full_dooms = stats_.GetCounter(Stats::DOOM_CACHE);
   int64 partial_dooms = stats_.GetCounter(Stats::DOOM_RECENT);
   int64 last_report = stats_.GetCounter(Stats::LAST_REPORT);
 
   PrepareForRestart();
@@ skipping 87 matching lines @@
   if (IsLoaded()) {
     CACHE_UMA(AGE_MS, "LoadTime", 0, start);
   }
 
   if (!cache_entry->SanityCheck()) {
     LOG(WARNING) << "Messed up entry found.";
     STRESS_NOTREACHED();
     return ERR_INVALID_ENTRY;
   }
 
-  STRESS_DCHECK(block_files_.IsValid(
-                    Addr(cache_entry->entry()->Data()->rankings_node)));
+  STRESS_DCHECK(
+      block_files_.IsValid(Addr(cache_entry->entry()->Data()->rankings_node)));
 
   if (!cache_entry->LoadNodeAddress())
     return ERR_READ_FAILURE;
 
   if (!rankings_.SanityCheck(cache_entry->rankings(), false)) {
     STRESS_NOTREACHED();
     cache_entry->SetDirtyFlag(0);
     // Don't remove this from the list (it is not linked properly). Instead,
     // break the link back to the entry because it is going away, and leave the
     // rankings node to be deleted if we find it through a list.
     rankings_.SetContents(cache_entry->rankings(), 0);
   } else if (!rankings_.DataSanityCheck(cache_entry->rankings(), false)) {
     STRESS_NOTREACHED();
     cache_entry->SetDirtyFlag(0);
     rankings_.SetContents(cache_entry->rankings(), address.value());
   }
 
   if (!cache_entry->DataSanityCheck()) {
     LOG(WARNING) << "Messed up entry found.";
     cache_entry->SetDirtyFlag(0);
     cache_entry->FixForDelete();
   }
 
   // Prevent overwriting the dirty flag on the destructor.
   cache_entry->SetDirtyFlag(GetCurrentEntryId());
 
   if (cache_entry->dirty()) {
-    Trace("Dirty entry 0x%p 0x%x", reinterpret_cast<void*>(cache_entry.get()),
+    Trace("Dirty entry 0x%p 0x%x",
+          reinterpret_cast<void*>(cache_entry.get()),
           address.value());
   }
 
   open_entries_[address.value()] = cache_entry.get();
 
   cache_entry->BeginLogging(net_log_, false);
   cache_entry.swap(entry);
   return 0;
 }
 
 // This is the actual implementation for OpenNextEntry and OpenPrevEntry.
-int BackendImplV3::OpenFollowingEntry(bool forward, void** iter,
+int BackendImplV3::OpenFollowingEntry(bool forward,
+                                      void** iter,
                                       Entry** next_entry,
                                       const CompletionCallback& callback) {
   if (disabled_)
     return net::ERR_FAILED;
 
   DCHECK(iter);
 
   const int kListsToSearch = 3;
   scoped_refptr<EntryImpl> entries[kListsToSearch];
   scoped_ptr<Rankings::Iterator> iterator(
       reinterpret_cast<Rankings::Iterator*>(*iter));
   *iter = NULL;
 
   if (!iterator.get()) {
     iterator.reset(new Rankings::Iterator(&rankings_));
     bool ret = false;
 
     // Get an entry from each list.
     for (int i = 0; i < kListsToSearch; i++) {
       EntryImpl* temp = NULL;
-      ret |= OpenFollowingEntryFromList(forward, static_cast<Rankings::List>(i),
-                                        &iterator->nodes[i], &temp);
+      ret |= OpenFollowingEntryFromList(
+          forward, static_cast<Rankings::List>(i), &iterator->nodes[i], &temp);
       entries[i].swap(&temp);  // The entry was already addref'd.
     }
     if (!ret)
       return NULL;
   } else {
     // Get the next entry from the last list, and the actual entries for the
     // elements on the other lists.
     for (int i = 0; i < kListsToSearch; i++) {
       EntryImpl* temp = NULL;
       if (iterator->list == i) {
-          OpenFollowingEntryFromList(forward, iterator->list,
-                                     &iterator->nodes[i], &temp);
+        OpenFollowingEntryFromList(
+            forward, iterator->list, &iterator->nodes[i], &temp);
       } else {
         temp = GetEnumeratedEntry(iterator->nodes[i],
                                   static_cast<Rankings::List>(i));
       }
 
       entries[i].swap(&temp);  // The entry was already addref'd.
     }
   }
 
   int newest = -1;
@@ skipping 86 matching lines @@
 
   num_refs_ = num_pending_io_ = max_refs_ = 0;
   entry_count_ = byte_count_ = 0;
 
   if (!restarted_) {
     buffer_bytes_ = 0;
     trace_object_ = TraceObject::GetTraceObject();
     // Create a recurrent timer of 30 secs.
     int timer_delay = unit_test_ ? 1000 : 30000;
     timer_.reset(new base::RepeatingTimer<BackendImplV3>());
-    timer_->Start(FROM_HERE, TimeDelta::FromMilliseconds(timer_delay), this,
+    timer_->Start(FROM_HERE,
+                  TimeDelta::FromMilliseconds(timer_delay),
+                  this,
                   &BackendImplV3::OnStatsTimer);
   }
 
   init_ = true;
   Trace("Init");
 
   if (data_->header.experiment != NO_EXPERIMENT &&
       cache_type_ != net::DISK_CACHE) {
     // No experiment for other caches.
     return net::ERR_FAILED;
@@ skipping 198 matching lines @@
 
   int current_size = header->num_bytes / (1024 * 1024);
   int max_size = max_size_ / (1024 * 1024);
 
   CACHE_UMA(COUNTS_10000, "Size", current_size);
   CACHE_UMA(COUNTS_10000, "MaxSize", max_size);
   if (!max_size)
     max_size++;
   CACHE_UMA(PERCENTAGE, "UsedSpace", current_size * 100 / max_size);
 
-  CACHE_UMA(COUNTS_10000, "AverageOpenEntries",
+  CACHE_UMA(COUNTS_10000,
+            "AverageOpenEntries",
             static_cast<int>(stats_.GetCounter(Stats::OPEN_ENTRIES)));
-  CACHE_UMA(COUNTS_10000, "MaxOpenEntries",
+  CACHE_UMA(COUNTS_10000,
+            "MaxOpenEntries",
             static_cast<int>(stats_.GetCounter(Stats::MAX_ENTRIES)));
   stats_.SetCounter(Stats::MAX_ENTRIES, 0);
 
-  CACHE_UMA(COUNTS_10000, "TotalFatalErrors",
+  CACHE_UMA(COUNTS_10000,
+            "TotalFatalErrors",
             static_cast<int>(stats_.GetCounter(Stats::FATAL_ERROR)));
-  CACHE_UMA(COUNTS_10000, "TotalDoomCache",
+  CACHE_UMA(COUNTS_10000,
+            "TotalDoomCache",
             static_cast<int>(stats_.GetCounter(Stats::DOOM_CACHE)));
-  CACHE_UMA(COUNTS_10000, "TotalDoomRecentEntries",
+  CACHE_UMA(COUNTS_10000,
+            "TotalDoomRecentEntries",
             static_cast<int>(stats_.GetCounter(Stats::DOOM_RECENT)));
   stats_.SetCounter(Stats::FATAL_ERROR, 0);
   stats_.SetCounter(Stats::DOOM_CACHE, 0);
   stats_.SetCounter(Stats::DOOM_RECENT, 0);
 
   int64 total_hours = stats_.GetCounter(Stats::TIMER) / 120;
   if (!(header->flags & CACHE_EVICTED)) {
     CACHE_UMA(HOURS, "TotalTimeNotFull", static_cast<int>(total_hours));
     return;
   }
@@ skipping 22 matching lines @@
   int avg_size = header->num_bytes / GetEntryCount();
   CACHE_UMA(COUNTS, "EntrySize", avg_size);
   CACHE_UMA(COUNTS, "EntriesFull", header->num_entries);
 
   int large_entries_bytes = stats_.GetLargeEntriesSize();
   int large_ratio = large_entries_bytes * 100 / header->num_bytes;
   CACHE_UMA(PERCENTAGE, "LargeEntriesRatio", large_ratio);
 
   if (!lru_eviction_) {
     CACHE_UMA(PERCENTAGE, "ResurrectRatio", stats_.GetResurrectRatio());
-    CACHE_UMA(PERCENTAGE, "NoUseRatio",
+    CACHE_UMA(PERCENTAGE,
+              "NoUseRatio",
               header->num_no_use_entries * 100 / header->num_entries);
-    CACHE_UMA(PERCENTAGE, "LowUseRatio",
+    CACHE_UMA(PERCENTAGE,
+              "LowUseRatio",
               header->num_low_use_entries * 100 / header->num_entries);
-    CACHE_UMA(PERCENTAGE, "HighUseRatio",
+    CACHE_UMA(PERCENTAGE,
+              "HighUseRatio",
               header->num_high_use_entries * 100 / header->num_entries);
-    CACHE_UMA(PERCENTAGE, "DeletedRatio",
+    CACHE_UMA(PERCENTAGE,
+              "DeletedRatio",
               header->num_evicted_entries * 100 / header->num_entries);
   }
 
   stats_.ResetRatios();
   stats_.SetCounter(Stats::TRIM_ENTRY, 0);
 
   if (cache_type_ == net::DISK_CACHE)
     block_files_.ReportStats();
 }
 
@@ skipping 96 matching lines @@
 
       DCHECK_EQ(i, cache_entry->entry()->Data()->hash & mask_);
       address.set_value(cache_entry->GetNextAddress());
       if (!address.is_initialized())
         break;
     }
   }
 
   Trace("CheckAllEntries End");
   if (num_entries + num_dirty != data_->header.num_entries) {
-    LOG(ERROR) << "Number of entries " << num_entries << " " << num_dirty <<
-                  " " << data_->header.num_entries;
+    LOG(ERROR) << "Number of entries " << num_entries << " " << num_dirty << " "
+               << data_->header.num_entries;
     DCHECK_LT(num_entries, data_->header.num_entries);
     return ERR_NUM_ENTRIES_MISMATCH;
   }
 
   return num_dirty;
 }
 
 bool BackendImplV3::CheckEntry(EntryImpl* cache_entry) {
   bool ok = block_files_.IsValid(cache_entry->entry()->address());
   ok = ok && block_files_.IsValid(cache_entry->rankings()->address());
@@ skipping 34 matching lines @@
 }
 
 net::CacheType BackendImplV3::GetCacheType() const {
   return cache_type_;
 }
 
 int32 BackendImplV3::GetEntryCount() const {
   return 0;
 }
 
-int BackendImplV3::OpenEntry(const std::string& key, Entry** entry,
+int BackendImplV3::OpenEntry(const std::string& key,
+                             Entry** entry,
                              const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
-int BackendImplV3::CreateEntry(const std::string& key, Entry** entry,
+int BackendImplV3::CreateEntry(const std::string& key,
+                               Entry** entry,
                                const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 int BackendImplV3::DoomEntry(const std::string& key,
                              const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 int BackendImplV3::DoomAllEntries(const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 int BackendImplV3::DoomEntriesBetween(base::Time initial_time,
                                       base::Time end_time,
                                       const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 int BackendImplV3::DoomEntriesSince(base::Time initial_time,
                                     const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
-int BackendImplV3::OpenNextEntry(void** iter, Entry** next_entry,
+int BackendImplV3::OpenNextEntry(void** iter,
+                                 Entry** next_entry,
                                  const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 void BackendImplV3::EndEnumeration(void** iter) {
   NOTIMPLEMENTED();
 }
 
 void BackendImplV3::GetStats(StatsItems* stats) {
   NOTIMPLEMENTED();
 }
 
 void BackendImplV3::OnExternalCacheHit(const std::string& key) {
   NOTIMPLEMENTED();
 }
 
 void BackendImplV3::CleanupCache() {
 }
 
 }  // namespace disk_cache