Move ServiceWorkerCache backend creation to a lazy init function.

content/browser/service_worker/service_worker_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/service_worker/service_worker_cache.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
@@ skipping 632 matching lines @@
       new ServiceWorkerCache(path, request_context, blob_context));
 }
 
 ServiceWorkerCache::~ServiceWorkerCache() {
 }
 
 base::WeakPtr<ServiceWorkerCache> ServiceWorkerCache::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-void ServiceWorkerCache::CreateBackend(const ErrorCallback& callback) {
-  DCHECK(!backend_);
-
-  // Use APP_CACHE as opposed to DISK_CACHE to prevent cache eviction.
-  net::CacheType cache_type =
-      path_.empty() ? net::MEMORY_CACHE : net::APP_CACHE;
-
-  scoped_ptr<ScopedBackendPtr> backend_ptr(new ScopedBackendPtr());
-
-  // Temporary pointer so that backend_ptr can be Pass()'d in Bind below.
-  ScopedBackendPtr* backend = backend_ptr.get();
-
-  net::CompletionCallback create_cache_callback =
-      base::Bind(CreateBackendDidCreate,
-                 callback,
-                 base::Passed(backend_ptr.Pass()),
-                 weak_ptr_factory_.GetWeakPtr());
-
-  // TODO(jkarlin): Use the cache MessageLoopProxy that ServiceWorkerCacheCore
-  // has for disk caches.
-  // TODO(jkarlin): Switch to SimpleCache after it supports APP_CACHE and after
-  // debugging why the QuickStressBody unittest fails with it.
-  int rv = disk_cache::CreateCacheBackend(
-      cache_type,
-      net::CACHE_BACKEND_SIMPLE,
-      path_,
-      kMaxCacheBytes,
-      false, /* force */
-      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE).get(),
-      NULL,
-      backend,
-      create_cache_callback);
-  if (rv != net::ERR_IO_PENDING)
-    create_cache_callback.Run(rv);
-}
-
 void ServiceWorkerCache::Put(scoped_ptr<ServiceWorkerFetchRequest> request,
                              scoped_ptr<ServiceWorkerResponse> response,
                              const ErrorCallback& callback) {
-  DCHECK(backend_);
-
-  scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
-
-  disk_cache::Entry** entry_ptr = entry.get();
-
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
 
   if (!response->blob_uuid.empty()) {
     if (!blob_storage_context_) {
       callback.Run(ErrorTypeStorage);
       return;
     }
     blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(response->blob_uuid);
     if (!blob_data_handle) {
       callback.Run(ErrorTypeStorage);
       return;
     }
   }
 
-  ServiceWorkerFetchRequest* request_ptr = request.get();
+  base::Closure continuation = base::Bind(&ServiceWorkerCache::PutImpl,
+                                          weak_ptr_factory_.GetWeakPtr(),
+                                          base::Passed(request.Pass()),
+                                          base::Passed(response.Pass()),
+                                          base::Passed(blob_data_handle.Pass()),
+                                          callback);
 
-  net::CompletionCallback create_entry_callback =
-      base::Bind(PutDidCreateEntry,
-                 base::Passed(request.Pass()),
-                 base::Passed(response.Pass()),
-                 callback,
-                 base::Passed(entry.Pass()),
-                 base::Passed(blob_data_handle.Pass()),
-                 request_context_);
+  if (!initialized_) {
+    Init(continuation);
+    return;
+  }
 
-  int rv = backend_->CreateEntry(
-      request_ptr->url.spec(), entry_ptr, create_entry_callback);
-
-  if (rv != net::ERR_IO_PENDING)
-    create_entry_callback.Run(rv);
+  continuation.Run();
 }
 
 void ServiceWorkerCache::Match(scoped_ptr<ServiceWorkerFetchRequest> request,
                                const ResponseCallback& callback) {
-  DCHECK(backend_);
+  if (!initialized_) {
+    Init(base::Bind(&ServiceWorkerCache::Match,
+                    weak_ptr_factory_.GetWeakPtr(),
+                    base::Passed(request.Pass()),
+                    callback));
+    return;
+  }
+  if (!backend_) {
+    callback.Run(ErrorTypeStorage,
+                 scoped_ptr<ServiceWorkerResponse>(),
+                 scoped_ptr<storage::BlobDataHandle>());
+    return;
+  }
 
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
   disk_cache::Entry** entry_ptr = entry.get();
 
   ServiceWorkerFetchRequest* request_ptr = request.get();
 
   net::CompletionCallback open_entry_callback =
       base::Bind(MatchDidOpenEntry,
                  base::Passed(request.Pass()),
                  callback,
                  blob_storage_context_,
                  base::Passed(entry.Pass()));
 
   int rv = backend_->OpenEntry(
       request_ptr->url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void ServiceWorkerCache::Delete(scoped_ptr<ServiceWorkerFetchRequest> request,
                                 const ErrorCallback& callback) {
-  DCHECK(backend_);
+  if (!initialized_) {
+    Init(base::Bind(&ServiceWorkerCache::Delete,
+                    weak_ptr_factory_.GetWeakPtr(),
+                    base::Passed(request.Pass()),
+                    callback));
+    return;
+  }
+  if (!backend_) {
+    callback.Run(ErrorTypeStorage);
+    return;
+  }
 
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
   disk_cache::Entry** entry_ptr = entry.get();
 
   ServiceWorkerFetchRequest* request_ptr = request.get();
 
   net::CompletionCallback open_entry_callback =
       base::Bind(DeleteDidOpenEntry,
                  base::Passed(request.Pass()),
                  callback,
                  base::Passed(entry.Pass()));
 
   int rv = backend_->OpenEntry(
       request_ptr->url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void ServiceWorkerCache::Keys(const RequestsCallback& callback) {
-  DCHECK(backend_);
+  if (!initialized_) {
+    Init(base::Bind(
+        &ServiceWorkerCache::Keys, weak_ptr_factory_.GetWeakPtr(), callback));
+    return;
+  }
+  if (!backend_) {
+    callback.Run(ErrorTypeStorage, scoped_ptr<Requests>());
+    return;
+  }
 
   // 1. Iterate through all of the entries, open them, and add them to a vector.
   // 2. For each open entry:
   //  2.1. Read the headers into a protobuf.
   //  2.2. Copy the protobuf into a ServiceWorkerFetchRequest (a "key").
   //  2.3. Push the response into a vector of requests to be returned.
   // 3. Return the vector of requests (keys).
 
   // The entries have to be loaded into a vector first because enumeration loops
   // forever if you read data from a cache entry while enumerating.
 
   scoped_ptr<KeysContext> keys_context(
       new KeysContext(callback, weak_ptr_factory_.GetWeakPtr()));
 
   void** backend_iterator = &keys_context->backend_iterator;
   disk_cache::Entry** enumerated_entry = &keys_context->enumerated_entry;
 
   net::CompletionCallback open_entry_callback =
       base::Bind(KeysDidOpenNextEntry, base::Passed(keys_context.Pass()));
 
   int rv = backend_->OpenNextEntry(
       backend_iterator, enumerated_entry, open_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
-bool ServiceWorkerCache::HasCreatedBackend() const {
-  return backend_;
-}
-
 ServiceWorkerCache::ServiceWorkerCache(
     const base::FilePath& path,
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context)
     : path_(path),
       request_context_(request_context),
       blob_storage_context_(blob_context),
+      initialized_(false),
       weak_ptr_factory_(this) {
 }
 
+void ServiceWorkerCache::PutImpl(
+    scoped_ptr<ServiceWorkerFetchRequest> request,
+    scoped_ptr<ServiceWorkerResponse> response,
+    scoped_ptr<storage::BlobDataHandle> blob_data_handle,
+    const ErrorCallback& callback) {
+  if (!backend_) {
+    callback.Run(ErrorTypeStorage);
+    return;
+  }
+
+  scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
+
+  disk_cache::Entry** entry_ptr = entry.get();
+
+  ServiceWorkerFetchRequest* request_ptr = request.get();
+
+  net::CompletionCallback create_entry_callback =
+      base::Bind(PutDidCreateEntry,
+                 base::Passed(request.Pass()),
+                 base::Passed(response.Pass()),
+                 callback,
+                 base::Passed(entry.Pass()),
+                 base::Passed(blob_data_handle.Pass()),
+                 request_context_);
+
+  int rv = backend_->CreateEntry(
+      request_ptr->url.spec(), entry_ptr, create_entry_callback);
+
+  if (rv != net::ERR_IO_PENDING)
+    create_entry_callback.Run(rv);
+}
+
 // static
 void ServiceWorkerCache::KeysDidOpenNextEntry(
     scoped_ptr<KeysContext> keys_context,
     int rv) {
   if (rv == net::ERR_FAILED) {
     DCHECK(!keys_context->enumerated_entry);
     // Enumeration is complete, extract the requests from the entries.
     Entries::iterator iter = keys_context->entries.begin();
     KeysProcessNextEntry(keys_context.Pass(), iter);
     return;
@@ skipping 63 matching lines @@
           headers->request_headers(i);
       req_headers.insert(std::make_pair(header.name(), header.value()));
     }
   } else {
     entry->Doom();
   }
 
   KeysProcessNextEntry(keys_context.Pass(), iter + 1);
 }
 
+void ServiceWorkerCache::CreateBackend(const ErrorCallback& callback) {
+  DCHECK(!backend_);
+
+  // Use APP_CACHE as opposed to DISK_CACHE to prevent cache eviction.
+  net::CacheType cache_type =
+      path_.empty() ? net::MEMORY_CACHE : net::APP_CACHE;
+
+  scoped_ptr<ScopedBackendPtr> backend_ptr(new ScopedBackendPtr());
+
+  // Temporary pointer so that backend_ptr can be Pass()'d in Bind below.
+  ScopedBackendPtr* backend = backend_ptr.get();
+
+  net::CompletionCallback create_cache_callback =
+      base::Bind(CreateBackendDidCreate,
+                 callback,
+                 base::Passed(backend_ptr.Pass()),
+                 weak_ptr_factory_.GetWeakPtr());
+
+  // TODO(jkarlin): Use the cache MessageLoopProxy that ServiceWorkerCacheCore
+  // has for disk caches.
+  int rv = disk_cache::CreateCacheBackend(
+      cache_type,
+      net::CACHE_BACKEND_SIMPLE,
+      path_,
+      kMaxCacheBytes,
+      false, /* force */
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE).get(),
+      NULL,
+      backend,
+      create_cache_callback);
+  if (rv != net::ERR_IO_PENDING)
+    create_cache_callback.Run(rv);
+}
+
+void ServiceWorkerCache::Init(const base::Closure& callback) {
+  init_callbacks_.push_back(callback);
+
+  // If this isn't the first call to Init then return as the initialization
+  // has already started.
+  if (init_callbacks_.size() > 1u)
+    return;
+
+  CreateBackend(base::Bind(&ServiceWorkerCache::InitDone,
+                           weak_ptr_factory_.GetWeakPtr()));
+}
+
+void ServiceWorkerCache::InitDone(ErrorType error) {
+  initialized_ = true;
+  for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
+       it != init_callbacks_.end();
+       ++it) {
+    it->Run();
+  }
+  init_callbacks_.clear();
+}
+
 }  // namespace content