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

net/disk_cache/backend_impl.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/backend_impl.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ skipping 801 matching lines @@
     stats_.OnEvent(Stats::CREATE_ERROR);
     return NULL;
   }
 
   cache_entry->BeginLogging(net_log_, true);
 
   // We are not failing the operation; let's add this to the map.
   open_entries_[entry_address.value()] = cache_entry;
 
   // Save the entry.
-  block_files_.GetFile(entry_address)->Store(cache_entry->entry());
-  block_files_.GetFile(node_address)->Store(cache_entry->rankings());
+  cache_entry->entry()->Store();
+  cache_entry->rankings()->Store();

[gavinp, 2011/11/29 15:47:42]

Nice.

   IncreaseNumEntries();
   entry_count_++;
 
   // Link this entry through the index.
   if (parent.get()) {
     parent->SetNextAddress(entry_address);
   } else {
     data_->table[hash & mask_] = entry_address.value();
   }
 
@@ skipping 802 matching lines @@
     STRESS_NOTREACHED();
     return ERR_INVALID_ENTRY;
   }
 
   STRESS_DCHECK(block_files_.IsValid(
                     Addr(cache_entry->entry()->Data()->rankings_node)));
 
   if (!cache_entry->LoadNodeAddress())
     return ERR_READ_FAILURE;
 
-  // Prevent overwriting the dirty flag on the destructor.
-  cache_entry->SetDirtyFlag(GetCurrentEntryId());
-
   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());

[gavinp, 2011/11/29 15:47:42]

Why is this moving beyond the two sanity-check blocks?

[rvargas (doing something else), 2011/11/29 19:08:56]

Because this is reading Rankings; we want the first access to read the hash and
verify it. On the other hand, all code paths end up calling SetDirtyFlag (even
if a future refactor decides to return after one of the sanity checks)

+
   if (cache_entry->dirty()) {
     Trace("Dirty entry 0x%p 0x%x", reinterpret_cast<void*>(cache_entry.get()),
           address.value());
   }
 
   open_entries_[address.value()] = cache_entry;
 
   cache_entry->BeginLogging(net_log_, false);
   cache_entry.swap(entry);
   return 0;
@@ skipping 534 matching lines @@
   ok = ok && block_files_.IsValid(cache_entry->rankings()->address());
   EntryStore* data = cache_entry->entry()->Data();
   for (size_t i = 0; i < arraysize(data->data_addr); i++) {
     if (data->data_addr[i]) {
       Addr address(data->data_addr[i]);
       if (address.is_block_file())
         ok = ok && block_files_.IsValid(address);
     }
   }
 
-  RankingsNode* rankings = cache_entry->rankings()->Data();
-  return ok && !rankings->dummy;
+  return ok && cache_entry->rankings()->VerifyHash();
 }
 
 int BackendImpl::MaxBuffersSize() {
   static int64 total_memory = base::SysInfo::AmountOfPhysicalMemory();
   static bool done = false;
 
   if (!done) {
     const int kMaxBuffersSize = 30 * 1024 * 1024;
 
     // We want to use up to 2% of the computer's memory.
     total_memory = total_memory * 2 / 100;
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache