[CacheStorage] Simpler way to wrap callbacks to run pending operation completions

content/browser/cache_storage/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/cache_storage/cache_storage.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
@@ skipping 503 matching lines @@
                              const CacheAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   quota_manager_proxy_->NotifyStorageAccessed(
       storage::QuotaClient::kServiceWorkerCache, origin_,
       storage::kStorageTypeTemporary);
 
-  CacheAndErrorCallback pending_callback =
-      base::Bind(&CacheStorage::PendingCacheAndErrorCallback,
-                 weak_factory_.GetWeakPtr(), callback);
-  scheduler_->ScheduleOperation(base::Bind(&CacheStorage::OpenCacheImpl,
-                                           weak_factory_.GetWeakPtr(),
-                                           cache_name, pending_callback));
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorage::OpenCacheImpl, weak_factory_.GetWeakPtr(),
+                 cache_name, scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorage::HasCache(const std::string& cache_name,
                             const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   quota_manager_proxy_->NotifyStorageAccessed(
       storage::QuotaClient::kServiceWorkerCache, origin_,
       storage::kStorageTypeTemporary);
 
-  BoolAndErrorCallback pending_callback =
-      base::Bind(&CacheStorage::PendingBoolAndErrorCallback,
-                 weak_factory_.GetWeakPtr(), callback);
-  scheduler_->ScheduleOperation(base::Bind(&CacheStorage::HasCacheImpl,
-                                           weak_factory_.GetWeakPtr(),
-                                           cache_name, pending_callback));
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorage::HasCacheImpl, weak_factory_.GetWeakPtr(),
+                 cache_name, scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorage::DeleteCache(const std::string& cache_name,
                                const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   quota_manager_proxy_->NotifyStorageAccessed(
       storage::QuotaClient::kServiceWorkerCache, origin_,
       storage::kStorageTypeTemporary);
 
-  BoolAndErrorCallback pending_callback =
-      base::Bind(&CacheStorage::PendingBoolAndErrorCallback,
-                 weak_factory_.GetWeakPtr(), callback);
-  scheduler_->ScheduleOperation(base::Bind(&CacheStorage::DeleteCacheImpl,
-                                           weak_factory_.GetWeakPtr(),
-                                           cache_name, pending_callback));
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorage::DeleteCacheImpl, weak_factory_.GetWeakPtr(),
+                 cache_name, scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorage::EnumerateCaches(const StringsAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   quota_manager_proxy_->NotifyStorageAccessed(
       storage::QuotaClient::kServiceWorkerCache, origin_,
       storage::kStorageTypeTemporary);
 
-  StringsAndErrorCallback pending_callback =
-      base::Bind(&CacheStorage::PendingStringsAndErrorCallback,
-                 weak_factory_.GetWeakPtr(), callback);
-  scheduler_->ScheduleOperation(base::Bind(&CacheStorage::EnumerateCachesImpl,
-                                           weak_factory_.GetWeakPtr(),
-                                           pending_callback));
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorage::EnumerateCachesImpl, weak_factory_.GetWeakPtr(),
+                 scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorage::MatchCache(
     const std::string& cache_name,
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ResponseCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   quota_manager_proxy_->NotifyStorageAccessed(
       storage::QuotaClient::kServiceWorkerCache, origin_,
       storage::kStorageTypeTemporary);
 
-  CacheStorageCache::ResponseCallback pending_callback =
-      base::Bind(&CacheStorage::PendingResponseCallback,
-                 weak_factory_.GetWeakPtr(), callback);
-  scheduler_->ScheduleOperation(base::Bind(
-      &CacheStorage::MatchCacheImpl, weak_factory_.GetWeakPtr(), cache_name,
-      base::Passed(std::move(request)), pending_callback));
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorage::MatchCacheImpl, weak_factory_.GetWeakPtr(),
+                 cache_name, base::Passed(std::move(request)),
+                 scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorage::MatchAllCaches(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ResponseCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
   quota_manager_proxy_->NotifyStorageAccessed(
       storage::QuotaClient::kServiceWorkerCache, origin_,
       storage::kStorageTypeTemporary);
 
-  CacheStorageCache::ResponseCallback pending_callback =
-      base::Bind(&CacheStorage::PendingResponseCallback,
-                 weak_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorage::MatchAllCachesImpl, weak_factory_.GetWeakPtr(),
-                 base::Passed(std::move(request)), pending_callback));
+                 base::Passed(std::move(request)),
+                 scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorage::GetSizeThenCloseAllCaches(const SizeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
-  CacheStorageCache::SizeCallback pending_callback = base::Bind(
-      &CacheStorage::PendingSizeCallback, weak_factory_.GetWeakPtr(), callback);
-
-  scheduler_->ScheduleOperation(
-      base::Bind(&CacheStorage::GetSizeThenCloseAllCachesImpl,
-                 weak_factory_.GetWeakPtr(), pending_callback));
+  scheduler_->ScheduleOperation(base::Bind(
+      &CacheStorage::GetSizeThenCloseAllCachesImpl, weak_factory_.GetWeakPtr(),
+      scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorage::Size(const CacheStorage::SizeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_)
     LazyInit();
 
-  CacheStorageCache::SizeCallback pending_callback = base::Bind(
-      &CacheStorage::PendingSizeCallback, weak_factory_.GetWeakPtr(), callback);
-
-  scheduler_->ScheduleOperation(base::Bind(
-      &CacheStorage::SizeImpl, weak_factory_.GetWeakPtr(), pending_callback));
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorage::SizeImpl, weak_factory_.GetWeakPtr(),
+                 scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorage::StartAsyncOperationForTesting() {
   scheduler_->ScheduleOperation(base::Bind(&base::DoNothing));
 }
 
 void CacheStorage::CompleteAsyncOperationForTesting() {
   scheduler_->CompleteOperationAndRunNext();
 }
 
@@ skipping 372 matching lines @@
   for (const std::string& cache_name : ordered_cache_names_) {
     std::unique_ptr<CacheStorageCacheHandle> cache_handle =
         GetLoadedCache(cache_name);
     CacheStorageCache* cache = cache_handle->value();
     cache->Size(base::Bind(&SizeRetrievedFromCache,
                            base::Passed(std::move(cache_handle)),
                            barrier_closure, accumulator_ptr));
   }
 }
 
-void CacheStorage::PendingClosure(const base::Closure& callback) {
-  base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
-
-  callback.Run();
-  if (cache_storage)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
-void CacheStorage::PendingBoolAndErrorCallback(
-    const BoolAndErrorCallback& callback,
-    bool found,
-    CacheStorageError error) {
-  base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
-
-  callback.Run(found, error);
-  if (cache_storage)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
-void CacheStorage::PendingCacheAndErrorCallback(
-    const CacheAndErrorCallback& callback,
-    std::unique_ptr<CacheStorageCacheHandle> cache_handle,
-    CacheStorageError error) {
-  base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
-
-  callback.Run(std::move(cache_handle), error);
-  if (cache_storage)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
-void CacheStorage::PendingStringsAndErrorCallback(
-    const StringsAndErrorCallback& callback,
-    const StringVector& strings,
-    CacheStorageError error) {
-  base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
-
-  callback.Run(strings, error);
-  if (cache_storage)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
-void CacheStorage::PendingResponseCallback(
-    const CacheStorageCache::ResponseCallback& callback,
-    CacheStorageError error,
-    std::unique_ptr<ServiceWorkerResponse> response,
-    std::unique_ptr<storage::BlobDataHandle> blob_data_handle) {
-  base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
-
-  callback.Run(error, std::move(response), std::move(blob_data_handle));
-  if (cache_storage)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
-void CacheStorage::PendingSizeCallback(const SizeCallback& callback,
-                                       int64_t size) {
-  base::WeakPtr<CacheStorage> cache_storage = weak_factory_.GetWeakPtr();
-
-  callback.Run(size);
-  if (cache_storage)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
 }  // namespace content