[CacheStorage] Clean up CacheStorageCache lifetimes

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>
@@ skipping 30 matching lines @@
 
 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,
+void SizeRetrievedFromCache(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;
@@ skipping 623 matching lines @@
   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) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
+  DCHECK(!callback_cache_.get());
   UMA_HISTOGRAM_BOOLEAN("ServiceWorkerCache.CreateCacheStorageResult",
                         static_cast<bool>(cache));
 
   if (!cache.get()) {
     callback.Run(scoped_refptr<CacheStorageCache>(),
                  CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   cache_map_.insert(std::make_pair(cache_name, cache->AsWeakPtr()));
   ordered_cache_names_.push_back(cache_name);
 
   TemporarilyPreserveCache(cache);
+  callback_cache_ = std::move(cache);
 
-  cache_loader_->WriteIndex(
-      ordered_cache_names_,
-      base::Bind(&CacheStorage::CreateCacheDidWriteIndex,
-                 weak_factory_.GetWeakPtr(), callback, std::move(cache)));
+  cache_loader_->WriteIndex(ordered_cache_names_,
+                            base::Bind(&CacheStorage::CreateCacheDidWriteIndex,
+                                       weak_factory_.GetWeakPtr(), callback));
 }
 
 void CacheStorage::CreateCacheDidWriteIndex(
     const CacheAndErrorCallback& callback,
-    scoped_refptr<CacheStorageCache> cache,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(cache.get());
+  DCHECK(callback_cache_.get());
 
   // TODO(jkarlin): Handle !success.
-
-  callback.Run(std::move(cache), CACHE_STORAGE_OK);
+  callback.Run(std::move(callback_cache_), 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) {
+  DCHECK(!callback_cache_.get());
   scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
   if (!cache.get()) {
     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);
   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));
+                                     callback, ordered_cache_names_));
+  callback_cache_ = std::move(cache);
 }
 
 void CacheStorage::DeleteCacheDidClose(const std::string& cache_name,
                                        const BoolAndErrorCallback& callback,
                                        const StringVector& ordered_cache_names,
-                                       scoped_refptr<CacheStorageCache> cache,
                                        int64_t cache_size) {
+  callback_cache_ = nullptr;
   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) {
+  DCHECK(!callback_cache_.get());
   scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
 
   if (!cache.get()) {
     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));
+                          weak_factory_.GetWeakPtr(), callback));
+  callback_cache_ = std::move(cache);
 }
 
 void CacheStorage::MatchCacheDidMatch(
-    scoped_refptr<CacheStorageCache> cache,
     const CacheStorageCache::ResponseCallback& callback,
     CacheStorageError error,
     std::unique_ptr<ServiceWorkerResponse> response,
     std::unique_ptr<storage::BlobDataHandle> handle) {
+  callback_cache_ = nullptr;
   callback.Run(error, std::move(response), std::move(handle));
 }
 
 void CacheStorage::MatchAllCachesImpl(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ResponseCallback& callback) {
+  DCHECK(callback_caches_.empty());
   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));
 
+  callback_caches_.resize(ordered_cache_names_.size());
   for (size_t i = 0, max = ordered_cache_names_.size(); i < max; ++i) {
     scoped_refptr<CacheStorageCache> cache =
         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));
+                            weak_factory_.GetWeakPtr(), &match_responses->at(i),
+                            barrier_closure));
+    callback_caches_.push_back(std::move(cache));
   }
 }
 
 void CacheStorage::MatchAllCachesDidMatch(
-    scoped_refptr<CacheStorageCache> cache,
     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) {
+  callback_caches_.clear();
   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>(),
@@ skipping 46 matching lines @@
 void CacheStorage::RemovePreservedCache(const CacheStorageCache* cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(ContainsKey(preserved_caches_, cache));
 
   preserved_caches_.erase(cache);
 }
 
 void CacheStorage::GetSizeThenCloseAllCachesImpl(const SizeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
+  DCHECK(callback_caches_.empty());
 
   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::Bind(&CacheStorage::SizeRetrievedFromAllCaches,
+                 weak_factory_.GetWeakPtr(),
                  base::Passed(std::move(accumulator)), callback));
 
+  callback_caches_.resize(ordered_cache_names_.size());
   for (const std::string& cache_name : ordered_cache_names_) {
     scoped_refptr<CacheStorageCache> cache = GetLoadedCache(cache_name);
-    cache->GetSizeThenClose(base::Bind(&SizeRetrievedFromCache, cache,
-                                       barrier_closure, accumulator_ptr));
+    cache->GetSizeThenClose(
+        base::Bind(&SizeRetrievedFromCache, barrier_closure, accumulator_ptr));
+    callback_caches_.push_back(std::move(cache));
   }
 }
 
 void CacheStorage::SizeImpl(const SizeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
+  DCHECK(callback_caches_.empty());
 
   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::Bind(&CacheStorage::SizeRetrievedFromAllCaches,
+                 weak_factory_.GetWeakPtr(),
                  base::Passed(std::move(accumulator)), callback));
 
+  callback_caches_.resize(ordered_cache_names_.size());
   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));
+    cache->Size(
+        base::Bind(&SizeRetrievedFromCache, barrier_closure, accumulator_ptr));
+    callback_caches_.push_back(std::move(cache));
   }
 }
 
+void CacheStorage::SizeRetrievedFromAllCaches(
+    std::unique_ptr<int64_t> accumulator,
+    const CacheStorage::SizeCallback& callback) {
+  callback_caches_.clear();
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(callback, *accumulator));
+}
+
 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,
@@ skipping 43 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