[CacheStorage] Give ownership of all CacheStorageCaches to CacheStorage

content/browser/cache_storage/cache_storage.cc

 // Copyright 2014 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 "content/browser/cache_storage/cache_storage.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/sha1.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #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"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 
 namespace content {
 
 namespace {
 
 const int kCachePreservationInSecs = 30;
 
 std::string HexedHash(const std::string& value) {
   std::string value_hash = base::SHA1HashString(value);
   std::string valued_hexed_hash = base::ToLowerASCII(
       base::HexEncode(value_hash.c_str(), value_hash.length()));
   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();
 }
 
 void SizeRetrievedFromAllCaches(std::unique_ptr<int64_t> accumulator,
                                 const CacheStorage::SizeCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, *accumulator));
 }
 
 }  // namespace
 
 const char CacheStorage::kIndexFileName[] = "index.txt";
 
 struct CacheStorage::CacheMatchResponse {
   CacheMatchResponse() = default;
   ~CacheMatchResponse() = default;
 
   CacheStorageError error;
   std::unique_ptr<ServiceWorkerResponse> service_worker_response;
   std::unique_ptr<storage::BlobDataHandle> blob_data_handle;
 };
 
 // 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;
 
   CacheLoader(
       base::SequencedTaskRunner* cache_task_runner,
       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());
   }
 
   virtual ~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.
   virtual void PrepareNewCacheDestination(const std::string& cache_name,
                                           const CacheCallback& callback) = 0;
 
   // After the backend has been deleted, do any extra house keeping such as
   // removing the cache's directory.
   virtual void CleanUpDeletedCache(const std::string& key,
                                    const BoolCallback& callback) = 0;
 
   // Writes the cache names (and sizes) to disk if applicable.
   virtual void WriteIndex(const StringVector& cache_names,
                           const BoolCallback& callback) = 0;
 
   // Loads the cache names from disk if applicable.
   virtual void LoadIndex(std::unique_ptr<std::vector<std::string>> cache_names,
                          const StringVectorCallback& callback) = 0;
 
  protected:
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner_;
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
   // Owned by CacheStorage which owns this.
   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_;
 };
 
 // Creates memory-only ServiceWorkerCaches. Because these caches have no
 // persistent storage it is not safe to free them from memory if they might be
 // used again. Therefore this class holds a reference to each cache until the
 // cache is deleted.
 class CacheStorage::MemoryLoader : public CacheStorage::CacheLoader {
  public:
   MemoryLoader(base::SequencedTaskRunner* cache_task_runner,
                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);
   }
 
   void WriteIndex(const StringVector& cache_names,
                   const BoolCallback& callback) override {
     callback.Run(false);
   }
 
   void LoadIndex(std::unique_ptr<std::vector<std::string>> cache_names,
                  const StringVectorCallback& callback) override {
     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 {
  public:
   SimpleCacheLoader(const base::FilePath& origin_path,
                     base::SequencedTaskRunner* cache_task_runner,
                     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));
 
     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,
                                   const CacheCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     PostTaskAndReplyWithResult(
         cache_task_runner_.get(), FROM_HERE,
         base::Bind(&SimpleCacheLoader::PrepareNewCacheDirectoryInPool,
                    origin_path_),
@@ skipping 11 matching lines @@
       cache_path = origin_path.AppendASCII(cache_dir);
     } while (base::PathExists(cache_path));
 
     return base::CreateDirectory(cache_path) ? cache_dir : "";
   }
 
   void PrepareNewCacheCreateCache(const std::string& cache_name,
                                   const CacheCallback& callback,
                                   const std::string& cache_dir) {
     if (cache_dir.empty()) {
-      callback.Run(scoped_refptr<CacheStorageCache>());
+      callback.Run(std::unique_ptr<CacheStorageCache>());
       return;
     }
 
     cache_name_to_cache_dir_[cache_name] = cache_dir;
     callback.Run(CreateCache(cache_name));
   }
 
   void CleanUpDeletedCache(const std::string& cache_name,
                            const BoolCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 198 matching lines @@
 CacheStorage::CacheStorage(
     const base::FilePath& path,
     bool memory_only,
     base::SequencedTaskRunner* cache_task_runner,
     scoped_refptr<net::URLRequestContextGetter> request_context,
     scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context,
     const GURL& origin)
     : initialized_(false),
       initializing_(false),
+      memory_only_(memory_only),
       scheduler_(new CacheStorageScheduler()),
       origin_path_(path),
       cache_task_runner_(cache_task_runner),
       quota_manager_proxy_(quota_manager_proxy),
       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() {
 }
 
 void CacheStorage::OpenCache(const std::string& cache_name,
                              const CacheAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
@@ skipping 175 matching lines @@
                            base::Bind(&CacheStorage::LazyInitDidLoadIndex,
                                       weak_factory_.GetWeakPtr()));
 }
 
 void CacheStorage::LazyInitDidLoadIndex(
     std::unique_ptr<std::vector<std::string>> indexed_cache_names) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   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));
   }
 
   initializing_ = false;
   initialized_ = true;
 
   scheduler_->CompleteOperationAndRunNext();
 }
 
 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;
   }
 
   cache_loader_->PrepareNewCacheDestination(
       cache_name, base::Bind(&CacheStorage::CreateCacheDidCreateCache,
                              weak_factory_.GetWeakPtr(), cache_name, callback));
 }
 
 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,
                                 const BoolAndErrorCallback& callback) {
   bool has_cache = ContainsKey(cache_map_, cache_name);
   callback.Run(has_cache, CACHE_STORAGE_OK);
 }
 
 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_.
   StringVector::iterator iter = std::find(
       ordered_cache_names_.begin(), ordered_cache_names_.end(), 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,
                  weak_factory_.GetWeakPtr(), cache_name, callback, cache_size));
 }
 
 void CacheStorage::DeleteCacheDidWriteIndex(
     const std::string& cache_name,
     const BoolAndErrorCallback& callback,
     int cache_size,
@@ skipping 18 matching lines @@
 
 void CacheStorage::EnumerateCachesImpl(
     const StringsAndErrorCallback& callback) {
   callback.Run(ordered_cache_names_, CACHE_STORAGE_OK);
 }
 
 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,
     std::unique_ptr<storage::BlobDataHandle> handle) {
   callback.Run(error, std::move(response), std::move(handle));
 }
 
 void CacheStorage::MatchAllCachesImpl(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ResponseCallback& callback) {
   std::vector<CacheMatchResponse>* match_responses =
       new std::vector<CacheMatchResponse>(ordered_cache_names_.size());
 
   base::Closure barrier_closure = base::BarrierClosure(
       ordered_cache_names_.size(),
       base::Bind(&CacheStorage::MatchAllCachesDidMatchAll,
                  weak_factory_.GetWeakPtr(),
                  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());
+    DCHECK(cache_handle);
 
-    cache->Match(base::WrapUnique(new ServiceWorkerFetchRequest(*request)),
-                 base::Bind(&CacheStorage::MatchAllCachesDidMatch,
-                            weak_factory_.GetWeakPtr(), cache,
-                            &match_responses->at(i), barrier_closure));
+    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,
     std::unique_ptr<ServiceWorkerResponse> service_worker_response,
     std::unique_ptr<storage::BlobDataHandle> handle) {
   out_match_response->error = error;
   out_match_response->service_worker_response =
       std::move(service_worker_response);
   out_match_response->blob_data_handle = std::move(handle);
   barrier_closure.Run();
 }
 
 void CacheStorage::MatchAllCachesDidMatchAll(
     std::unique_ptr<std::vector<CacheMatchResponse>> match_responses,
     const CacheStorageCache::ResponseCallback& callback) {
   for (CacheMatchResponse& match_response : *match_responses) {
     if (match_response.error == CACHE_STORAGE_ERROR_NOT_FOUND)
       continue;
     callback.Run(match_response.error,
                  std::move(match_response.service_worker_response),
                  std::move(match_response.blob_data_handle));
     return;
   }
   callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
                std::unique_ptr<ServiceWorkerResponse>(),
                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(
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, callback,
       base::TimeDelta::FromSeconds(kCachePreservationInSecs));
 }
@@ skipping 11 matching lines @@
 
   std::unique_ptr<int64_t> accumulator(new int64_t(0));
   int64_t* accumulator_ptr = accumulator.get();
 
   base::Closure barrier_closure = base::BarrierClosure(
       ordered_cache_names_.size(),
       base::Bind(&SizeRetrievedFromAllCaches,
                  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));
   }
 }
 
 void CacheStorage::SizeImpl(const SizeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
   std::unique_ptr<int64_t> accumulator(new int64_t(0));
   int64_t* accumulator_ptr = accumulator.get();
 
   base::Closure barrier_closure = base::BarrierClosure(
       ordered_cache_names_.size(),
       base::Bind(&SizeRetrievedFromAllCaches,
                  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));
   }
 }
 
 void CacheStorage::PendingClosure(const base::Closure& callback) {
   base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
 
   callback.Run();
   if (cache_storage)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 void CacheStorage::PendingBoolAndErrorCallback(
     const BoolAndErrorCallback& callback,
     bool found,
     CacheStorageError error) {
   base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
 
   callback.Run(found, error);
   if (cache_storage)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 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();
 }
 
 void CacheStorage::PendingStringsAndErrorCallback(
     const StringsAndErrorCallback& callback,
     const StringVector& strings,
     CacheStorageError error) {
   base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
 
@@ skipping 17 matching lines @@
 void CacheStorage::PendingSizeCallback(const SizeCallback& callback,
                                        int64_t size) {
   base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
 
   callback.Run(size);
   if (cache_storage)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 }  // namespace content