Disk cache: move eviction code to a separate file....

net/disk_cache/backend_impl.cc

 // Copyright (c) 2006-2008 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/backend_impl.h"
 
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/timer.h"
 #include "base/worker_pool.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
 #include "net/disk_cache/hash.h"
 #include "net/disk_cache/file.h"
 
 using base::Time;
 using base::TimeDelta;
 
 namespace {
 
 const wchar_t* kIndexName = L"index";
-const int kCleanUpMargin = 1024 * 1024;
 const int kMaxOldFolders = 100;
 
 // Seems like ~240 MB correspond to less than 50k entries for 99% of the people.
 const int k64kEntriesStore = 240 * 1000 * 1000;
 const int kBaseTableLen = 64 * 1024;
 const int kDefaultCacheSize = 80 * 1024 * 1024;
 
 int DesiredIndexTableLen(int32 storage_size) {
   if (storage_size <= k64kEntriesStore)
     return kBaseTableLen;
@@ skipping 10 matching lines @@
 
 int MaxStorageSizeForTable(int table_len) {
   return table_len * (k64kEntriesStore / kBaseTableLen);
 }
 
 size_t GetIndexSize(int table_len) {
   size_t table_size = sizeof(disk_cache::CacheAddr) * table_len;
   return sizeof(disk_cache::IndexHeader) + table_size;
 }
 
-int LowWaterAdjust(int high_water) {
-  if (high_water < kCleanUpMargin)
-    return 0;
-
-  return high_water - kCleanUpMargin;
-}
-
 // ------------------------------------------------------------------------
 
 // Returns a fully qualified name from path and name, using a given name prefix
 // and index number. For instance, if the arguments are "/foo", "bar" and 5, it
 // will return "/foo/old_bar_005".
 std::wstring GetPrefixedName(const std::wstring& path, const std::wstring& name,
                              int index) {
   std::wstring prefixed(path);
   std::wstring tmp = StringPrintf(L"%ls%ls_%03d", L"old_", name.c_str(), index);
   file_util::AppendToPath(&prefixed, tmp);
@@ skipping 167 matching lines @@
 
   if (!block_files_.Init(create_files))
     return false;
 
   // stats_ and rankings_ may end up calling back to us so we better be enabled.
   disabled_ = false;
   if (!stats_.Init(this, &data_->header.stats))
     return false;
 
   disabled_ = !rankings_.Init(this);
+  eviction_.Init(this);
 
   return !disabled_;
 }
 
 BackendImpl::~BackendImpl() {
   Trace("Backend destructor");
   if (!init_)
     return;
 
   if (data_)
@@ skipping 19 matching lines @@
 
   Time start = Time::Now();
   uint32 hash = Hash(key);
 
   EntryImpl* cache_entry = MatchEntry(key, hash, false);
   if (!cache_entry) {
     stats_.OnEvent(Stats::OPEN_MISS);
     return false;
   }
 
+  eviction_.OnOpenEntry(cache_entry);
   DCHECK(entry);
   *entry = cache_entry;
 
   UMA_HISTOGRAM_TIMES(L"DiskCache.OpenTime", Time::Now() - start);
   stats_.OnEvent(Stats::OPEN_HIT);
   return true;
 }
 
 bool BackendImpl::CreateEntry(const std::string& key, Entry** entry) {
   if (disabled_ || key.empty())
@@ skipping 48 matching lines @@
   }
 
   if (parent.get())
     parent->SetNextAddress(entry_address);
 
   block_files_.GetFile(entry_address)->Store(cache_entry->entry());
   block_files_.GetFile(node_address)->Store(cache_entry->rankings());
 
   data_->header.num_entries++;
   DCHECK(data_->header.num_entries > 0);
-  rankings_.Insert(cache_entry->rankings(), true, Rankings::NO_USE);
+  eviction_.OnCreateEntry(cache_entry);
   if (!parent.get())
     data_->table[hash & mask_] = entry_address.value();
 
   DCHECK(entry);
   *entry = NULL;
   cache_entry.swap(reinterpret_cast<EntryImpl**>(entry));
 
   UMA_HISTOGRAM_TIMES(L"DiskCache.CreateTime", Time::Now() - start);
   stats_.OnEvent(Stats::CREATE_HIT);
   Trace("create entry hit ");
@@ skipping 18 matching lines @@
 
 bool BackendImpl::DoomAllEntries() {
   if (!num_refs_) {
     PrepareForRestart();
     DeleteCache(path_.c_str(), false);
     return Init();
   } else {
     if (disabled_)
       return false;
 
-    TrimCache(true);
+    eviction_.TrimCache(true);
     stats_.OnEvent(Stats::DOOM_CACHE);
     return true;
   }
 }
 
 bool BackendImpl::DoomEntriesBetween(const Time initial_time,
                                      const Time end_time) {
   if (end_time.is_null())
     return DoomEntriesSince(initial_time);
 
@@ skipping 160 matching lines @@
 void BackendImpl::DeleteBlock(Addr block_address, bool deep) {
   block_files_.DeleteBlock(block_address, deep);
 }
 
 LruData* BackendImpl::GetLruData() {
   return &data_->header.lru;
 }
 
 void BackendImpl::UpdateRank(EntryImpl* entry, bool modified) {
   if (!read_only_) {
-    rankings_.UpdateRank(entry->rankings(), modified, Rankings::NO_USE);
+    eviction_.UpdateRank(entry, modified);
   }
 }
 
 void BackendImpl::RecoveredEntry(CacheRankingsBlock* rankings) {
   Addr address(rankings->Data()->contents);
   EntryImpl* cache_entry = NULL;
   bool dirty;
   if (NewEntry(address, &cache_entry, &dirty))
     return;
 
   uint32 hash = cache_entry->GetHash();
   cache_entry->Release();
 
   // Anything on the table means that this entry is there.
   if (data_->table[hash & mask_])
     return;
 
   data_->table[hash & mask_] = address.value();
 }
 
 void BackendImpl::InternalDoomEntry(EntryImpl* entry) {
   uint32 hash = entry->GetHash();
   std::string key = entry->GetKey();
   EntryImpl* parent_entry = MatchEntry(key, hash, true);
   CacheAddr child(entry->GetNextAddress());
 
   Trace("Doom entry 0x%p", entry);
 
-  rankings_.Remove(entry->rankings(), Rankings::NO_USE);
-
+  eviction_.OnDoomEntry(entry);
   entry->InternalDoom();
 
   if (parent_entry) {
     parent_entry->SetNextAddress(Addr(child));
     parent_entry->Release();
   } else {
     data_->table[hash & mask_] = child;
   }
 
   data_->header.num_entries--;
@@ skipping 394 matching lines @@
 
   entry.swap(reinterpret_cast<EntryImpl**>(next_entry));
   *iter = next.release();
   return true;
 }
 
 void BackendImpl::DestroyInvalidEntry(Addr address, EntryImpl* entry) {
   LOG(WARNING) << "Destroying invalid entry.";
   Trace("Destroying invalid entry 0x%p", entry);
 
-  rankings_.Remove(entry->rankings(), Rankings::NO_USE);
   entry->SetPointerForInvalidEntry(GetCurrentEntryId());
 
+  eviction_.OnDoomEntry(entry);
   entry->InternalDoom();
 
   data_->header.num_entries--;
   DCHECK(data_->header.num_entries >= 0);
   stats_.OnEvent(Stats::INVALID_ENTRY);
 }
 
-void BackendImpl::TrimCache(bool empty) {
-  Trace("*** Trim Cache ***");
-  if (disabled_)
-    return;
-
-  Time start = Time::Now();
-  Rankings::ScopedRankingsBlock node(&rankings_);
-  Rankings::ScopedRankingsBlock next(&rankings_,
-      rankings_.GetPrev(node.get(), Rankings::NO_USE));
-  DCHECK(next.get());
-  int target_size = empty ? 0 : LowWaterAdjust(max_size_);
-  int deleted = 0;
-  while (data_->header.num_bytes > target_size && next.get()) {
-    node.reset(next.release());
-    next.reset(rankings_.GetPrev(node.get(), Rankings::NO_USE));
-    if (!node->Data()->pointer || empty) {
-      // This entry is not being used by anybody.
-      EntryImpl* entry;
-      bool dirty;
-      if (NewEntry(Addr(node->Data()->contents), &entry, &dirty)) {
-        Trace("NewEntry failed on Trim 0x%x", node->address().value());
-        continue;
-      }
-
-      if (node->Data()->pointer) {
-        entry = EntryImpl::Update(entry);
-      }
-      ReportTrimTimes(entry);
-      entry->Doom();
-      entry->Release();
-      if (!empty)
-        stats_.OnEvent(Stats::TRIM_ENTRY);
-      if (++deleted == 4 && !empty) {
-#if defined(OS_WIN)
-        MessageLoop::current()->PostTask(FROM_HERE,
-            factory_.NewRunnableMethod(&BackendImpl::TrimCache, false));
-        break;
-#endif
-      }
-    }
-  }
-
-  UMA_HISTOGRAM_TIMES(L"DiskCache.TotalTrimTime", Time::Now() - start);
-  Trace("*** Trim Cache end ***");
-  return;
-}
-
-void BackendImpl::ReportTrimTimes(EntryImpl* entry) {
-  static bool first_time = true;
-  if (first_time) {
-    first_time = false;
-    std::wstring name(StringPrintf(L"DiskCache.TrimAge_%d",
-                                   data_->header.experiment));
-    static Histogram counter(name.c_str(), 1, 10000, 50);
-    counter.SetFlags(kUmaTargetedHistogramFlag);
-    counter.Add((Time::Now() - entry->GetLastUsed()).InHours());
-  }
-}
-
 void BackendImpl::AddStorageSize(int32 bytes) {
   data_->header.num_bytes += bytes;
   DCHECK(data_->header.num_bytes >= 0);
 
   if (data_->header.num_bytes > max_size_)
-    TrimCache(false);
+    eviction_.TrimCache(false);
 }
 
 void BackendImpl::SubstractStorageSize(int32 bytes) {
   data_->header.num_bytes -= bytes;
   DCHECK(data_->header.num_bytes >= 0);
 }
 
 void BackendImpl::IncreaseNumRefs() {
   num_refs_++;
   if (max_refs_ < num_refs_)
@@ skipping 103 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->pointer;
 }
 
 }  // namespace disk_cache