Disk Cache: Remove deprecated methods from the disk cache interface....

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 348 matching lines @@
                       data_->header.lru.sizes[Rankings::DELETED];
 
   if (not_deleted < 0) {
     NOTREACHED();
     not_deleted = 0;
   }
 
   return not_deleted;
 }
 
-bool BackendImpl::OpenEntry(const std::string& key, Entry** entry) {
+EntryImpl* BackendImpl::OpenEntryImpl(const std::string& key) {
   if (disabled_)
-    return false;
+    return NULL;
 
   TimeTicks start = TimeTicks::Now();
   uint32 hash = Hash(key);
 
   EntryImpl* cache_entry = MatchEntry(key, hash, false);
   if (!cache_entry) {
     stats_.OnEvent(Stats::OPEN_MISS);
-    return false;
+    return NULL;
   }
 
   if (ENTRY_NORMAL != cache_entry->entry()->Data()->state) {
     // The entry was already evicted.
     cache_entry->Release();
     stats_.OnEvent(Stats::OPEN_MISS);
-    return false;
+    return NULL;
   }
 
   eviction_.OnOpenEntry(cache_entry);
-  DCHECK(entry);
-  *entry = cache_entry;
 
   CACHE_UMA(AGE_MS, "OpenTime", GetSizeGroup(), start);
   stats_.OnEvent(Stats::OPEN_HIT);
-  return true;
+  return cache_entry;
+}
+
+bool BackendImpl::OpenEntry(const std::string& key, Entry** entry) {
+  DCHECK(entry);
+  *entry = OpenEntryImpl(key);
+  return (*entry) ? true : false;
 }
 
 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) {
+EntryImpl* BackendImpl::CreateEntryImpl(const std::string& key) {
   if (disabled_ || key.empty())
-    return false;
-
-  DCHECK(entry);
-  *entry = NULL;
+    return NULL;
 
   TimeTicks start = TimeTicks::Now();
   uint32 hash = Hash(key);
 
   scoped_refptr<EntryImpl> parent;
   Addr entry_address(data_->table[hash & mask_]);
   if (entry_address.is_initialized()) {
     // We have an entry already. It could be the one we are looking for, or just
     // a hash conflict.
     EntryImpl* old_entry = MatchEntry(key, hash, false);
     if (old_entry)
-      return ResurrectEntry(old_entry, entry);
+      return ResurrectEntry(old_entry);
 
     EntryImpl* parent_entry = MatchEntry(key, hash, true);
     if (!parent_entry) {
       NOTREACHED();
-      return false;
+      return NULL;
     }
     parent.swap(&parent_entry);
   }
 
   int num_blocks;
   size_t key1_len = sizeof(EntryStore) - offsetof(EntryStore, key);
   if (key.size() < key1_len ||
       key.size() > static_cast<size_t>(kMaxInternalKeyLength))
     num_blocks = 1;
   else
     num_blocks = static_cast<int>((key.size() - key1_len) / 256 + 2);
 
   if (!block_files_.CreateBlock(BLOCK_256, num_blocks, &entry_address)) {
     LOG(ERROR) << "Create entry failed " << key.c_str();
     stats_.OnEvent(Stats::CREATE_ERROR);
-    return false;
+    return NULL;
   }
 
   Addr node_address(0);
   if (!block_files_.CreateBlock(RANKINGS, 1, &node_address)) {
     block_files_.DeleteBlock(entry_address, false);
     LOG(ERROR) << "Create entry failed " << key.c_str();
     stats_.OnEvent(Stats::CREATE_ERROR);
-    return false;
+    return NULL;
   }
 
   scoped_refptr<EntryImpl> cache_entry(new EntryImpl(this, entry_address));
   IncreaseNumRefs();
 
   if (!cache_entry->CreateEntry(node_address, key, hash)) {
     block_files_.DeleteBlock(entry_address, false);
     block_files_.DeleteBlock(node_address, false);
     LOG(ERROR) << "Create entry failed " << key.c_str();
     stats_.OnEvent(Stats::CREATE_ERROR);
-    return false;
+    return NULL;
   }
 
   // We are not failing the operation; let's add this to the map.
   open_entries_[entry_address.value()] = cache_entry;
 
   if (parent.get())
     parent->SetNextAddress(entry_address);
 
   block_files_.GetFile(entry_address)->Store(cache_entry->entry());
   block_files_.GetFile(node_address)->Store(cache_entry->rankings());
 
   IncreaseNumEntries();
   eviction_.OnCreateEntry(cache_entry);
   if (!parent.get())
     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;
+  return cache_entry.release();
+}
+
+bool BackendImpl::CreateEntry(const std::string& key, Entry** entry) {
+  DCHECK(entry);
+  *entry = CreateEntryImpl(key);
+  return (*entry) ? true : false;
 }
 
 int BackendImpl::CreateEntry(const std::string& key, Entry** entry,
                              CompletionCallback* callback) {
   if (CreateEntry(key, entry))
     return net::OK;
 
   return net::ERR_FAILED;
 }
 
@@ skipping 919 matching lines @@
 
   // There is no need to store the entry to disk if we want to delete it.
   if (!to_evict && !entry->Update()) {
     entry->Release();
     return NULL;
   }
 
   return entry;
 }
 
-bool BackendImpl::ResurrectEntry(EntryImpl* deleted_entry, Entry** entry) {
+EntryImpl* BackendImpl::ResurrectEntry(EntryImpl* deleted_entry) {
   if (ENTRY_NORMAL == deleted_entry->entry()->Data()->state) {
     deleted_entry->Release();
     stats_.OnEvent(Stats::CREATE_MISS);
     Trace("create entry miss ");
-    return false;
+    return NULL;
   }
 
   // We are attempting to create an entry and found out that the entry was
   // previously deleted.
 
   eviction_.OnCreateEntry(deleted_entry);
-  *entry = deleted_entry;
 
   stats_.OnEvent(Stats::CREATE_HIT);
   Trace("Resurrect entry hit ");
-  return true;
+  return deleted_entry;
 }
 
 void BackendImpl::DestroyInvalidEntry(EntryImpl* entry) {
   LOG(WARNING) << "Destroying invalid entry.";
   Trace("Destroying invalid entry 0x%p", entry);
 
   entry->SetPointerForInvalidEntry(GetCurrentEntryId());
 
   eviction_.OnDoomEntry(entry);
   entry->InternalDoom();
@@ skipping 253 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->dummy;
 }
 
 }  // namespace disk_cache