[CacheStorage] Temporarily preserve recently opened caches from CacheStorageDispatcherHost

content/browser/cache_storage/cache_storage_dispatcher_host.cc

Index: content/browser/cache_storage/cache_storage_dispatcher_host.cc
diff --git a/content/browser/cache_storage/cache_storage_dispatcher_host.cc b/content/browser/cache_storage/cache_storage_dispatcher_host.cc
index e3ab6fa7faf33cfdeeac9fc64716b046ba1e959a..ec75a6dfea919e4dc79438cd4fa3cb47011219c5 100644
--- a/content/browser/cache_storage/cache_storage_dispatcher_host.cc
+++ b/content/browser/cache_storage/cache_storage_dispatcher_host.cc
@@ -10,8 +10,11 @@
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/cache_storage/cache_storage_cache.h"
@@ -31,6 +34,7 @@ namespace content {
 namespace {
 
 const uint32_t kFilteredMessageClasses[] = {CacheStorageMsgStart};
+const int32_t kCachePreservationSeconds = 5;
 
 blink::WebServiceWorkerCacheError ToWebServiceWorkerCacheError(
     CacheStorageError err) {
@@ -63,8 +67,7 @@ bool OriginCanAccessCacheStorage(const url::Origin& origin) {
 
 CacheStorageDispatcherHost::CacheStorageDispatcherHost()
     : BrowserMessageFilter(kFilteredMessageClasses,
-                           arraysize(kFilteredMessageClasses)) {
-}
+                           arraysize(kFilteredMessageClasses)) {}
 
 CacheStorageDispatcherHost::~CacheStorageDispatcherHost() {
 }
@@ -354,6 +357,18 @@ void CacheStorageDispatcherHost::OnCacheStorageOpenCallback(
         thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
+
+  // Hang on to the cache for a few seconds (if we aren't already doing so).
+  // This way if the user quickly closes and reopens it the next open operation
+  // will be fast.
+  if (!ContainsKey(preserved_cache_handles_, cache_handle->value())) {
+    preserved_cache_handles_[cache_handle->value()] = cache_handle->Clone();
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&CacheStorageDispatcherHost::StopPreservingCache,
+                              this, cache_handle->value()),

[nhiroki, 2016/06/29 09:15:39]

This may extend the lifetime of MessageFilter. Although I'm not really sure
whether this extension is harmful, I think it might be better to avoid it.

Instead of passing "this", we could make a cancelable task to stop preserving a
cache and cancel all scheduled tasks when the dispatcher host is to be destroyed
like this:

class Task {
  void Run() {
    dispatcher_host_->StopPreservingCache(cache_);
    dispatcher_host_->RemoveTask(task_id_);
    // This task is destroyed at this point.
  }

  CacheStorageDispatcherHost* dispatcher_host_;
  CacheStorageCache* cache_;
  int task_id_;
}

class CacheStorageDispatcherHost {
  ~CacheStorageDispatcherHost() { tasks_.Clear(); }

  Task* CreateTask(cache_handle) {
    Task* task = new Task(this, cache_handle->value());
    int task_id = tasks_.Add(task);
    task->set_task_id(task_id);
    return task;
  }

  void RemoveTask(task_id) {
    tasks_->Remove(task_id);
  }

  IDMap<Task, IDMapOwnPointer> tasks_;
}

// In CacheStorageDispatcherHost::OnCacheStorageOpenCallback
PostDelayedTask(
    FROM_HERE,
    base::Bind(&Task::Run, CreateTask(cache_handle)->GetWeakPtr()),
    delay);

[jkarlin, 2016/06/29 12:52:53]

Actually, there isn't even a need to run the callback on the
CacheStorageDispatcherHost. There is no need for it to hang onto the cache
handle. Since the cache handle is weak (it dies when the CacheStorage that owns
it dies), let's just keep the cache handle in the callback itself. Fixed.

+        base::TimeDelta::FromSeconds(kCachePreservationSeconds));
+  }
+
   CacheID cache_id = StoreCacheReference(std::move(cache_handle));
   Send(new CacheStorageMsg_CacheStorageOpenSuccess(thread_id, request_id,
                                                    cache_id));
@@ -508,6 +523,12 @@ void CacheStorageDispatcherHost::OnCacheBatchCallback(
   Send(new CacheStorageMsg_CacheBatchSuccess(thread_id, request_id));
 }
 
+void CacheStorageDispatcherHost::StopPreservingCache(
+    const CacheStorageCache* cache) {
+  DCHECK(ContainsKey(preserved_cache_handles_, cache));
+  preserved_cache_handles_.erase(cache);
+}
+
 CacheStorageDispatcherHost::CacheID
 CacheStorageDispatcherHost::StoreCacheReference(
     std::unique_ptr<CacheStorageCacheHandle> cache_handle) {