Revert 51456 - Disk cache: Switch the disk cache to use the cache_thread....

net/disk_cache/backend_impl.cc

 // Copyright (c) 2006-2010 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 144 matching lines @@
   if (!first)
     return;
 
   // Field trials involve static objects so we have to do this only once.
   first = false;
   scoped_refptr<FieldTrial> trial1 = new FieldTrial("CacheSize", 10);
   std::string group1 = StringPrintf("CacheSizeGroup_%d", size_group);
   trial1->AppendGroup(group1, FieldTrial::kAllRemainingProbability);
 }
 
-// ------------------------------------------------------------------------
-
-// This class takes care of building an instance of the backend.
-class CacheCreator {
- public:
-  CacheCreator(const FilePath& path, bool force, int max_bytes,
-               net::CacheType type, uint32 flags,
-               base::MessageLoopProxy* thread, disk_cache::Backend** backend,
-               net::CompletionCallback* callback)
-      : path_(path), force_(force), retry_(false), max_bytes_(max_bytes),
-        type_(type), flags_(flags), thread_(thread), backend_(backend),
-        callback_(callback), cache_(NULL),
-        ALLOW_THIS_IN_INITIALIZER_LIST(
-            my_callback_(this, &CacheCreator::OnIOComplete)) {
-  }
-  ~CacheCreator() {}
-
-  // Creates the backend.
-  int Run();
-
-  // Callback implementation.
-  void OnIOComplete(int result);
-
- private:
-  void DoCallback(int result);
-
-  const FilePath& path_;
-  bool force_;
-  bool retry_;
-  int max_bytes_;
-  net::CacheType type_;
-  uint32 flags_;
-  scoped_refptr<base::MessageLoopProxy> thread_;
-  disk_cache::Backend** backend_;
-  net::CompletionCallback* callback_;
-  disk_cache::BackendImpl* cache_;
-  net::CompletionCallbackImpl<CacheCreator> my_callback_;
-
-  DISALLOW_COPY_AND_ASSIGN(CacheCreator);
-};
-
-int CacheCreator::Run() {
-  cache_ = new disk_cache::BackendImpl(path_, thread_);
-  cache_->SetMaxSize(max_bytes_);
-  cache_->SetType(type_);
-  cache_->SetFlags(flags_);
-  int rv = cache_->Init(&my_callback_);
-  DCHECK_EQ(net::ERR_IO_PENDING, rv);
-  return rv;
-}
-
-void CacheCreator::OnIOComplete(int result) {
-  if (result == net::OK || !force_ || retry_)
-    return DoCallback(result);
-
-  // This is a failure and we are supposed to try again, so delete the object,
-  // delete all the files, and try again.
-  retry_ = true;
-  delete cache_;
-  if (!DelayedCacheCleanup(path_))
-    return DoCallback(result);
-
-  // The worker thread will start deleting files soon, but the original folder
-  // is not there anymore... let's create a new set of files.
-  int rv = Run();
-  DCHECK_EQ(net::ERR_IO_PENDING, rv);
-}
-
-void CacheCreator::DoCallback(int result) {
-  DCHECK_NE(net::ERR_IO_PENDING, result);
-  if (result == net::OK) {
-    *backend_ = cache_;
-  } else {
-    LOG(ERROR) << "Unable to create cache";
-    *backend_ = NULL;
-    delete cache_;
-  }
-  callback_->Run(result);
-  delete this;
-}
-
-// ------------------------------------------------------------------------
-
-// A task to perform final cleanup on the background thread.
-class FinalCleanup : public Task {
- public:
-  explicit FinalCleanup(disk_cache::BackendImpl* backend) : backend_(backend) {}
-  ~FinalCleanup() {}
-
-  virtual void Run();
- private:
-  disk_cache::BackendImpl* backend_;
-  DISALLOW_EVIL_CONSTRUCTORS(FinalCleanup);
-};
-
-void FinalCleanup::Run() {
-  backend_->CleanupCache();
-}
-
 }  // namespace
 
 // ------------------------------------------------------------------------
 
 namespace disk_cache {
 
 int CreateCacheBackend(net::CacheType type, const FilePath& path, int max_bytes,
                        bool force, base::MessageLoopProxy* thread,
                        Backend** backend, CompletionCallback* callback) {
   DCHECK(callback);
@@ skipping 46 matching lines @@
 // 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,
                                Backend** backend,
                                CompletionCallback* callback) {
-  CacheCreator* creator = new CacheCreator(full_path, force, max_bytes, type,
-                                           flags, thread, backend, callback);
-  // This object will self-destroy when finished.
-  return creator->Run();
-}
+  BackendImpl* cache = new BackendImpl(full_path, thread);
+  cache->SetMaxSize(max_bytes);
+  cache->SetType(type);
+  cache->SetFlags(flags);
+  if (cache->Init()) {
+    *backend = cache;
+    return net::OK;
+  }
 
-int BackendImpl::SyncInit() {
-  if (Init())
+  *backend = NULL;
+  delete cache;
+  if (!force)
+    return net::ERR_FAILED;
+
+  if (!DelayedCacheCleanup(full_path))
+    return net::ERR_FAILED;
+
+  // The worker thread will start deleting files soon, but the original folder
+  // is not there anymore... let's create a new set of files.
+  cache = new BackendImpl(full_path, thread);
+  cache->SetMaxSize(max_bytes);
+  cache->SetType(type);
+  cache->SetFlags(flags);
+  if (cache->Init()) {
+    *backend = cache;
     return net::OK;
+  }
 
+  delete cache;
+  LOG(ERROR) << "Unable to create cache";
   return net::ERR_FAILED;
 }
 
 bool BackendImpl::Init() {
   DCHECK(!init_);
   if (init_)
     return false;
 
   bool create_files = false;
   if (!InitBackingStore(&create_files)) {
@@ skipping 26 matching lines @@
     new_eviction_ = (cache_type_ == net::DISK_CACHE);
   }
 
   if (!CheckIndex()) {
     ReportError(ERR_INIT_FAILED);
     return false;
   }
 
   // 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
+  // Increasing the value once per second gives us many years before a we start
   // having collisions.
   data_->header.this_id++;
   if (!data_->header.this_id)
     data_->header.this_id++;
 
   if (data_->header.crash) {
     ReportError(ERR_PREVIOUS_CRASH);
   } else {
     ReportError(0);
     data_->header.crash = 1;
@@ skipping 10 matching lines @@
   disabled_ = !rankings_.Init(this, new_eviction_);
   eviction_.Init(this);
 
   // Setup load-time data only for the main cache.
   if (cache_type() == net::DISK_CACHE)
     SetFieldTrialInfo(GetSizeGroup());
 
   return !disabled_;
 }
 
-int BackendImpl::Init(CompletionCallback* callback) {
-  background_queue_.Init(callback);
-  return net::ERR_IO_PENDING;
-}
-
 BackendImpl::~BackendImpl() {
+  Trace("Backend destructor");
   if (!init_)
     return;
 
   if (data_)
     data_->header.crash = 0;
 
-  background_queue_.WaitForPendingIO();
+  timer_.Stop();
 
-  if (background_queue_.BackgroundIsCurrentThread()) {
-    // Unit tests may use the same thread for everything.
-    CleanupCache();
-  } else {
-    background_queue_.background_thread()->PostTask(FROM_HERE,
-                                                    new FinalCleanup(this));
-    done_.Wait();
-  }
-}
-
-void BackendImpl::CleanupCache() {
-  Trace("Backend Cleanup");
-  timer_.Stop();
   File::WaitForPendingIO(&num_pending_io_);
   DCHECK(!num_refs_);
-  factory_.RevokeAll();
-  done_.Signal();
 }
 
 // ------------------------------------------------------------------------
 
 int32 BackendImpl::GetEntryCount() const {
   if (!index_)
     return 0;
   // num_entries includes entries already evicted.
   int32 not_deleted = data_->header.num_entries -
                       data_->header.lru.sizes[Rankings::DELETED];
@@ skipping 26 matching lines @@
     return NULL;
   }
 
   eviction_.OnOpenEntry(cache_entry);
 
   CACHE_UMA(AGE_MS, "OpenTime", GetSizeGroup(), start);
   stats_.OnEvent(Stats::OPEN_HIT);
   return cache_entry;
 }
 
-int BackendImpl::SyncOpenEntry(const std::string& key, Entry** entry) {
+bool BackendImpl::OpenEntry(const std::string& key, Entry** entry) {
   DCHECK(entry);
   *entry = OpenEntryImpl(key);
-  return (*entry) ? net::OK : net::ERR_FAILED;
+  return (*entry) ? true : false;
 }
 
 int BackendImpl::OpenEntry(const std::string& key, Entry** entry,
                            CompletionCallback* callback) {
-  DCHECK(callback);
-  background_queue_.OpenEntry(key, entry, callback);
-  return net::ERR_IO_PENDING;
+  if (OpenEntry(key, entry))
+    return net::OK;
+
+  return net::ERR_FAILED;
 }
 
 EntryImpl* BackendImpl::CreateEntryImpl(const std::string& key) {
   if (disabled_ || key.empty())
     return NULL;
 
   TimeTicks start = TimeTicks::Now();
   uint32 hash = Hash(key);
 
   scoped_refptr<EntryImpl> parent;
@@ skipping 59 matching lines @@
   eviction_.OnCreateEntry(cache_entry);
   if (!parent.get())
     data_->table[hash & mask_] = entry_address.value();
 
   CACHE_UMA(AGE_MS, "CreateTime", GetSizeGroup(), start);
   stats_.OnEvent(Stats::CREATE_HIT);
   Trace("create entry hit ");
   return cache_entry.release();
 }
 
-int BackendImpl::SyncCreateEntry(const std::string& key, Entry** entry) {
+bool BackendImpl::CreateEntry(const std::string& key, Entry** entry) {
   DCHECK(entry);
   *entry = CreateEntryImpl(key);
-  return (*entry) ? net::OK : net::ERR_FAILED;
+  return (*entry) ? true : false;
 }
 
 int BackendImpl::CreateEntry(const std::string& key, Entry** entry,
                              CompletionCallback* callback) {
-  DCHECK(callback);
-  background_queue_.CreateEntry(key, entry, callback);
-  return net::ERR_IO_PENDING;
-}
-
-int BackendImpl::SyncDoomEntry(const std::string& key) {
-  if (DoomEntry(key))
+  if (CreateEntry(key, entry))
     return net::OK;
 
   return net::ERR_FAILED;
 }
 
 bool BackendImpl::DoomEntry(const std::string& key) {
   if (disabled_)
     return false;
 
-  EntryImpl* entry = OpenEntryImpl(key);
-  if (!entry)
+  Entry* entry;
+  if (!OpenEntry(key, &entry))
     return false;
 
-  entry->DoomImpl();
-  entry->Release();
+  // Note that you'd think you could just pass &entry_impl to OpenEntry,
+  // but that triggers strict aliasing problems with gcc.
+  EntryImpl* entry_impl = reinterpret_cast<EntryImpl*>(entry);
+  entry_impl->Doom();
+  entry_impl->Release();
   return true;
 }
 
 int BackendImpl::DoomEntry(const std::string& key,
                            CompletionCallback* callback) {
-  DCHECK(callback);
-  background_queue_.DoomEntry(key, callback);
-  return net::ERR_IO_PENDING;
-}
-
-int BackendImpl::SyncDoomAllEntries() {
-  if (DoomAllEntries())
+  if (DoomEntry(key))
     return net::OK;
 
   return net::ERR_FAILED;
 }
 
 bool BackendImpl::DoomAllEntries() {
   if (!num_refs_) {
     PrepareForRestart();
     DeleteCache(path_, false);
     return Init();
   } else {
     if (disabled_)
       return false;
 
     eviction_.TrimCache(true);
     stats_.OnEvent(Stats::DOOM_CACHE);
     return true;
   }
 }
 
 int BackendImpl::DoomAllEntries(CompletionCallback* callback) {
-  DCHECK(callback);
-  background_queue_.DoomAllEntries(callback);
-  return net::ERR_IO_PENDING;
-}
-
-int BackendImpl::SyncDoomEntriesBetween(const base::Time initial_time,
-                                        const base::Time end_time) {
-  if (DoomEntriesBetween(initial_time, end_time))
+  if (DoomAllEntries())
     return net::OK;
 
   return net::ERR_FAILED;
 }
 
 bool BackendImpl::DoomEntriesBetween(const Time initial_time,
                                      const Time end_time) {
   if (end_time.is_null())
     return DoomEntriesSince(initial_time);
 
   DCHECK(end_time >= initial_time);
 
   if (disabled_)
     return false;
 
-  EntryImpl* node;
+  Entry* node, *next;
   void* iter = NULL;
-  EntryImpl* next = OpenNextEntryImpl(&iter);
-  if (!next)
+  if (!OpenNextEntry(&iter, &next))
     return true;
 
   while (next) {
     node = next;
-    next = OpenNextEntryImpl(&iter);
+    if (!OpenNextEntry(&iter, &next))
+      next = NULL;
 
     if (node->GetLastUsed() >= initial_time &&
         node->GetLastUsed() < end_time) {
-      node->DoomImpl();
+      node->Doom();
     } else if (node->GetLastUsed() < initial_time) {
       if (next)
-        next->Release();
+        next->Close();
       next = NULL;
-      SyncEndEnumeration(iter);
+      EndEnumeration(&iter);
     }
 
-    node->Release();
+    node->Close();
   }
 
   return true;
 }
 
 int BackendImpl::DoomEntriesBetween(const base::Time initial_time,
                                     const base::Time end_time,
                                     CompletionCallback* callback) {
-  DCHECK(callback);
-  background_queue_.DoomEntriesBetween(initial_time, end_time, callback);
-  return net::ERR_IO_PENDING;
+  if (DoomEntriesBetween(initial_time, end_time))
+    return net::OK;
+
+  return net::ERR_FAILED;
 }
 
-int BackendImpl::SyncDoomEntriesSince(const base::Time initial_time) {
+// We use OpenNextEntry to retrieve elements from the cache, until we get
+// entries that are too old.
+bool BackendImpl::DoomEntriesSince(const Time initial_time) {
+  if (disabled_)
+    return false;
+
+  for (;;) {
+    Entry* entry;
+    void* iter = NULL;
+    if (!OpenNextEntry(&iter, &entry))
+      return true;
+
+    if (initial_time > entry->GetLastUsed()) {
+      entry->Close();
+      EndEnumeration(&iter);
+      return true;
+    }
+
+    entry->Doom();
+    entry->Close();
+    EndEnumeration(&iter);  // Dooming the entry invalidates the iterator.
+  }
+}
+
+int BackendImpl::DoomEntriesSince(const base::Time initial_time,
+                                  CompletionCallback* callback) {
   if (DoomEntriesSince(initial_time))
     return net::OK;
 
   return net::ERR_FAILED;
 }
 
-// We use OpenNextEntryImpl to retrieve elements from the cache, until we get
-// entries that are too old.
-bool BackendImpl::DoomEntriesSince(const Time initial_time) {
-  if (disabled_)
-    return false;
-
-  for (;;) {
-    void* iter = NULL;
-    EntryImpl* entry = OpenNextEntryImpl(&iter);
-    if (!entry)
-      return true;
-
-    if (initial_time > entry->GetLastUsed()) {
-      entry->Release();
-      SyncEndEnumeration(iter);
-      return true;
-    }
-
-    entry->DoomImpl();
-    entry->Release();
-    SyncEndEnumeration(iter);  // Dooming the entry invalidates the iterator.
-  }
-}
-
-int BackendImpl::DoomEntriesSince(const base::Time initial_time,
-                                  CompletionCallback* callback) {
-  DCHECK(callback);
-  background_queue_.DoomEntriesSince(initial_time, callback);
-  return net::ERR_IO_PENDING;
-}
-
-int BackendImpl::SyncOpenNextEntry(void** iter, Entry** next_entry) {
-  *next_entry = OpenNextEntryImpl(iter);
-  return (*next_entry) ? net::OK : net::ERR_FAILED;
-}
-
-EntryImpl* BackendImpl::OpenNextEntryImpl(void** iter) {
-  return OpenFollowingEntry(true, iter);
+bool BackendImpl::OpenNextEntry(void** iter, Entry** next_entry) {
+  return OpenFollowingEntry(true, iter, next_entry);
 }
 
 int BackendImpl::OpenNextEntry(void** iter, Entry** next_entry,
                                CompletionCallback* callback) {
-  DCHECK(callback);
-  background_queue_.OpenNextEntry(iter, next_entry, callback);
-  return net::ERR_IO_PENDING;
-}
+  if (OpenNextEntry(iter, next_entry))
+    return net::OK;
 
-void BackendImpl::SyncEndEnumeration(void* iter) {
-  scoped_ptr<Rankings::Iterator> iterator(
-      reinterpret_cast<Rankings::Iterator*>(iter));
+  return net::ERR_FAILED;
 }
 
 void BackendImpl::EndEnumeration(void** iter) {
-  background_queue_.EndEnumeration(*iter);
+  scoped_ptr<Rankings::Iterator> iterator(
+      reinterpret_cast<Rankings::Iterator*>(*iter));
   *iter = NULL;
 }
 
 void BackendImpl::GetStats(StatsItems* stats) {
   if (disabled_)
     return;
 
   std::pair<std::string, std::string> item;
 
   item.first = "Entries";
@@ skipping 360 matching lines @@
 }
 
 void BackendImpl::SetFlags(uint32 flags) {
   user_flags_ |= flags;
 }
 
 void BackendImpl::ClearRefCountForTest() {
   num_refs_ = 0;
 }
 
-int BackendImpl::FlushQueueForTest(CompletionCallback* callback) {
-  background_queue_.FlushQueue(callback);
-  return net::ERR_IO_PENDING;
-}
-
 int BackendImpl::SelfCheck() {
   if (!init_) {
     LOG(ERROR) << "Init failed";
     return ERR_INIT_FAILED;
   }
 
   int num_entries = rankings_.SelfCheck();
   if (num_entries < 0) {
     LOG(ERROR) << "Invalid rankings list, error " << num_entries;
     return num_entries;
   }
 
   if (num_entries != data_->header.num_entries) {
     LOG(ERROR) << "Number of entries mismatch";
     return ERR_NUM_ENTRIES_MISMATCH;
   }
 
   return CheckAllEntries();
 }
 
-int BackendImpl::SyncOpenPrevEntry(void** iter, Entry** prev_entry) {
-  *prev_entry = OpenPrevEntryImpl(iter);
-  return (*prev_entry) ? net::OK : net::ERR_FAILED;
-}
-
-int BackendImpl::OpenPrevEntry(void** iter, Entry** prev_entry,
-                               CompletionCallback* callback) {
-  DCHECK(callback);
-  background_queue_.OpenPrevEntry(iter, prev_entry, callback);
-  return net::ERR_IO_PENDING;
-}
-
-EntryImpl* BackendImpl::OpenPrevEntryImpl(void** iter) {
-  return OpenFollowingEntry(false, iter);
+bool BackendImpl::OpenPrevEntry(void** iter, Entry** prev_entry) {
+  return OpenFollowingEntry(false, iter, prev_entry);
 }
 
 // ------------------------------------------------------------------------
 
 // We just created a new file so we're going to write the header and set the
 // file length to include the hash table (zero filled).
 bool BackendImpl::CreateBackingStore(disk_cache::File* file) {
   AdjustMaxCacheSize(0);
 
   IndexHeader header;
@@ skipping 93 matching lines @@
   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 (SyncInit())
+  else if (Init())
     stats_.SetCounter(Stats::FATAL_ERROR, errors + 1);
 }
 
 void BackendImpl::PrepareForRestart() {
   // Reset the mask_ if it was not given by the user.
   if (!(user_flags_ & kMask))
     mask_ = 0;
 
   if (!(user_flags_ & kNewEviction))
     new_eviction_ = false;
@@ skipping 129 matching lines @@
     parent_entry = NULL;
 
   if (cache_entry && (find_parent || !found))
     cache_entry = NULL;
 
   find_parent ? parent_entry.swap(&tmp) : cache_entry.swap(&tmp);
   return tmp;
 }
 
 // This is the actual implementation for OpenNextEntry and OpenPrevEntry.
-EntryImpl* BackendImpl::OpenFollowingEntry(bool forward, void** iter) {
+bool BackendImpl::OpenFollowingEntry(bool forward, void** iter,
+                                     Entry** next_entry) {
   if (disabled_)
-    return NULL;
+    return false;
 
   DCHECK(iter);
+  DCHECK(next_entry);
+  *next_entry = NULL;
 
   const int kListsToSearch = 3;
   scoped_refptr<EntryImpl> entries[kListsToSearch];
   scoped_ptr<Rankings::Iterator> iterator(
       reinterpret_cast<Rankings::Iterator*>(*iter));
   *iter = NULL;
 
   if (!iterator.get()) {
     iterator.reset(new Rankings::Iterator(&rankings_));
     bool ret = false;
 
     // Get an entry from each list.
     for (int i = 0; i < kListsToSearch; i++) {
       EntryImpl* temp = NULL;
       ret |= OpenFollowingEntryFromList(forward, static_cast<Rankings::List>(i),
                                         &iterator->nodes[i], &temp);
       entries[i].swap(&temp);  // The entry was already addref'd.
     }
     if (!ret)
-      return NULL;
+      return false;
   } else {
     // Get the next entry from the last list, and the actual entries for the
     // elements on the other lists.
     for (int i = 0; i < kListsToSearch; i++) {
       EntryImpl* temp = NULL;
       if (iterator->list == i) {
           OpenFollowingEntryFromList(forward, iterator->list,
                                      &iterator->nodes[i], &temp);
       } else {
         temp = GetEnumeratedEntry(iterator->nodes[i], false);
@@ skipping 15 matching lines @@
         continue;
       }
       if (access_times[i] > access_times[newest])
         newest = i;
       if (access_times[i] < access_times[oldest])
         oldest = i;
     }
   }
 
   if (newest < 0 || oldest < 0)
-    return NULL;
+    return false;
 
-  EntryImpl* next_entry;
   if (forward) {
-    next_entry = entries[newest].release();
+    entries[newest].swap(reinterpret_cast<EntryImpl**>(next_entry));
     iterator->list = static_cast<Rankings::List>(newest);
   } else {
-    next_entry = entries[oldest].release();
+    entries[oldest].swap(reinterpret_cast<EntryImpl**>(next_entry));
     iterator->list = static_cast<Rankings::List>(oldest);
   }
 
   *iter = iterator.release();
-  return next_entry;
+  return true;
 }
 
 bool BackendImpl::OpenFollowingEntryFromList(bool forward, Rankings::List list,
                                              CacheRankingsBlock** from_entry,
                                              EntryImpl** next_entry) {
   if (disabled_)
     return false;
 
   if (!new_eviction_ && Rankings::NO_USE != list)
     return false;
@@ skipping 320 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->dummy;
 }
 
 }  // namespace disk_cache