Disk cache: Avoid restarting the cache while it may be in use....

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/field_trial.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
@@ skipping 863 matching lines @@
 
   LogStats();
   ReportError(error);
 
   // Setting the index table length to an invalid value will force re-creation
   // of the cache files.
   data_->header.table_len = 1;
   disabled_ = true;
 
   if (!num_refs_)
-    RestartCache();
+    MessageLoop::current()->PostTask(FROM_HERE,
+        factory_.NewRunnableMethod(&BackendImpl::RestartCache));
 }
 
 void BackendImpl::ReportError(int error) {
   // We transmit positive numbers, instead of direct error codes.
   DCHECK(error <= 0);
   CACHE_UMA(CACHE_ERROR, "Error", 0, error * -1);
 }
 
 void BackendImpl::OnEvent(Stats::Counters an_event) {
   stats_.OnEvent(an_event);
@@ skipping 164 matching lines @@
 
   if (!table_len)
     return;
 
   // If we already have a table, adjust the size to it.
   int current_max_size = MaxStorageSizeForTable(table_len);
   if (max_size_ > current_max_size)
     max_size_= current_max_size;
 }
 
+// We always execute this method from the message loop so that we can freely
+// release files, memory pointers etc.
 void BackendImpl::RestartCache() {
+  DCHECK(!num_refs_);
+  DCHECK(!open_entries_.size());
   PrepareForRestart();
   DelayedCacheCleanup(path_);
 
   int64 errors = stats_.GetCounter(Stats::FATAL_ERROR);
 
   // Don't call Init() if directed by the unit test: we are simulating a failure
   // trying to re-enable the cache.
   if (unit_test_)
     init_ = true;  // Let the destructor do proper cleanup.
   else if (Init())
@@ skipping 237 matching lines @@
   *next_entry = GetEnumeratedEntry(next.get(), false);
   if (!*next_entry)
     return false;
 
   *from_entry = next.release();
   return true;
 }
 
 EntryImpl* BackendImpl::GetEnumeratedEntry(CacheRankingsBlock* next,
                                            bool to_evict) {
-  if (!next)
+  if (!next || disabled_)
     return NULL;
 
   EntryImpl* entry;
   bool dirty;
   if (NewEntry(Addr(next->Data()->contents), &entry, &dirty))
     return NULL;
 
   if (dirty) {
     // We cannot trust this entry. This code also releases the reference.
     DestroyInvalidEntryFromEnumeration(entry);
@@ skipping 95 matching lines @@
   num_refs_++;
   if (max_refs_ < num_refs_)
     max_refs_ = num_refs_;
 }
 
 void BackendImpl::DecreaseNumRefs() {
   DCHECK(num_refs_);
   num_refs_--;
 
   if (!num_refs_ && disabled_)
-    RestartCache();
+    MessageLoop::current()->PostTask(FROM_HERE,
+        factory_.NewRunnableMethod(&BackendImpl::RestartCache));
 }
 
 void BackendImpl::IncreaseNumEntries() {
   data_->header.num_entries++;
   DCHECK(data_->header.num_entries > 0);
 }
 
 void BackendImpl::DecreaseNumEntries() {
   data_->header.num_entries--;
   if (data_->header.num_entries < 0) {
@@ skipping 178 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->pointer;
 }
 
 }  // namespace disk_cache