[CacheStorage] Clean up CacheStorageCache lifetimes

content/browser/cache_storage/cache_storage.h

 // 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.
 
 #ifndef CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_H_
 #define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 120 matching lines @@
   void LazyInitDidLoadIndex(
       std::unique_ptr<std::vector<std::string>> indexed_cache_names);
 
   // The Open and CreateCache callbacks are below.
   void OpenCacheImpl(const std::string& cache_name,
                      const CacheAndErrorCallback& callback);
   void CreateCacheDidCreateCache(const std::string& cache_name,
                                  const CacheAndErrorCallback& callback,
                                  scoped_refptr<CacheStorageCache> cache);
   void CreateCacheDidWriteIndex(const CacheAndErrorCallback& callback,
-                                scoped_refptr<CacheStorageCache> cache,
                                 bool success);
 
   // The HasCache callbacks are below.
   void HasCacheImpl(const std::string& cache_name,
                     const BoolAndErrorCallback& callback);
 
   // The DeleteCache callbacks are below.
   void DeleteCacheImpl(const std::string& cache_name,
                        const BoolAndErrorCallback& callback);
 
   void DeleteCacheDidClose(const std::string& cache_name,
                            const BoolAndErrorCallback& callback,
                            const StringVector& ordered_cache_names,
-                           scoped_refptr<CacheStorageCache> cache,
                            int64_t cache_size);
   void DeleteCacheDidWriteIndex(const std::string& cache_name,
                                 const BoolAndErrorCallback& callback,
                                 int cache_size,
                                 bool success);
   void DeleteCacheDidCleanUp(const BoolAndErrorCallback& callback,
                              bool success);
 
   // The EnumerateCache callbacks are below.
   void EnumerateCachesImpl(const StringsAndErrorCallback& callback);
 
   // The MatchCache callbacks are below.
   void MatchCacheImpl(const std::string& cache_name,
                       std::unique_ptr<ServiceWorkerFetchRequest> request,
                       const CacheStorageCache::ResponseCallback& callback);
-  void MatchCacheDidMatch(scoped_refptr<CacheStorageCache> cache,
-                          const CacheStorageCache::ResponseCallback& callback,
+  void MatchCacheDidMatch(const CacheStorageCache::ResponseCallback& callback,
                           CacheStorageError error,
                           std::unique_ptr<ServiceWorkerResponse> response,
                           std::unique_ptr<storage::BlobDataHandle> handle);
 
   // The MatchAllCaches callbacks are below.
   void MatchAllCachesImpl(std::unique_ptr<ServiceWorkerFetchRequest> request,
                           const CacheStorageCache::ResponseCallback& callback);
   void 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);
   void MatchAllCachesDidMatchAll(
       std::unique_ptr<std::vector<CacheMatchResponse>> match_responses,
       const CacheStorageCache::ResponseCallback& callback);
 
   void GetSizeThenCloseAllCachesImpl(const SizeCallback& callback);
 
   void SizeImpl(const SizeCallback& callback);
+  void SizeRetrievedFromAllCaches(std::unique_ptr<int64_t> accumulator,
+                                  const CacheStorage::SizeCallback& callback);
 
   void PendingClosure(const base::Closure& callback);
   void PendingBoolAndErrorCallback(const BoolAndErrorCallback& callback,
                                    bool found,
                                    CacheStorageError error);
   void PendingCacheAndErrorCallback(const CacheAndErrorCallback& callback,
                                     scoped_refptr<CacheStorageCache> cache,
                                     CacheStorageError error);
   void PendingStringsAndErrorCallback(const StringsAndErrorCallback& callback,
                                       const StringVector& strings,
@@ skipping 32 matching lines @@
   // without having the open the cache again.
   std::map<const CacheStorageCache*, scoped_refptr<CacheStorageCache>>
       preserved_caches_;
 
   // The quota manager.
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
 
   // The origin that this CacheStorage is associated with.
   GURL origin_;
 
+  // Used to keep caches alive during async operations.
+  scoped_refptr<CacheStorageCache> callback_cache_;
+  std::vector<scoped_refptr<CacheStorageCache>> callback_caches_;
+
   base::WeakPtrFactory<CacheStorage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_H_