Disk cache: remove the hard coded list from rankings.cc...

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"
@@ skipping 337 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_.Insert(cache_entry->rankings(), true, Rankings::NO_USE);
   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 197 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(CacheRankingsBlock* node, bool modified) {
-  if (!read_only_)
-    rankings_.UpdateRank(node, modified);
+void BackendImpl::UpdateRank(EntryImpl* entry, bool modified) {
+  if (!read_only_) {
+    rankings_.UpdateRank(entry->rankings(), modified, Rankings::NO_USE);
+  }
 }
 
 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_.Remove(entry->rankings(), Rankings::NO_USE);
 
   entry->InternalDoom();
 
   if (parent_entry) {
     parent_entry->SetNextAddress(Addr(child));
     parent_entry->Release();
   } else {
     data_->table[hash & mask_] = child;
   }
 
@@ skipping 347 matching lines @@
 }
 
 // This is the actual implementation for OpenNextEntry and OpenPrevEntry.
 bool BackendImpl::OpenFollowingEntry(bool forward, void** iter,
                                      Entry** next_entry) {
   if (disabled_)
     return false;
 
   Rankings::ScopedRankingsBlock rankings(&rankings_,
       reinterpret_cast<CacheRankingsBlock*>(*iter));
-  CacheRankingsBlock* next_block = forward ? rankings_.GetNext(rankings.get()) :
-                                             rankings_.GetPrev(rankings.get());
+  CacheRankingsBlock* next_block = forward ?
+      rankings_.GetNext(rankings.get(), Rankings::NO_USE) :
+      rankings_.GetPrev(rankings.get(), Rankings::NO_USE);
   Rankings::ScopedRankingsBlock next(&rankings_, next_block);
   *next_entry = NULL;
   *iter = NULL;
   if (!next.get())
     return false;
 
   scoped_refptr<EntryImpl> entry;
   if (next->Data()->pointer) {
     entry = reinterpret_cast<EntryImpl*>(next->Data()->pointer);
   } else {
@@ skipping 25 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_.Remove(entry->rankings(), Rankings::NO_USE);
   entry->SetPointerForInvalidEntry(GetCurrentEntryId());
 
   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::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()));
+    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) {
@@ skipping 149 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->pointer;
 }
 
 }  // namespace disk_cache