Guarantees ServiceWorkerCacheStorage callbacks are called.

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"
@@ skipping 426 matching lines @@
   }
 
   if (GetLoadedCache(cache_name)) {
     callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_EXISTS);
     return;
   }
 
   cache_loader_->CreateCache(
       cache_name,
       base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidCreateCache,
-                 weak_factory_.GetWeakPtr(),
                  cache_name,
-                 callback));
+                 callback,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerCacheStorage::GetCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::GetCache,
                         weak_factory_.GetWeakPtr(),
@@ skipping 12 matching lines @@
     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));
 }
 
 void ServiceWorkerCacheStorage::HasCache(const std::string& cache_name,
                                          const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
@@ skipping 39 matching lines @@
   }
 
   name_map_.erase(cache_name);
   cache_map_.erase(cache_context->id);
   cache_context.reset();
 
   // Update the Index
   cache_loader_->WriteIndex(
       cache_map_,
       base::Bind(&ServiceWorkerCacheStorage::DeleteCacheDidWriteIndex,
-                 weak_factory_.GetWeakPtr(),
                  cache_name,
-                 callback));
+                 callback,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerCacheStorage::EnumerateCaches(
     const StringsAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::EnumerateCaches,
                         weak_factory_.GetWeakPtr(),
                         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.Run(names, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
+// static
 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.
@@ skipping 111 matching lines @@
     scoped_ptr<ServiceWorkerCache> cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   CacheID id = next_cache_id_++;
   CacheContext* cache_context = new CacheContext(cache_name, id, cache.Pass());
   cache_map_.insert(std::make_pair(id, cache_context));  // Takes ownership
   name_map_.insert(std::make_pair(cache_name, id));
   return cache_context;
 }
 
+// static
 void ServiceWorkerCacheStorage::CreateCacheDidCreateCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback,
+    base::WeakPtr<ServiceWorkerCacheStorage> storage,
     scoped_ptr<ServiceWorkerCache> cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  if (!cache) {
+  if (!cache || !storage) {
     callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_CLOSING);
     return;
   }
 
-  CacheContext* cache_context = AddCacheToMaps(cache_name, cache.Pass());
+  CacheContext* cache_context =
+      storage->AddCacheToMaps(cache_name, cache.Pass());
 
-  cache_loader_->WriteIndex(
-      cache_map_,
+  storage->cache_loader_->WriteIndex(
+      storage->cache_map_,
       base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidWriteIndex,
-                 weak_factory_.GetWeakPtr(),
                  callback,
                  cache_context->cache->AsWeakPtr(),
                  cache_context->id));
 }
 
+// static
 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);
     return;
   }
 
   cache->CreateBackend(base::Bind(&ServiceWorkerCacheStorage::DidCreateBackend,
-                                  weak_factory_.GetWeakPtr(),
                                   cache,
                                   id,
                                   callback));
 }
 
+// static
 void ServiceWorkerCacheStorage::DeleteCacheDidWriteIndex(
     const std::string& cache_name,
     const BoolAndErrorCallback& callback,
+    base::WeakPtr<ServiceWorkerCacheStorage> storage,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  cache_loader_->CleanUpDeletedCache(
+  if (!storage)
+    return callback.Run(false, CACHE_STORAGE_ERROR_CLOSING);
+
+  storage->cache_loader_->CleanUpDeletedCache(
       cache_name,
-      base::Bind(&ServiceWorkerCacheStorage::DeleteCacheDidCleanUp,
-                 weak_factory_.GetWeakPtr(),
-                 callback));
+      base::Bind(&ServiceWorkerCacheStorage::DeleteCacheDidCleanUp, callback));
 }
 
+// static
 void ServiceWorkerCacheStorage::DeleteCacheDidCleanUp(
     const BoolAndErrorCallback& callback,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   callback.Run(true, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 ServiceWorkerCacheStorage::CacheContext*
 ServiceWorkerCacheStorage::GetLoadedCache(const std::string& cache_name) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
   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