[CacheStorage] Initialize the cache backend immediately upon opening

content/browser/cache_storage/cache_storage_cache.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_cache.h"
 
 #include <stddef.h>
 #include <string>
 #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"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_blob_to_disk_cache.h"
 #include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/browser/cache_storage/cache_storage_scheduler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/referrer.h"
@@ skipping 257 matching lines @@
 };
 
 // static
 std::unique_ptr<CacheStorageCache> CacheStorageCache::CreateMemoryCache(
     const GURL& origin,
     const std::string& cache_name,
     CacheStorage* cache_storage,
     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
 std::unique_ptr<CacheStorageCache> CacheStorageCache::CreatePersistentCache(
     const GURL& origin,
     const std::string& cache_name,
     CacheStorage* cache_storage,
     const base::FilePath& path,
     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() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 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>());
     return;
   }
 
   ResponseCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingResponseCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(request)), pending_callback));
 }
 
 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;
   }
 
   ResponsesCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingResponsesCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
 
   std::unique_ptr<MatchAllContext> context(
       new MatchAllContext(std::move(request), match_params, pending_callback));
   scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::MatchAllImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            base::Passed(std::move(context))));
 }
 
 void CacheStorageCache::WriteSideData(const ErrorCallback& callback,
                                       const GURL& url,
                                       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;
   }
 
   // GetUsageAndQuota is called before entering a scheduled operation since it
   // can call Size, another scheduled operation.
   quota_manager_proxy_->GetUsageAndQuota(
       base::ThreadTaskRunnerHandle::Get().get(), origin_,
       storage::kStorageTypeTemporary,
       base::Bind(&CacheStorageCache::WriteSideDataDidGetQuota,
                  weak_ptr_factory_.GetWeakPtr(), callback, url,
                  expected_response_time, buffer, buf_len));
 }
 
 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;
   }
 
   // Estimate the required size of the put operations. The size of the deletes
   // is unknown and not considered.
   int64_t space_required = 0;
   for (const auto& operation : operations) {
     if (operation.operation_type == CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT) {
@@ skipping 79 matching lines @@
 }
 
 void CacheStorageCache::BatchDidAllOperations(
     std::unique_ptr<ErrorCallback> callback) {
   if (callback->is_null())
     return;
   callback->Run(CACHE_STORAGE_OK);
 }
 
 void CacheStorageCache::Keys(const RequestsCallback& callback) {
-  if (!LazyInitialize()) {
+  if (backend_state_ == BACKEND_CLOSED) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Requests>());
     return;
   }
 
   RequestsCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingRequestsCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::KeysImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            pending_callback));
 }
 
 void CacheStorageCache::Close(const base::Closure& callback) {
   DCHECK_NE(BACKEND_CLOSED, backend_state_)
       << "Was CacheStorageCache::Close() called twice?";
 
   base::Closure pending_callback =
       base::Bind(&CacheStorageCache::PendingClosure,
                  weak_ptr_factory_.GetWeakPtr(), callback);
 
   scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::CloseImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            pending_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));
     return;
   }
 
   SizeCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingSizeCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
 
   scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::SizeImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            pending_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;
   }
 
   SizeCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingSizeCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
 
   scheduler_->ScheduleOperation(
@@ skipping 23 matching lines @@
       blob_storage_context_(blob_context),
       scheduler_(new CacheStorageScheduler()),
       memory_only_(path.empty()),
       weak_ptr_factory_(this) {
   DCHECK(!origin_.is_empty());
   DCHECK(quota_manager_proxy_.get());
 
   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);
   entries_context->backend_iterator = backend_->CreateIterator();
   disk_cache::Backend::Iterator& iterator = *entries_context->backend_iterator;
   disk_cache::Entry** enumerated_entry = &entries_context->enumerated_entry;
 
   net::CompletionCallback open_entry_callback = base::Bind(
       &CacheStorageCache::DidOpenNextEntry, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(std::move(entries_context)), callback);
@@ skipping 835 matching lines @@
     callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   backend_ = std::move(*backend_ptr);
   callback.Run(CACHE_STORAGE_OK);
 }
 
 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;
   backend_state_ = (cache_create_error == CACHE_STORAGE_OK && backend_ &&
                     backend_state_ == BACKEND_UNINITIALIZED)
                        ? BACKEND_OPEN
                        : BACKEND_CLOSED;
 
   UMA_HISTOGRAM_ENUMERATION("ServiceWorkerCache.InitBackendResult",
                             cache_create_error, CACHE_STORAGE_ERROR_LAST + 1);
 
-  scheduler_->CompleteOperationAndRunNext();
+  callback.Run();
 }
 
 void CacheStorageCache::PendingClosure(const base::Closure& callback) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run();
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
@@ skipping 89 matching lines @@
       temp_entry, INDEX_RESPONSE_BODY, INDEX_SIDE_DATA);
   return blob_storage_context_->AddFinishedBlob(&blob_data);
 }
 
 std::unique_ptr<CacheStorageCacheHandle>
 CacheStorageCache::CreateCacheHandle() {
   return cache_storage_->CreateCacheHandle(this);
 }
 
 }  // namespace content