Clang format slam.

net/disk_cache/blockfile/eviction.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.
 
 // The eviction policy is a very simple pure LRU, so the elements at the end of
 // the list are evicted until kCleanUpMargin free space is available. There is
 // only one list in use (Rankings::NO_USE), and elements are sent to the front
 // of the list whenever they are accessed.
 
 // The new (in-development) eviction policy adds re-use as a factor to evict
@@ skipping 32 matching lines @@
 
 // Provide a BackendImpl object to macros from histogram_macros.h.
 #define CACHE_UMA_BACKEND_IMPL_OBJ backend_
 
 using base::Time;
 using base::TimeTicks;
 
 namespace {
 
 const int kCleanUpMargin = 1024 * 1024;
-const int kHighUse = 10;  // Reuse count to be on the HIGH_USE list.
+const int kHighUse = 10;         // Reuse count to be on the HIGH_USE list.
 const int kTargetTime = 24 * 7;  // Time to be evicted (hours since last use).
 const int kMaxDelayedTrims = 60;
 
 int LowWaterAdjust(int high_water) {
   if (high_water < kCleanUpMargin)
     return 0;
 
   return high_water - kCleanUpMargin;
 }
 
 bool FallingBehind(int current_size, int max_size) {
   return current_size > max_size - kCleanUpMargin * 20;
 }
 
 }  // namespace
 
 namespace disk_cache {
 
 // The real initialization happens during Init(), init_ is the only member that
 // has to be initialized here.
-Eviction::Eviction()
-    : backend_(NULL),
-      init_(false),
-      ptr_factory_(this) {
+Eviction::Eviction() : backend_(NULL), init_(false), ptr_factory_(this) {
 }
 
 Eviction::~Eviction() {
 }
 
 void Eviction::Init(BackendImpl* backend) {
   // We grab a bunch of info from the backend to make the code a little cleaner
   // when we're actually doing work.
   backend_ = backend;
   rankings_ = &backend->rankings_;
@@ skipping 150 matching lines @@
   trim_delays_ = 0;
   return true;
 }
 
 bool Eviction::ShouldTrimDeleted() {
   int index_load = header_->num_entries * 100 / index_size_;
 
   // If the index is not loaded, the deleted list will tend to double the size
   // of the other lists 3 lists (40% of the total). Otherwise, all lists will be
   // about the same size.
-  int max_length = (index_load < 25) ? header_->num_entries * 2 / 5 :
-                                       header_->num_entries / 4;
+  int max_length = (index_load < 25) ? header_->num_entries * 2 / 5
+                                     : header_->num_entries / 4;
   return (!test_mode_ && header_->lru.sizes[Rankings::DELETED] > max_length);
 }
 
 void Eviction::ReportTrimTimes(EntryImpl* entry) {
   if (first_trim_) {
     first_trim_ = false;
     if (backend_->ShouldReportAgain()) {
       CACHE_UMA(AGE, "TrimAge", 0, entry->GetLastUsed());
       ReportListStats();
     }
@@ skipping 15 matching lines @@
       old.day_of_month = 1;
       header_->create_time = Time::FromLocalExploded(old).ToInternalValue();
     }
   }
 }
 
 Rankings::List Eviction::GetListForEntry(EntryImpl* entry) {
   return Rankings::NO_USE;
 }
 
-bool Eviction::EvictEntry(CacheRankingsBlock* node, bool empty,
+bool Eviction::EvictEntry(CacheRankingsBlock* node,
+                          bool empty,
                           Rankings::List list) {
   EntryImpl* entry = backend_->GetEnumeratedEntry(node, list);
   if (!entry) {
     Trace("NewEntry failed on Trim 0x%x", node->address().value());
     return false;
   }
 
   ReportTrimTimes(entry);
   if (empty || !new_eviction_) {
     entry->DoomImpl();
@@ skipping 50 matching lines @@
   int deleted_entries = 0;
   int target_size = empty ? 0 : max_size_;
 
   for (; list < kListsToSearch; list++) {
     while ((header_->num_bytes > target_size || test_mode_) &&
            next[list].get()) {
       // The iterator could be invalidated within EvictEntry().
       if (!next[list]->HasData())
         break;
       node.reset(next[list].release());
-      next[list].reset(rankings_->GetPrev(node.get(),
-                                          static_cast<Rankings::List>(list)));
+      next[list].reset(
+          rankings_->GetPrev(node.get(), static_cast<Rankings::List>(list)));
       if (node->Data()->dirty != backend_->GetCurrentEntryId() || empty) {
         // This entry is not being used by anybody.
         // Do NOT use node as an iterator after this point.
         rankings_->TrackRankingsBlock(node.get(), false);
         if (EvictEntry(node.get(), empty, static_cast<Rankings::List>(list)))
           deleted_entries++;
 
         if (!empty && test_mode_)
           break;
       }
@@ skipping 124 matching lines @@
 // This is a minimal implementation that just discards the oldest nodes.
 // TODO(rvargas): Do something better here.
 void Eviction::TrimDeleted(bool empty) {
   Trace("*** Trim Deleted ***");
   if (backend_->disabled_)
     return;
 
   TimeTicks start = TimeTicks::Now();
   Rankings::ScopedRankingsBlock node(rankings_);
   Rankings::ScopedRankingsBlock next(
-    rankings_, rankings_->GetPrev(node.get(), Rankings::DELETED));
+      rankings_, rankings_->GetPrev(node.get(), Rankings::DELETED));
   int deleted_entries = 0;
   while (next.get() &&
          (empty || (deleted_entries < 20 &&
                     (TimeTicks::Now() - start).InMilliseconds() < 20))) {
     node.reset(next.release());
     next.reset(rankings_->GetPrev(node.get(), Rankings::DELETED));
     if (RemoveDeletedNode(node.get()))
       deleted_entries++;
     if (test_mode_)
       break;
@@ skipping 31 matching lines @@
 
   // If possible, we want to keep entries on each list at least kTargetTime
   // hours. Each successive list on the enumeration has 2x the target time of
   // the previous list.
   Time used = Time::FromInternalValue(node->Data()->last_used);
   int multiplier = 1 << list;
   return (Time::Now() - used).InHours() > kTargetTime * multiplier;
 }
 
 int Eviction::SelectListByLength(Rankings::ScopedRankingsBlock* next) {
-  int data_entries = header_->num_entries -
-                     header_->lru.sizes[Rankings::DELETED];
+  int data_entries =
+      header_->num_entries - header_->lru.sizes[Rankings::DELETED];
   // Start by having each list to be roughly the same size.
   if (header_->lru.sizes[0] > data_entries / 3)
     return 0;
 
   int list = (header_->lru.sizes[1] > data_entries / 3) ? 1 : 2;
 
   // Make sure that frequently used items are kept for a minimum time; we know
   // that this entry is not older than its current target, but it must be at
   // least older than the target for list 0 (kTargetTime), as long as we don't
   // exhaust list 0.
   if (!NodeIsOldEnough(next[list].get(), 0) &&
       header_->lru.sizes[0] > data_entries / 10)
     list = 0;
 
   return list;
 }
 
 void Eviction::ReportListStats() {
   if (!new_eviction_)
     return;
 
-  Rankings::ScopedRankingsBlock last1(rankings_,
-      rankings_->GetPrev(NULL, Rankings::NO_USE));
-  Rankings::ScopedRankingsBlock last2(rankings_,
-      rankings_->GetPrev(NULL, Rankings::LOW_USE));
-  Rankings::ScopedRankingsBlock last3(rankings_,
-      rankings_->GetPrev(NULL, Rankings::HIGH_USE));
-  Rankings::ScopedRankingsBlock last4(rankings_,
-      rankings_->GetPrev(NULL, Rankings::DELETED));
+  Rankings::ScopedRankingsBlock last1(
+      rankings_, rankings_->GetPrev(NULL, Rankings::NO_USE));
+  Rankings::ScopedRankingsBlock last2(
+      rankings_, rankings_->GetPrev(NULL, Rankings::LOW_USE));
+  Rankings::ScopedRankingsBlock last3(
+      rankings_, rankings_->GetPrev(NULL, Rankings::HIGH_USE));
+  Rankings::ScopedRankingsBlock last4(
+      rankings_, rankings_->GetPrev(NULL, Rankings::DELETED));
 
   if (last1.get())
-    CACHE_UMA(AGE, "NoUseAge", 0,
+    CACHE_UMA(AGE,
+              "NoUseAge",
+              0,
               Time::FromInternalValue(last1.get()->Data()->last_used));
   if (last2.get())
-    CACHE_UMA(AGE, "LowUseAge", 0,
+    CACHE_UMA(AGE,
+              "LowUseAge",
+              0,
               Time::FromInternalValue(last2.get()->Data()->last_used));
   if (last3.get())
-    CACHE_UMA(AGE, "HighUseAge", 0,
+    CACHE_UMA(AGE,
+              "HighUseAge",
+              0,
               Time::FromInternalValue(last3.get()->Data()->last_used));
   if (last4.get())
-    CACHE_UMA(AGE, "DeletedAge", 0,
+    CACHE_UMA(AGE,
+              "DeletedAge",
+              0,
               Time::FromInternalValue(last4.get()->Data()->last_used));
 }
 
 }  // namespace disk_cache