Guarantees ServiceWorkerCacheStorage callbacks are called.

content/browser/service_worker/service_worker_cache_storage.cc

Index: content/browser/service_worker/service_worker_cache_storage.cc
diff --git a/content/browser/service_worker/service_worker_cache_storage.cc b/content/browser/service_worker/service_worker_cache_storage.cc
index 734174eb73444c094a7668d57ff5a1e167727000..ab3bc8460341b87ea0fe7b15550d5ba20d2718df 100644
--- a/content/browser/service_worker/service_worker_cache_storage.cc
+++ b/content/browser/service_worker/service_worker_cache_storage.cc
@@ -444,9 +444,9 @@ void ServiceWorkerCacheStorage::CreateCache(
   cache_loader_->CreateCache(
       cache_name,
       base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidCreateCache,
-                 weak_factory_.GetWeakPtr(),
                  cache_name,
-                 callback));
+                 callback,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerCacheStorage::GetCache(
@@ -479,7 +479,6 @@ void ServiceWorkerCacheStorage::GetCache(
     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));
@@ -539,9 +538,9 @@ void ServiceWorkerCacheStorage::DeleteCache(
   cache_loader_->WriteIndex(
       cache_map_,
       base::Bind(&ServiceWorkerCacheStorage::DeleteCacheDidWriteIndex,
-                 weak_factory_.GetWeakPtr(),
                  cache_name,
-                 callback));
+                 callback,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerCacheStorage::EnumerateCaches(
@@ -564,6 +563,7 @@ void ServiceWorkerCacheStorage::EnumerateCaches(
   callback.Run(names, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
+// static
 void ServiceWorkerCacheStorage::DidCreateBackend(
     base::WeakPtr<ServiceWorkerCache> cache,
     CacheID cache_id,
@@ -695,28 +695,31 @@ ServiceWorkerCacheStorage::AddCacheToMaps(
   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,
@@ -729,25 +732,28 @@ void ServiceWorkerCacheStorage::CreateCacheDidWriteIndex(
   }
 
   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) {