Decouple Cache Storage messaging from Service Worker/Embedded Worker

content/browser/service_worker/cache_storage_context_impl.cc

Index: content/browser/service_worker/cache_storage_context_impl.cc
diff --git a/content/browser/service_worker/cache_storage_context_impl.cc b/content/browser/service_worker/cache_storage_context_impl.cc
new file mode 100644
index 0000000000000000000000000000000000000000..358d745aa5ac5115cf458a86891eca0ed67d2ab1
--- /dev/null
+++ b/content/browser/service_worker/cache_storage_context_impl.cc
@@ -0,0 +1,105 @@
+// 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/service_worker/cache_storage_context_impl.h"
+
+#include "base/bind.h"
+#include "base/files/file_path.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "content/browser/fileapi/chrome_blob_storage_context.h"
+#include "content/browser/service_worker/service_worker_cache_storage_manager.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.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"
+#include "storage/browser/quota/special_storage_policy.h"
+
+namespace content {
+
+CacheStorageContextImpl::CacheStorageContextImpl(
+    BrowserContext* browser_context) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+}
+
+CacheStorageContextImpl::~CacheStorageContextImpl() {
+}
+
+void CacheStorageContextImpl::Init(
+    const base::FilePath& user_data_directory,
+    storage::QuotaManagerProxy* quota_manager_proxy,
+    storage::SpecialStoragePolicy* special_storage_policy) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  is_incognito_ = user_data_directory.empty();
+  base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
+  scoped_refptr<base::SequencedTaskRunner> cache_task_runner =
+      pool->GetSequencedTaskRunnerWithShutdownBehavior(
+          BrowserThread::GetBlockingPool()->GetSequenceToken(),
+          base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+
+  // This thread-hopping antipattern is needed here for some unit tests, where
+  // browser threads are collapsed the quota manager is initialized before the
+  // posted task can register the quota client.
+  // TODO: Fix the tests to let the quota manager initialize normally.

[michaeln, 2015/03/12 02:03:43]

Right, all clients have to be registered prior to the qm LazyInitialing itself,
one of the many things that makes startup delicate.

The way we generally have tried to handle this is to have all calls to
qm_proxy->RegisterClient(x) happen prior to return from
StoragePartitionImpl::Create which is run on the UI thread (and to not do
anything in StoragePartitionImpl::Create that would cause the QM to lazyinit
itself). I think we've deviated from that somewhat and its tripping us up here?

Typically RegisterClient() is called in the constructor of the context'ish class
thats a member of the storage partition. I think we could do here too by having
ServiceWorkerCacheQuotaClient reference the CacheStorageManager indirectly thru
a scoped_refptr<> to 'this' ContextImpl. Then it could be created and registered
in this method.

(looks like the ServiceWorkerQuotaClient also got this wrong, i think its being
registered later on IO thread sometime after StoragePartitionImpl::Create has
finished too, i can take care of that separately)

[kinuko, 2015/03/12 10:57:25]

Uh oh... yeah nice if we can fix this.

+  if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    CreateCacheStorageManager(user_data_directory, cache_task_runner,
+                              quota_manager_proxy, special_storage_policy);
+    return;
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CacheStorageContextImpl::CreateCacheStorageManager, this,
+                 user_data_directory, cache_task_runner,
+                 make_scoped_refptr(quota_manager_proxy),
+                 make_scoped_refptr(special_storage_policy)));
+}
+
+void CacheStorageContextImpl::Shutdown() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&CacheStorageContextImpl::ShutdownOnIO, this));
+}
+
+ServiceWorkerCacheStorageManager* CacheStorageContextImpl::cache_manager()
+    const {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  return cache_manager_.get();
+}
+
+void CacheStorageContextImpl::SetBlobParametersForCache(
+    net::URLRequestContextGetter* request_context,
+    ChromeBlobStorageContext* blob_storage_context) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (cache_manager_ && request_context && blob_storage_context) {
+    cache_manager_->SetBlobParametersForCache(
+        request_context->GetURLRequestContext(),
+        blob_storage_context->context()->AsWeakPtr());
+  }
+}
+
+void CacheStorageContextImpl::CreateCacheStorageManager(
+    const base::FilePath& user_data_directory,
+    const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner,
+    storage::QuotaManagerProxy* quota_manager_proxy,
+    storage::SpecialStoragePolicy* special_storage_policy) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  DCHECK(!cache_manager_);
+  cache_manager_ = ServiceWorkerCacheStorageManager::Create(
+      user_data_directory, cache_task_runner.get(),
+      make_scoped_refptr(quota_manager_proxy));
+}
+
+void CacheStorageContextImpl::ShutdownOnIO() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  cache_manager_.reset();
+}
+
+}  // namespace content