[CacheStorage] Keep deleted caches alive until last reference is gone

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 59 matching lines @@
   // The cache will also be deleted in the CacheStorage's destructor so be sure
   // to check the handle's value before using it.
   void OpenCache(const std::string& cache_name,
                  const CacheAndErrorCallback& callback);
 
   // Calls the callback with whether or not the cache exists.
   void HasCache(const std::string& cache_name,
                 const BoolAndErrorCallback& callback);
 
   // Deletes the cache if it exists. If it doesn't exist,
-  // CACHE_STORAGE_ERROR_NOT_FOUND is returned.
+  // CACHE_STORAGE_ERROR_NOT_FOUND is returned. Any existing
+  // CacheStorageCacheHandle(s) to the cache will remain valid but future
+  // CacheStorage operations won't be able to access the cache. The cache
+  // isn't actually erased from disk until the last handle is dropped.
+  // TODO(jkarlin): Rename to DoomCache.
   void DeleteCache(const std::string& cache_name,
                    const BoolAndErrorCallback& callback);
 
   // Calls the callback with a vector of cache names (keys) available.
   void EnumerateCaches(const StringsAndErrorCallback& callback);
 
   // Calls match on the cache with the given |cache_name|.
   void MatchCache(const std::string& cache_name,
                   std::unique_ptr<ServiceWorkerFetchRequest> request,
                   const CacheStorageCache::ResponseCallback& callback);
@@ skipping 56 matching lines @@
       std::unique_ptr<CacheStorageCacheHandle> cache_handle,
       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(
+  void DeleteCacheDidWriteIndex(
       const std::string& cache_name,
+      const StringVector& original_ordered_cache_names,
       const BoolAndErrorCallback& callback,
-      const StringVector& ordered_cache_names,
-      std::unique_ptr<CacheStorageCacheHandle> cache_handle,
-      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);
+      bool success);
+  void DeleteCacheFinalize(std::unique_ptr<CacheStorageCache> doomed_cache);
+  void DeleteCacheDidGetSize(std::unique_ptr<CacheStorageCache> cache,
+                             int64_t cache_size);
+  void DeleteCacheDidCleanUp(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(std::unique_ptr<CacheStorageCacheHandle> cache_handle,
                           const CacheStorageCache::ResponseCallback& callback,
@@ skipping 47 matching lines @@
 
   // The pending operation scheduler.
   std::unique_ptr<CacheStorageScheduler> scheduler_;
 
   // The map of cache names to CacheStorageCache objects.
   CacheMap cache_map_;
 
   // Caches that have been deleted but must still be held onto until all handles
   // have been released.
   std::map<CacheStorageCache*, std::unique_ptr<CacheStorageCache>>
-      deleted_caches_;
+      doomed_caches_;
 
   // CacheStorageCacheHandle reference counts
   std::map<CacheStorageCache*, size_t> cache_handle_counts_;
 
   // The names of caches in the order that they were created.
   StringVector ordered_cache_names_;
 
   // The file path for this CacheStorage.
   base::FilePath origin_path_;
 
@@ skipping 10 matching lines @@
   GURL origin_;
 
   base::WeakPtrFactory<CacheStorage> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_H_