[CacheStorage] Check doomed caches first when dropping cache handles

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 164 matching lines @@
         quota_manager_proxy_, blob_context_);
   }
 
   void PrepareNewCacheDestination(const std::string& cache_name,
                                   const CacheCallback& callback) override {
     std::unique_ptr<CacheStorageCache> cache = CreateCache(cache_name);
     callback.Run(std::move(cache));
   }
 
   void CleanUpDeletedCache(const std::string& cache_name) override {
-    DCHECK(!ContainsKey(cache_handles_, cache_name));
   }
 
   void WriteIndex(const StringVector& cache_names,
                   const BoolCallback& callback) override {
     callback.Run(true);
   }
 
   void LoadIndex(std::unique_ptr<std::vector<std::string>> cache_names,
                  const StringVectorCallback& callback) override {
     callback.Run(std::move(cache_names));
@@ skipping 725 matching lines @@
 }
 
 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 doomed caches map.
-    auto cache_map_iter = cache_map_.find(cache->cache_name());
-
-    if (cache_map_iter == cache_map_.end()) {
-      auto doomed_caches_iter = doomed_caches_.find(cache);
-      DCHECK(doomed_caches_iter != doomed_caches_.end());
-
+    auto doomed_caches_iter = doomed_caches_.find(cache);
+    if (doomed_caches_iter != doomed_caches_.end()) {
       // The last reference to a doomed cache is gone, perform clean up.
       DeleteCacheFinalize(std::move(doomed_caches_iter->second));
       doomed_caches_.erase(doomed_caches_iter);
       return;
     }
 
+    auto cache_map_iter = cache_map_.find(cache->cache_name());
+    DCHECK(cache_map_iter != cache_map_.end());
+
     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()));
@@ skipping 60 matching lines @@
     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));
   }
 }
 
 }  // namespace content