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

net/disk_cache/mem_backend_impl.cc

 // Copyright (c) 2006-2009 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/mem_backend_impl.h"
 
 #include "base/logging.h"
 #include "base/sys_info.h"
+#include "net/base/net_errors.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/mem_entry_impl.h"
 
 using base::Time;
 
 namespace {
 
 const int kDefaultCacheSize = 10 * 1024 * 1024;
 const int kCleanUpMargin = 1024 * 1024;
 
@@ skipping 73 matching lines @@
   EntryMap::iterator it = entries_.find(key);
   if (it == entries_.end())
     return false;
 
   it->second->Open();
 
   *entry = it->second;
   return true;
 }
 
+int MemBackendImpl::OpenEntry(const std::string& key, Entry** entry,
+                              CompletionCallback* callback) {
+  if (OpenEntry(key, entry))
+    return net::OK;
+
+  return net::ERR_FAILED;
+}
+
 bool MemBackendImpl::CreateEntry(const std::string& key, Entry** entry) {
   EntryMap::iterator it = entries_.find(key);
   if (it != entries_.end())
     return false;
 
   MemEntryImpl* cache_entry = new MemEntryImpl(this);
   if (!cache_entry->CreateEntry(key)) {
     delete entry;
     return false;
   }
 
   rankings_.Insert(cache_entry);
   entries_[key] = cache_entry;
 
   *entry = cache_entry;
   return true;
 }
 
+int MemBackendImpl::CreateEntry(const std::string& key, Entry** entry,
+                                CompletionCallback* callback) {
+  if (CreateEntry(key, entry))
+    return net::OK;
+
+  return net::ERR_FAILED;
+}
+
 bool MemBackendImpl::DoomEntry(const std::string& key) {
   Entry* entry;
   if (!OpenEntry(key, &entry))
     return false;
 
   entry->Doom();
   entry->Close();
   return true;
 }
 
 void MemBackendImpl::InternalDoomEntry(MemEntryImpl* entry) {
   // Only parent entries can be passed into this method.
   DCHECK(entry->type() == MemEntryImpl::kParentEntry);
 
   rankings_.Remove(entry);
   EntryMap::iterator it = entries_.find(entry->GetKey());
   if (it != entries_.end())
     entries_.erase(it);
   else
     NOTREACHED();
 
   entry->InternalDoom();
 }
 
 bool MemBackendImpl::DoomAllEntries() {
   TrimCache(true);
   return true;
 }
 
+int MemBackendImpl::DoomAllEntries(CompletionCallback* callback) {
+  if (DoomAllEntries())
+    return net::OK;
+
+  return net::ERR_FAILED;
+}
+
 bool MemBackendImpl::DoomEntriesBetween(const Time initial_time,
                                         const Time end_time) {
   if (end_time.is_null())
     return DoomEntriesSince(initial_time);
 
   DCHECK(end_time >= initial_time);
 
   MemEntryImpl* next = rankings_.GetNext(NULL);
 
   // rankings_ is ordered by last used, this will descend through the cache
   // and start dooming items before the end_time, and will stop once it reaches
   // an item used before the initial time.
   while (next) {
     MemEntryImpl* node = next;
     next = rankings_.GetNext(next);
 
     if (node->GetLastUsed() < initial_time)
       break;
 
     if (node->GetLastUsed() < end_time)
       node->Doom();
   }
 
   return true;
 }
 
+int MemBackendImpl::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;
+}
+
 bool MemBackendImpl::DoomEntriesSince(const Time initial_time) {
   for (;;) {
     // Get the entry in the front.
     Entry* entry = rankings_.GetNext(NULL);
 
     // Break the loop when there are no more entries or the entry is too old.
     if (!entry || entry->GetLastUsed() < initial_time)
       return true;
     entry->Doom();
   }
 }
 
+int MemBackendImpl::DoomEntriesSince(const base::Time initial_time,
+                                     CompletionCallback* callback) {
+  if (DoomEntriesSince(initial_time))
+    return net::OK;
+
+  return net::ERR_FAILED;
+}
+
 bool MemBackendImpl::OpenNextEntry(void** iter, Entry** next_entry) {
   MemEntryImpl* current = reinterpret_cast<MemEntryImpl*>(*iter);
   MemEntryImpl* node = rankings_.GetNext(current);
   // We should never return a child entry so iterate until we hit a parent
   // entry.
   while (node && node->type() != MemEntryImpl::kParentEntry) {
     node = rankings_.GetNext(node);
   }
   *next_entry = node;
   *iter = node;
 
   if (node)
     node->Open();
 
   return NULL != node;
 }
 
+int MemBackendImpl::OpenNextEntry(void** iter, Entry** next_entry,
+                                  CompletionCallback* callback) {
+  if (OpenNextEntry(iter, next_entry))
+    return net::OK;
+
+  return net::ERR_FAILED;
+}
+
 void MemBackendImpl::EndEnumeration(void** iter) {
   *iter = NULL;
 }
 
 void MemBackendImpl::TrimCache(bool empty) {
   MemEntryImpl* next = rankings_.GetPrev(NULL);
 
   DCHECK(next);
 
   int target_size = empty ? 0 : LowWaterAdjust(max_size_);
@@ skipping 38 matching lines @@
 
 void MemBackendImpl::InsertIntoRankingList(MemEntryImpl* entry) {
   rankings_.Insert(entry);
 }
 
 void MemBackendImpl::RemoveFromRankingList(MemEntryImpl* entry) {
   rankings_.Remove(entry);
 }
 
 }  // namespace disk_cache