[CacheStorage] Give ownership of all CacheStorageCaches to CacheStorage

content/browser/cache_storage/cache_storage.cc

Index: content/browser/cache_storage/cache_storage.cc
diff --git a/content/browser/cache_storage/cache_storage.cc b/content/browser/cache_storage/cache_storage.cc
index c1e9820e0ee1333d7af887fb50ac99904e03f31e..b61593aa5e5b76bd8aa31c04234726b0df7cf208 100644
--- a/content/browser/cache_storage/cache_storage.cc
+++ b/content/browser/cache_storage/cache_storage.cc
@@ -27,6 +27,7 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_cache.h"
+#include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/browser/cache_storage/cache_storage_scheduler.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/directory_lister.h"
@@ -48,10 +49,11 @@ std::string HexedHash(const std::string& value) {
   return valued_hexed_hash;
 }
 
-void SizeRetrievedFromCache(const scoped_refptr<CacheStorageCache>& cache,
-                            const base::Closure& closure,
-                            int64_t* accumulator,
-                            int64_t size) {
+void SizeRetrievedFromCache(
+    std::unique_ptr<CacheStorageCacheHandle> cache_handle,
+    const base::Closure& closure,
+    int64_t* accumulator,
+    int64_t size) {
   *accumulator += size;
   closure.Run();
 }
@@ -78,7 +80,8 @@ struct CacheStorage::CacheMatchResponse {
 // Handles the loading and clean up of CacheStorageCache objects.
 class CacheStorage::CacheLoader {
  public:
-  typedef base::Callback<void(scoped_refptr<CacheStorageCache>)> CacheCallback;
+  typedef base::Callback<void(std::unique_ptr<CacheStorageCache>)>
+      CacheCallback;
   typedef base::Callback<void(bool)> BoolCallback;
   typedef base::Callback<void(std::unique_ptr<std::vector<std::string>>)>
       StringVectorCallback;
@@ -88,11 +91,13 @@ class CacheStorage::CacheLoader {
       scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       storage::QuotaManagerProxy* quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
+      CacheStorage* cache_storage,
       const GURL& origin)
       : cache_task_runner_(cache_task_runner),
         request_context_getter_(request_context_getter),
         quota_manager_proxy_(quota_manager_proxy),
         blob_context_(blob_context),
+        cache_storage_(cache_storage),
         origin_(origin) {
     DCHECK(!origin_.is_empty());
   }
@@ -101,7 +106,7 @@ class CacheStorage::CacheLoader {
 
   // Creates a CacheStorageCache with the given name. It does not attempt to
   // load the backend, that happens lazily when the cache is used.
-  virtual scoped_refptr<CacheStorageCache> CreateCache(
+  virtual std::unique_ptr<CacheStorageCache> CreateCache(
       const std::string& cache_name) = 0;
 
   // Deletes any pre-existing cache of the same name and then loads it.
@@ -129,6 +134,10 @@ class CacheStorage::CacheLoader {
   storage::QuotaManagerProxy* quota_manager_proxy_;
 
   base::WeakPtr<storage::BlobStorageContext> blob_context_;
+
+  // Raw pointer is safe because this object is owned by cache_storage_.
+  CacheStorage* cache_storage_;
+
   GURL origin_;
 };
 
@@ -142,32 +151,33 @@ class CacheStorage::MemoryLoader : public CacheStorage::CacheLoader {
                scoped_refptr<net::URLRequestContextGetter> request_context,
                storage::QuotaManagerProxy* quota_manager_proxy,
                base::WeakPtr<storage::BlobStorageContext> blob_context,
+               CacheStorage* cache_storage,
                const GURL& origin)
       : CacheLoader(cache_task_runner,
                     request_context,
                     quota_manager_proxy,
                     blob_context,
+                    cache_storage,
                     origin) {}
 
-  scoped_refptr<CacheStorageCache> CreateCache(
+  std::unique_ptr<CacheStorageCache> CreateCache(
       const std::string& cache_name) override {
     return CacheStorageCache::CreateMemoryCache(
-        origin_, cache_name, request_context_getter_, quota_manager_proxy_,
-        blob_context_);
+        origin_, cache_name, cache_storage_, request_context_getter_,
+        quota_manager_proxy_, blob_context_);
   }
 
   void PrepareNewCacheDestination(const std::string& cache_name,
                                   const CacheCallback& callback) override {
-    scoped_refptr<CacheStorageCache> cache = CreateCache(cache_name);
-    cache_refs_.insert(std::make_pair(cache_name, cache));
+    std::unique_ptr<CacheStorageCache> cache = CreateCache(cache_name);
     callback.Run(std::move(cache));
   }
 
   void CleanUpDeletedCache(const std::string& cache_name,
                            const BoolCallback& callback) override {
-    CacheRefMap::iterator it = cache_refs_.find(cache_name);
-    DCHECK(it != cache_refs_.end());
-    cache_refs_.erase(it);
+    CacheHandles::iterator it = cache_handles_.find(cache_name);
+    DCHECK(it != cache_handles_.end());
+    cache_handles_.erase(it);
     callback.Run(true);
   }
 
@@ -181,14 +191,21 @@ class CacheStorage::MemoryLoader : public CacheStorage::CacheLoader {
     callback.Run(std::move(cache_names));
   }
 
+  void StoreCacheHandle(const std::string& cache_name,
+                        std::unique_ptr<CacheStorageCacheHandle> cache_handle) {
+    DCHECK(!ContainsKey(cache_handles_, cache_name));
+    cache_handles_.insert(std::make_pair(cache_name, std::move(cache_handle)));
+  }
+
  private:
-  typedef std::map<std::string, scoped_refptr<CacheStorageCache>> CacheRefMap;
+  typedef std::map<std::string, std::unique_ptr<CacheStorageCacheHandle>>
+      CacheHandles;
   ~MemoryLoader() override {}
 
   // Keep a reference to each cache to ensure that it's not freed before the
   // client calls CacheStorage::Delete or the CacheStorage is
   // freed.
-  CacheRefMap cache_refs_;
+  CacheHandles cache_handles_;
 };
 
 class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
@@ -198,16 +215,18 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
                     scoped_refptr<net::URLRequestContextGetter> request_context,
                     storage::QuotaManagerProxy* quota_manager_proxy,
                     base::WeakPtr<storage::BlobStorageContext> blob_context,
+                    CacheStorage* cache_storage,
                     const GURL& origin)
       : CacheLoader(cache_task_runner,
                     request_context,
                     quota_manager_proxy,
                     blob_context,
+                    cache_storage,
                     origin),
         origin_path_(origin_path),
         weak_ptr_factory_(this) {}
 
-  scoped_refptr<CacheStorageCache> CreateCache(
+  std::unique_ptr<CacheStorageCache> CreateCache(
       const std::string& cache_name) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     DCHECK(ContainsKey(cache_name_to_cache_dir_, cache_name));
@@ -215,8 +234,8 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
     std::string cache_dir = cache_name_to_cache_dir_[cache_name];
     base::FilePath cache_path = origin_path_.AppendASCII(cache_dir);
     return CacheStorageCache::CreatePersistentCache(
-        origin_, cache_name, cache_path, request_context_getter_,
-        quota_manager_proxy_, blob_context_);
+        origin_, cache_name, cache_storage_, cache_path,
+        request_context_getter_, quota_manager_proxy_, blob_context_);
   }
 
   void PrepareNewCacheDestination(const std::string& cache_name,
@@ -248,7 +267,7 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
                                   const CacheCallback& callback,
                                   const std::string& cache_dir) {
     if (cache_dir.empty()) {
-      callback.Run(scoped_refptr<CacheStorageCache>());
+      callback.Run(std::unique_ptr<CacheStorageCache>());
       return;
     }
 
@@ -467,6 +486,7 @@ CacheStorage::CacheStorage(
     const GURL& origin)
     : initialized_(false),
       initializing_(false),
+      memory_only_(memory_only),
       scheduler_(new CacheStorageScheduler()),
       origin_path_(path),
       cache_task_runner_(cache_task_runner),
@@ -474,13 +494,13 @@ CacheStorage::CacheStorage(
       origin_(origin),
       weak_factory_(this) {
   if (memory_only)
-    cache_loader_.reset(
-        new MemoryLoader(cache_task_runner_.get(), std::move(request_context),
-                         quota_manager_proxy.get(), blob_context, origin));
+    cache_loader_.reset(new MemoryLoader(
+        cache_task_runner_.get(), std::move(request_context),
+        quota_manager_proxy.get(), blob_context, this, origin));
   else
     cache_loader_.reset(new SimpleCacheLoader(
         origin_path_, cache_task_runner_.get(), std::move(request_context),
-        quota_manager_proxy.get(), blob_context, origin));
+        quota_manager_proxy.get(), blob_context, this, origin));
 }
 
 CacheStorage::~CacheStorage() {
@@ -676,7 +696,7 @@ void CacheStorage::LazyInitDidLoadIndex(
 
   for (size_t i = 0u, max = indexed_cache_names->size(); i < max; ++i) {
     cache_map_.insert(std::make_pair(indexed_cache_names->at(i),
-                                     base::WeakPtr<CacheStorageCache>()));
+                                     std::unique_ptr<CacheStorageCache>()));
     ordered_cache_names_.push_back(indexed_cache_names->at(i));
   }
 
@@ -688,9 +708,10 @@ void CacheStorage::LazyInitDidLoadIndex(
 
 void CacheStorage::OpenCacheImpl(const std::string& cache_name,
                                  const CacheAndErrorCallback& callback) {
-  scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
-  if (cache.get()) {
-    callback.Run(std::move(cache), CACHE_STORAGE_OK);
+  std::unique_ptr<CacheStorageCacheHandle> cache_handle =
+      GetLoadedCache(cache_name);
+  if (cache_handle) {
+    callback.Run(std::move(cache_handle), CACHE_STORAGE_OK);
     return;
   }
 
@@ -702,39 +723,47 @@ void CacheStorage::OpenCacheImpl(const std::string& cache_name,
 void CacheStorage::CreateCacheDidCreateCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback,
-    scoped_refptr<CacheStorageCache> cache) {
+    std::unique_ptr<CacheStorageCache> cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   UMA_HISTOGRAM_BOOLEAN("ServiceWorkerCache.CreateCacheStorageResult",
                         static_cast<bool>(cache));
 
-  if (!cache.get()) {
-    callback.Run(scoped_refptr<CacheStorageCache>(),
+  if (!cache) {
+    callback.Run(std::unique_ptr<CacheStorageCacheHandle>(),
                  CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
-  cache_map_.insert(std::make_pair(cache_name, cache->AsWeakPtr()));
+  CacheStorageCache* cache_ptr = cache.get();
+
+  cache_map_.insert(std::make_pair(cache_name, std::move(cache)));
   ordered_cache_names_.push_back(cache_name);
 
-  TemporarilyPreserveCache(cache);
+  if (memory_only_) {
+    static_cast<MemoryLoader*>(cache_loader_.get())
+        ->StoreCacheHandle(cache_name, CreateCacheHandle(cache_ptr));
+  }
+
+  TemporarilyPreserveCache(CreateCacheHandle(cache_ptr));
 
   cache_loader_->WriteIndex(
       ordered_cache_names_,
       base::Bind(&CacheStorage::CreateCacheDidWriteIndex,
-                 weak_factory_.GetWeakPtr(), callback, std::move(cache)));
+                 weak_factory_.GetWeakPtr(), callback,
+                 base::Passed(CreateCacheHandle(cache_ptr))));
 }
 
 void CacheStorage::CreateCacheDidWriteIndex(
     const CacheAndErrorCallback& callback,
-    scoped_refptr<CacheStorageCache> cache,
+    std::unique_ptr<CacheStorageCacheHandle> cache_handle,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(cache.get());
+  DCHECK(cache_handle);
 
   // TODO(jkarlin): Handle !success.
 
-  callback.Run(std::move(cache), CACHE_STORAGE_OK);
+  callback.Run(std::move(cache_handle), CACHE_STORAGE_OK);
 }
 
 void CacheStorage::HasCacheImpl(const std::string& cache_name,
@@ -745,14 +774,17 @@ void CacheStorage::HasCacheImpl(const std::string& cache_name,
 
 void CacheStorage::DeleteCacheImpl(const std::string& cache_name,
                                    const BoolAndErrorCallback& callback) {
-  scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
-  if (!cache.get()) {
+  std::unique_ptr<CacheStorageCacheHandle> cache_handle =
+      GetLoadedCache(cache_name);
+  if (!cache_handle) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, false, CACHE_STORAGE_ERROR_NOT_FOUND));
     return;
   }
 
   CacheMap::iterator map_iter = cache_map_.find(cache_name);
+  deleted_caches_.insert(
+      std::make_pair(cache_handle->value(), std::move(map_iter->second)));
   cache_map_.erase(map_iter);
 
   // Delete the name from ordered_cache_names_.
@@ -761,16 +793,19 @@ void CacheStorage::DeleteCacheImpl(const std::string& cache_name,
   DCHECK(iter != ordered_cache_names_.end());
   ordered_cache_names_.erase(iter);
 
-  cache->GetSizeThenClose(base::Bind(&CacheStorage::DeleteCacheDidClose,
-                                     weak_factory_.GetWeakPtr(), cache_name,
-                                     callback, ordered_cache_names_, cache));
+  CacheStorageCache* cache_ptr = cache_handle->value();
+  cache_ptr->GetSizeThenClose(
+      base::Bind(&CacheStorage::DeleteCacheDidClose, weak_factory_.GetWeakPtr(),
+                 cache_name, callback, ordered_cache_names_,
+                 base::Passed(std::move(cache_handle))));
 }
 
-void CacheStorage::DeleteCacheDidClose(const std::string& cache_name,
-                                       const BoolAndErrorCallback& callback,
-                                       const StringVector& ordered_cache_names,
-                                       scoped_refptr<CacheStorageCache> cache,
-                                       int64_t cache_size) {
+void CacheStorage::DeleteCacheDidClose(
+    const std::string& cache_name,
+    const BoolAndErrorCallback& callback,
+    const StringVector& ordered_cache_names,
+    std::unique_ptr<CacheStorageCacheHandle> cache_handle,
+    int64_t cache_size) {
   cache_loader_->WriteIndex(
       ordered_cache_names,
       base::Bind(&CacheStorage::DeleteCacheDidWriteIndex,
@@ -809,24 +844,27 @@ void CacheStorage::MatchCacheImpl(
     const std::string& cache_name,
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ResponseCallback& callback) {
-  scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
+  std::unique_ptr<CacheStorageCacheHandle> cache_handle =
+      GetLoadedCache(cache_name);
 
-  if (!cache.get()) {
+  if (!cache_handle) {
     callback.Run(CACHE_STORAGE_ERROR_CACHE_NAME_NOT_FOUND,
                  std::unique_ptr<ServiceWorkerResponse>(),
                  std::unique_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  // Pass the cache along to the callback to keep the cache open until match is
-  // done.
-  cache->Match(std::move(request),
-               base::Bind(&CacheStorage::MatchCacheDidMatch,
-                          weak_factory_.GetWeakPtr(), cache, callback));
+  // Pass the cache handle along to the callback to keep the cache open until
+  // match is done.
+  CacheStorageCache* cache_ptr = cache_handle->value();
+  cache_ptr->Match(
+      std::move(request),
+      base::Bind(&CacheStorage::MatchCacheDidMatch, weak_factory_.GetWeakPtr(),
+                 base::Passed(std::move(cache_handle)), callback));
 }
 
 void CacheStorage::MatchCacheDidMatch(
-    scoped_refptr<CacheStorageCache> cache,
+    std::unique_ptr<CacheStorageCacheHandle> cache_handle,
     const CacheStorageCache::ResponseCallback& callback,
     CacheStorageError error,
     std::unique_ptr<ServiceWorkerResponse> response,
@@ -847,19 +885,21 @@ void CacheStorage::MatchAllCachesImpl(
                  base::Passed(base::WrapUnique(match_responses)), callback));
 
   for (size_t i = 0, max = ordered_cache_names_.size(); i < max; ++i) {
-    scoped_refptr<CacheStorageCache> cache =
+    std::unique_ptr<CacheStorageCacheHandle> cache_handle =
         GetLoadedCache(ordered_cache_names_[i]);
-    DCHECK(cache.get());
-
-    cache->Match(base::WrapUnique(new ServiceWorkerFetchRequest(*request)),
-                 base::Bind(&CacheStorage::MatchAllCachesDidMatch,
-                            weak_factory_.GetWeakPtr(), cache,
-                            &match_responses->at(i), barrier_closure));
+    DCHECK(cache_handle);
+
+    CacheStorageCache* cache_ptr = cache_handle->value();
+    cache_ptr->Match(base::WrapUnique(new ServiceWorkerFetchRequest(*request)),
+                     base::Bind(&CacheStorage::MatchAllCachesDidMatch,
+                                weak_factory_.GetWeakPtr(),
+                                base::Passed(std::move(cache_handle)),
+                                &match_responses->at(i), barrier_closure));
   }
 }
 
 void CacheStorage::MatchAllCachesDidMatch(
-    scoped_refptr<CacheStorageCache> cache,
+    std::unique_ptr<CacheStorageCacheHandle> cache_handle,
     CacheMatchResponse* out_match_response,
     const base::Closure& barrier_closure,
     CacheStorageError error,
@@ -888,38 +928,83 @@ void CacheStorage::MatchAllCachesDidMatchAll(
                std::unique_ptr<storage::BlobDataHandle>());
 }
 
-scoped_refptr<CacheStorageCache> CacheStorage::GetLoadedCache(
+void CacheStorage::AddCacheHandleRef(CacheStorageCache* cache) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  auto iter = cache_handle_counts_.find(cache);
+  if (iter == cache_handle_counts_.end()) {
+    cache_handle_counts_[cache] = 1;
+    return;
+  }
+
+  iter->second += 1;
+}
+
+void CacheStorage::DropCacheHandleRef(CacheStorageCache* cache) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  auto iter = cache_handle_counts_.find(cache);
+  DCHECK(iter != cache_handle_counts_.end());
+  DCHECK(iter->second >= 1);
+
+  iter->second -= 1;
+  if (iter->second == 0) {
+    // Delete the CacheStorageCache object. It's either in the main cache map or
+    // the CacheStorage::Delete operation has run on the cache, in which case
+    // it's in the deleted caches map.
+    auto cache_map_iter = cache_map_.find(cache->cache_name());
+
+    if (cache_map_iter == cache_map_.end()) {
+      auto deleted_caches_iter = deleted_caches_.find(cache);
+      DCHECK(deleted_caches_iter != deleted_caches_.end());
+      deleted_caches_.erase(deleted_caches_iter);
+      return;
+    }
+
+    cache_map_iter->second.reset();
+    cache_handle_counts_.erase(iter);
+  }
+}
+
+std::unique_ptr<CacheStorageCacheHandle> CacheStorage::CreateCacheHandle(
+    CacheStorageCache* cache) {
+  DCHECK(cache);
+  return std::unique_ptr<CacheStorageCacheHandle>(new CacheStorageCacheHandle(
+      cache->AsWeakPtr(), weak_factory_.GetWeakPtr()));
+}
+
+std::unique_ptr<CacheStorageCacheHandle> CacheStorage::GetLoadedCache(
     const std::string& cache_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
   CacheMap::iterator map_iter = cache_map_.find(cache_name);
   if (map_iter == cache_map_.end())
-    return scoped_refptr<CacheStorageCache>();
+    return std::unique_ptr<CacheStorageCacheHandle>();
 
-  base::WeakPtr<CacheStorageCache> cache = map_iter->second;
+  CacheStorageCache* cache = map_iter->second.get();
 
   if (!cache) {
-    scoped_refptr<CacheStorageCache> new_cache =
+    std::unique_ptr<CacheStorageCache> new_cache =
         cache_loader_->CreateCache(cache_name);
-    map_iter->second = new_cache->AsWeakPtr();
+    CacheStorageCache* cache_ptr = new_cache.get();
+    map_iter->second = std::move(new_cache);
 
-    TemporarilyPreserveCache(new_cache);
-    return new_cache;
+    TemporarilyPreserveCache(CreateCacheHandle(cache_ptr));
+    return CreateCacheHandle(cache_ptr);
   }
 
-  return make_scoped_refptr(cache.get());
+  return CreateCacheHandle(cache);
 }
 
 void CacheStorage::TemporarilyPreserveCache(
-    scoped_refptr<CacheStorageCache> cache) {
+    std::unique_ptr<CacheStorageCacheHandle> cache_handle) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(!ContainsKey(preserved_caches_, cache.get()));
+  DCHECK(!ContainsKey(preserved_caches_, cache_handle->value()));
 
-  preserved_caches_[cache.get()] = cache;
+  CacheStorageCache* cache_ptr = cache_handle->value();
   SchedulePreservedCacheRemoval(base::Bind(&CacheStorage::RemovePreservedCache,
                                            weak_factory_.GetWeakPtr(),
-                                           base::Unretained(cache.get())));
+                                           cache_ptr));
+  preserved_caches_[cache_ptr] = std::move(cache_handle);
 }
 
 void CacheStorage::SchedulePreservedCacheRemoval(
@@ -951,8 +1036,11 @@ void CacheStorage::GetSizeThenCloseAllCachesImpl(const SizeCallback& callback) {
                  base::Passed(std::move(accumulator)), callback));
 
   for (const std::string& cache_name : ordered_cache_names_) {
-    scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
-    cache->GetSizeThenClose(base::Bind(&SizeRetrievedFromCache, cache,
+    std::unique_ptr<CacheStorageCacheHandle> cache_handle =
+        GetLoadedCache(cache_name);
+    CacheStorageCache* cache = cache_handle->value();
+    cache->GetSizeThenClose(base::Bind(&SizeRetrievedFromCache,
+                                       base::Passed(std::move(cache_handle)),
                                        barrier_closure, accumulator_ptr));
   }
 }
@@ -970,9 +1058,12 @@ void CacheStorage::SizeImpl(const SizeCallback& callback) {
                  base::Passed(std::move(accumulator)), callback));
 
   for (const std::string& cache_name : ordered_cache_names_) {
-    scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
-    cache->Size(base::Bind(&SizeRetrievedFromCache, cache, barrier_closure,
-                           accumulator_ptr));
+    std::unique_ptr<CacheStorageCacheHandle> cache_handle =
+        GetLoadedCache(cache_name);
+    CacheStorageCache* cache = cache_handle->value();
+    cache->Size(base::Bind(&SizeRetrievedFromCache,
+                           base::Passed(std::move(cache_handle)),
+                           barrier_closure, accumulator_ptr));
   }
 }
 
@@ -997,11 +1088,11 @@ void CacheStorage::PendingBoolAndErrorCallback(
 
 void CacheStorage::PendingCacheAndErrorCallback(
     const CacheAndErrorCallback& callback,
-    scoped_refptr<CacheStorageCache> cache,
+    std::unique_ptr<CacheStorageCacheHandle> cache_handle,
     CacheStorageError error) {
   base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
 
-  callback.Run(std::move(cache), error);
+  callback.Run(std::move(cache_handle), error);
   if (cache_storage)
     scheduler_->CompleteOperationAndRunNext();
 }