[CacheStorage] Temporarily preserve recently opened caches from CacheStorageDispatcherHost

content/browser/cache_storage/cache_storage_dispatcher_host.cc

 // Copyright 2015 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_dispatcher_host.h"
 
 #include <stddef.h>
 #include <utility>
 
 #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"
 #include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/browser/cache_storage/cache_storage_context_impl.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
 #include "content/common/cache_storage/cache_storage_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/origin_util.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerCacheError.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace content {
 
 namespace {
 
 const uint32_t kFilteredMessageClasses[] = {CacheStorageMsgStart};
+const int32_t kCachePreservationSeconds = 5;
 
 blink::WebServiceWorkerCacheError ToWebServiceWorkerCacheError(
     CacheStorageError err) {
   switch (err) {
     case CACHE_STORAGE_OK:
       NOTREACHED();
       return blink::WebServiceWorkerCacheErrorNotImplemented;
     case CACHE_STORAGE_ERROR_EXISTS:
       return blink::WebServiceWorkerCacheErrorExists;
     case CACHE_STORAGE_ERROR_STORAGE:
@@ skipping 12 matching lines @@
 }
 
 bool OriginCanAccessCacheStorage(const url::Origin& origin) {
   return !origin.unique() && IsOriginSecure(GURL(origin.Serialize()));
 }
 
 }  // namespace
 
 CacheStorageDispatcherHost::CacheStorageDispatcherHost()
     : BrowserMessageFilter(kFilteredMessageClasses,
-                           arraysize(kFilteredMessageClasses)) {
-}
+                           arraysize(kFilteredMessageClasses)) {}
 
 CacheStorageDispatcherHost::~CacheStorageDispatcherHost() {
 }
 
 void CacheStorageDispatcherHost::Init(CacheStorageContextImpl* context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&CacheStorageDispatcherHost::CreateCacheListener, this,
                  base::RetainedRef(context)));
@@ skipping 269 matching lines @@
 void CacheStorageDispatcherHost::OnCacheStorageOpenCallback(
     int thread_id,
     int request_id,
     std::unique_ptr<CacheStorageCacheHandle> cache_handle,
     CacheStorageError error) {
   if (error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheStorageOpenError(
         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));
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageDeleteCallback(
     int thread_id,
     int request_id,
     bool deleted,
     CacheStorageError error) {
@@ skipping 134 matching lines @@
     CacheStorageError error) {
   if (error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheBatchError(
         thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
 
   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) {
   int cache_id = next_cache_id_++;
   id_to_cache_map_[cache_id] = std::move(cache_handle);
   return cache_id;
 }
 
 void CacheStorageDispatcherHost::DropCacheReference(CacheID cache_id) {
   id_to_cache_map_.erase(cache_id);
@@ skipping 11 matching lines @@
   UUIDToBlobDataHandleList::iterator it = blob_handle_store_.find(uuid);
   if (it == blob_handle_store_.end())
     return;
   DCHECK(!it->second.empty());
   it->second.pop_front();
   if (it->second.empty())
     blob_handle_store_.erase(it);
 }
 
 }  // namespace content