[CacheStorage] Initialize the cache backend immediately upon opening

content/browser/cache_storage/cache_storage_cache.cc

Index: content/browser/cache_storage/cache_storage_cache.cc
diff --git a/content/browser/cache_storage/cache_storage_cache.cc b/content/browser/cache_storage/cache_storage_cache.cc
index 5a9bb3dbc860c25d9bd8807a972dfeda63b63b44..ca7605f3931db53d9ad1d5071b9d29d72fdead1e 100644
--- a/content/browser/cache_storage/cache_storage_cache.cc
+++ b/content/browser/cache_storage/cache_storage_cache.cc
@@ -9,9 +9,11 @@
 #include <utility>
 
 #include "base/barrier_closure.h"
+#include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
@@ -289,10 +291,12 @@ std::unique_ptr<CacheStorageCache> CacheStorageCache::CreateMemoryCache(
     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
-  return std::unique_ptr<CacheStorageCache>(
+  CacheStorageCache* cache =
       new CacheStorageCache(origin, cache_name, base::FilePath(), cache_storage,
                             std::move(request_context_getter),
-                            std::move(quota_manager_proxy), blob_context));
+                            std::move(quota_manager_proxy), blob_context);
+  cache->InitBackend();
+  return base::WrapUnique(cache);
 }
 
 // static
@@ -304,10 +308,12 @@ std::unique_ptr<CacheStorageCache> CacheStorageCache::CreatePersistentCache(
     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
-  return std::unique_ptr<CacheStorageCache>(
+  CacheStorageCache* cache =
       new CacheStorageCache(origin, cache_name, path, cache_storage,
                             std::move(request_context_getter),
-                            std::move(quota_manager_proxy), blob_context));
+                            std::move(quota_manager_proxy), blob_context);
+  cache->InitBackend();
+  return base::WrapUnique(cache);
 }
 
 base::WeakPtr<CacheStorageCache> CacheStorageCache::AsWeakPtr() {
@@ -317,7 +323,7 @@ base::WeakPtr<CacheStorageCache> CacheStorageCache::AsWeakPtr() {
 void CacheStorageCache::Match(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const ResponseCallback& callback) {
-  if (!LazyInitialize()) {
+  if (backend_state_ == BACKEND_CLOSED) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                  std::unique_ptr<ServiceWorkerResponse>(),
                  std::unique_ptr<storage::BlobDataHandle>());
@@ -336,7 +342,7 @@ void CacheStorageCache::MatchAll(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& match_params,
     const ResponsesCallback& callback) {
-  if (!LazyInitialize()) {
+  if (backend_state_ == BACKEND_CLOSED) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Responses>(),
                  std::unique_ptr<BlobDataHandles>());
     return;
@@ -358,7 +364,7 @@ void CacheStorageCache::WriteSideData(const ErrorCallback& callback,
                                       base::Time expected_response_time,
                                       scoped_refptr<net::IOBuffer> buffer,
                                       int buf_len) {
-  if (!LazyInitialize()) {
+  if (backend_state_ == BACKEND_CLOSED) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, CACHE_STORAGE_ERROR_STORAGE));
     return;
@@ -377,7 +383,7 @@ void CacheStorageCache::WriteSideData(const ErrorCallback& callback,
 void CacheStorageCache::BatchOperation(
     const std::vector<CacheStorageBatchOperation>& operations,
     const ErrorCallback& callback) {
-  if (!LazyInitialize()) {
+  if (backend_state_ == BACKEND_CLOSED) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, CACHE_STORAGE_ERROR_STORAGE));
     return;
@@ -477,7 +483,7 @@ void CacheStorageCache::BatchDidAllOperations(
 }
 
 void CacheStorageCache::Keys(const RequestsCallback& callback) {
-  if (!LazyInitialize()) {
+  if (backend_state_ == BACKEND_CLOSED) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Requests>());
     return;
   }
@@ -504,7 +510,7 @@ void CacheStorageCache::Close(const base::Closure& callback) {
 }
 
 void CacheStorageCache::Size(const SizeCallback& callback) {
-  if (!LazyInitialize()) {
+  if (backend_state_ == BACKEND_CLOSED) {
     // TODO(jkarlin): Delete caches that can't be initialized.
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, 0));
@@ -521,7 +527,7 @@ void CacheStorageCache::Size(const SizeCallback& callback) {
 }
 
 void CacheStorageCache::GetSizeThenClose(const SizeCallback& callback) {
-  if (!LazyInitialize()) {
+  if (backend_state_ == BACKEND_CLOSED) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, 0));
     return;
@@ -565,21 +571,6 @@ CacheStorageCache::CacheStorageCache(
   quota_manager_proxy_->NotifyOriginInUse(origin_);
 }
 
-bool CacheStorageCache::LazyInitialize() {
-  switch (backend_state_) {
-    case BACKEND_UNINITIALIZED:
-      InitBackend();
-      return true;
-    case BACKEND_CLOSED:
-      return false;
-    case BACKEND_OPEN:
-      DCHECK(backend_);
-      return true;
-  }
-  NOTREACHED();
-  return false;
-}
-
 void CacheStorageCache::OpenAllEntries(const OpenAllEntriesCallback& callback) {
   std::unique_ptr<OpenAllEntriesContext> entries_context(
       new OpenAllEntriesContext);
@@ -1435,35 +1426,38 @@ void CacheStorageCache::CreateBackendDidCreate(
 
 void CacheStorageCache::InitBackend() {
   DCHECK_EQ(BACKEND_UNINITIALIZED, backend_state_);
-
-  if (initializing_)
-    return;
-
+  DCHECK(!initializing_);
   DCHECK(!scheduler_->ScheduledOperations());
   initializing_ = true;
 
+  base::Closure pending_callback =
+      base::Bind(&CacheStorageCache::PendingClosure,
+                 weak_ptr_factory_.GetWeakPtr(), base::Bind(&base::DoNothing));
+
   scheduler_->ScheduleOperation(base::Bind(
       &CacheStorageCache::CreateBackend, weak_ptr_factory_.GetWeakPtr(),
       base::Bind(&CacheStorageCache::InitDidCreateBackend,
-                 weak_ptr_factory_.GetWeakPtr())));
+                 weak_ptr_factory_.GetWeakPtr(), pending_callback)));
 }
 
 void CacheStorageCache::InitDidCreateBackend(
+    const base::Closure& callback,
     CacheStorageError cache_create_error) {
   if (cache_create_error != CACHE_STORAGE_OK) {
-    InitGotCacheSize(cache_create_error, 0);
+    InitGotCacheSize(callback, cache_create_error, 0);
     return;
   }
 
   int rv = backend_->CalculateSizeOfAllEntries(
       base::Bind(&CacheStorageCache::InitGotCacheSize,
-                 weak_ptr_factory_.GetWeakPtr(), cache_create_error));
+                 weak_ptr_factory_.GetWeakPtr(), callback, cache_create_error));
 
   if (rv != net::ERR_IO_PENDING)
-    InitGotCacheSize(cache_create_error, rv);
+    InitGotCacheSize(callback, cache_create_error, rv);
 }
 
-void CacheStorageCache::InitGotCacheSize(CacheStorageError cache_create_error,
+void CacheStorageCache::InitGotCacheSize(const base::Closure& callback,
+                                         CacheStorageError cache_create_error,
                                          int cache_size) {
   cache_size_ = cache_size;
   initializing_ = false;
@@ -1475,7 +1469,7 @@ void CacheStorageCache::InitGotCacheSize(CacheStorageError cache_create_error,
   UMA_HISTOGRAM_ENUMERATION("ServiceWorkerCache.InitBackendResult",
                             cache_create_error, CACHE_STORAGE_ERROR_LAST + 1);
 
-  scheduler_->CompleteOperationAndRunNext();
+  callback.Run();
 }
 
 void CacheStorageCache::PendingClosure(const base::Closure& callback) {