Disk cache: Remove all non essential synchronization from the cache destructor.

net/disk_cache/backend_impl.cc

 // Copyright (c) 2012 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/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 334 matching lines @@
       disabled_(false),
       new_eviction_(false),
       first_timer_(true),
       user_load_(false),
       net_log_(net_log),
       done_(true, false),
       ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) {
 }
 
 BackendImpl::~BackendImpl() {
-  background_queue_.WaitForPendingIO();
+  if (user_flags_ & kNoRandom) {
+    // This is a unit test, so we want to be strict about not leaking entries
+    // and completing all the work.
+    background_queue_.WaitForPendingIO();
+  } else {
+    // This is most likely not a test, so we want to do as little work as
+    // possible at this time, at the price of leaving dirty entries behind.
+    background_queue_.DropPendingIO();
+  }
 
   if (background_queue_.BackgroundIsCurrentThread()) {
     // Unit tests may use the same thread for everything.
     CleanupCache();
   } else {
     background_queue_.background_thread()->PostTask(
         FROM_HERE, base::Bind(&FinalCleanupCallback, base::Unretained(this)));
     done_.Wait();
   }
 }
 
 // If the initialization of the cache fails, and force is true, we will discard
 // the whole cache and create a new one. In order to process a potentially large
 // number of files, we'll rename the cache folder to old_ + original_name +
 // number, (located on the same parent folder), and spawn a worker thread to
 // delete all the files on all the stale cache folders. The whole process can
 // still fail if we are not able to rename the cache folder (for instance due to
 // a sharing violation), and in that case a cache for this profile (on the
 // desired path) cannot be created.
 //
 // Static.
 int BackendImpl::CreateBackend(const FilePath& full_path, bool force,
                                int max_bytes, net::CacheType type,
                                uint32 flags, base::MessageLoopProxy* thread,
                                net::NetLog* net_log, Backend** backend,
-                               const net::CompletionCallback& callback) {
+                               const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   CacheCreator* creator =
       new CacheCreator(full_path, force, max_bytes, type, flags, thread,
                        net_log, backend, callback);
   // This object will self-destroy when finished.
   return creator->Run();
 }
 
-int BackendImpl::Init(const net::CompletionCallback& callback) {
+int BackendImpl::Init(const CompletionCallback& callback) {
   background_queue_.Init(callback);
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::SyncInit() {
 #if defined(NET_BUILD_STRESS_CACHE)
   // Start evictions right away.
   up_ticks_ = kTrimDelay * 2;
 #endif
   DCHECK(!init_);
@@ skipping 20 matching lines @@
 
   init_ = true;
   Trace("Init");
 
   if (data_->header.experiment != NO_EXPERIMENT &&
       cache_type_ != net::DISK_CACHE) {
     // No experiment for other caches.
     return net::ERR_FAILED;
   }
 
-  if (!(user_flags_ & disk_cache::kNoRandom)) {
+  if (!(user_flags_ & kNoRandom)) {
     // The unit test controls directly what to test.
     new_eviction_ = (cache_type_ == net::DISK_CACHE);
   }
 
   if (!CheckIndex()) {
     ReportError(ERR_INIT_FAILED);
     return net::ERR_FAILED;
   }
 
-  if (!(user_flags_ & disk_cache::kNoRandom) &&
+  if (!(user_flags_ & kNoRandom) &&
       cache_type_ == net::DISK_CACHE && !InitExperiment(&data_->header))
     return net::ERR_FAILED;
 
   // We don't care if the value overflows. The only thing we care about is that
   // the id cannot be zero, because that value is used as "not dirty".
   // Increasing the value once per second gives us many years before we start
   // having collisions.
   data_->header.this_id++;
   if (!data_->header.this_id)
     data_->header.this_id++;
@@ skipping 37 matching lines @@
 void BackendImpl::CleanupCache() {
   Trace("Backend Cleanup");
   eviction_.Stop();
   timer_.Stop();
 
   if (init_) {
     stats_.Store();
     if (data_)
       data_->header.crash = 0;
 
-    File::WaitForPendingIO(&num_pending_io_);
     if (user_flags_ & kNoRandom) {
       // This is a net_unittest, verify that we are not 'leaking' entries.
+      File::WaitForPendingIO(&num_pending_io_);
       DCHECK(!num_refs_);
     }
   }
   block_files_.CloseFiles();
   index_ = NULL;
   ptr_factory_.InvalidateWeakPtrs();
   done_.Signal();
 }
 
 // ------------------------------------------------------------------------
 
 int BackendImpl::OpenPrevEntry(void** iter, Entry** prev_entry,
-                               const net::CompletionCallback& callback) {
+                               const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.OpenPrevEntry(iter, prev_entry, callback);
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::SyncOpenEntry(const std::string& key, Entry** entry) {
   DCHECK(entry);
   *entry = OpenEntryImpl(key);
   return (*entry) ? net::OK : net::ERR_FAILED;
 }
@@ skipping 294 matching lines @@
   std::string tmp = base::StringPrintf("f_%06x", address.FileNumber());
   return path_.AppendASCII(tmp);
 }
 
 MappedFile* BackendImpl::File(Addr address) {
   if (disabled_)
     return NULL;
   return block_files_.GetFile(address);
 }
 
+base::WeakPtr<InFlightBackendIO> BackendImpl::GetBackgroundQueue() {
+  return background_queue_.GetWeakPtr();
+}
+
 bool BackendImpl::CreateExternalFile(Addr* address) {
   int file_number = data_->header.last_file + 1;
   Addr file_address(0);
   bool success = false;
   for (int i = 0; i < 0x0fffffff; i++, file_number++) {
     if (!file_address.SetFileNumber(file_number)) {
       file_number = 1;
       continue;
     }
     FilePath name = GetFileName(file_address);
@@ skipping 138 matching lines @@
 
 void BackendImpl::OnEntryDestroyBegin(Addr address) {
   EntriesMap::iterator it = open_entries_.find(address.value());
   if (it != open_entries_.end())
     open_entries_.erase(it);
 }
 
 void BackendImpl::OnEntryDestroyEnd() {
   DecreaseNumRefs();
   if (data_->header.num_bytes > max_size_ && !read_only_ &&
-      (up_ticks_ > kTrimDelay || user_flags_ & disk_cache::kNoRandom))
+      (up_ticks_ > kTrimDelay || user_flags_ & kNoRandom))
     eviction_.TrimCache(false);
 }
 
 EntryImpl* BackendImpl::GetOpenEntry(CacheRankingsBlock* rankings) const {
   DCHECK(rankings->HasData());
   EntriesMap::const_iterator it =
       open_entries_.find(rankings->Data()->contents);
   if (it != open_entries_.end()) {
     // We have this entry in memory.
     return it->second;
@@ skipping 239 matching lines @@
 }
 
 void BackendImpl::SetFlags(uint32 flags) {
   user_flags_ |= flags;
 }
 
 void BackendImpl::ClearRefCountForTest() {
   num_refs_ = 0;
 }
 
-int BackendImpl::FlushQueueForTest(const net::CompletionCallback& callback) {
+int BackendImpl::FlushQueueForTest(const CompletionCallback& callback) {
   background_queue_.FlushQueue(callback);
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::RunTaskForTest(const base::Closure& task,
-                                const net::CompletionCallback& callback) {
+                                const CompletionCallback& callback) {
   background_queue_.RunTask(task, callback);
   return net::ERR_IO_PENDING;
 }
 
 void BackendImpl::TrimForTest(bool empty) {
   eviction_.SetTestMode();
   eviction_.TrimCache(empty);
 }
 
 void BackendImpl::TrimDeletedListForTest(bool empty) {
@@ skipping 36 matching lines @@
 
   if (not_deleted < 0) {
     NOTREACHED();
     not_deleted = 0;
   }
 
   return not_deleted;
 }
 
 int BackendImpl::OpenEntry(const std::string& key, Entry** entry,
-                           const net::CompletionCallback& callback) {
+                           const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.OpenEntry(key, entry, callback);
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::CreateEntry(const std::string& key, Entry** entry,
-                             const net::CompletionCallback& callback) {
+                             const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.CreateEntry(key, entry, callback);
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::DoomEntry(const std::string& key,
-                           const net::CompletionCallback& callback) {
+                           const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.DoomEntry(key, callback);
   return net::ERR_IO_PENDING;
 }
 
-int BackendImpl::DoomAllEntries(const net::CompletionCallback& callback) {
+int BackendImpl::DoomAllEntries(const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.DoomAllEntries(callback);
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::DoomEntriesBetween(const base::Time initial_time,
                                     const base::Time end_time,
-                                    const net::CompletionCallback& callback) {
+                                    const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.DoomEntriesBetween(initial_time, end_time, callback);
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::DoomEntriesSince(const base::Time initial_time,
-                                  const net::CompletionCallback& callback) {
+                                  const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.DoomEntriesSince(initial_time, callback);
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::OpenNextEntry(void** iter, Entry** next_entry,
-                               const net::CompletionCallback& callback) {
+                               const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.OpenNextEntry(iter, next_entry, callback);
   return net::ERR_IO_PENDING;
 }
 
 void BackendImpl::EndEnumeration(void** iter) {
   background_queue_.EndEnumeration(*iter);
   *iter = NULL;
 }
 
@@ skipping 803 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache