CacheStorage: Migrate to BindOnce/OnceCallback/OnceClosure

content/browser/cache_storage/cache_storage_cache.cc

Index: content/browser/cache_storage/cache_storage_cache.cc
diff --git a/content/browser/cache_storage/cache_storage_cache.cc b/content/browser/cache_storage/cache_storage_cache.cc
index a120339b5d9c1bccf7d60979c248d805a032b29f..dcb5f0768262c79e8988ee43c564cbf1c4cb09b1 100644
--- a/content/browser/cache_storage/cache_storage_cache.cc
+++ b/content/browser/cache_storage/cache_storage_cache.cc
@@ -69,8 +69,8 @@ class CacheStorageCacheDataHandle
   DISALLOW_COPY_AND_ASSIGN(CacheStorageCacheDataHandle);
 };
 
-typedef base::Callback<void(std::unique_ptr<proto::CacheMetadata>)>
-    MetadataCallback;
+using MetadataCallback =
+    base::OnceCallback<void(std::unique_ptr<proto::CacheMetadata>)>;
 
 // The maximum size of each cache. Ultimately, cache size
 // is controlled per-origin by the QuotaManager.
@@ -118,9 +118,9 @@ proto::CacheResponse::ResponseType WebResponseTypeToProtoResponseType(
 
 // Copy headers out of a cache entry and into a protobuf. The callback is
 // guaranteed to be run.
-void ReadMetadata(disk_cache::Entry* entry, const MetadataCallback& callback);
+void ReadMetadata(disk_cache::Entry* entry, MetadataCallback callback);
 void ReadMetadataDidReadMetadata(disk_cache::Entry* entry,
-                                 const MetadataCallback& callback,
+                                 MetadataCallback callback,
                                  scoped_refptr<net::IOBufferWithSize> buffer,
                                  int rv);
 
@@ -162,14 +162,15 @@ GURL RemoveQueryParam(const GURL& url) {
   return url.ReplaceComponents(replacements);
 }
 
-void ReadMetadata(disk_cache::Entry* entry, const MetadataCallback& callback) {
+void ReadMetadata(disk_cache::Entry* entry, MetadataCallback callback) {
   DCHECK(entry);
 
   scoped_refptr<net::IOBufferWithSize> buffer(new net::IOBufferWithSize(
       entry->GetDataSize(CacheStorageCache::INDEX_HEADERS)));
 
   net::CompletionCallback read_header_callback =
-      base::Bind(ReadMetadataDidReadMetadata, entry, callback, buffer);
+      base::AdaptCallbackForRepeating(base::BindOnce(
+          ReadMetadataDidReadMetadata, entry, std::move(callback), buffer));
 
   int read_rv =
       entry->ReadData(CacheStorageCache::INDEX_HEADERS, 0, buffer.get(),
@@ -180,11 +181,11 @@ void ReadMetadata(disk_cache::Entry* entry, const MetadataCallback& callback) {
 }
 
 void ReadMetadataDidReadMetadata(disk_cache::Entry* entry,
-                                 const MetadataCallback& callback,
+                                 MetadataCallback callback,
                                  scoped_refptr<net::IOBufferWithSize> buffer,
                                  int rv) {
   if (rv != buffer->size()) {
-    callback.Run(std::unique_ptr<proto::CacheMetadata>());
+    std::move(callback).Run(std::unique_ptr<proto::CacheMetadata>());
     return;
   }
 
@@ -194,11 +195,11 @@ void ReadMetadataDidReadMetadata(disk_cache::Entry* entry,
   std::unique_ptr<proto::CacheMetadata> metadata(new proto::CacheMetadata());
 
   if (!metadata->ParseFromArray(buffer->data(), buffer->size())) {
-    callback.Run(std::unique_ptr<proto::CacheMetadata>());
+    std::move(callback).Run(std::unique_ptr<proto::CacheMetadata>());
     return;
   }
 
-  callback.Run(std::move(metadata));
+  std::move(callback).Run(std::move(metadata));
 }
 
 std::unique_ptr<ServiceWorkerFetchRequest> CreateRequest(
@@ -261,11 +262,11 @@ struct CacheStorageCache::PutContext {
   PutContext(std::unique_ptr<ServiceWorkerFetchRequest> request,
              std::unique_ptr<ServiceWorkerResponse> response,
              std::unique_ptr<storage::BlobDataHandle> blob_data_handle,
-             const CacheStorageCache::ErrorCallback& callback)
+             CacheStorageCache::ErrorCallback callback)
       : request(std::move(request)),
         response(std::move(response)),
         blob_data_handle(std::move(blob_data_handle)),
-        callback(callback) {}
+        callback(std::move(callback)) {}
 
   // Input parameters to the Put function.
   std::unique_ptr<ServiceWorkerFetchRequest> request;
@@ -291,10 +292,10 @@ struct CacheStorageCache::QueryCacheResult {
 struct CacheStorageCache::QueryCacheContext {
   QueryCacheContext(std::unique_ptr<ServiceWorkerFetchRequest> request,
                     const CacheStorageCacheQueryParams& options,
-                    const QueryCacheCallback& callback)
+                    QueryCacheCallback callback)
       : request(std::move(request)),
         options(options),
-        callback(callback),
+        callback(std::move(callback)),
         matches(base::MakeUnique<QueryCacheResults>()) {}
 
   ~QueryCacheContext() {
@@ -367,44 +368,46 @@ base::WeakPtr<CacheStorageCache> CacheStorageCache::AsWeakPtr() {
 void CacheStorageCache::Match(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& match_params,
-    const ResponseCallback& callback) {
+    ResponseCallback callback) {
   if (backend_state_ == BACKEND_CLOSED) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE,
-                 std::unique_ptr<ServiceWorkerResponse>(),
-                 std::unique_ptr<storage::BlobDataHandle>());
+    std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE,
+                            std::unique_ptr<ServiceWorkerResponse>(),
+                            std::unique_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  scheduler_->ScheduleOperation(
-      base::Bind(&CacheStorageCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(std::move(request)), match_params,
-                 scheduler_->WrapCallbackToRunNext(callback)));
+  scheduler_->ScheduleOperation(base::BindOnce(
+      &CacheStorageCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
+      base::Passed(std::move(request)), match_params,
+      scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorageCache::MatchAll(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& match_params,
-    const ResponsesCallback& callback) {
+    ResponsesCallback callback) {
   if (backend_state_ == BACKEND_CLOSED) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Responses>(),
-                 std::unique_ptr<BlobDataHandles>());
+    std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE,
+                            std::unique_ptr<Responses>(),
+                            std::unique_ptr<BlobDataHandles>());
     return;
   }
 
-  scheduler_->ScheduleOperation(base::Bind(
+  scheduler_->ScheduleOperation(base::BindOnce(
       &CacheStorageCache::MatchAllImpl, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(std::move(request)), match_params,
-      scheduler_->WrapCallbackToRunNext(callback)));
+      scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
-void CacheStorageCache::WriteSideData(const ErrorCallback& callback,
+void CacheStorageCache::WriteSideData(ErrorCallback callback,
                                       const GURL& url,
                                       base::Time expected_response_time,
                                       scoped_refptr<net::IOBuffer> buffer,
                                       int buf_len) {
   if (backend_state_ == BACKEND_CLOSED) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, CACHE_STORAGE_ERROR_STORAGE));
+        FROM_HERE,
+        base::BindOnce(std::move(callback), CACHE_STORAGE_ERROR_STORAGE));
     return;
   }
 
@@ -413,17 +416,19 @@ void CacheStorageCache::WriteSideData(const ErrorCallback& callback,
   quota_manager_proxy_->GetUsageAndQuota(
       base::ThreadTaskRunnerHandle::Get().get(), origin_,
       storage::kStorageTypeTemporary,
-      base::Bind(&CacheStorageCache::WriteSideDataDidGetQuota,
-                 weak_ptr_factory_.GetWeakPtr(), callback, url,
-                 expected_response_time, buffer, buf_len));
+      base::AdaptCallbackForRepeating(
+          base::BindOnce(&CacheStorageCache::WriteSideDataDidGetQuota,
+                         weak_ptr_factory_.GetWeakPtr(), std::move(callback),
+                         url, expected_response_time, buffer, buf_len)));
 }
 
 void CacheStorageCache::BatchOperation(
     const std::vector<CacheStorageBatchOperation>& operations,
-    const ErrorCallback& callback) {
+    ErrorCallback callback) {
   if (backend_state_ == BACKEND_CLOSED) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, CACHE_STORAGE_ERROR_STORAGE));
+        FROM_HERE,
+        base::BindOnce(std::move(callback), CACHE_STORAGE_ERROR_STORAGE));
     return;
   }
 
@@ -445,20 +450,21 @@ void CacheStorageCache::BatchOperation(
     quota_manager_proxy_->GetUsageAndQuota(
         base::ThreadTaskRunnerHandle::Get().get(), origin_,
         storage::kStorageTypeTemporary,
-        base::Bind(&CacheStorageCache::BatchDidGetUsageAndQuota,
-                   weak_ptr_factory_.GetWeakPtr(), operations, callback,
-                   space_required));
+        base::AdaptCallbackForRepeating(
+            base::BindOnce(&CacheStorageCache::BatchDidGetUsageAndQuota,
+                           weak_ptr_factory_.GetWeakPtr(), operations,
+                           std::move(callback), space_required)));
     return;
   }
 
-  BatchDidGetUsageAndQuota(operations, callback, 0 /* space_required */,
-                           storage::kQuotaStatusOk, 0 /* usage */,
-                           0 /* quota */);
+  BatchDidGetUsageAndQuota(operations, std::move(callback),
+                           0 /* space_required */, storage::kQuotaStatusOk,
+                           0 /* usage */, 0 /* quota */);
 }
 
 void CacheStorageCache::BatchDidGetUsageAndQuota(
     const std::vector<CacheStorageBatchOperation>& operations,
-    const ErrorCallback& callback,
+    ErrorCallback callback,
     int64_t space_required,
     storage::QuotaStatusCode status_code,
     int64_t usage,
@@ -466,19 +472,23 @@ void CacheStorageCache::BatchDidGetUsageAndQuota(
   if (status_code != storage::kQuotaStatusOk ||
       space_required > quota - usage) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(callback, CACHE_STORAGE_ERROR_QUOTA_EXCEEDED));
+        FROM_HERE, base::BindOnce(std::move(callback),
+                                  CACHE_STORAGE_ERROR_QUOTA_EXCEEDED));
     return;
   }
 
-  std::unique_ptr<ErrorCallback> callback_copy(new ErrorCallback(callback));
-  ErrorCallback* callback_ptr = callback_copy.get();
-  base::Closure barrier_closure = base::BarrierClosure(
-      operations.size(), base::Bind(&CacheStorageCache::BatchDidAllOperations,
-                                    weak_ptr_factory_.GetWeakPtr(),
-                                    base::Passed(std::move(callback_copy))));
-  ErrorCallback completion_callback =
-      base::Bind(&CacheStorageCache::BatchDidOneOperation,
-                 weak_ptr_factory_.GetWeakPtr(), barrier_closure, callback_ptr);
+  // The following relies on the guarantee that the RepeatingCallback returned
+  // from AdaptCallbackForRepeating invokes the original callback on the first
+  // invocation, and (critically) that subsequent invocations are ignored.
+  // TODO(jsbell): Replace AdaptCallbackForRepeating with ...? crbug.com/730593
+  auto callback_copy = base::AdaptCallbackForRepeating(std::move(callback));
+  auto barrier_closure = base::BarrierClosure(
+      operations.size(),
+      base::BindOnce(&CacheStorageCache::BatchDidAllOperations,
+                     weak_ptr_factory_.GetWeakPtr(), callback_copy));
+  auto completion_callback = base::BindRepeating(
+      &CacheStorageCache::BatchDidOneOperation, weak_ptr_factory_.GetWeakPtr(),
+      barrier_closure, callback_copy);
 
   for (const auto& operation : operations) {
     switch (operation.operation_type) {
@@ -500,74 +510,73 @@ void CacheStorageCache::BatchDidGetUsageAndQuota(
 }
 
 void CacheStorageCache::BatchDidOneOperation(
-    const base::Closure& barrier_closure,
-    ErrorCallback* callback,
+    base::OnceClosure completion_closure,
+    ErrorCallback error_callback,
     CacheStorageError error) {
-  if (callback->is_null() || error == CACHE_STORAGE_OK) {
-    barrier_closure.Run();
-    return;
+  if (error != CACHE_STORAGE_OK) {
+    // This relies on |callback| being created by AdaptCallbackForRepeating
+    // and ignoring anything but the first invocation.
+    std::move(error_callback).Run(error);
   }
-  callback->Run(error);
-  callback->Reset();  // Only call the callback once.
 
-  barrier_closure.Run();
+  std::move(completion_closure).Run();
 }
 
-void CacheStorageCache::BatchDidAllOperations(
-    std::unique_ptr<ErrorCallback> callback) {
-  if (callback->is_null())
-    return;
-  callback->Run(CACHE_STORAGE_OK);
+void CacheStorageCache::BatchDidAllOperations(ErrorCallback callback) {
+  // This relies on |callback| being created by AdaptCallbackForRepeating
+  // and ignoring anything but the first invocation.
+  std::move(callback).Run(CACHE_STORAGE_OK);
 }
 
 void CacheStorageCache::Keys(std::unique_ptr<ServiceWorkerFetchRequest> request,
                              const CacheStorageCacheQueryParams& options,
-                             const RequestsCallback& callback) {
+                             RequestsCallback callback) {
   if (backend_state_ == BACKEND_CLOSED) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Requests>());
+    std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE,
+                            std::unique_ptr<Requests>());
     return;
   }
 
-  scheduler_->ScheduleOperation(
-      base::Bind(&CacheStorageCache::KeysImpl, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(std::move(request)), options,
-                 scheduler_->WrapCallbackToRunNext(callback)));
+  scheduler_->ScheduleOperation(base::BindOnce(
+      &CacheStorageCache::KeysImpl, weak_ptr_factory_.GetWeakPtr(),
+      base::Passed(std::move(request)), options,
+      scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
-void CacheStorageCache::Close(const base::Closure& callback) {
+void CacheStorageCache::Close(base::OnceClosure callback) {
   DCHECK_NE(BACKEND_CLOSED, backend_state_)
       << "Was CacheStorageCache::Close() called twice?";
 
-  scheduler_->ScheduleOperation(
-      base::Bind(&CacheStorageCache::CloseImpl, weak_ptr_factory_.GetWeakPtr(),
-                 scheduler_->WrapCallbackToRunNext(callback)));
+  scheduler_->ScheduleOperation(base::BindOnce(
+      &CacheStorageCache::CloseImpl, weak_ptr_factory_.GetWeakPtr(),
+      scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
-void CacheStorageCache::Size(const SizeCallback& callback) {
+void CacheStorageCache::Size(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));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::BindOnce(std::move(callback), 0));
     return;
   }
 
-  scheduler_->ScheduleOperation(
-      base::Bind(&CacheStorageCache::SizeImpl, weak_ptr_factory_.GetWeakPtr(),
-                 scheduler_->WrapCallbackToRunNext(callback)));
+  scheduler_->ScheduleOperation(base::BindOnce(
+      &CacheStorageCache::SizeImpl, weak_ptr_factory_.GetWeakPtr(),
+      scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
-void CacheStorageCache::GetSizeThenClose(const SizeCallback& callback) {
+void CacheStorageCache::GetSizeThenClose(SizeCallback callback) {
   if (backend_state_ == BACKEND_CLOSED) {
-    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                  base::Bind(callback, 0));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::BindOnce(std::move(callback), 0));
     return;
   }
 
-  scheduler_->ScheduleOperation(
-      base::Bind(&CacheStorageCache::SizeImpl, weak_ptr_factory_.GetWeakPtr(),
-                 base::Bind(&CacheStorageCache::GetSizeThenCloseDidGetSize,
-                            weak_ptr_factory_.GetWeakPtr(),
-                            scheduler_->WrapCallbackToRunNext(callback))));
+  scheduler_->ScheduleOperation(base::BindOnce(
+      &CacheStorageCache::SizeImpl, weak_ptr_factory_.GetWeakPtr(),
+      base::BindOnce(&CacheStorageCache::GetSizeThenCloseDidGetSize,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback)))));
 }
 
 void CacheStorageCache::SetObserver(CacheStorageCacheObserver* observer) {
@@ -612,23 +621,24 @@ void CacheStorageCache::QueryCache(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& options,
     QueryCacheType query_type,
-    const QueryCacheCallback& callback) {
+    QueryCacheCallback callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE,
-                 std::unique_ptr<QueryCacheResults>());
+    std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE,
+                            std::unique_ptr<QueryCacheResults>());
     return;
   }
 
   if (!options.ignore_method && request && !request->method.empty() &&
       request->method != "GET") {
-    callback.Run(CACHE_STORAGE_OK, base::MakeUnique<QueryCacheResults>());
+    std::move(callback).Run(CACHE_STORAGE_OK,
+                            base::MakeUnique<QueryCacheResults>());
     return;
   }
 
   ServiceWorkerFetchRequest* request_ptr = request.get();
   std::unique_ptr<QueryCacheContext> query_cache_context(
-      new QueryCacheContext(std::move(request), options, callback));
+      new QueryCacheContext(std::move(request), options, std::move(callback)));
   query_cache_context->query_type = query_type;
 
   if (query_cache_context->request &&
@@ -637,9 +647,10 @@ void CacheStorageCache::QueryCache(
     // URL.
     disk_cache::Entry** entry_ptr = &query_cache_context->enumerated_entry;
     net::CompletionCallback open_entry_callback =
-        base::Bind(&CacheStorageCache::QueryCacheDidOpenFastPath,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   base::Passed(std::move(query_cache_context)));
+        base::AdaptCallbackForRepeating(
+            base::BindOnce(&CacheStorageCache::QueryCacheDidOpenFastPath,
+                           weak_ptr_factory_.GetWeakPtr(),
+                           base::Passed(std::move(query_cache_context))));
     int rv = backend_->OpenEntry(request_ptr->url.spec(), entry_ptr,
                                  open_entry_callback);
     if (rv != net::ERR_IO_PENDING)
@@ -656,8 +667,8 @@ void CacheStorageCache::QueryCacheDidOpenFastPath(
     int rv) {
   if (rv != net::OK) {
     QueryCacheContext* results = query_cache_context.get();
-    results->callback.Run(CACHE_STORAGE_OK,
-                          std::move(query_cache_context->matches));
+    std::move(results->callback)
+        .Run(CACHE_STORAGE_OK, std::move(query_cache_context->matches));
     return;
   }
   QueryCacheFilterEntry(std::move(query_cache_context), rv);
@@ -672,17 +683,18 @@ void CacheStorageCache::QueryCacheOpenNextEntry(
     std::sort(query_cache_context->matches->begin(),
               query_cache_context->matches->end(), QueryCacheResultCompare);
 
-    query_cache_context->callback.Run(CACHE_STORAGE_OK,
-                                      std::move(query_cache_context->matches));
+    std::move(query_cache_context->callback)
+        .Run(CACHE_STORAGE_OK, std::move(query_cache_context->matches));
     return;
   }
 
   disk_cache::Backend::Iterator& iterator =
       *query_cache_context->backend_iterator;
   disk_cache::Entry** enumerated_entry = &query_cache_context->enumerated_entry;
-  net::CompletionCallback open_entry_callback = base::Bind(
-      &CacheStorageCache::QueryCacheFilterEntry, weak_ptr_factory_.GetWeakPtr(),
-      base::Passed(std::move(query_cache_context)));
+  net::CompletionCallback open_entry_callback = base::AdaptCallbackForRepeating(
+      base::BindOnce(&CacheStorageCache::QueryCacheFilterEntry,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     base::Passed(std::move(query_cache_context))));
 
   int rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
 
@@ -701,9 +713,9 @@ void CacheStorageCache::QueryCacheFilterEntry(
   }
 
   if (rv < 0) {
-    QueryCacheCallback callback = query_cache_context->callback;
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE,
-                 std::move(query_cache_context->matches));
+    std::move(query_cache_context->callback)
+        .Run(CACHE_STORAGE_ERROR_STORAGE,
+             std::move(query_cache_context->matches));
     return;
   }
 
@@ -711,9 +723,9 @@ void CacheStorageCache::QueryCacheFilterEntry(
   query_cache_context->enumerated_entry = nullptr;
 
   if (backend_state_ != BACKEND_OPEN) {
-    QueryCacheCallback callback = query_cache_context->callback;
-    callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
-                 std::move(query_cache_context->matches));
+    std::move(query_cache_context->callback)
+        .Run(CACHE_STORAGE_ERROR_NOT_FOUND,
+             std::move(query_cache_context->matches));
     return;
   }
 
@@ -735,10 +747,10 @@ void CacheStorageCache::QueryCacheFilterEntry(
 
   disk_cache::Entry* entry_ptr = entry.get();
   ReadMetadata(entry_ptr,
-               base::Bind(&CacheStorageCache::QueryCacheDidReadMetadata,
-                          weak_ptr_factory_.GetWeakPtr(),
-                          base::Passed(std::move(query_cache_context)),
-                          base::Passed(std::move(entry))));
+               base::BindOnce(&CacheStorageCache::QueryCacheDidReadMetadata,
+                              weak_ptr_factory_.GetWeakPtr(),
+                              base::Passed(std::move(query_cache_context)),
+                              base::Passed(std::move(entry))));
 }
 
 void CacheStorageCache::QueryCacheDidReadMetadata(
@@ -783,8 +795,9 @@ void CacheStorageCache::QueryCacheDidReadMetadata(
   query_cache_context->estimated_out_bytes +=
       match->request->EstimatedStructSize();
   if (query_cache_context->estimated_out_bytes > max_query_size_bytes_) {
-    query_cache_context->callback.Run(CACHE_STORAGE_ERROR_QUERY_TOO_LARGE,
-                                      std::unique_ptr<QueryCacheResults>());
+    std::move(query_cache_context->callback)
+        .Run(CACHE_STORAGE_ERROR_QUERY_TOO_LARGE,
+             std::unique_ptr<QueryCacheResults>());
     return;
   }
 
@@ -800,8 +813,9 @@ void CacheStorageCache::QueryCacheDidReadMetadata(
   query_cache_context->estimated_out_bytes +=
       match->response->EstimatedStructSize();
   if (query_cache_context->estimated_out_bytes > max_query_size_bytes_) {
-    query_cache_context->callback.Run(CACHE_STORAGE_ERROR_QUERY_TOO_LARGE,
-                                      std::unique_ptr<QueryCacheResults>());
+    std::move(query_cache_context->callback)
+        .Run(CACHE_STORAGE_ERROR_QUERY_TOO_LARGE,
+             std::unique_ptr<QueryCacheResults>());
     return;
   }
 
@@ -811,8 +825,9 @@ void CacheStorageCache::QueryCacheDidReadMetadata(
   }
 
   if (!blob_storage_context_) {
-    query_cache_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE,
-                                      base::MakeUnique<QueryCacheResults>());
+    std::move(query_cache_context->callback)
+        .Run(CACHE_STORAGE_ERROR_STORAGE,
+             base::MakeUnique<QueryCacheResults>());
     return;
   }
 
@@ -832,61 +847,64 @@ bool CacheStorageCache::QueryCacheResultCompare(const QueryCacheResult& lhs,
 void CacheStorageCache::MatchImpl(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& match_params,
-    const ResponseCallback& callback) {
-  MatchAllImpl(std::move(request), match_params,
-               base::Bind(&CacheStorageCache::MatchDidMatchAll,
-                          weak_ptr_factory_.GetWeakPtr(), callback));
+    ResponseCallback callback) {
+  MatchAllImpl(
+      std::move(request), match_params,
+      base::BindOnce(&CacheStorageCache::MatchDidMatchAll,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void CacheStorageCache::MatchDidMatchAll(
-    const ResponseCallback& callback,
+    ResponseCallback callback,
     CacheStorageError match_all_error,
     std::unique_ptr<Responses> match_all_responses,
     std::unique_ptr<BlobDataHandles> match_all_handles) {
   if (match_all_error != CACHE_STORAGE_OK) {
-    callback.Run(match_all_error, std::unique_ptr<ServiceWorkerResponse>(),
-                 std::unique_ptr<storage::BlobDataHandle>());
+    std::move(callback).Run(match_all_error,
+                            std::unique_ptr<ServiceWorkerResponse>(),
+                            std::unique_ptr<storage::BlobDataHandle>());
     return;
   }
 
   if (match_all_responses->empty()) {
-    callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
-                 std::unique_ptr<ServiceWorkerResponse>(),
-                 std::unique_ptr<storage::BlobDataHandle>());
+    std::move(callback).Run(CACHE_STORAGE_ERROR_NOT_FOUND,
+                            std::unique_ptr<ServiceWorkerResponse>(),
+                            std::unique_ptr<storage::BlobDataHandle>());
     return;
   }
 
   std::unique_ptr<ServiceWorkerResponse> response =
       base::MakeUnique<ServiceWorkerResponse>(match_all_responses->at(0));
 
-  callback.Run(CACHE_STORAGE_OK, std::move(response),
-               std::move(match_all_handles->at(0)));
+  std::move(callback).Run(CACHE_STORAGE_OK, std::move(response),
+                          std::move(match_all_handles->at(0)));
 }
 
 void CacheStorageCache::MatchAllImpl(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& options,
-    const ResponsesCallback& callback) {
+    ResponsesCallback callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Responses>(),
-                 std::unique_ptr<BlobDataHandles>());
+    std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE,
+                            std::unique_ptr<Responses>(),
+                            std::unique_ptr<BlobDataHandles>());
     return;
   }
 
-  QueryCache(std::move(request), options,
-             QueryCacheType::REQUESTS_AND_RESPONSES,
-             base::Bind(&CacheStorageCache::MatchAllDidQueryCache,
-                        weak_ptr_factory_.GetWeakPtr(), callback));
+  QueryCache(
+      std::move(request), options, QueryCacheType::REQUESTS_AND_RESPONSES,
+      base::BindOnce(&CacheStorageCache::MatchAllDidQueryCache,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void CacheStorageCache::MatchAllDidQueryCache(
-    const ResponsesCallback& callback,
+    ResponsesCallback callback,
     CacheStorageError error,
     std::unique_ptr<QueryCacheResults> query_cache_results) {
   if (error != CACHE_STORAGE_OK) {
-    callback.Run(error, std::unique_ptr<Responses>(),
-                 std::unique_ptr<BlobDataHandles>());
+    std::move(callback).Run(error, std::unique_ptr<Responses>(),
+                            std::unique_ptr<BlobDataHandles>());
     return;
   }
 
@@ -901,12 +919,12 @@ void CacheStorageCache::MatchAllDidQueryCache(
     out_handles->push_back(std::move(result.blob_handle));
   }
 
-  callback.Run(CACHE_STORAGE_OK, std::move(out_responses),
-               std::move(out_handles));
+  std::move(callback).Run(CACHE_STORAGE_OK, std::move(out_responses),
+                          std::move(out_handles));
 }
 
 void CacheStorageCache::WriteSideDataDidGetQuota(
-    const ErrorCallback& callback,
+    ErrorCallback callback,
     const GURL& url,
     base::Time expected_response_time,
     scoped_refptr<net::IOBuffer> buffer,
@@ -916,34 +934,36 @@ void CacheStorageCache::WriteSideDataDidGetQuota(
     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));
+        FROM_HERE, base::BindOnce(std::move(callback),
+                                  CACHE_STORAGE_ERROR_QUOTA_EXCEEDED));
     return;
   }
 
-  scheduler_->ScheduleOperation(base::Bind(
+  scheduler_->ScheduleOperation(base::BindOnce(
       &CacheStorageCache::WriteSideDataImpl, weak_ptr_factory_.GetWeakPtr(),
-      scheduler_->WrapCallbackToRunNext(callback), url, expected_response_time,
-      buffer, buf_len));
+      scheduler_->WrapCallbackToRunNext(std::move(callback)), url,
+      expected_response_time, buffer, buf_len));
 }
 
-void CacheStorageCache::WriteSideDataImpl(const ErrorCallback& callback,
+void CacheStorageCache::WriteSideDataImpl(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);
+    std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   std::unique_ptr<disk_cache::Entry*> scoped_entry_ptr(
       new disk_cache::Entry*());
   disk_cache::Entry** entry_ptr = scoped_entry_ptr.get();
-  net::CompletionCallback open_entry_callback = base::Bind(
-      &CacheStorageCache::WriteSideDataDidOpenEntry,
-      weak_ptr_factory_.GetWeakPtr(), callback, expected_response_time, buffer,
-      buf_len, base::Passed(std::move(scoped_entry_ptr)));
+  net::CompletionCallback open_entry_callback = base::AdaptCallbackForRepeating(
+      base::BindOnce(&CacheStorageCache::WriteSideDataDidOpenEntry,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback),
+                     expected_response_time, buffer, buf_len,
+                     base::Passed(std::move(scoped_entry_ptr))));
 
   int rv = backend_->OpenEntry(url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
@@ -951,27 +971,27 @@ void CacheStorageCache::WriteSideDataImpl(const ErrorCallback& callback,
 }
 
 void CacheStorageCache::WriteSideDataDidOpenEntry(
-    const ErrorCallback& callback,
+    ErrorCallback callback,
     base::Time expected_response_time,
     scoped_refptr<net::IOBuffer> buffer,
     int buf_len,
     std::unique_ptr<disk_cache::Entry*> entry_ptr,
     int rv) {
   if (rv != net::OK) {
-    callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND);
+    std::move(callback).Run(CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
   disk_cache::ScopedEntryPtr entry(*entry_ptr);
 
   ReadMetadata(*entry_ptr,
-               base::Bind(&CacheStorageCache::WriteSideDataDidReadMetaData,
-                          weak_ptr_factory_.GetWeakPtr(), callback,
-                          expected_response_time, buffer, buf_len,
-                          base::Passed(std::move(entry))));
+               base::BindOnce(&CacheStorageCache::WriteSideDataDidReadMetaData,
+                              weak_ptr_factory_.GetWeakPtr(),
+                              std::move(callback), expected_response_time,
+                              buffer, buf_len, base::Passed(std::move(entry))));
 }
 
 void CacheStorageCache::WriteSideDataDidReadMetaData(
-    const ErrorCallback& callback,
+    ErrorCallback callback,
     base::Time expected_response_time,
     scoped_refptr<net::IOBuffer> buffer,
     int buf_len,
@@ -980,15 +1000,17 @@ void CacheStorageCache::WriteSideDataDidReadMetaData(
   if (!headers ||
       headers->response().response_time() !=
           expected_response_time.ToInternalValue()) {
-    callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND);
+    std::move(callback).Run(CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
   // Get a temporary copy of the entry pointer before passing it in base::Bind.
   disk_cache::Entry* temp_entry_ptr = entry.get();
 
-  net::CompletionCallback write_side_data_callback = base::Bind(
-      &CacheStorageCache::WriteSideDataDidWrite, weak_ptr_factory_.GetWeakPtr(),
-      callback, base::Passed(std::move(entry)), buf_len);
+  net::CompletionCallback write_side_data_callback =
+      base::AdaptCallbackForRepeating(
+          base::BindOnce(&CacheStorageCache::WriteSideDataDidWrite,
+                         weak_ptr_factory_.GetWeakPtr(), std::move(callback),
+                         base::Passed(std::move(entry)), buf_len));
 
   int rv = temp_entry_ptr->WriteData(
       INDEX_SIDE_DATA, 0 /* offset */, buffer.get(), buf_len,
@@ -998,24 +1020,25 @@ void CacheStorageCache::WriteSideDataDidReadMetaData(
     write_side_data_callback.Run(rv);
 }
 
-void CacheStorageCache::WriteSideDataDidWrite(const ErrorCallback& callback,
+void CacheStorageCache::WriteSideDataDidWrite(ErrorCallback callback,
                                               disk_cache::ScopedEntryPtr entry,
                                               int expected_bytes,
                                               int rv) {
   if (rv != expected_bytes) {
     entry->Doom();
-    UpdateCacheSize(base::Bind(callback, CACHE_STORAGE_ERROR_NOT_FOUND));
+    UpdateCacheSize(
+        base::BindOnce(std::move(callback), CACHE_STORAGE_ERROR_NOT_FOUND));
     return;
   }
 
   if (rv > 0)
     storage::RecordBytesWritten(kRecordBytesLabel, rv);
 
-  UpdateCacheSize(base::Bind(callback, CACHE_STORAGE_OK));
+  UpdateCacheSize(base::BindOnce(std::move(callback), CACHE_STORAGE_OK));
 }
 
 void CacheStorageCache::Put(const CacheStorageBatchOperation& operation,
-                            const ErrorCallback& callback) {
+                            ErrorCallback callback) {
   DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
   DCHECK_EQ(CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT, operation.operation_type);
 
@@ -1031,13 +1054,13 @@ void CacheStorageCache::Put(const CacheStorageBatchOperation& operation,
 
   if (!response->blob_uuid.empty()) {
     if (!blob_storage_context_) {
-      callback.Run(CACHE_STORAGE_ERROR_STORAGE);
+      std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE);
       return;
     }
     blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(response->blob_uuid);
     if (!blob_data_handle) {
-      callback.Run(CACHE_STORAGE_ERROR_STORAGE);
+      std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE);
       return;
     }
   }
@@ -1050,25 +1073,26 @@ void CacheStorageCache::Put(const CacheStorageBatchOperation& operation,
 
   std::unique_ptr<PutContext> put_context(new PutContext(
       std::move(request), std::move(response), std::move(blob_data_handle),
-      scheduler_->WrapCallbackToRunNext(callback)));
+      scheduler_->WrapCallbackToRunNext(std::move(callback))));
 
-  scheduler_->ScheduleOperation(
-      base::Bind(&CacheStorageCache::PutImpl, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(std::move(put_context))));
+  scheduler_->ScheduleOperation(base::BindOnce(
+      &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);
+    std::move(put_context->callback).Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   std::string key = put_context->request->url.spec();
 
-  net::CompletionCallback callback = base::Bind(
-      &CacheStorageCache::PutDidDoomEntry, weak_ptr_factory_.GetWeakPtr(),
-      base::Passed(std::move(put_context)));
+  net::CompletionCallback callback =
+      base::AdaptCallbackForRepeating(base::BindOnce(
+          &CacheStorageCache::PutDidDoomEntry, weak_ptr_factory_.GetWeakPtr(),
+          base::Passed(std::move(put_context))));
 
   int rv = backend_->DoomEntry(key, callback);
   if (rv != net::ERR_IO_PENDING)
@@ -1078,7 +1102,7 @@ void CacheStorageCache::PutImpl(std::unique_ptr<PutContext> put_context) {
 void CacheStorageCache::PutDidDoomEntry(std::unique_ptr<PutContext> put_context,
                                         int rv) {
   if (backend_state_ != BACKEND_OPEN) {
-    put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
+    std::move(put_context->callback).Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
@@ -1090,10 +1114,11 @@ void CacheStorageCache::PutDidDoomEntry(std::unique_ptr<PutContext> put_context,
   ServiceWorkerFetchRequest* request_ptr = put_context->request.get();
   disk_cache::Backend* backend_ptr = backend_.get();
 
-  net::CompletionCallback create_entry_callback = base::Bind(
-      &CacheStorageCache::PutDidCreateEntry, weak_ptr_factory_.GetWeakPtr(),
-      base::Passed(std::move(scoped_entry_ptr)),
-      base::Passed(std::move(put_context)));
+  net::CompletionCallback create_entry_callback =
+      base::AdaptCallbackForRepeating(base::BindOnce(
+          &CacheStorageCache::PutDidCreateEntry, weak_ptr_factory_.GetWeakPtr(),
+          base::Passed(std::move(scoped_entry_ptr)),
+          base::Passed(std::move(put_context))));
 
   int create_rv = backend_ptr->CreateEntry(request_ptr->url.spec(), entry_ptr,
                                            create_entry_callback);
@@ -1109,7 +1134,7 @@ void CacheStorageCache::PutDidCreateEntry(
   put_context->cache_entry.reset(*entry_ptr);
 
   if (rv != net::OK) {
-    put_context->callback.Run(CACHE_STORAGE_ERROR_EXISTS);
+    std::move(put_context->callback).Run(CACHE_STORAGE_ERROR_EXISTS);
     return;
   }
 
@@ -1150,7 +1175,7 @@ void CacheStorageCache::PutDidCreateEntry(
 
   std::unique_ptr<std::string> serialized(new std::string());
   if (!metadata.SerializeToString(serialized.get())) {
-    put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
+    std::move(put_context->callback).Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
@@ -1160,9 +1185,11 @@ void CacheStorageCache::PutDidCreateEntry(
   // Get a temporary copy of the entry pointer before passing it in base::Bind.
   disk_cache::Entry* temp_entry_ptr = put_context->cache_entry.get();
 
-  net::CompletionCallback write_headers_callback = base::Bind(
-      &CacheStorageCache::PutDidWriteHeaders, weak_ptr_factory_.GetWeakPtr(),
-      base::Passed(std::move(put_context)), buffer->size());
+  net::CompletionCallback write_headers_callback =
+      base::AdaptCallbackForRepeating(
+          base::BindOnce(&CacheStorageCache::PutDidWriteHeaders,
+                         weak_ptr_factory_.GetWeakPtr(),
+                         base::Passed(std::move(put_context)), buffer->size()));
 
   rv = temp_entry_ptr->WriteData(INDEX_HEADERS, 0 /* offset */, buffer.get(),
                                  buffer->size(), write_headers_callback,
@@ -1178,7 +1205,7 @@ void CacheStorageCache::PutDidWriteHeaders(
     int rv) {
   if (rv != expected_bytes) {
     put_context->cache_entry->Doom();
-    put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
+    std::move(put_context->callback).Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
@@ -1189,7 +1216,8 @@ void CacheStorageCache::PutDidWriteHeaders(
   // from the blob into the cache entry.
 
   if (put_context->response->blob_uuid.empty()) {
-    UpdateCacheSize(base::Bind(put_context->callback, CACHE_STORAGE_OK));
+    UpdateCacheSize(
+        base::BindOnce(std::move(put_context->callback), CACHE_STORAGE_OK));
     return;
   }
 
@@ -1209,9 +1237,9 @@ void CacheStorageCache::PutDidWriteHeaders(
   blob_to_cache_raw->StreamBlobToCache(
       std::move(entry), INDEX_RESPONSE_BODY, request_context_getter_.get(),
       std::move(blob_data_handle),
-      base::Bind(&CacheStorageCache::PutDidWriteBlobToCache,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(std::move(put_context)), blob_to_cache_key));
+      base::BindOnce(&CacheStorageCache::PutDidWriteBlobToCache,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     base::Passed(std::move(put_context)), blob_to_cache_key));
 }
 
 void CacheStorageCache::PutDidWriteBlobToCache(
@@ -1226,32 +1254,34 @@ void CacheStorageCache::PutDidWriteBlobToCache(
 
   if (!success) {
     put_context->cache_entry->Doom();
-    put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
+    std::move(put_context->callback).Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
-  UpdateCacheSize(base::Bind(put_context->callback, CACHE_STORAGE_OK));
+  UpdateCacheSize(
+      base::BindOnce(std::move(put_context->callback), CACHE_STORAGE_OK));
 }
 
-void CacheStorageCache::UpdateCacheSize(const base::Closure& callback) {
+void CacheStorageCache::UpdateCacheSize(base::OnceClosure callback) {
   if (backend_state_ != BACKEND_OPEN)
     return;
 
   // Note that the callback holds a cache handle to keep the cache alive during
   // the operation since this UpdateCacheSize is often run after an operation
   // completes and runs its callback.
-  int rv = backend_->CalculateSizeOfAllEntries(
-      base::Bind(&CacheStorageCache::UpdateCacheSizeGotSize,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(CreateCacheHandle()), callback));
+  net::CompletionCallback size_callback = base::AdaptCallbackForRepeating(
+      base::BindOnce(&CacheStorageCache::UpdateCacheSizeGotSize,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     base::Passed(CreateCacheHandle()), std::move(callback)));
 
+  int rv = backend_->CalculateSizeOfAllEntries(size_callback);
   if (rv != net::ERR_IO_PENDING)
-    UpdateCacheSizeGotSize(CreateCacheHandle(), callback, rv);
+    std::move(size_callback).Run(rv);
 }
 
 void CacheStorageCache::UpdateCacheSizeGotSize(
     std::unique_ptr<CacheStorageCacheHandle> cache_handle,
-    const base::Closure& callback,
+    base::OnceClosure callback,
     int current_cache_size) {
   DCHECK_NE(current_cache_size, CacheStorage::kSizeUnknown);
   int64_t old_cache_size = cache_size_;
@@ -1266,11 +1296,11 @@ void CacheStorageCache::UpdateCacheSizeGotSize(
   if (cache_observer_)
     cache_observer_->CacheSizeUpdated(this, current_cache_size);
 
-  callback.Run();
+  std::move(callback).Run();
 }
 
 void CacheStorageCache::Delete(const CacheStorageBatchOperation& operation,
-                               const ErrorCallback& callback) {
+                               ErrorCallback callback) {
   DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
   DCHECK_EQ(CACHE_STORAGE_CACHE_OPERATION_TYPE_DELETE,
             operation.operation_type);
@@ -1281,38 +1311,39 @@ void CacheStorageCache::Delete(const CacheStorageBatchOperation& operation,
           operation.request.headers, operation.request.referrer,
           operation.request.is_reload));
 
-  scheduler_->ScheduleOperation(
-      base::Bind(&CacheStorageCache::DeleteImpl, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(std::move(request)), operation.match_params,
-                 scheduler_->WrapCallbackToRunNext(callback)));
+  scheduler_->ScheduleOperation(base::BindOnce(
+      &CacheStorageCache::DeleteImpl, weak_ptr_factory_.GetWeakPtr(),
+      base::Passed(std::move(request)), operation.match_params,
+      scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorageCache::DeleteImpl(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& match_params,
-    const ErrorCallback& callback) {
+    ErrorCallback callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE);
+    std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
-  QueryCache(std::move(request), match_params, QueryCacheType::CACHE_ENTRIES,
-             base::Bind(&CacheStorageCache::DeleteDidQueryCache,
-                        weak_ptr_factory_.GetWeakPtr(), callback));
+  QueryCache(
+      std::move(request), match_params, QueryCacheType::CACHE_ENTRIES,
+      base::BindOnce(&CacheStorageCache::DeleteDidQueryCache,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void CacheStorageCache::DeleteDidQueryCache(
-    const ErrorCallback& callback,
+    ErrorCallback callback,
     CacheStorageError error,
     std::unique_ptr<QueryCacheResults> query_cache_results) {
   if (error != CACHE_STORAGE_OK) {
-    callback.Run(error);
+    std::move(callback).Run(error);
     return;
   }
 
   if (query_cache_results->empty()) {
-    callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND);
+    std::move(callback).Run(CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
@@ -1321,30 +1352,32 @@ void CacheStorageCache::DeleteDidQueryCache(
     entry->Doom();
   }
 
-  UpdateCacheSize(base::Bind(callback, CACHE_STORAGE_OK));
+  UpdateCacheSize(base::BindOnce(std::move(callback), CACHE_STORAGE_OK));
 }
 
 void CacheStorageCache::KeysImpl(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& options,
-    const RequestsCallback& callback) {
+    RequestsCallback callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Requests>());
+    std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE,
+                            std::unique_ptr<Requests>());
     return;
   }
 
-  QueryCache(std::move(request), options, QueryCacheType::REQUESTS,
-             base::Bind(&CacheStorageCache::KeysDidQueryCache,
-                        weak_ptr_factory_.GetWeakPtr(), callback));
+  QueryCache(
+      std::move(request), options, QueryCacheType::REQUESTS,
+      base::BindOnce(&CacheStorageCache::KeysDidQueryCache,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
 }
 
 void CacheStorageCache::KeysDidQueryCache(
-    const RequestsCallback& callback,
+    RequestsCallback callback,
     CacheStorageError error,
     std::unique_ptr<QueryCacheResults> query_cache_results) {
   if (error != CACHE_STORAGE_OK) {
-    callback.Run(error, std::unique_ptr<Requests>());
+    std::move(callback).Run(error, std::unique_ptr<Requests>());
     return;
   }
 
@@ -1353,31 +1386,31 @@ void CacheStorageCache::KeysDidQueryCache(
   for (const auto& result : *query_cache_results)
     out_requests->push_back(*result.request);
 
-  callback.Run(CACHE_STORAGE_OK, std::move(out_requests));
+  std::move(callback).Run(CACHE_STORAGE_OK, std::move(out_requests));
 }
 
-void CacheStorageCache::CloseImpl(const base::Closure& callback) {
+void CacheStorageCache::CloseImpl(base::OnceClosure callback) {
   DCHECK_NE(BACKEND_CLOSED, backend_state_);
 
   backend_state_ = BACKEND_CLOSED;
   backend_.reset();
-  callback.Run();
+  std::move(callback).Run();
 }
 
-void CacheStorageCache::SizeImpl(const SizeCallback& callback) {
+void CacheStorageCache::SizeImpl(SizeCallback callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
 
   int64_t size = backend_state_ == BACKEND_OPEN ? cache_size_ : 0;
-  base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
-                                                base::Bind(callback, size));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), size));
 }
 
-void CacheStorageCache::GetSizeThenCloseDidGetSize(const SizeCallback& callback,
+void CacheStorageCache::GetSizeThenCloseDidGetSize(SizeCallback callback,
                                                    int64_t cache_size) {
-  CloseImpl(base::Bind(callback, cache_size));
+  CloseImpl(base::BindOnce(std::move(callback), cache_size));
 }
 
-void CacheStorageCache::CreateBackend(const ErrorCallback& callback) {
+void CacheStorageCache::CreateBackend(ErrorCallback callback) {
   DCHECK(!backend_);
 
   // Use APP_CACHE as opposed to DISK_CACHE to prevent cache eviction.
@@ -1389,9 +1422,10 @@ void CacheStorageCache::CreateBackend(const ErrorCallback& callback) {
   ScopedBackendPtr* backend = backend_ptr.get();
 
   net::CompletionCallback create_cache_callback =
-      base::Bind(&CacheStorageCache::CreateBackendDidCreate,
-                 weak_ptr_factory_.GetWeakPtr(), callback,
-                 base::Passed(std::move(backend_ptr)));
+      base::AdaptCallbackForRepeating(
+          base::BindOnce(&CacheStorageCache::CreateBackendDidCreate,
+                         weak_ptr_factory_.GetWeakPtr(), std::move(callback),
+                         base::Passed(std::move(backend_ptr))));
 
   // TODO(jkarlin): Use the cache task runner that ServiceWorkerCacheCore
   // has for disk caches.
@@ -1405,16 +1439,16 @@ void CacheStorageCache::CreateBackend(const ErrorCallback& callback) {
 }
 
 void CacheStorageCache::CreateBackendDidCreate(
-    const CacheStorageCache::ErrorCallback& callback,
+    CacheStorageCache::ErrorCallback callback,
     std::unique_ptr<ScopedBackendPtr> backend_ptr,
     int rv) {
   if (rv != net::OK) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE);
+    std::move(callback).Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
   backend_ = std::move(*backend_ptr);
-  callback.Run(CACHE_STORAGE_OK);
+  std::move(callback).Run(CACHE_STORAGE_OK);
 }
 
 void CacheStorageCache::InitBackend() {
@@ -1423,31 +1457,33 @@ void CacheStorageCache::InitBackend() {
   DCHECK(!scheduler_->ScheduledOperations());
   initializing_ = true;
 
-  scheduler_->ScheduleOperation(base::Bind(
+  scheduler_->ScheduleOperation(base::BindOnce(
       &CacheStorageCache::CreateBackend, weak_ptr_factory_.GetWeakPtr(),
-      base::Bind(
-          &CacheStorageCache::InitDidCreateBackend,
-          weak_ptr_factory_.GetWeakPtr(),
-          scheduler_->WrapCallbackToRunNext(base::Bind(&base::DoNothing)))));
+      base::BindOnce(&CacheStorageCache::InitDidCreateBackend,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     scheduler_->WrapCallbackToRunNext(
+                         base::BindOnce(&base::DoNothing)))));
 }
 
 void CacheStorageCache::InitDidCreateBackend(
-    const base::Closure& callback,
+    base::OnceClosure callback,
     CacheStorageError cache_create_error) {
   if (cache_create_error != CACHE_STORAGE_OK) {
-    InitGotCacheSize(callback, cache_create_error, 0);
+    InitGotCacheSize(std::move(callback), cache_create_error, 0);
     return;
   }
 
-  int rv = backend_->CalculateSizeOfAllEntries(
-      base::Bind(&CacheStorageCache::InitGotCacheSize,
-                 weak_ptr_factory_.GetWeakPtr(), callback, cache_create_error));
+  net::CompletionCallback size_callback =
+      base::AdaptCallbackForRepeating(base::BindOnce(
+          &CacheStorageCache::InitGotCacheSize, weak_ptr_factory_.GetWeakPtr(),
+          std::move(callback), cache_create_error));
 
+  int rv = backend_->CalculateSizeOfAllEntries(size_callback);

[cmumford, 2017/06/21 19:07:56]

Don't you lose copy elision by converting to a local variable? Do you need to
std::move(size_callback)?

[jsbell, 2017/06/21 20:38:16]

Nope - because size_callback is a RepeatingClosure.

The subsequent std::move(size_callback) on line 1483 is unnecessary here (it
could just be `size_callback.Run(rv)`) but is harmless.

   if (rv != net::ERR_IO_PENDING)
-    InitGotCacheSize(callback, cache_create_error, rv);
+    std::move(size_callback).Run(rv);
 }
 
-void CacheStorageCache::InitGotCacheSize(const base::Closure& callback,
+void CacheStorageCache::InitGotCacheSize(base::OnceClosure callback,
                                          CacheStorageError cache_create_error,
                                          int cache_size) {
   // Now that we know the cache size either 1) the cache size should be unknown
@@ -1476,7 +1512,7 @@ void CacheStorageCache::InitGotCacheSize(const base::Closure& callback,
   if (cache_observer_)
     cache_observer_->CacheSizeUpdated(this, cache_size_);
 
-  callback.Run();
+  std::move(callback).Run();
 }
 
 std::unique_ptr<storage::BlobDataHandle>