Move ServiceWorkerCache backend creation to a lazy init function.

content/browser/service_worker/service_worker_cache_storage.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_storage.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
@@ skipping 419 matching lines @@
                         callback));
     return;
   }
 
   CacheContext* cache_context = GetLoadedCache(cache_name);
   if (!cache_context) {
     callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
-  ServiceWorkerCache* cache = cache_context->cache.get();
-
-  if (cache->HasCreatedBackend())
-    return callback.Run(cache_context->id, CACHE_STORAGE_ERROR_NO_ERROR);
-
-  cache->CreateBackend(base::Bind(&ServiceWorkerCacheStorage::DidCreateBackend,
-                                  weak_factory_.GetWeakPtr(),
-                                  cache->AsWeakPtr(),
-                                  cache_context->id,
-                                  callback));
+  callback.Run(cache_context->id, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::HasCache(const std::string& cache_name,
                                          const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::HasCache,
                         weak_factory_.GetWeakPtr(),
                         cache_name,
@@ skipping 51 matching lines @@
 
   std::vector<std::string> names;
   for (NameMap::const_iterator it = name_map_.begin(); it != name_map_.end();
        ++it) {
     names.push_back(it->first);
   }
 
   callback.Run(names, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
-void ServiceWorkerCacheStorage::DidCreateBackend(
-    base::WeakPtr<ServiceWorkerCache> cache,
-    CacheID cache_id,
-    const CacheAndErrorCallback& callback,
-    ServiceWorkerCache::ErrorType error) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (error != ServiceWorkerCache::ErrorTypeOK || !cache) {
-    // TODO(jkarlin): This should delete the directory and try again in case
-    // the cache is simply corrupt.
-    callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_STORAGE);
-    return;
-  }
-
-  callback.Run(cache_id, CACHE_STORAGE_ERROR_NO_ERROR);
-}
-
 // Init is run lazily so that it is called on the proper MessageLoop.
 void ServiceWorkerCacheStorage::LazyInit(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!initialized_);
 
   init_callbacks_.push_back(callback);
 
   // If this isn't the first call to LazyInit then return as the initialization
   // has already started.
   if (init_callbacks_.size() > 1u)
@@ skipping 109 matching lines @@
                  cache_context->id));
 }
 
 void ServiceWorkerCacheStorage::CreateCacheDidWriteIndex(
     const CacheAndErrorCallback& callback,
     base::WeakPtr<ServiceWorkerCache> cache,
     CacheID id,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!cache) {
-    callback.Run(false, CACHE_STORAGE_ERROR_CLOSING);
+    callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_CLOSING);
     return;
   }
 
-  cache->CreateBackend(base::Bind(&ServiceWorkerCacheStorage::DidCreateBackend,
-                                  weak_factory_.GetWeakPtr(),
-                                  cache,
-                                  id,
-                                  callback));
+  callback.Run(id, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::DeleteCacheDidWriteIndex(
     const std::string& cache_name,
     const BoolAndErrorCallback& callback,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   cache_loader_->CleanUpDeletedCache(
       cache_name,
@@ skipping 18 matching lines @@
   NameMap::const_iterator name_iter = name_map_.find(cache_name);
   if (name_iter == name_map_.end())
     return NULL;
 
   CacheMap::const_iterator map_iter = cache_map_.find(name_iter->second);
   DCHECK(map_iter != cache_map_.end());
   return map_iter->second;
 }
 
 }  // namespace content