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

content/browser/cache_storage/cache_storage_cache.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_cache.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 312 matching lines @@
 void CacheStorageCache::Match(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const ResponseCallback& callback) {
   if (backend_state_ == BACKEND_CLOSED) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                  std::unique_ptr<ServiceWorkerResponse>(),
                  std::unique_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  ResponseCallback pending_callback =
-      base::Bind(&CacheStorageCache::PendingResponseCallback,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(std::move(request)), pending_callback));
+                 base::Passed(std::move(request)),
+                 scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorageCache::MatchAll(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& match_params,
     const ResponsesCallback& callback) {
   if (backend_state_ == BACKEND_CLOSED) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Responses>(),
                  std::unique_ptr<BlobDataHandles>());
     return;
   }
 
-  ResponsesCallback pending_callback =
-      base::Bind(&CacheStorageCache::PendingResponsesCallback,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
-
   std::unique_ptr<MatchAllContext> context(
-      new MatchAllContext(std::move(request), match_params, pending_callback));
+      new MatchAllContext(std::move(request), match_params,
+                          scheduler_->WrapCallbackToRunNext(callback)));
   scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::MatchAllImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            base::Passed(std::move(context))));
 }
 
 void CacheStorageCache::WriteSideData(const ErrorCallback& callback,
                                       const GURL& url,
                                       base::Time expected_response_time,
                                       scoped_refptr<net::IOBuffer> buffer,
                                       int buf_len) {
@@ skipping 114 matching lines @@
     return;
   callback->Run(CACHE_STORAGE_OK);
 }
 
 void CacheStorageCache::Keys(const RequestsCallback& callback) {
   if (backend_state_ == BACKEND_CLOSED) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Requests>());
     return;
   }
 
-  RequestsCallback pending_callback =
-      base::Bind(&CacheStorageCache::PendingRequestsCallback,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
-  scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::KeysImpl,
-                                           weak_ptr_factory_.GetWeakPtr(),
-                                           pending_callback));
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorageCache::KeysImpl, weak_ptr_factory_.GetWeakPtr(),
+                 scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorageCache::Close(const base::Closure& callback) {
   DCHECK_NE(BACKEND_CLOSED, backend_state_)
       << "Was CacheStorageCache::Close() called twice?";
 
-  base::Closure pending_callback =
-      base::Bind(&CacheStorageCache::PendingClosure,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
-
-  scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::CloseImpl,
-                                           weak_ptr_factory_.GetWeakPtr(),
-                                           pending_callback));
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorageCache::CloseImpl, weak_ptr_factory_.GetWeakPtr(),
+                 scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorageCache::Size(const SizeCallback& callback) {
   if (backend_state_ == BACKEND_CLOSED) {
     // TODO(jkarlin): Delete caches that can't be initialized.
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, 0));
     return;
   }
 
-  SizeCallback pending_callback =
-      base::Bind(&CacheStorageCache::PendingSizeCallback,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
-
-  scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::SizeImpl,
-                                           weak_ptr_factory_.GetWeakPtr(),
-                                           pending_callback));
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorageCache::SizeImpl, weak_ptr_factory_.GetWeakPtr(),
+                 scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorageCache::GetSizeThenClose(const SizeCallback& callback) {
   if (backend_state_ == BACKEND_CLOSED) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, 0));
     return;
   }
 
-  SizeCallback pending_callback =
-      base::Bind(&CacheStorageCache::PendingSizeCallback,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
-
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::SizeImpl, weak_ptr_factory_.GetWeakPtr(),
                  base::Bind(&CacheStorageCache::GetSizeThenCloseDidGetSize,
-                            weak_ptr_factory_.GetWeakPtr(), pending_callback)));
+                            weak_ptr_factory_.GetWeakPtr(),
+                            scheduler_->WrapCallbackToRunNext(callback))));
 }
 
 CacheStorageCache::~CacheStorageCache() {
   quota_manager_proxy_->NotifyOriginNoLongerInUse(origin_);
 }
 
 CacheStorageCache::CacheStorageCache(
     const GURL& origin,
     const std::string& cache_name,
     const base::FilePath& path,
@@ skipping 272 matching lines @@
     int buf_len,
     storage::QuotaStatusCode status_code,
     int64_t usage,
     int64_t quota) {
   if (status_code != storage::kQuotaStatusOk || (buf_len > quota - usage)) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, CACHE_STORAGE_ERROR_QUOTA_EXCEEDED));
     return;
   }
 
-  ErrorCallback pending_callback =
-      base::Bind(&CacheStorageCache::PendingErrorCallback,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
-
   scheduler_->ScheduleOperation(base::Bind(
       &CacheStorageCache::WriteSideDataImpl, weak_ptr_factory_.GetWeakPtr(),
-      pending_callback, url, expected_response_time, buffer, buf_len));
+      scheduler_->WrapCallbackToRunNext(callback), url, expected_response_time,
+      buffer, buf_len));
 }
 
 void CacheStorageCache::WriteSideDataImpl(const ErrorCallback& callback,
                                           const GURL& url,
                                           base::Time expected_response_time,
                                           scoped_refptr<net::IOBuffer> buffer,
                                           int buf_len) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE);
@@ skipping 117 matching lines @@
       return;
     }
   }
 
   UMA_HISTOGRAM_ENUMERATION(
       "ServiceWorkerCache.Cache.AllWritesResponseType",
       operation.response.response_type,
       blink::WebServiceWorkerResponseType::WebServiceWorkerResponseTypeLast +
           1);
 
-  ErrorCallback pending_callback =
-      base::Bind(&CacheStorageCache::PendingErrorCallback,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
-
-  std::unique_ptr<PutContext> put_context(
-      new PutContext(std::move(request), std::move(response),
-                     std::move(blob_data_handle), pending_callback));
+  std::unique_ptr<PutContext> put_context(new PutContext(
+      std::move(request), std::move(response), std::move(blob_data_handle),
+      scheduler_->WrapCallbackToRunNext(callback)));
 
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::PutImpl, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(put_context))));
 }
 
 void CacheStorageCache::PutImpl(std::unique_ptr<PutContext> put_context) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
@@ skipping 193 matching lines @@
   DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
   DCHECK_EQ(CACHE_STORAGE_CACHE_OPERATION_TYPE_DELETE,
             operation.operation_type);
 
   std::unique_ptr<ServiceWorkerFetchRequest> request(
       new ServiceWorkerFetchRequest(
           operation.request.url, operation.request.method,
           operation.request.headers, operation.request.referrer,
           operation.request.is_reload));
 
-  ErrorCallback pending_callback =
-      base::Bind(&CacheStorageCache::PendingErrorCallback,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::DeleteImpl, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(request)), operation.match_params,
-                 pending_callback));
+                 scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorageCache::DeleteImpl(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& match_params,
     const ErrorCallback& callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
@@ skipping 206 matching lines @@
   backend_ = std::move(*backend_ptr);
   callback.Run(CACHE_STORAGE_OK);
 }
 
 void CacheStorageCache::InitBackend() {
   DCHECK_EQ(BACKEND_UNINITIALIZED, backend_state_);
   DCHECK(!initializing_);
   DCHECK(!scheduler_->ScheduledOperations());
   initializing_ = true;
 
-  base::Closure pending_callback =
-      base::Bind(&CacheStorageCache::PendingClosure,
-                 weak_ptr_factory_.GetWeakPtr(), base::Bind(&base::DoNothing));
-
   scheduler_->ScheduleOperation(base::Bind(
       &CacheStorageCache::CreateBackend, weak_ptr_factory_.GetWeakPtr(),
-      base::Bind(&CacheStorageCache::InitDidCreateBackend,
-                 weak_ptr_factory_.GetWeakPtr(), pending_callback)));
+      base::Bind(
+          &CacheStorageCache::InitDidCreateBackend,
+          weak_ptr_factory_.GetWeakPtr(),
+          scheduler_->WrapCallbackToRunNext(base::Bind(&base::DoNothing)))));
 }
 
 void CacheStorageCache::InitDidCreateBackend(
     const base::Closure& callback,
     CacheStorageError cache_create_error) {
   if (cache_create_error != CACHE_STORAGE_OK) {
     InitGotCacheSize(callback, cache_create_error, 0);
     return;
   }
 
@@ skipping 14 matching lines @@
                     backend_state_ == BACKEND_UNINITIALIZED)
                        ? BACKEND_OPEN
                        : BACKEND_CLOSED;
 
   UMA_HISTOGRAM_ENUMERATION("ServiceWorkerCache.InitBackendResult",
                             cache_create_error, CACHE_STORAGE_ERROR_LAST + 1);
 
   callback.Run();
 }
 
-void CacheStorageCache::PendingClosure(const base::Closure& callback) {
-  base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
-
-  callback.Run();
-  if (cache)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
-void CacheStorageCache::PendingErrorCallback(const ErrorCallback& callback,
-                                             CacheStorageError error) {
-  base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
-
-  callback.Run(error);
-  if (cache)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
-void CacheStorageCache::PendingResponseCallback(
-    const ResponseCallback& callback,
-    CacheStorageError error,
-    std::unique_ptr<ServiceWorkerResponse> response,
-    std::unique_ptr<storage::BlobDataHandle> blob_data_handle) {
-  base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
-
-  callback.Run(error, std::move(response), std::move(blob_data_handle));
-  if (cache)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
-void CacheStorageCache::PendingResponsesCallback(
-    const ResponsesCallback& callback,
-    CacheStorageError error,
-    std::unique_ptr<Responses> responses,
-    std::unique_ptr<BlobDataHandles> blob_data_handles) {
-  base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
-
-  callback.Run(error, std::move(responses), std::move(blob_data_handles));
-  if (cache)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
-void CacheStorageCache::PendingRequestsCallback(
-    const RequestsCallback& callback,
-    CacheStorageError error,
-    std::unique_ptr<Requests> requests) {
-  base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
-
-  callback.Run(error, std::move(requests));
-  if (cache)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
-void CacheStorageCache::PendingSizeCallback(const SizeCallback& callback,
-                                            int64_t size) {
-  base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
-
-  callback.Run(size);
-  if (cache)
-    scheduler_->CompleteOperationAndRunNext();
-}
-
 void CacheStorageCache::PopulateResponseMetadata(
     const CacheMetadata& metadata,
     ServiceWorkerResponse* response) {
   *response = ServiceWorkerResponse(
       GURL(metadata.response().url()), metadata.response().status_code(),
       metadata.response().status_text(),
       ProtoResponseTypeToWebResponseType(metadata.response().response_type()),
       ServiceWorkerHeaderMap(), "", 0, GURL(),
       blink::WebServiceWorkerResponseErrorUnknown,
       base::Time::FromInternalValue(metadata.response().response_time()),
@@ skipping 26 matching lines @@
       temp_entry, INDEX_RESPONSE_BODY, INDEX_SIDE_DATA);
   return blob_storage_context_->AddFinishedBlob(&blob_data);
 }
 
 std::unique_ptr<CacheStorageCacheHandle>
 CacheStorageCache::CreateCacheHandle() {
   return cache_storage_->CreateCacheHandle(this);
 }
 
 }  // namespace content