[CacheStorage] Temporarily preserve recently opened caches from CacheStorageDispatcherHost

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 22 matching lines @@
 #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(
     std::unique_ptr<CacheStorageCacheHandle> cache_handle,
     const base::Closure& closure,
@@ skipping 683 matching lines @@
   CacheStorageCache* cache_ptr = cache.get();
 
   cache_map_.insert(std::make_pair(cache_name, std::move(cache)));
   ordered_cache_names_.push_back(cache_name);
 
   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,
                  base::Passed(CreateCacheHandle(cache_ptr))));
 }
 
 void CacheStorage::CreateCacheDidWriteIndex(
     const CacheAndErrorCallback& callback,
     std::unique_ptr<CacheStorageCacheHandle> cache_handle,
@@ skipping 221 matching lines @@
     return std::unique_ptr<CacheStorageCacheHandle>();
 
   CacheStorageCache* cache = map_iter->second.get();
 
   if (!cache) {
     std::unique_ptr<CacheStorageCache> new_cache =
         cache_loader_->CreateCache(cache_name);
     CacheStorageCache* cache_ptr = new_cache.get();
     map_iter->second = std::move(new_cache);
 
-    TemporarilyPreserveCache(CreateCacheHandle(cache_ptr));
     return CreateCacheHandle(cache_ptr);
   }
 
   return CreateCacheHandle(cache);
 }
 
-void CacheStorage::TemporarilyPreserveCache(
-    std::unique_ptr<CacheStorageCacheHandle> cache_handle) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(!ContainsKey(preserved_caches_, cache_handle->value()));
-
-  CacheStorageCache* cache_ptr = cache_handle->value();
-  SchedulePreservedCacheRemoval(base::Bind(&CacheStorage::RemovePreservedCache,
-                                           weak_factory_.GetWeakPtr(),
-                                           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));
-}
-
-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_);
 
   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,
@@ skipping 87 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