Change threading in ServiceWorkerCacheStorage

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/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/sha1.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "content/browser/service_worker/service_worker_cache.h"
 #include "content/browser/service_worker/service_worker_cache.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/directory_lister.h"
+#include "net/base/net_errors.h"
 
 namespace content {
 
 // Handles the loading and clean up of ServiceWorkerCache objects.
 class ServiceWorkerCacheStorage::CacheLoader {
  public:
+  typedef base::Callback<void(ServiceWorkerCache*)> CacheCallback;
+  typedef base::Callback<void(bool)> BoolCallback;
+  typedef base::Callback<void(scoped_ptr<std::vector<std::string> >)>
+      StringsCallback;
+
+  explicit CacheLoader(base::SequencedTaskRunner* cache_task_runner)
+      : cache_task_runner_(cache_task_runner) {}
+
   virtual ~CacheLoader() {};
-  virtual ServiceWorkerCache* LoadCache(const std::string& cache_name) = 0;
-  // Creates a new cache, deleting any pre-existing cache of the same name.
-  virtual ServiceWorkerCache* CreateCache(const std::string& cache_name) = 0;
-  virtual bool CleanUpDeletedCache(const std::string& key) = 0;
-  virtual bool WriteIndex(CacheMap* caches) = 0;
-  virtual void LoadIndex(std::vector<std::string>* cache_names) = 0;
+
+  // Loads the given cache_name, the cache is NULL if it fails. If the cache
+  // doesn't exist a new one is created.
+  virtual void LoadCache(const std::string& cache_name,
+                         const CacheCallback& callback) = 0;
+
+  // Deletes any pre-existing cache of the same name and then loads it.
+  virtual void CreateCache(const std::string& cache_name,
+                           const CacheCallback& callback) = 0;
+
+  // After the backend has been deleted, do any extra house keeping such as
+  // removing the cache's directory.
+  virtual void CleanUpDeletedCache(const std::string& key,
+                                   const BoolCallback& callback) = 0;
+
+  // Writes the cache names to disk if applicable.
+  virtual void WriteIndex(CacheMap* caches, const BoolCallback& callback) = 0;
+
+  // Loads the cache names from disk if applicable.
+  virtual void LoadIndex(scoped_ptr<std::vector<std::string> > cache_names,
+                         const StringsCallback& callback) = 0;
+
+ protected:
+  virtual void LoadCacheImpl(const std::string&) {}
+  scoped_refptr<base::SequencedTaskRunner> cache_task_runner_;
 };
 
 class ServiceWorkerCacheStorage::MemoryLoader
     : public ServiceWorkerCacheStorage::CacheLoader {
  public:
-  virtual content::ServiceWorkerCache* LoadCache(
-      const std::string& cache_name) OVERRIDE {
+  explicit MemoryLoader(base::SequencedTaskRunner* cache_task_runner)
+      : CacheLoader(cache_task_runner) {}
+  virtual void LoadCache(const std::string& cache_name,
+                         const CacheCallback& callback) OVERRIDE {
     NOTREACHED();
-    return NULL;
-  }
-
-  virtual ServiceWorkerCache* CreateCache(
-      const std::string& cache_name) OVERRIDE {
-    return ServiceWorkerCache::CreateMemoryCache(cache_name);
-  }
-
-  virtual bool CleanUpDeletedCache(const std::string& cache_name) OVERRIDE {
-    return true;
-  }
-
-  virtual bool WriteIndex(CacheMap* caches) OVERRIDE { return false; }
-
-  virtual void LoadIndex(std::vector<std::string>* cache_names) OVERRIDE {
-    return;
+  }
+
+  virtual void CreateCache(const std::string& cache_name,
+                           const CacheCallback& callback) OVERRIDE {
+    ServiceWorkerCache* cache =
+        ServiceWorkerCache::CreateMemoryCache(cache_name);
+    callback.Run(cache);
+  }
+
+  virtual void CleanUpDeletedCache(const std::string& cache_name,
+                                   const BoolCallback& callback) OVERRIDE {
+    callback.Run(true);
+  }
+
+  virtual void WriteIndex(CacheMap* caches,
+                          const BoolCallback& callback) OVERRIDE {
+    callback.Run(false);
+  }
+
+  virtual void LoadIndex(scoped_ptr<std::vector<std::string> > cache_names,
+                         const StringsCallback& callback) OVERRIDE {
+    callback.Run(cache_names.Pass());
   }
 };
 
 class ServiceWorkerCacheStorage::SimpleCacheLoader
     : public ServiceWorkerCacheStorage::CacheLoader {
  public:
-  explicit SimpleCacheLoader(const base::FilePath& origin_path)
-      : origin_path_(origin_path) {}
-
-  virtual ServiceWorkerCache* LoadCache(
-      const std::string& cache_name) OVERRIDE {
-    base::CreateDirectory(CreatePersistentCachePath(origin_path_, cache_name));
-    return ServiceWorkerCache::CreatePersistentCache(
+  SimpleCacheLoader(const base::FilePath& origin_path,
+                    base::SequencedTaskRunner* cache_task_runner)
+      : CacheLoader(cache_task_runner), origin_path_(origin_path) {}
+
+  virtual void LoadCache(const std::string& cache_name,
+                         const CacheCallback& callback) OVERRIDE {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
+    // 1. Create the cache's directory if necessary. (LoadCreateDirectory)
+    // 2. Create the cache object. (LoadDidCreateDirectory)
+
+    cache_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&SimpleCacheLoader::LoadCreateDirectoryInPool,
+                   base::Unretained(this),  // should be weak_ptr?

[michaeln, 2014/08/11 19:30:17]

unretained is no good... deriving CacheLoader from RefCountedThreadSafe works
well for this arrangement

[jkarlin, 2014/08/12 14:55:02]

Done.

+                   CreatePersistentCachePath(origin_path_, cache_name),
+                   cache_name,
+                   callback,
+                   base::MessageLoopProxy::current()));
+  }
+
+  void LoadCreateDirectoryInPool(
+      const base::FilePath& path,
+      const std::string& cache_name,
+      const CacheCallback& callback,
+      scoped_refptr<base::MessageLoopProxy> original_loop) {
+    bool rv = base::CreateDirectory(path);
+    original_loop->PostTask(
+        FROM_HERE,
+        base::Bind(&SimpleCacheLoader::LoadDidCreateDirectory,
+                   base::Unretained(this),
+                   cache_name,
+                   callback,
+                   rv));
+  }
+
+  void LoadDidCreateDirectory(const std::string& cache_name,
+                              const CacheCallback& callback,
+                              bool dir_rv) {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
+    if (!dir_rv) {
+      callback.Run(NULL);
+      return;
+    }
+    ServiceWorkerCache* cache = ServiceWorkerCache::CreatePersistentCache(
         CreatePersistentCachePath(origin_path_, cache_name), cache_name);
-  }
-
-  virtual ServiceWorkerCache* CreateCache(
-      const std::string& cache_name) OVERRIDE {
+    callback.Run(cache);
+  }
+
+  virtual void CreateCache(const std::string& cache_name,
+                           const CacheCallback& callback) OVERRIDE {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
+    // 1. Delete the cache's directory if it exists. (CreateDeleteFiles)

[michaeln, 2014/08/11 20:30:14]

(CreateDeleteFiles) s/b (CreateCacheDeleteFilesInPool)

[jkarlin, 2014/08/12 14:55:03]

Done.

+    // 2. Load the cache. (LoadCache)
+
     base::FilePath cache_path =
         CreatePersistentCachePath(origin_path_, cache_name);
-    if (base::PathExists(cache_path))
-      base::DeleteFile(cache_path, /* recursive */ true);
-    return LoadCache(cache_name);
-  }
-
-  virtual bool CleanUpDeletedCache(const std::string& cache_name) OVERRIDE {
-    return base::DeleteFile(CreatePersistentCachePath(origin_path_, cache_name),
-                            true);
-  }
-
-  virtual bool WriteIndex(CacheMap* caches) OVERRIDE {
+
+    cache_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&SimpleCacheLoader::CreateCacheDeleteFilesInPool,
+                   base::Unretained(this),  // should be weak_ptr?
+                   cache_path,
+                   cache_name,
+                   callback,
+                   base::MessageLoopProxy::current()));
+  }
+
+  void CreateCacheDeleteFilesInPool(
+      const base::FilePath& cache_path,
+      const std::string& cache_name,
+      const CacheCallback& callback,
+      scoped_refptr<base::MessageLoopProxy> original_loop) {

[michaeln, 2014/08/11 20:30:14]

maybe add DCHECKS for cache_task_runner_.RunTasksOnCurrentThread() in methods
that are supposed to be executed there

[jkarlin, 2014/08/12 14:55:03]

Great idea, thanks!

+    base::FilePath path(cache_path);
+    if (base::PathExists(path))
+      base::DeleteFile(path, /* recursive */ true);
+    original_loop->PostTask(FROM_HERE,
+                            base::Bind(&SimpleCacheLoader::LoadCache,

[michaeln, 2014/08/11 20:30:14]

This operation take multiple hops to the cache_thread and back again and some
take only one. If all took exactly one, that might help reason about the
consistency of things and the ordering of operations and when things really
stick.

In this case, i think it could be done in one task on the cache thread, more or
less by calling LoadCreateDirectoryInPool() directly here.

[jkarlin, 2014/08/12 14:55:03]

Done.

+                                       base::Unretained(this),
+                                       cache_name,
+                                       callback));
+  }
+
+  virtual void CleanUpDeletedCache(const std::string& cache_name,
+                                   const BoolCallback& callback) OVERRIDE {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
+    // 1. Delete the cache's directory. (CleanUpDeleteCacheDir)
+
+    base::FilePath cache_path =
+        CreatePersistentCachePath(origin_path_, cache_name);
+    cache_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&SimpleCacheLoader::CleanUpDeleteCacheDirInPool,
+                   base::Unretained(this),
+                   cache_path,
+                   callback,
+                   base::MessageLoopProxy::current()));
+  }
+
+  void CleanUpDeleteCacheDirInPool(
+      const base::FilePath& cache_path,
+      const BoolCallback& callback,
+      scoped_refptr<base::MessageLoopProxy> original_loop) {

[michaeln, 2014/08/11 20:30:14]

can these be const refs (or a rawptr) to the MessageLoopProxy instead of pass by
value

[jkarlin, 2014/08/12 14:55:02]

Thanks! Done.

+    bool rv = base::DeleteFile(cache_path, true);
+    original_loop->PostTask(FROM_HERE, base::Bind(callback, rv));
+  }
+
+  virtual void WriteIndex(CacheMap* caches,
+                          const BoolCallback& callback) OVERRIDE {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
+    // 1. Create the index file as a string. (WriteIndex)
+    // 2. Write the file to disk. (WriteIndexWriteToFile)
+
     ServiceWorkerCacheStorageIndex index;
 
     for (CacheMap::const_iterator iter(caches); !iter.IsAtEnd();
          iter.Advance()) {
       const ServiceWorkerCache* cache = iter.GetCurrentValue();
       ServiceWorkerCacheStorageIndex::Cache* index_cache = index.add_cache();
       index_cache->set_name(cache->name());
       index_cache->set_size(0);  // TODO(jkarlin): Make this real.
     }
 
     std::string serialized;
     bool success = index.SerializeToString(&serialized);
     DCHECK(success);
 
     base::FilePath tmp_path = origin_path_.AppendASCII("index.txt.tmp");
     base::FilePath index_path = origin_path_.AppendASCII("index.txt");
 
-    int bytes_written =
-        base::WriteFile(tmp_path, serialized.c_str(), serialized.size());
-    if (bytes_written != implicit_cast<int>(serialized.size())) {
+    cache_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&SimpleCacheLoader::WriteIndexWriteToFileInPool,
+                   base::Unretained(this),  // should be weak?
+                   tmp_path,
+                   index_path,
+                   serialized,
+                   caches,
+                   callback,
+                   base::MessageLoopProxy::current()));
+  }
+
+  void WriteIndexWriteToFileInPool(
+      const base::FilePath& tmp_path,
+      const base::FilePath& index_path,
+      const std::string& data,
+      CacheMap* caches,
+      const BoolCallback& callback,
+      scoped_refptr<base::MessageLoopProxy> original_loop) {
+    int bytes_written = base::WriteFile(tmp_path, data.c_str(), data.size());
+    if (bytes_written != implicit_cast<int>(data.size())) {
       base::DeleteFile(tmp_path, /* recursive */ false);
-      return false;
+      original_loop->PostTask(FROM_HERE, base::Bind(callback, false));
     }
 
     // Atomically rename the temporary index file to become the real one.
-    return base::ReplaceFile(tmp_path, index_path, NULL);
+    bool rv = base::ReplaceFile(tmp_path, index_path, NULL);
+    original_loop->PostTask(FROM_HERE, base::Bind(callback, rv));
   }
 
-  virtual void LoadIndex(std::vector<std::string>* names) OVERRIDE {
+  virtual void LoadIndex(scoped_ptr<std::vector<std::string> > names,
+                         const StringsCallback& callback) OVERRIDE {
+    DCHECK(thread_checker_.CalledOnValidThread());
+
+    // 1. Read the file from disk. (LoadIndexReadFile)
+    // 2. Parse file and return the names of the caches (LoadIndexDidReadFile)
+
     base::FilePath index_path = origin_path_.AppendASCII("index.txt");
 
-    std::string serialized;
-    if (!base::ReadFileToString(index_path, &serialized))
-      return;
+    cache_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&SimpleCacheLoader::LoadIndexReadFileInPool,
+                   base::Unretained(this),
+                   index_path,
+                   base::Passed(names.Pass()),
+                   callback,
+                   base::MessageLoopProxy::current()));
+  }
+
+  void LoadIndexReadFileInPool(
+      const base::FilePath& index_path,
+      scoped_ptr<std::vector<std::string> > names,
+      const StringsCallback& callback,
+      scoped_refptr<base::MessageLoopProxy> original_loop) {
+    std::string body;
+    base::ReadFileToString(index_path, &body);
+
+    original_loop->PostTask(FROM_HERE,
+                            base::Bind(&SimpleCacheLoader::LoadIndexDidReadFile,
+                                       base::Unretained(this),
+                                       base::Passed(names.Pass()),
+                                       callback,
+                                       body));
+  }
+
+  void LoadIndexDidReadFile(scoped_ptr<std::vector<std::string> > names,
+                            const StringsCallback& callback,
+                            const std::string& serialized) {
+    DCHECK(thread_checker_.CalledOnValidThread());
 
     ServiceWorkerCacheStorageIndex index;
     index.ParseFromString(serialized);
 
     for (int i = 0, max = index.cache_size(); i < max; ++i) {
       const ServiceWorkerCacheStorageIndex::Cache& cache = index.cache(i);
       names->push_back(cache.name());
     }
 
     // TODO(jkarlin): Delete caches that are in the directory and not returned
     // in LoadIndex.
-    return;
+    callback.Run(names.Pass());
   }
 
  private:
   std::string HexedHash(const std::string& value) {
     std::string value_hash = base::SHA1HashString(value);
     std::string valued_hexed_hash = base::StringToLowerASCII(
         base::HexEncode(value_hash.c_str(), value_hash.length()));
     return valued_hexed_hash;
   }
 
   base::FilePath CreatePersistentCachePath(const base::FilePath& origin_path,
                                            const std::string& cache_name) {
     return origin_path.AppendASCII(HexedHash(cache_name));
   }
 
+  base::ThreadChecker thread_checker_;
   const base::FilePath origin_path_;
 };
 
 ServiceWorkerCacheStorage::ServiceWorkerCacheStorage(
     const base::FilePath& path,
     bool memory_only,
-    const scoped_refptr<base::MessageLoopProxy>& callback_loop)
-    : initialized_(false), origin_path_(path), callback_loop_(callback_loop) {
+    base::SequencedTaskRunner* cache_task_runner)
+    : initialized_(false),
+      origin_path_(path),
+      cache_task_runner_(cache_task_runner) {
   if (memory_only)
-    cache_loader_.reset(new MemoryLoader());
+    cache_loader_.reset(new MemoryLoader(cache_task_runner_));
   else
-    cache_loader_.reset(new SimpleCacheLoader(origin_path_));
+    cache_loader_.reset(
+        new SimpleCacheLoader(origin_path_, cache_task_runner_));
 }
 
 ServiceWorkerCacheStorage::~ServiceWorkerCacheStorage() {
 }
 
 void ServiceWorkerCacheStorage::CreateCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback) {
-  LazyInit();
+  if (!initialized_) {
+    LazyInit(base::Bind(&ServiceWorkerCacheStorage::CreateCache,
+                        base::Unretained(this),
+                        cache_name,
+                        callback));
+    return;
+  }
 
   if (cache_name.empty()) {
-    callback_loop_->PostTask(
-        FROM_HERE, base::Bind(callback, 0, CACHE_STORAGE_ERROR_EMPTY_KEY));
+    callback.Run(0, CACHE_STORAGE_ERROR_EMPTY_KEY);
     return;
   }
 
   if (GetLoadedCache(cache_name)) {
-    callback_loop_->PostTask(
-        FROM_HERE, base::Bind(callback, 0, CACHE_STORAGE_ERROR_EXISTS));
+    callback.Run(0, CACHE_STORAGE_ERROR_EXISTS);
     return;
   }
 
-  ServiceWorkerCache* cache = cache_loader_->CreateCache(cache_name);
-
-  if (!cache) {
-    callback_loop_->PostTask(
-        FROM_HERE, base::Bind(callback, 0, CACHE_STORAGE_ERROR_STORAGE));
-    return;
-  }
-
-  InitCache(cache);
-
-  cache_loader_->WriteIndex(&cache_map_);
-
-  cache->CreateBackend(
-      base::Bind(&ServiceWorkerCacheStorage::InitializeCacheCallback,
+  cache_loader_->CreateCache(
+      cache_name,
+      base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidCreateCache,
                  base::Unretained(this),

[michaeln, 2014/08/11 19:30:17]

use of unretained here and in other callbacks can be problematic, i think having
ServiceWorkerCacheStorage vend weakptrs works well for this particular pattern

[jkarlin, 2014/08/12 14:55:03]

Done.

-                 cache,
+                 cache_name,
                  callback));
 }
 
 void ServiceWorkerCacheStorage::GetCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback) {
-  LazyInit();
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!initialized_) {
+    LazyInit(base::Bind(&ServiceWorkerCacheStorage::GetCache,
+                        base::Unretained(this),
+                        cache_name,
+                        callback));
+    return;
+  }
 
   if (cache_name.empty()) {
-    callback_loop_->PostTask(
-        FROM_HERE, base::Bind(callback, 0, CACHE_STORAGE_ERROR_EMPTY_KEY));
+    callback.Run(0, CACHE_STORAGE_ERROR_EMPTY_KEY);
     return;
   }
 
   ServiceWorkerCache* cache = GetLoadedCache(cache_name);
   if (!cache) {
-    callback_loop_->PostTask(
-        FROM_HERE, base::Bind(callback, 0, CACHE_STORAGE_ERROR_NOT_FOUND));
+    callback.Run(0, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
-  cache->CreateBackend(
-      base::Bind(&ServiceWorkerCacheStorage::InitializeCacheCallback,
-                 base::Unretained(this),
-                 cache,
-                 callback));
+  cache->CreateBackend(base::Bind(&ServiceWorkerCacheStorage::DidCreateBackend,
+                                  base::Unretained(this),
+                                  cache,
+                                  callback));
 }
 
 void ServiceWorkerCacheStorage::HasCache(const std::string& cache_name,
                                          const BoolAndErrorCallback& callback) {
-  LazyInit();
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!initialized_) {
+    LazyInit(base::Bind(&ServiceWorkerCacheStorage::HasCache,
+                        base::Unretained(this),
+                        cache_name,
+                        callback));
+    return;
+  }
 
   if (cache_name.empty()) {
-    callback_loop_->PostTask(
-        FROM_HERE, base::Bind(callback, false, CACHE_STORAGE_ERROR_EMPTY_KEY));
+    callback.Run(false, CACHE_STORAGE_ERROR_EMPTY_KEY);
     return;
   }
 
   bool has_cache = GetLoadedCache(cache_name) != NULL;
 
-  callback_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          callback, has_cache, CACHE_STORAGE_ERROR_NO_ERROR));
+  callback.Run(has_cache, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::DeleteCache(
     const std::string& cache_name,
     const BoolAndErrorCallback& callback) {
-  LazyInit();
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!initialized_) {
+    LazyInit(base::Bind(&ServiceWorkerCacheStorage::DeleteCache,
+                        base::Unretained(this),
+                        cache_name,
+                        callback));
+    return;
+  }
 
   if (cache_name.empty()) {
-    callback_loop_->PostTask(
-        FROM_HERE, base::Bind(callback, false, CACHE_STORAGE_ERROR_EMPTY_KEY));
+    callback.Run(false, CACHE_STORAGE_ERROR_EMPTY_KEY);
     return;
   }
 
   ServiceWorkerCache* cache = GetLoadedCache(cache_name);
   if (!cache) {
-    callback_loop_->PostTask(
-        FROM_HERE, base::Bind(callback, false, CACHE_STORAGE_ERROR_NOT_FOUND));
+    callback.Run(false, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
   name_map_.erase(cache_name);
   cache_map_.Remove(cache->id());  // deletes cache
 
-  cache_loader_->WriteIndex(&cache_map_);  // Update the index.
-
-  cache_loader_->CleanUpDeletedCache(cache_name);
-
-  callback_loop_->PostTask(
-      FROM_HERE, base::Bind(callback, true, CACHE_STORAGE_ERROR_NO_ERROR));
+  // Update the Index
+  cache_loader_->WriteIndex(
+      &cache_map_,
+      base::Bind(&ServiceWorkerCacheStorage::DeleteCacheDidWriteIndex,
+                 base::Unretained(this),
+                 cache_name,
+                 callback));
 }
 
 void ServiceWorkerCacheStorage::EnumerateCaches(
     const StringsAndErrorCallback& callback) {
-  LazyInit();
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!initialized_) {
+    LazyInit(base::Bind(&ServiceWorkerCacheStorage::EnumerateCaches,
+                        base::Unretained(this),
+                        callback));
+    return;
+  }
 
   std::vector<std::string> names;
   for (NameMap::const_iterator it = name_map_.begin(); it != name_map_.end();
        ++it) {
     names.push_back(it->first);
   }
 
-  callback_loop_->PostTask(
-      FROM_HERE, base::Bind(callback, names, CACHE_STORAGE_ERROR_NO_ERROR));
+  callback.Run(names, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
-void ServiceWorkerCacheStorage::InitializeCacheCallback(
+void ServiceWorkerCacheStorage::DidCreateBackend(
     const ServiceWorkerCache* cache,
     const CacheAndErrorCallback& callback,
     bool success) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   if (!success) {
     // TODO(jkarlin): This should delete the directory and try again in case
     // the cache is simply corrupt.
-    callback_loop_->PostTask(
-        FROM_HERE, base::Bind(callback, 0, CACHE_STORAGE_ERROR_STORAGE));
+    callback.Run(0, CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
-  callback_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(callback, cache->id(), CACHE_STORAGE_ERROR_NO_ERROR));
+  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() {
-  if (initialized_)
+void ServiceWorkerCacheStorage::LazyInit(const base::Closure& callback) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  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)
     return;
 
-  std::vector<std::string> indexed_cache_names;
-  cache_loader_->LoadIndex(&indexed_cache_names);
+  // 1. Get the list of cache names (async call)
+  // 2. For each cache name, load the cache (async call)
+  // 3. Once each load is complete, update the map variables.
+  // 4. Call the list of waiting callbacks.
 
-  for (std::vector<std::string>::const_iterator it =
-           indexed_cache_names.begin();
-       it != indexed_cache_names.end();
-       ++it) {
-    ServiceWorkerCache* cache = cache_loader_->LoadCache(*it);
-    InitCache(cache);
-  }
-  initialized_ = true;
+  scoped_ptr<std::vector<std::string> > indexed_cache_names(
+      new std::vector<std::string>());
+
+  cache_loader_->LoadIndex(
+      indexed_cache_names.Pass(),
+      base::Bind(&ServiceWorkerCacheStorage::LazyInitDidLoadIndex,
+                 base::Unretained(this),
+                 callback));
 }
 
-void ServiceWorkerCacheStorage::InitCache(ServiceWorkerCache* cache) {
+void ServiceWorkerCacheStorage::LazyInitDidLoadIndex(
+    const base::Closure& callback,
+    scoped_ptr<std::vector<std::string> > indexed_cache_names) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (indexed_cache_names->empty()) {
+    LazyInitDone();
+    return;
+  }
+
+  std::vector<std::string>::const_iterator iter = indexed_cache_names->begin();
+  std::vector<std::string>::const_iterator iter_next = iter + 1;
+
+  cache_loader_->LoadCache(
+      *iter,
+      base::Bind(&ServiceWorkerCacheStorage::LazyInitIterateAndLoadCacheName,
+                 base::Unretained(this),
+                 callback,
+                 base::Passed(indexed_cache_names.Pass()),
+                 iter_next));
+}
+
+void ServiceWorkerCacheStorage::LazyInitIterateAndLoadCacheName(
+    const base::Closure& callback,
+    scoped_ptr<std::vector<std::string> > indexed_cache_names,
+    std::vector<std::string>::const_iterator iter,
+    ServiceWorkerCache* cache) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (cache)
+    AddCacheToMaps(cache);
+
+  if (iter == indexed_cache_names->end()) {
+    LazyInitDone();
+    return;
+  }
+
+  std::vector<std::string>::const_iterator iter_next = iter + 1;
+  cache_loader_->LoadCache(
+      *iter,
+      base::Bind(&ServiceWorkerCacheStorage::LazyInitIterateAndLoadCacheName,
+                 base::Unretained(this),
+                 callback,
+                 base::Passed(indexed_cache_names.Pass()),
+                 iter_next));
+}
+
+void ServiceWorkerCacheStorage::LazyInitDone() {
+  initialized_ = true;
+  for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
+       it != init_callbacks_.end();
+       ++it) {
+    it->Run();
+  }
+  init_callbacks_.clear();
+}
+
+void ServiceWorkerCacheStorage::AddCacheToMaps(ServiceWorkerCache* cache) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   CacheID id = cache_map_.Add(cache);
   name_map_.insert(std::make_pair(cache->name(), id));
   cache->set_id(id);
 }
 
+void ServiceWorkerCacheStorage::CreateCacheDidCreateCache(
+    const std::string& cache_name,
+    const CacheAndErrorCallback& callback,
+    ServiceWorkerCache* cache) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (!cache) {
+    callback.Run(0, CACHE_STORAGE_ERROR_STORAGE);
+    return;
+  }
+
+  AddCacheToMaps(cache);
+
+  cache_loader_->WriteIndex(
+      &cache_map_,
+      base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidWriteIndex,
+                 base::Unretained(this),
+                 callback,
+                 base::Unretained(cache)));
+}
+
+void ServiceWorkerCacheStorage::CreateCacheDidWriteIndex(
+    const CacheAndErrorCallback& callback,
+    ServiceWorkerCache* cache,
+    bool success) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  cache->CreateBackend(base::Bind(&ServiceWorkerCacheStorage::DidCreateBackend,
+                                  base::Unretained(this),
+                                  cache,
+                                  callback));
+}
+
+void ServiceWorkerCacheStorage::DeleteCacheDidWriteIndex(
+    const std::string& cache_name,
+    const BoolAndErrorCallback& callback,
+    bool success) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  cache_loader_->CleanUpDeletedCache(
+      cache_name,
+      base::Bind(&ServiceWorkerCacheStorage::DeleteCacheDidCleanUp,
+                 base::Unretained(this),
+                 callback));
+}
+
+void ServiceWorkerCacheStorage::DeleteCacheDidCleanUp(
+    const BoolAndErrorCallback& callback,
+    bool success) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  callback.Run(true, CACHE_STORAGE_ERROR_NO_ERROR);
+}
+
 ServiceWorkerCache* ServiceWorkerCacheStorage::GetLoadedCache(
     const std::string& cache_name) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(initialized_);
 
   NameMap::const_iterator it = name_map_.find(cache_name);
   if (it == name_map_.end())
     return NULL;
 
   ServiceWorkerCache* cache = cache_map_.Lookup(it->second);
   DCHECK(cache);
   return cache;
 }
 
 }  // namespace content