Disk Cache: New interface that enables asynchronous completion...

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"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/timer.h"
 #include "base/worker_pool.h"
+#include "net/base/net_errors.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
 #include "net/disk_cache/hash.h"
 #include "net/disk_cache/file.h"
 
 // This has to be defined before including histogram_macros.h from this file.
 #define NET_DISK_CACHE_BACKEND_IMPL_CC_
 #include "net/disk_cache/histogram_macros.h"
 
@@ skipping 345 matching lines @@
 
   eviction_.OnOpenEntry(cache_entry);
   DCHECK(entry);
   *entry = cache_entry;
 
   CACHE_UMA(AGE_MS, "OpenTime", GetSizeGroup(), start);
   stats_.OnEvent(Stats::OPEN_HIT);
   return true;
 }
 
+int BackendImpl::OpenEntry(const std::string& key, Entry** entry,
+                           CompletionCallback* callback) {
+  if (OpenEntry(key, entry))
+    return net::OK;
+
+  return net::ERR_FAILED;
+}
+
 bool BackendImpl::CreateEntry(const std::string& key, Entry** entry) {
   if (disabled_ || key.empty())
     return false;
 
   DCHECK(entry);
   *entry = NULL;
 
   Time start = Time::Now();
   uint32 hash = Hash(key);
 
@@ skipping 62 matching lines @@
     data_->table[hash & mask_] = entry_address.value();
 
   cache_entry.swap(reinterpret_cast<EntryImpl**>(entry));
 
   CACHE_UMA(AGE_MS, "CreateTime", GetSizeGroup(), start);
   stats_.OnEvent(Stats::CREATE_HIT);
   Trace("create entry hit ");
   return true;
 }
 
+int BackendImpl::CreateEntry(const std::string& key, Entry** entry,
+                             CompletionCallback* callback) {
+  if (CreateEntry(key, entry))
+    return net::OK;
+
+  return net::ERR_FAILED;
+}
+
 bool BackendImpl::DoomEntry(const std::string& key) {
   if (disabled_)
     return false;
 
   Entry* entry;
   if (!OpenEntry(key, &entry))
     return false;
 
   // Note that you'd think you could just pass &entry_impl to OpenEntry,
   // but that triggers strict aliasing problems with gcc.
@@ skipping 11 matching lines @@
   } else {
     if (disabled_)
       return false;
 
     eviction_.TrimCache(true);
     stats_.OnEvent(Stats::DOOM_CACHE);
     return true;
   }
 }
 
+int BackendImpl::DoomAllEntries(CompletionCallback* callback) {
+  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;
 
@@ skipping 16 matching lines @@
       next = NULL;
       EndEnumeration(&iter);
     }
 
     node->Close();
   }
 
   return true;
 }
 
+int BackendImpl::DoomEntriesBetween(const base::Time initial_time,
+                                    const base::Time end_time,
+                                    CompletionCallback* callback) {
+  if (DoomEntriesBetween(initial_time, end_time))
+    return net::OK;
+
+  return net::ERR_FAILED;
+}
+
 // 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;
+}
+
 bool BackendImpl::OpenNextEntry(void** iter, Entry** next_entry) {
   return OpenFollowingEntry(true, iter, next_entry);
 }
 
+int BackendImpl::OpenNextEntry(void** iter, Entry** next_entry,
+                               CompletionCallback* callback) {
+  if (OpenNextEntry(iter, next_entry))
+    return net::OK;
+
+  return net::ERR_FAILED;
+}
+
 void BackendImpl::EndEnumeration(void** iter) {
   scoped_ptr<Rankings::Iterator> iterator(
       reinterpret_cast<Rankings::Iterator*>(*iter));
   *iter = NULL;
 }
 
 void BackendImpl::GetStats(StatsItems* stats) {
   if (disabled_)
     return;
 
@@ skipping 1049 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->dummy;
 }
 
 }  // namespace disk_cache