Appcache: BindOnce refactoring

Create net::OnceCompletionCallback and use it in
AppCacheService::GetAllAppCacheInfo

TBR=jam@chromium.org

Bug: 714018
Change-Id: Ie134d99a7c54deb9ded852e3a817420f5ac59b93
Reviewed-on: https://chromium-review.googlesource.com/664844
Commit-Queue: Mark Pilgrim <pilgrim@chromium.org>
Reviewed-by: Michael Nordman <michaeln@chromium.org>
Cr-Commit-Position: refs/heads/master@{#502912}

content/browser/appcache/appcache_internals_ui.cc

@@ -184,7 +184,7 @@ void AppCacheInternalsUI::Proxy::RequestAllAppCacheInfo() {
         new AppCacheInfoCollection());
     appcache_service_->GetAllAppCacheInfo(
         collection.get(),
-        base::Bind(&Proxy::OnAllAppCacheInfoReady, this, collection));
+        base::BindOnce(&Proxy::OnAllAppCacheInfoReady, this, collection));
   }
 }
 

content/browser/appcache/appcache_service_impl.cc

@@ -34,8 +34,8 @@ namespace content {
 
 namespace {
 
-void DeferredCallback(const net::CompletionCallback& callback, int rv) {
-  callback.Run(rv);
+void DeferredCallback(OnceCompletionCallback callback, int rv) {
+  std::move(callback).Run(rv);
 }
 
 }  // namespace
@@ -49,9 +49,8 @@ AppCacheInfoCollection::~AppCacheInfoCollection() {}
 class AppCacheServiceImpl::AsyncHelper
     : public AppCacheStorage::Delegate {
  public:
-  AsyncHelper(AppCacheServiceImpl* service,
-              const net::CompletionCallback& callback)
-      : service_(service), callback_(callback) {
+  AsyncHelper(AppCacheServiceImpl* service, OnceCompletionCallback callback)
+      : service_(service), callback_(std::move(callback)) {
     service_->pending_helpers_[this] = base::WrapUnique(this);
   }
 
@@ -70,19 +69,19 @@ class AppCacheServiceImpl::AsyncHelper
     if (!callback_.is_null()) {
       // Defer to guarantee async completion.
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::BindOnce(&DeferredCallback, callback_, rv));
+          FROM_HERE,
+          base::BindOnce(&DeferredCallback, std::move(callback_), rv));
     }
     callback_.Reset();
   }
 
   AppCacheServiceImpl* service_;
-  net::CompletionCallback callback_;
+  OnceCompletionCallback callback_;
 };
 
 void AppCacheServiceImpl::AsyncHelper::Cancel() {
   if (!callback_.is_null()) {
-    callback_.Run(net::ERR_ABORTED);
-    callback_.Reset();
+    std::move(callback_).Run(net::ERR_ABORTED);
   }
   service_->storage()->CancelDelegateCallbacks(this);
   service_ = nullptr;
@@ -231,11 +230,10 @@ void AppCacheServiceImpl::DeleteOriginHelper::CacheCompleted(bool success) {
 
 class AppCacheServiceImpl::GetInfoHelper : AsyncHelper {
  public:
-  GetInfoHelper(
-      AppCacheServiceImpl* service, AppCacheInfoCollection* collection,
-      const net::CompletionCallback& callback)
-      : AsyncHelper(service, callback), collection_(collection) {
-  }
+  GetInfoHelper(AppCacheServiceImpl* service,
+                AppCacheInfoCollection* collection,
+                OnceCompletionCallback callback)
+      : AsyncHelper(service, std::move(callback)), collection_(collection) {}
 
   void Start() override { service_->storage()->GetAllInfo(this); }
 
@@ -480,11 +478,11 @@ void AppCacheServiceImpl::Reinitialize() {
   Initialize(cache_directory_);
 }
 
-void AppCacheServiceImpl::GetAllAppCacheInfo(
-    AppCacheInfoCollection* collection,
-    const net::CompletionCallback& callback) {
+void AppCacheServiceImpl::GetAllAppCacheInfo(AppCacheInfoCollection* collection,
+                                             OnceCompletionCallback callback) {
   DCHECK(collection);
-  GetInfoHelper* helper = new GetInfoHelper(this, collection, callback);
+  GetInfoHelper* helper =
+      new GetInfoHelper(this, collection, std::move(callback));
   helper->Start();
 }
 

content/browser/appcache/appcache_service_impl.h

@@ -103,7 +103,7 @@ class CONTENT_EXPORT AppCacheServiceImpl
 
   // AppCacheService implementation:
   void GetAllAppCacheInfo(AppCacheInfoCollection* collection,
-                          const net::CompletionCallback& callback) override;
+                          OnceCompletionCallback callback) override;
   void DeleteAppCacheGroup(const GURL& manifest_url,
                            const net::CompletionCallback& callback) override;
 

content/public/browser/appcache_service.h

@@ -16,6 +16,8 @@
 
 namespace content {
 
+typedef base::OnceCallback<void(int)> OnceCompletionCallback;
+
 // Refcounted container to avoid copying the collection in callbacks.
 struct CONTENT_EXPORT AppCacheInfoCollection
     : public base::RefCountedThreadSafe<AppCacheInfoCollection> {
@@ -37,7 +39,7 @@ class CONTENT_EXPORT AppCacheService {
   // acquires a reference to the 'collection' until completion.
   // This method always completes asynchronously.
   virtual void GetAllAppCacheInfo(AppCacheInfoCollection* collection,
-                                  const net::CompletionCallback& callback) = 0;
+                                  OnceCompletionCallback callback) = 0;
 
   // Deletes the group identified by 'manifest_url', 'callback' is
   // invoked upon completion. Upon completion, the cache group and