Clang format slam.

net/disk_cache/blockfile/backend_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/backend_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/file.h"
@@ skipping 67 matching lines @@
 // Sets group for the current experiment. Returns false if the files should be
 // discarded.
 bool InitExperiment(disk_cache::IndexHeader* header, bool cache_created) {
   if (header->experiment == disk_cache::EXPERIMENT_OLD_FILE1 ||
       header->experiment == disk_cache::EXPERIMENT_OLD_FILE2) {
     // Discard current cache.
     return false;
   }
 
   if (base::FieldTrialList::FindFullName("SimpleCacheTrial") ==
-          "ExperimentControl") {
+      "ExperimentControl") {
     if (cache_created) {
       header->experiment = disk_cache::EXPERIMENT_SIMPLE_CONTROL;
       return true;
     }
     return header->experiment == disk_cache::EXPERIMENT_SIMPLE_CONTROL;
   }
 
   header->experiment = disk_cache::NO_EXPERIMENT;
   return true;
 }
@@ skipping 184 matching lines @@
   } else if (!restarted_) {
     ReportError(ERR_NO_ERROR);
   }
 
   FlushIndex();
 
   if (!disabled_ && should_create_timer) {
     // Create a recurrent timer of 30 secs.
     int timer_delay = unit_test_ ? 1000 : 30000;
     timer_.reset(new base::RepeatingTimer<BackendImpl>());
-    timer_->Start(FROM_HERE, TimeDelta::FromMilliseconds(timer_delay), this,
+    timer_->Start(FROM_HERE,
+                  TimeDelta::FromMilliseconds(timer_delay),
+                  this,
                   &BackendImpl::OnStatsTimer);
   }
 
   return disabled_ ? net::ERR_FAILED : net::OK;
 }
 
 void BackendImpl::CleanupCache() {
   Trace("Backend Cleanup");
   eviction_.Stop();
   timer_.reset();
@@ skipping 13 matching lines @@
   }
   block_files_.CloseFiles();
   FlushIndex();
   index_ = NULL;
   ptr_factory_.InvalidateWeakPtrs();
   done_.Signal();
 }
 
 // ------------------------------------------------------------------------
 
-int BackendImpl::OpenPrevEntry(void** iter, Entry** prev_entry,
+int BackendImpl::OpenPrevEntry(void** iter,
+                               Entry** prev_entry,
                                const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.OpenPrevEntry(iter, prev_entry, callback);
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::SyncOpenEntry(const std::string& key, Entry** entry) {
   DCHECK(entry);
   *entry = OpenEntryImpl(key);
   return (*entry) ? net::OK : net::ERR_FAILED;
@@ skipping 48 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 83 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;
 }
 
@@ skipping 175 matching lines @@
 
   DCHECK(success);
   if (!success)
     return false;
 
   data_->header.last_file = file_number;
   address->set_value(file_address.value());
   return true;
 }
 
-bool BackendImpl::CreateBlock(FileType block_type, int block_count,
-                             Addr* block_address) {
+bool BackendImpl::CreateBlock(FileType block_type,
+                              int block_count,
+                              Addr* block_address) {
   return block_files_.CreateBlock(block_type, block_count, block_address);
 }
 
 void BackendImpl::DeleteBlock(Addr block_address, bool deep) {
   block_files_.DeleteBlock(block_address, deep);
 }
 
 LruData* BackendImpl::GetLruData() {
   return &data_->header.lru;
 }
@@ skipping 175 matching lines @@
   CACHE_UMA(COUNTS, "PendingIO", 0, num_pending_io_);
   if (user_flags_ & kNoLoadProtection)
     return false;
 
   return (num_pending_io_ > 5 || user_load_);
 }
 
 std::string BackendImpl::HistogramName(const char* name, int experiment) const {
   if (!experiment)
     return base::StringPrintf("DiskCache.%d.%s", cache_type_, name);
-  return base::StringPrintf("DiskCache.%d.%s_%d", cache_type_,
-                            name, experiment);
+  return base::StringPrintf(
+      "DiskCache.%d.%s_%d", cache_type_, name, experiment);
 }
 
 base::WeakPtr<BackendImpl> BackendImpl::GetWeakPtr() {
   return ptr_factory_.GetWeakPtr();
 }
 
 // We want to remove biases from some histograms so we only send data once per
 // week.
 bool BackendImpl::ShouldReportAgain() {
   if (uma_report_)
@@ skipping 17 matching lines @@
 
   Time create_time = Time::FromInternalValue(data_->header.create_time);
   CACHE_UMA(AGE, "FillupAge", 0, create_time);
 
   int64 use_time = stats_.GetCounter(Stats::TIMER);
   CACHE_UMA(HOURS, "FillupTime", 0, static_cast<int>(use_time / 120));
   CACHE_UMA(PERCENTAGE, "FirstHitRatio", 0, stats_.GetHitRatio());
 
   if (!use_time)
     use_time = 1;
-  CACHE_UMA(COUNTS_10000, "FirstEntryAccessRate", 0,
+  CACHE_UMA(COUNTS_10000,
+            "FirstEntryAccessRate",
+            0,
             static_cast<int>(data_->header.num_entries / use_time));
-  CACHE_UMA(COUNTS, "FirstByteIORate", 0,
+  CACHE_UMA(COUNTS,
+            "FirstByteIORate",
+            0,
             static_cast<int>((data_->header.num_bytes / 1024) / use_time));
 
   int avg_size = data_->header.num_bytes / GetEntryCount();
   CACHE_UMA(COUNTS, "FirstEntrySize", 0, avg_size);
 
   int large_entries_bytes = stats_.GetLargeEntriesSize();
   int large_ratio = large_entries_bytes * 100 / data_->header.num_bytes;
   CACHE_UMA(PERCENTAGE, "FirstLargeEntriesRatio", 0, large_ratio);
 
   if (new_eviction_) {
     CACHE_UMA(PERCENTAGE, "FirstResurrectRatio", 0, stats_.GetResurrectRatio());
-    CACHE_UMA(PERCENTAGE, "FirstNoUseRatio", 0,
+    CACHE_UMA(PERCENTAGE,
+              "FirstNoUseRatio",
+              0,
               data_->header.lru.sizes[0] * 100 / data_->header.num_entries);
-    CACHE_UMA(PERCENTAGE, "FirstLowUseRatio", 0,
+    CACHE_UMA(PERCENTAGE,
+              "FirstLowUseRatio",
+              0,
               data_->header.lru.sizes[1] * 100 / data_->header.num_entries);
-    CACHE_UMA(PERCENTAGE, "FirstHighUseRatio", 0,
+    CACHE_UMA(PERCENTAGE,
+              "FirstHighUseRatio",
+              0,
               data_->header.lru.sizes[2] * 100 / data_->header.num_entries);
   }
 
   stats_.ResetRatios();
 }
 
 void BackendImpl::CriticalError(int error) {
   STRESS_NOTREACHED();
   LOG(ERROR) << "Critical error found " << error;
   if (disabled_)
@@ skipping 169 matching lines @@
 // ------------------------------------------------------------------------
 
 net::CacheType BackendImpl::GetCacheType() const {
   return cache_type_;
 }
 
 int32 BackendImpl::GetEntryCount() const {
   if (!index_.get() || disabled_)
     return 0;
   // num_entries includes entries already evicted.
-  int32 not_deleted = data_->header.num_entries -
-                      data_->header.lru.sizes[Rankings::DELETED];
+  int32 not_deleted =
+      data_->header.num_entries - data_->header.lru.sizes[Rankings::DELETED];
 
   if (not_deleted < 0) {
     NOTREACHED();
     not_deleted = 0;
   }
 
   return not_deleted;
 }
 
-int BackendImpl::OpenEntry(const std::string& key, Entry** entry,
+int BackendImpl::OpenEntry(const std::string& key,
+                           Entry** entry,
                            const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.OpenEntry(key, entry, callback);
   return net::ERR_IO_PENDING;
 }
 
-int BackendImpl::CreateEntry(const std::string& key, Entry** entry,
+int BackendImpl::CreateEntry(const std::string& key,
+                             Entry** entry,
                              const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.CreateEntry(key, entry, callback);
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::DoomEntry(const std::string& key,
                            const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.DoomEntry(key, callback);
@@ skipping 14 matching lines @@
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::DoomEntriesSince(const base::Time initial_time,
                                   const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.DoomEntriesSince(initial_time, callback);
   return net::ERR_IO_PENDING;
 }
 
-int BackendImpl::OpenNextEntry(void** iter, Entry** next_entry,
+int BackendImpl::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 BackendImpl::EndEnumeration(void** iter) {
   background_queue_.EndEnumeration(*iter);
   *iter = NULL;
 }
@@ skipping 113 matching lines @@
     available += data_->header.num_bytes;
 
   max_size_ = PreferredCacheSize(available);
 
   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 BackendImpl::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);
@@ skipping 10 matching lines @@
     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 BackendImpl::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 BackendImpl::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 66 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;
 }
 
-EntryImpl* BackendImpl::MatchEntry(const std::string& key, uint32 hash,
-                                   bool find_parent, Addr entry_addr,
+EntryImpl* BackendImpl::MatchEntry(const std::string& key,
+                                   uint32 hash,
+                                   bool find_parent,
+                                   Addr entry_addr,
                                    bool* match_error) {
   Addr address(data_->table[hash & mask_]);
   scoped_refptr<EntryImpl> cache_entry, parent_entry;
   EntryImpl* tmp = NULL;
   bool found = false;
   std::set<CacheAddr> visited;
   *match_error = false;
 
   for (;;) {
     if (disabled_)
@@ skipping 24 matching lines @@
       if (!error)
         child.set_value(cache_entry->GetNextAddress());
 
       if (parent_entry.get()) {
         parent_entry->SetNextAddress(child);
         parent_entry = NULL;
       } else {
         data_->table[hash & mask_] = child.value();
       }
 
-      Trace("MatchEntry dirty %d 0x%x 0x%x", find_parent, entry_addr.value(),
+      Trace("MatchEntry dirty %d 0x%x 0x%x",
+            find_parent,
+            entry_addr.value(),
             address.value());
 
       if (!error) {
         // It is important to call DestroyInvalidEntry after removing this
         // entry from the table.
         DestroyInvalidEntry(cache_entry.get());
         cache_entry = NULL;
       } else {
         Trace("NewEntry failed on MatchEntry 0x%x", address.value());
       }
@@ skipping 55 matching lines @@
       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 24 matching lines @@
   } else {
     next_entry = entries[oldest].get();
     iterator->list = static_cast<Rankings::List>(oldest);
   }
 
   *iter = iterator.release();
   next_entry->AddRef();
   return next_entry;
 }
 
-bool BackendImpl::OpenFollowingEntryFromList(bool forward, Rankings::List list,
+bool BackendImpl::OpenFollowingEntryFromList(bool forward,
+                                             Rankings::List list,
                                              CacheRankingsBlock** from_entry,
                                              EntryImpl** next_entry) {
   if (disabled_)
     return false;
 
   if (!new_eviction_ && Rankings::NO_USE != list)
     return false;
 
   Rankings::ScopedRankingsBlock rankings(&rankings_, *from_entry);
-  CacheRankingsBlock* next_block = forward ?
-      rankings_.GetNext(rankings.get(), list) :
-      rankings_.GetPrev(rankings.get(), list);
+  CacheRankingsBlock* next_block =
+      forward ? rankings_.GetNext(rankings.get(), list)
+              : rankings_.GetPrev(rankings.get(), list);
   Rankings::ScopedRankingsBlock next(&rankings_, next_block);
   *from_entry = NULL;
 
   *next_entry = GetEnumeratedEntry(next.get(), list);
   if (!*next_entry)
     return false;
 
   *from_entry = next.release();
   return true;
 }
@@ skipping 132 matching lines @@
   // For any bin in HitRatioBySize2, the hit ratio of caches of that size is the
   // ratio of that bin's total count to the count in the same bin in the Size2
   // histogram.
   if (base::RandInt(0, 99) < hit_ratio_as_percentage)
     CACHE_UMA(COUNTS_10000, "HitRatioBySize2", 0, current_size);
   CACHE_UMA(COUNTS_10000, "MaxSize2", 0, max_size);
   if (!max_size)
     max_size++;
   CACHE_UMA(PERCENTAGE, "UsedSpace", 0, current_size * 100 / max_size);
 
-  CACHE_UMA(COUNTS_10000, "AverageOpenEntries2", 0,
+  CACHE_UMA(COUNTS_10000,
+            "AverageOpenEntries2",
+            0,
             static_cast<int>(stats_.GetCounter(Stats::OPEN_ENTRIES)));
-  CACHE_UMA(COUNTS_10000, "MaxOpenEntries2", 0,
+  CACHE_UMA(COUNTS_10000,
+            "MaxOpenEntries2",
+            0,
             static_cast<int>(stats_.GetCounter(Stats::MAX_ENTRIES)));
   stats_.SetCounter(Stats::MAX_ENTRIES, 0);
 
-  CACHE_UMA(COUNTS_10000, "TotalFatalErrors", 0,
+  CACHE_UMA(COUNTS_10000,
+            "TotalFatalErrors",
+            0,
             static_cast<int>(stats_.GetCounter(Stats::FATAL_ERROR)));
-  CACHE_UMA(COUNTS_10000, "TotalDoomCache", 0,
+  CACHE_UMA(COUNTS_10000,
+            "TotalDoomCache",
+            0,
             static_cast<int>(stats_.GetCounter(Stats::DOOM_CACHE)));
-  CACHE_UMA(COUNTS_10000, "TotalDoomRecentEntries", 0,
+  CACHE_UMA(COUNTS_10000,
+            "TotalDoomRecentEntries",
+            0,
             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);
 
-  int age = (Time::Now() -
-             Time::FromInternalValue(data_->header.create_time)).InHours();
+  int age = (Time::Now() - Time::FromInternalValue(data_->header.create_time))
+                .InHours();
   if (age)
     CACHE_UMA(HOURS, "FilesAge", 0, age);
 
   int64 total_hours = stats_.GetCounter(Stats::TIMER) / 120;
   if (!data_->header.create_time || !data_->header.lru.filled) {
     int cause = data_->header.create_time ? 0 : 1;
     if (!data_->header.lru.filled)
       cause |= 2;
     CACHE_UMA(CACHE_ERROR, "ShortReport", 0, cause);
     CACHE_UMA(HOURS, "TotalTimeNotFull", 0, static_cast<int>(total_hours));
@@ skipping 29 matching lines @@
     CACHE_UMA(HOURS, "HitRatioByUseTime", 0, implicit_cast<int>(use_hours));
   CACHE_UMA(PERCENTAGE, "HitRatio", 0, hit_ratio_as_percentage);
 
   int64 trim_rate = stats_.GetCounter(Stats::TRIM_ENTRY) / use_hours;
   CACHE_UMA(COUNTS, "TrimRate", 0, static_cast<int>(trim_rate));
 
   int avg_size = data_->header.num_bytes / GetEntryCount();
   CACHE_UMA(COUNTS, "EntrySize", 0, avg_size);
   CACHE_UMA(COUNTS, "EntriesFull", 0, data_->header.num_entries);
 
-  CACHE_UMA(PERCENTAGE, "IndexLoad", 0,
+  CACHE_UMA(PERCENTAGE,
+            "IndexLoad",
+            0,
             data_->header.num_entries * 100 / (mask_ + 1));
 
   int large_entries_bytes = stats_.GetLargeEntriesSize();
   int large_ratio = large_entries_bytes * 100 / data_->header.num_bytes;
   CACHE_UMA(PERCENTAGE, "LargeEntriesRatio", 0, large_ratio);
 
   if (new_eviction_) {
     CACHE_UMA(PERCENTAGE, "ResurrectRatio", 0, stats_.GetResurrectRatio());
-    CACHE_UMA(PERCENTAGE, "NoUseRatio", 0,
+    CACHE_UMA(PERCENTAGE,
+              "NoUseRatio",
+              0,
               data_->header.lru.sizes[0] * 100 / data_->header.num_entries);
-    CACHE_UMA(PERCENTAGE, "LowUseRatio", 0,
+    CACHE_UMA(PERCENTAGE,
+              "LowUseRatio",
+              0,
               data_->header.lru.sizes[1] * 100 / data_->header.num_entries);
-    CACHE_UMA(PERCENTAGE, "HighUseRatio", 0,
+    CACHE_UMA(PERCENTAGE,
+              "HighUseRatio",
+              0,
               data_->header.lru.sizes[2] * 100 / data_->header.num_entries);
-    CACHE_UMA(PERCENTAGE, "DeletedRatio", 0,
+    CACHE_UMA(PERCENTAGE,
+              "DeletedRatio",
+              0,
               data_->header.lru.sizes[4] * 100 / data_->header.num_entries);
   }
 
   stats_.ResetRatios();
   stats_.SetCounter(Stats::TRIM_ENTRY, 0);
 
   if (cache_type_ == net::DISK_CACHE)
     block_files_.ReportStats();
 }
 
@@ skipping 94 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 BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   bool ok = block_files_.IsValid(cache_entry->entry()->address());
   ok = ok && block_files_.IsValid(cache_entry->rankings()->address());
@@ skipping 21 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache