Disk Cache: Improve handling of dirty entries.

net/disk_cache/entry_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/entry_impl.h"
 
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
@@ skipping 478 matching lines @@
       DeleteData(address, index);
     }
   }
 
   if (!everything)
     return;
 
   // Remove all traces of this entry.
   backend_->RemoveEntry(this);
 
+  // Note that at this point node_ and entry_ are just two blocks of data, and
+  // even if they reference each other, nobody should be referencing them.
+
   Addr address(entry_.Data()->long_key);
   DeleteData(address, kKeyFileIndex);
   backend_->ModifyStorageSize(entry_.Data()->key_len, 0);
 
-  memset(node_.buffer(), 0, node_.size());
-  memset(entry_.buffer(), 0, entry_.size());
-  node_.Store();
-  entry_.Store();
+  backend_->DeleteBlock(entry_.address(), true);
 
-  backend_->DeleteBlock(node_.address(), false);
-  backend_->DeleteBlock(entry_.address(), false);
+  if (!LeaveRankingsBehind())
+    backend_->DeleteBlock(node_.address(), true);
 }
 
 CacheAddr EntryImpl::GetNextAddress() {
   return entry_.Data()->next;
 }
 
 void EntryImpl::SetNextAddress(Addr address) {
   DCHECK_NE(address.value(), entry_.address().value());
   entry_.Data()->next = address.value();
   bool success = entry_.Store();
@@ skipping 24 matching lines @@
 
 void EntryImpl::SetDirtyFlag(int32 current_id) {
   DCHECK(node_.HasData());
   // We are checking if the entry is valid or not. If there is a pointer here,
   // we should not be checking the entry.
   if (node_.Data()->dummy)
     dirty_ = true;
 
   if (node_.Data()->dirty && current_id != node_.Data()->dirty)
     dirty_ = true;
+
+  if (!current_id)
+    dirty_ = true;
 }
 
 void EntryImpl::SetPointerForInvalidEntry(int32 new_id) {
   node_.Data()->dirty = new_id;
   node_.Data()->dummy = 0;
   node_.Store();
 }
 
+bool EntryImpl::LeaveRankingsBehind() {
+  return !node_.Data()->contents;
+}
+
+// This only includes checks that relate to the first block of the entry (the
+// first 256 bytes), and values that should be set from the entry creation.
+// Basically, even if there is something wrong with this entry, we want to see
+// if it is possible to load the rankings node and delete them together.
 bool EntryImpl::SanityCheck() {
   EntryStore* stored = entry_.Data();
   if (!stored->rankings_node || stored->key_len <= 0)
     return false;
 
   if (stored->reuse_count < 0 || stored->refetch_count < 0)
     return false;
 
   Addr rankings_addr(stored->rankings_node);
   if (!rankings_addr.is_initialized() || rankings_addr.is_separate_file() ||
-      rankings_addr.file_type() != RANKINGS)
+      rankings_addr.file_type() != RANKINGS || rankings_addr.num_blocks() != 1)
     return false;
 
   Addr next_addr(stored->next);
   if (next_addr.is_initialized() &&
       (next_addr.is_separate_file() || next_addr.file_type() != BLOCK_256))
     return false;
 
   if (!rankings_addr.SanityCheck() || !next_addr.SanityCheck())
     return false;
 
@@ skipping 10 matching lines @@
 
   if (key_addr.is_initialized() &&
       ((stored->key_len <= kMaxBlockSize && key_addr.is_separate_file()) ||
        (stored->key_len > kMaxBlockSize && key_addr.is_block_file())))
     return false;
 
   int num_blocks = NumBlocksForEntry(stored->key_len);
   if (entry_.address().num_blocks() != num_blocks)
     return false;
 
+  return true;
+}
+
+bool EntryImpl::DataSanityCheck() {
+  EntryStore* stored = entry_.Data();
+  Addr key_addr(stored->long_key);
+
   // The key must be NULL terminated.
   if (!key_addr.is_initialized() && stored->key[stored->key_len])
     return false;
 
   if (stored->hash != Hash(GetKey()))
     return false;
 
   for (int i = 0; i < kNumStreams; i++) {
     Addr data_addr(stored->data_addr[i]);
     int data_size = stored->data_size[i];
     if (data_size < 0)
       return false;
     if (!data_size && data_addr.is_initialized())
       return false;
     if (!data_addr.SanityCheck())
       return false;
     if (!data_size)
       continue;
     if (data_size <= kMaxBlockSize && data_addr.is_separate_file())
       return false;
     if (data_size > kMaxBlockSize && data_addr.is_block_file())
       return false;
   }
+  return true;
+}
 
-  return true;
+void EntryImpl::FixForDelete() {
+  EntryStore* stored = entry_.Data();
+  Addr key_addr(stored->long_key);
+
+  if (!key_addr.is_initialized())
+    stored->key[stored->key_len] = '\0';
+
+  for (int i = 0; i < kNumStreams; i++) {
+    Addr data_addr(stored->data_addr[i]);
+    int data_size = stored->data_size[i];
+    if (data_addr.is_initialized()) {
+      if ((data_size <= kMaxBlockSize && data_addr.is_separate_file()) ||
+          (data_size > kMaxBlockSize && data_addr.is_block_file()) ||
+          !data_addr.SanityCheck()) {
+        // The address is weird so don't attempt to delete it.
+        stored->data_addr[i] = 0;
+        // In general, trust the stored size as it should be in sync with the
+        // total size tracked by the backend.
+      }
+    }
+    if (data_size < 0)
+      stored->data_size[i] = 0;
+  }
+  entry_.Store();
 }
 
 void EntryImpl::IncrementIoCount() {
   backend_->IncrementIoCount();
 }
 
 void EntryImpl::DecrementIoCount() {
   backend_->DecrementIoCount();
 }
 
@@ skipping 788 matching lines @@
   Trace("%s 0x%p 0x%x 0x%x", msg, reinterpret_cast<void*>(this),
         entry_.address().value(), node_.address().value());
 
   Trace("  data: 0x%x 0x%x 0x%x", entry_.Data()->data_addr[0],
         entry_.Data()->data_addr[1], entry_.Data()->long_key);
 
   Trace("  doomed: %d 0x%x", doomed_, dirty);
 }
 
 }  // namespace disk_cache