Disk cache: Add a hash to the entry's internal data.

net/disk_cache/rankings.cc

 // Copyright (c) 2011 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/rankings.h"
 
 #include "base/metrics/histogram.h"
 #include "net/disk_cache/backend_impl.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
@@ skipping 476 matching lines @@
   for (int i = 0; i < LAST_ELEMENT; i++) {
     int partial = CheckList(static_cast<List>(i));
     if (partial < 0)
       return partial;
     total += partial;
   }
   return total;
 }
 
 bool Rankings::SanityCheck(CacheRankingsBlock* node, bool from_list) const {
+  if (!node->VerifyHash())
+    return false;
+
   const RankingsNode* data = node->Data();
 
   if ((!data->next && data->prev) || (data->next && !data->prev))
     return false;
 
   // Both pointers on zero is a node out of the list.
   if (!data->next && !data->prev && from_list)
     return false;
 
   List list = NO_USE;  // Initialize it to something.
@@ skipping 58 matching lines @@
   if (!rankings->Load())
     return false;
 
   if (!SanityCheck(rankings, true)) {
     backend_->CriticalError(ERR_INVALID_LINKS);
     return false;
   }
 
   backend_->OnEvent(Stats::OPEN_RANKINGS);
 
-  // "dummy" is the old "pointer" value, so it has to be 0.
-  if (!rankings->Data()->dirty && !rankings->Data()->dummy)
+  if (!rankings->Data()->dirty)
     return true;
 
   EntryImpl* entry = backend_->GetOpenEntry(rankings);
   if (!entry) {
     // We cannot trust this entry, but we cannot initiate a cleanup from this
-    // point (we may be in the middle of a cleanup already). Just get rid of
-    // the invalid pointer and continue; the entry will be deleted when detected
-    // from a regular open/create path.
-    rankings->Data()->dummy = 0;
+    // point (we may be in the middle of a cleanup already). The entry will be
+    // deleted when detected from a regular open/create path.
     rankings->Data()->dirty = backend_->GetCurrentEntryId() - 1;
     if (!rankings->Data()->dirty)
       rankings->Data()->dirty--;
     return true;
   }
 
   // Note that we should not leave this module without deleting rankings first.
   rankings->SetData(entry->rankings()->Data());
 
   CACHE_UMA(AGE_MS, "GetRankings", 0, start);
@@ skipping 20 matching lines @@
     LOG(ERROR) << "Invalid rankings info.";
     return;
   }
 
   Trace("CompleteTransaction 0x%x", node_addr.value());
 
   CacheRankingsBlock node(backend_->File(node_addr), node_addr);
   if (!node.Load())
     return;
 
-  node.Data()->dummy = 0;
   node.Store();
 
   Addr& my_head = heads_[control_data_->operation_list];
   Addr& my_tail = tails_[control_data_->operation_list];
 
   // We want to leave the node inside the list. The entry must me marked as
   // dirty, and will be removed later. Otherwise, we'll get assertions when
   // attempting to remove the dirty entry.
   if (INSERT == control_data_->operation) {
     Trace("FinishInsert h:0x%x t:0x%x", my_head.value(), my_tail.value());
@@ skipping 76 matching lines @@
     WriteTail(my_list);
   }
 
   next.Store();
   prev.Store();
   control_data_->transaction = 0;
   control_data_->operation = 0;
 }
 
 bool Rankings::CheckEntry(CacheRankingsBlock* rankings) {
-  if (!rankings->Data()->dummy)
+  if (rankings->VerifyHash())
     return true;
 
   // If this entry is not dirty, it is a serious problem.
   return backend_->GetCurrentEntryId() != rankings->Data()->dirty;
 }
 
 bool Rankings::CheckLinks(CacheRankingsBlock* node, CacheRankingsBlock* prev,
                           CacheRankingsBlock* next, List* list) {
   CacheAddr node_addr = node->address().value();
   if (prev->Data()->next == node_addr &&
@@ skipping 149 matching lines @@
 void Rankings::DecrementCounter(List list) {
   if (!count_lists_)
     return;
 
   DCHECK(control_data_->sizes[list] > 0);
   if (control_data_->sizes[list] > 0)
     control_data_->sizes[list]--;
 }
 
 }  // namespace disk_cache