Use CompletionOnceCallback in //content/browser/appcache.

Use CompletionOnceCallback instead of CompletionCallback, and
CancelableCompletionOnceCallback instead of CancelableCompletionCallback
in //content/browser/appcache.

Bug: 807724

This exact CL has been reviewed and approved at
https://crrev.com/c/1163933.  However, due to a bug in Gerrit, I
inadvertently submitted that CL skipping the CQ.  See
https://crbug.com/872722.  That CL was reverted, and now I am relanding
it properly in this CL, through CQ this time.  Original reviewer is
TBR'd.

TBR=kinuko@chromium.org

Change-Id: Ie1d8e275e754cc51457aca6537ad08b228cfaaac
Reviewed-on: https://chromium-review.googlesource.com/1169307Reviewed-by: Bence Béky <bnc@chromium.org>
Commit-Queue: Bence Béky <bnc@chromium.org>
Cr-Commit-Position: refs/heads/master@{#581894}

content/browser/appcache/appcache_disk_cache.h

@@ -15,6 +15,7 @@
 #include "base/memory/ref_counted.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/common/content_export.h"
+#include "net/base/completion_once_callback.h"
 #include "net/disk_cache/disk_cache.h"
 
 namespace content {
@@ -32,23 +33,23 @@ class CONTENT_EXPORT AppCacheDiskCache
                           int disk_cache_size,
                           bool force,
                           base::OnceClosure post_cleanup_callback,
-                          const net::CompletionCallback& callback);
+                          net::CompletionOnceCallback callback);
 
   // Initializes the object to use memory only storage.
   // This is used for Chrome's incognito browsing.
   int InitWithMemBackend(int disk_cache_size,
-                         const net::CompletionCallback& callback);
+                         net::CompletionOnceCallback callback);
 
   void Disable();
   bool is_disabled() const { return is_disabled_; }
 
   int CreateEntry(int64_t key,
                   Entry** entry,
-                  const net::CompletionCallback& callback) override;
+                  net::CompletionOnceCallback callback) override;
   int OpenEntry(int64_t key,
                 Entry** entry,
-                const net::CompletionCallback& callback) override;
-  int DoomEntry(int64_t key, const net::CompletionCallback& callback) override;
+                net::CompletionOnceCallback callback) override;
+  int DoomEntry(int64_t key, net::CompletionOnceCallback callback) override;
 
   void set_is_waiting_to_initialize(bool is_waiting_to_initialize) {
     is_waiting_to_initialize_ = is_waiting_to_initialize;
@@ -73,21 +74,19 @@ class CONTENT_EXPORT AppCacheDiskCache
     DOOM
   };
   struct PendingCall {
-    PendingCallType call_type;
-    int64_t key;
-    Entry** entry;
-    net::CompletionCallback callback;
-
     PendingCall();
-
     PendingCall(PendingCallType call_type,
                 int64_t key,
                 Entry** entry,
-                const net::CompletionCallback& callback);
-
-    PendingCall(const PendingCall& other);
+                net::CompletionOnceCallback callback);
+    PendingCall(PendingCall&& other);
 
     ~PendingCall();
+
+    PendingCallType call_type;
+    int64_t key;
+    Entry** entry;
+    net::CompletionOnceCallback callback;
   };
   using PendingCalls = std::vector<PendingCall>;
 
@@ -104,7 +103,7 @@ class CONTENT_EXPORT AppCacheDiskCache
            int cache_size,
            bool force,
            base::OnceClosure post_cleanup_callback,
-           const net::CompletionCallback& callback);
+           net::CompletionOnceCallback callback);
   void OnCreateBackendComplete(int rv);
   void AddOpenEntry(EntryImpl* entry) { open_entries_.insert(entry); }
   void RemoveOpenEntry(EntryImpl* entry) { open_entries_.erase(entry); }
@@ -112,7 +111,7 @@ class CONTENT_EXPORT AppCacheDiskCache
   bool use_simple_cache_;
   bool is_disabled_;
   bool is_waiting_to_initialize_;
-  net::CompletionCallback init_callback_;
+  net::CompletionOnceCallback init_callback_;
   scoped_refptr<CreateBackendCallbackShim> create_backend_callback_;
   PendingCalls pending_calls_;
   OpenEntries open_entries_;

content/browser/appcache/appcache_disk_cache_unittest.cc

@@ -10,6 +10,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "net/base/completion_repeating_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ -24,9 +25,8 @@ class AppCacheDiskCacheTest : public testing::Test {
 
   void SetUp() override {
     ASSERT_TRUE(directory_.CreateUniqueTempDir());
-    completion_callback_ = base::Bind(
-        &AppCacheDiskCacheTest::OnComplete,
-        base::Unretained(this));
+    completion_callback_ = base::BindRepeating(
+        &AppCacheDiskCacheTest::OnComplete, base::Unretained(this));
   }
 
   void TearDown() override { scoped_task_environment_.RunUntilIdle(); }
@@ -42,7 +42,7 @@ class AppCacheDiskCacheTest : public testing::Test {
 
   base::test::ScopedTaskEnvironment scoped_task_environment_;
   base::ScopedTempDir directory_;
-  net::CompletionCallback completion_callback_;
+  net::CompletionRepeatingCallback completion_callback_;
   std::vector<int> completion_results_;
 
   static const int k10MBytes = 10 * 1024 * 1024;

content/browser/appcache/appcache_quota_client.cc

@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <map>
 #include <set>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ -207,15 +208,16 @@ const AppCacheStorage::UsageMap* AppCacheQuotaClient::GetUsageMap() {
   return service_->storage()->usage_map();
 }
 
-net::CancelableCompletionCallback*
+net::CancelableCompletionRepeatingCallback*
 AppCacheQuotaClient::GetServiceDeleteCallback() {
-  // Lazily created due to CancelableCompletionCallback's threading
-  // restrictions, there is no way to detach from the thread created on.
+  // Lazily created due to base::CancelableCallback's threading restrictions,
+  // there is no way to detach from the thread created on.
   if (!service_delete_callback_) {
-    service_delete_callback_.reset(
-        new net::CancelableCompletionCallback(
-            base::Bind(&AppCacheQuotaClient::DidDeleteAppCachesForOrigin,
-                       base::Unretained(this))));
+    service_delete_callback_ =
+        std::make_unique<net::CancelableCompletionRepeatingCallback>(
+            base::BindRepeating(
+                &AppCacheQuotaClient::DidDeleteAppCachesForOrigin,
+                base::Unretained(this)));
   }
   return service_delete_callback_.get();
 }

content/browser/appcache/appcache_quota_client.h

@@ -14,7 +14,7 @@
 #include "base/memory/ref_counted.h"
 #include "content/browser/appcache/appcache_storage.h"
 #include "content/common/content_export.h"
-#include "net/base/completion_callback.h"
+#include "net/base/completion_repeating_callback.h"
 #include "storage/browser/quota/quota_client.h"
 #include "storage/browser/quota/quota_task.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
@@ -67,7 +67,7 @@ class AppCacheQuotaClient : public storage::QuotaClient {
   void ProcessPendingRequests();
   void DeletePendingRequests();
   const AppCacheStorage::UsageMap* GetUsageMap();
-  net::CancelableCompletionCallback* GetServiceDeleteCallback();
+  net::CancelableCompletionRepeatingCallback* GetServiceDeleteCallback();
 
   // For use by appcache internals during initialization and shutdown.
   CONTENT_EXPORT void NotifyAppCacheReady();
@@ -81,7 +81,8 @@ class AppCacheQuotaClient : public storage::QuotaClient {
   // And once it's ready, we can only handle one delete request at a time,
   // so we queue up additional requests while one is in already in progress.
   DeletionCallback current_delete_request_callback_;
-  std::unique_ptr<net::CancelableCompletionCallback> service_delete_callback_;
+  std::unique_ptr<net::CancelableCompletionRepeatingCallback>
+      service_delete_callback_;
 
   AppCacheServiceImpl* service_;
   bool appcache_is_ready_;

content/browser/appcache/appcache_request_handler.cc

@@ -403,8 +403,8 @@ void AppCacheRequestHandler::OnMainResponseFound(
   }
 
   if (should_reset_appcache_ && !manifest_url.is_empty()) {
-    host_->service()->DeleteAppCacheGroup(
-        manifest_url, net::CompletionCallback());
+    host_->service()->DeleteAppCacheGroup(manifest_url,
+                                          net::CompletionOnceCallback());
     DeliverNetworkResponse();
     return;
   }

content/browser/appcache/appcache_response.cc

@@ -6,6 +6,8 @@
 
 #include <stddef.h>
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
@@ -17,7 +19,7 @@
 #include "base/strings/string_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/appcache/appcache_storage.h"
-#include "net/base/completion_callback.h"
+#include "net/base/completion_once_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "storage/common/storage_histograms.h"
@@ -159,28 +161,34 @@ void AppCacheResponseIO::OpenEntryIfNeeded() {
     rv = net::ERR_FAILED;
   } else {
     entry_ptr = new AppCacheDiskCacheInterface::Entry*;
-    open_callback_ =
-        base::Bind(&AppCacheResponseIO::OpenEntryCallback,
-                   weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
-    rv = disk_cache_->OpenEntry(response_id_, entry_ptr, open_callback_);
+    rv = disk_cache_->OpenEntry(
+        response_id_, entry_ptr,
+        base::BindOnce(&AppCacheResponseIO::OpenEntryCallback,
+                       weak_factory_.GetWeakPtr(), entry_ptr));
   }
 
   if (rv != net::ERR_IO_PENDING)
-    OpenEntryCallback(entry_ptr, rv);
+    OpenEntryCallback(weak_factory_.GetWeakPtr(), entry_ptr, rv);
 }
 
+// static
 void AppCacheResponseIO::OpenEntryCallback(
-    AppCacheDiskCacheInterface::Entry** entry, int rv) {
-  DCHECK(info_buffer_.get() || buffer_.get());
+    base::WeakPtr<AppCacheResponseIO> response,
+    AppCacheDiskCacheInterface::Entry** entry,
+    int rv) {
+  if (!response) {
+    delete entry;
+    return;
+  }
 
-  if (!open_callback_.is_null()) {
-    if (rv == net::OK) {
-      DCHECK(entry);
-      entry_ = *entry;
-    }
-    open_callback_.Reset();
+  DCHECK(response->info_buffer_.get() || response->buffer_.get());
+
+  if (!response->entry_ && rv == net::OK) {
+    DCHECK(entry);
+    response->entry_ = *entry;
   }
-  OnOpenEntryComplete();
+  delete entry;
+  response->OnOpenEntryComplete();
 }
 
 
@@ -408,55 +416,73 @@ void AppCacheResponseWriter::CreateEntryIfNeededAndContinue() {
   } else {
     creation_phase_ = INITIAL_ATTEMPT;
     entry_ptr = new AppCacheDiskCacheInterface::Entry*;
-    create_callback_ =
-        base::Bind(&AppCacheResponseWriter::OnCreateEntryComplete,
-                   weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
-    rv = disk_cache_->CreateEntry(response_id_, entry_ptr, create_callback_);
+    rv = disk_cache_->CreateEntry(
+        response_id_, entry_ptr,
+        base::BindOnce(&AppCacheResponseWriter::OnCreateEntryComplete,
+                       weak_factory_.GetWeakPtr(), entry_ptr));
   }
   if (rv != net::ERR_IO_PENDING)
-    OnCreateEntryComplete(entry_ptr, rv);
+    OnCreateEntryComplete(weak_factory_.GetWeakPtr(), entry_ptr, rv);
 }
 
+// static
 void AppCacheResponseWriter::OnCreateEntryComplete(
-    AppCacheDiskCacheInterface::Entry** entry, int rv) {
-  DCHECK(info_buffer_.get() || buffer_.get());
+    base::WeakPtr<AppCacheResponseWriter> writer,
+    AppCacheDiskCacheInterface::Entry** entry,
+    int rv) {
+  if (!writer) {
+    if (entry) {
+      delete entry;
+    }
+    return;
+  }
 
-  if (!disk_cache_) {
-    ScheduleIOCompletionCallback(net::ERR_FAILED);
+  DCHECK(writer->info_buffer_.get() || writer->buffer_.get());
+
+  if (!writer->disk_cache_) {
+    if (entry) {
+      delete entry;
+    }
+    writer->ScheduleIOCompletionCallback(net::ERR_FAILED);
     return;
-  } else if (creation_phase_ == INITIAL_ATTEMPT) {
+  } else if (writer->creation_phase_ == INITIAL_ATTEMPT) {
     if (rv != net::OK) {
       // We may try to overwrite existing entries.
-      creation_phase_ = DOOM_EXISTING;
-      rv = disk_cache_->DoomEntry(response_id_, create_callback_);
+      delete entry;
+      writer->creation_phase_ = DOOM_EXISTING;
+      rv = writer->disk_cache_->DoomEntry(
+          writer->response_id_,
+          base::BindOnce(&AppCacheResponseWriter::OnCreateEntryComplete, writer,
+                         nullptr));
       if (rv != net::ERR_IO_PENDING)
-        OnCreateEntryComplete(nullptr, rv);
+        OnCreateEntryComplete(writer, nullptr, rv);
       return;
     }
-  } else if (creation_phase_ == DOOM_EXISTING) {
-    creation_phase_ = SECOND_ATTEMPT;
+  } else if (writer->creation_phase_ == DOOM_EXISTING) {
+    DCHECK_EQ(nullptr, entry);
+    writer->creation_phase_ = SECOND_ATTEMPT;
     AppCacheDiskCacheInterface::Entry** entry_ptr =
         new AppCacheDiskCacheInterface::Entry*;
-    create_callback_ =
-        base::Bind(&AppCacheResponseWriter::OnCreateEntryComplete,
-                   weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
-    rv = disk_cache_->CreateEntry(response_id_, entry_ptr, create_callback_);
+    rv = writer->disk_cache_->CreateEntry(
+        writer->response_id_, entry_ptr,
+        base::BindOnce(&AppCacheResponseWriter::OnCreateEntryComplete, writer,
+                       entry_ptr));
     if (rv != net::ERR_IO_PENDING)
-      OnCreateEntryComplete(entry_ptr, rv);
+      OnCreateEntryComplete(writer, entry_ptr, rv);
     return;
   }
 
-  if (!create_callback_.is_null()) {
-    if (rv == net::OK)
-      entry_ = *entry;
-
-    create_callback_.Reset();
+  if (!writer->entry_ && rv == net::OK) {
+    DCHECK(entry);
+    writer->entry_ = *entry;
   }
 
-  if (info_buffer_.get())
-    ContinueWriteInfo();
+  delete entry;
+
+  if (writer->info_buffer_.get())
+    writer->ContinueWriteInfo();
   else
-    ContinueWriteData();
+    writer->ContinueWriteData();
 }
 
 // AppCacheResponseMetadataWriter ----------------------------------------------
@@ -474,7 +500,7 @@ AppCacheResponseMetadataWriter::~AppCacheResponseMetadataWriter() {
 void AppCacheResponseMetadataWriter::WriteMetadata(
     net::IOBuffer* buf,
     int buf_len,
-    const net::CompletionCallback& callback) {
+    net::CompletionOnceCallback callback) {
   DCHECK(!callback.is_null());
   DCHECK(!IsIOPending());
   DCHECK(buf);
@@ -483,7 +509,7 @@ void AppCacheResponseMetadataWriter::WriteMetadata(
 
   buffer_ = buf;
   write_amount_ = buf_len;
-  callback_ = callback;  // cleared on completion
+  callback_ = std::move(callback);  // cleared on completion
   OpenEntryIfNeeded();
 }
 

content/browser/appcache/appcache_response.h

@@ -14,7 +14,7 @@
 #include "base/memory/weak_ptr.h"
 #include "content/common/appcache_interfaces.h"
 #include "content/common/content_export.h"
-#include "net/base/completion_callback.h"
+#include "net/base/completion_once_callback.h"
 #include "net/http/http_response_info.h"
 #include "url/gurl.h"
 
@@ -84,12 +84,12 @@ class CONTENT_EXPORT AppCacheDiskCacheInterface {
                      int64_t offset,
                      net::IOBuffer* buf,
                      int buf_len,
-                     const net::CompletionCallback& callback) = 0;
+                     net::CompletionOnceCallback callback) = 0;
     virtual int Write(int index,
                       int64_t offset,
                       net::IOBuffer* buf,
                       int buf_len,
-                      const net::CompletionCallback& callback) = 0;
+                      net::CompletionOnceCallback callback) = 0;
     virtual int64_t GetSize(int index) = 0;
     virtual void Close() = 0;
    protected:
@@ -101,12 +101,11 @@ class CONTENT_EXPORT AppCacheDiskCacheInterface {
 
   virtual int CreateEntry(int64_t key,
                           Entry** entry,
-                          const net::CompletionCallback& callback) = 0;
+                          net::CompletionOnceCallback callback) = 0;
   virtual int OpenEntry(int64_t key,
                         Entry** entry,
-                        const net::CompletionCallback& callback) = 0;
-  virtual int DoomEntry(int64_t key,
-                        const net::CompletionCallback& callback) = 0;
+                        net::CompletionOnceCallback callback) = 0;
+  virtual int DoomEntry(int64_t key, net::CompletionOnceCallback callback) = 0;
 
   const char* uma_name() const { return uma_name_; }
   base::WeakPtr<AppCacheDiskCacheInterface> GetWeakPtr();
@@ -146,12 +145,14 @@ class CONTENT_EXPORT AppCacheResponseIO {
   scoped_refptr<net::IOBuffer> buffer_;
   int buffer_len_;
   OnceCompletionCallback callback_;
-  net::CompletionCallback open_callback_;
+  net::CompletionOnceCallback open_callback_;
   base::WeakPtrFactory<AppCacheResponseIO> weak_factory_;
 
  private:
   void OnRawIOComplete(int result);
-  void OpenEntryCallback(AppCacheDiskCacheInterface::Entry** entry, int rv);
+  static void OpenEntryCallback(base::WeakPtr<AppCacheResponseIO> response,
+                                AppCacheDiskCacheInterface::Entry** entry,
+                                int rv);
 };
 
 // Reads existing response data from storage. If the object is deleted
@@ -277,13 +278,15 @@ class CONTENT_EXPORT AppCacheResponseWriter
   void ContinueWriteInfo();
   void ContinueWriteData();
   void CreateEntryIfNeededAndContinue();
-  void OnCreateEntryComplete(AppCacheDiskCacheInterface::Entry** entry, int rv);
+  static void OnCreateEntryComplete(
+      base::WeakPtr<AppCacheResponseWriter> writer,
+      AppCacheDiskCacheInterface::Entry** entry,
+      int rv);
 
   int info_size_;
   int write_position_;
   int write_amount_;
   CreationPhase creation_phase_;
-  net::CompletionCallback create_callback_;
   base::WeakPtrFactory<AppCacheResponseWriter> weak_factory_;
 };
 
@@ -307,7 +310,7 @@ class CONTENT_EXPORT AppCacheResponseMetadataWriter
   // progress.
   void WriteMetadata(net::IOBuffer* buf,
                      int buf_len,
-                     const net::CompletionCallback& callback);
+                     net::CompletionOnceCallback callback);
 
   // Returns true if there is a write pending.
   bool IsWritePending() { return IsIOPending(); }

content/browser/appcache/appcache_service_impl.cc

@@ -25,7 +25,6 @@
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/appcache_service_impl.h"
 #include "content/browser/appcache/appcache_storage_impl.h"
-#include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
@@ -90,11 +89,11 @@ void AppCacheServiceImpl::AsyncHelper::Cancel() {
 
 class AppCacheServiceImpl::DeleteHelper : public AsyncHelper {
  public:
-  DeleteHelper(
-      AppCacheServiceImpl* service, const GURL& manifest_url,
-      const net::CompletionCallback& callback)
-      : AsyncHelper(service, callback), manifest_url_(manifest_url) {
-  }
+  DeleteHelper(AppCacheServiceImpl* service,
+               const GURL& manifest_url,
+               net::CompletionOnceCallback callback)
+      : AsyncHelper(service, std::move(callback)),
+        manifest_url_(manifest_url) {}
 
   void Start() override {
     service_->storage()->LoadOrCreateGroup(manifest_url_, this);
@@ -137,8 +136,8 @@ class AppCacheServiceImpl::DeleteOriginHelper : public AsyncHelper {
  public:
   DeleteOriginHelper(AppCacheServiceImpl* service,
                      const url::Origin& origin,
-                     const net::CompletionCallback& callback)
-      : AsyncHelper(service, callback),
+                     net::CompletionOnceCallback callback)
+      : AsyncHelper(service, std::move(callback)),
         origin_(origin),
         num_caches_to_delete_(0),
         successes_(0),
@@ -261,7 +260,7 @@ class AppCacheServiceImpl::CheckResponseHelper : AsyncHelper {
                       const GURL& manifest_url,
                       int64_t cache_id,
                       int64_t response_id)
-      : AsyncHelper(service, net::CompletionCallback()),
+      : AsyncHelper(service, net::CompletionOnceCallback()),
         manifest_url_(manifest_url),
         cache_id_(cache_id),
         response_id_(response_id),
@@ -320,7 +319,8 @@ void AppCacheServiceImpl::CheckResponseHelper::OnGroupLoaded(
     if (cache_->cache_id() == cache_id_) {
       AppCacheHistograms::CountCheckResponseResult(
           AppCacheHistograms::ENTRY_NOT_FOUND);
-      service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
+      service_->DeleteAppCacheGroup(manifest_url_,
+                                    net::CompletionOnceCallback());
     } else {
       AppCacheHistograms::CountCheckResponseResult(
           AppCacheHistograms::RESPONSE_OUT_OF_DATE);
@@ -344,7 +344,7 @@ void AppCacheServiceImpl::CheckResponseHelper::OnReadInfoComplete(int result) {
   if (result < 0) {
     AppCacheHistograms::CountCheckResponseResult(
         AppCacheHistograms::READ_HEADERS_ERROR);
-    service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
+    service_->DeleteAppCacheGroup(manifest_url_, net::CompletionOnceCallback());
     delete this;
     return;
   }
@@ -380,7 +380,7 @@ void AppCacheServiceImpl::CheckResponseHelper::OnReadDataComplete(int result) {
   AppCacheHistograms::CountCheckResponseResult(check_result);
 
   if (check_result != AppCacheHistograms::RESPONSE_OK)
-    service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
+    service_->DeleteAppCacheGroup(manifest_url_, net::CompletionOnceCallback());
   delete this;
 }
 
@@ -484,15 +484,17 @@ void AppCacheServiceImpl::GetAllAppCacheInfo(AppCacheInfoCollection* collection,
 
 void AppCacheServiceImpl::DeleteAppCacheGroup(
     const GURL& manifest_url,
-    const net::CompletionCallback& callback) {
-  DeleteHelper* helper = new DeleteHelper(this, manifest_url, callback);
+    net::CompletionOnceCallback callback) {
+  DeleteHelper* helper =
+      new DeleteHelper(this, manifest_url, std::move(callback));
   helper->Start();
 }
 
 void AppCacheServiceImpl::DeleteAppCachesForOrigin(
     const url::Origin& origin,
-    const net::CompletionCallback& callback) {
-  DeleteOriginHelper* helper = new DeleteOriginHelper(this, origin, callback);
+    net::CompletionOnceCallback callback) {
+  DeleteOriginHelper* helper =
+      new DeleteOriginHelper(this, origin, std::move(callback));
   helper->Start();
 }
 

content/browser/appcache/appcache_service_impl.h

@@ -21,7 +21,7 @@
 #include "content/common/appcache_interfaces.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/appcache_service.h"
-#include "net/base/completion_callback.h"
+#include "net/base/completion_once_callback.h"
 #include "net/base/net_errors.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 
@@ -105,14 +105,13 @@ class CONTENT_EXPORT AppCacheServiceImpl
   void GetAllAppCacheInfo(AppCacheInfoCollection* collection,
                           OnceCompletionCallback callback) override;
   void DeleteAppCacheGroup(const GURL& manifest_url,
-                           const net::CompletionCallback& callback) override;
+                           net::CompletionOnceCallback callback) override;
 
   // Deletes all appcaches for the origin, 'callback' is invoked upon
   // completion. This method always completes asynchronously.
   // (virtual for unit testing)
-  virtual void DeleteAppCachesForOrigin(
-      const url::Origin& origin,
-      const net::CompletionCallback& callback);
+  virtual void DeleteAppCachesForOrigin(const url::Origin& origin,
+                                        net::CompletionOnceCallback callback);
 
   // Checks the integrity of 'response_id' by reading the headers and data.
   // If it cannot be read, the cache group for 'manifest_url' is deleted.

content/browser/appcache/appcache_service_unittest.cc

@@ -18,7 +18,7 @@
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/appcache_service_impl.h"
 #include "content/browser/appcache/mock_appcache_storage.h"
-#include "net/base/completion_callback.h"
+#include "net/base/completion_once_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -101,10 +101,7 @@ class AppCacheServiceImplTest : public testing::Test {
         kManifestUrl(kOriginURL.Resolve("manifest")),
         service_(new AppCacheServiceImpl(nullptr)),
         delete_result_(net::OK),
-        delete_completion_count_(0),
-        deletion_callback_(
-            base::Bind(&AppCacheServiceImplTest::OnDeleteAppCachesComplete,
-                       base::Unretained(this))) {
+        delete_completion_count_(0) {
     // Setup to use mock storage.
     service_->storage_.reset(new MockAppCacheStorage(service_.get()));
   }
@@ -183,6 +180,11 @@ class AppCacheServiceImplTest : public testing::Test {
     return pickle->size();
   }
 
+  net::CompletionOnceCallback deletion_callback() {
+    return base::BindOnce(&AppCacheServiceImplTest::OnDeleteAppCachesComplete,
+                          base::Unretained(this));
+  }
+
   const GURL kOriginURL;
   const url::Origin kOrigin;
   const GURL kManifestUrl;
@@ -191,12 +193,11 @@ class AppCacheServiceImplTest : public testing::Test {
   std::unique_ptr<AppCacheServiceImpl> service_;
   int delete_result_;
   int delete_completion_count_;
-  net::CompletionCallback deletion_callback_;
 };
 
 TEST_F(AppCacheServiceImplTest, DeleteAppCachesForOrigin) {
   // Without giving mock storage simiulated info, should fail.
-  service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
+  service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback());
   EXPECT_EQ(0, delete_completion_count_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, delete_completion_count_);
@@ -205,7 +206,7 @@ TEST_F(AppCacheServiceImplTest, DeleteAppCachesForOrigin) {
 
   // Should succeed given an empty info collection.
   mock_storage()->SimulateGetAllInfo(new content::AppCacheInfoCollection);
-  service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
+  service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback());
   EXPECT_EQ(0, delete_completion_count_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, delete_completion_count_);
@@ -227,7 +228,7 @@ TEST_F(AppCacheServiceImplTest, DeleteAppCachesForOrigin) {
   info_vector.push_back(mock_manifest_3);
   info->infos_by_origin[kOrigin] = info_vector;
   mock_storage()->SimulateGetAllInfo(info.get());
-  service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
+  service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback());
   EXPECT_EQ(0, delete_completion_count_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, delete_completion_count_);
@@ -238,7 +239,7 @@ TEST_F(AppCacheServiceImplTest, DeleteAppCachesForOrigin) {
   info->infos_by_origin[kOrigin] = info_vector;
   mock_storage()->SimulateGetAllInfo(info.get());
   mock_storage()->SimulateMakeGroupObsoleteFailure();
-  service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
+  service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback());
   EXPECT_EQ(0, delete_completion_count_);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, delete_completion_count_);
@@ -247,7 +248,7 @@ TEST_F(AppCacheServiceImplTest, DeleteAppCachesForOrigin) {
 
   // Should complete with abort error if the service is deleted
   // prior to a delete completion.
-  service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback_);
+  service_->DeleteAppCachesForOrigin(kOrigin, deletion_callback());
   EXPECT_EQ(0, delete_completion_count_);
   service_.reset();  // kill it
   EXPECT_EQ(1, delete_completion_count_);

content/browser/appcache/appcache_storage.h

@@ -18,7 +18,6 @@
 #include "base/memory/weak_ptr.h"
 #include "content/browser/appcache/appcache_working_set.h"
 #include "content/common/content_export.h"
-#include "net/base/completion_callback.h"
 #include "url/origin.h"
 
 class GURL;

content/browser/appcache/appcache_update_job.cc

@@ -893,7 +893,8 @@ void AppCacheUpdateJob::CheckIfManifestChanged() {
                                GURL(), 0, false /*is_cross_origin*/),
           DB_ERROR, GURL());
       AppCacheHistograms::AddMissingManifestEntrySample();
-      service->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
+      service->DeleteAppCacheGroup(manifest_url_,
+                                   net::CompletionOnceCallback());
     }
     return;
   }

content/browser/appcache/appcache_update_job.h

@@ -26,7 +26,6 @@
 #include "content/browser/appcache/appcache_storage.h"
 #include "content/common/appcache_interfaces.h"
 #include "content/common/content_export.h"
-#include "net/base/completion_callback.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "url/gurl.h"

content/browser/appcache/mock_appcache_service.cc

@@ -4,6 +4,8 @@
 
 #include "content/browser/appcache/mock_appcache_service.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ -11,17 +13,16 @@
 
 namespace content {
 
-static void DeferredCallCallback(
-    const net::CompletionCallback& callback, int rv) {
-  callback.Run(rv);
+static void DeferredCallCallback(net::CompletionOnceCallback callback, int rv) {
+  std::move(callback).Run(rv);
 }
 
 void MockAppCacheService::DeleteAppCachesForOrigin(
     const url::Origin& origin,
-    const net::CompletionCallback& callback) {
+    net::CompletionOnceCallback callback) {
   ++delete_called_count_;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(&DeferredCallCallback, callback,
+      FROM_HERE, base::BindOnce(&DeferredCallCallback, std::move(callback),
                                 mock_delete_appcaches_for_origin_result_));
 }
 

content/browser/appcache/mock_appcache_service.h

@@ -24,9 +24,8 @@ class MockAppCacheService : public AppCacheServiceImpl {
 
   // Just returns a canned completion code without actually
   // removing groups and caches in our mock storage instance.
-  void DeleteAppCachesForOrigin(
-      const url::Origin& origin,
-      const net::CompletionCallback& callback) override;
+  void DeleteAppCachesForOrigin(const url::Origin& origin,
+                                net::CompletionOnceCallback callback) override;
 
   void set_quota_manager_proxy(storage::QuotaManagerProxy* proxy) {
     quota_manager_proxy_ = proxy;

content/browser/appcache/mock_appcache_storage.h

@@ -144,7 +144,8 @@ class MockAppCacheStorage : public AppCacheStorage {
     if (!disk_cache_) {
       const int kMaxCacheSize = 10 * 1024 * 1024;
       disk_cache_.reset(new AppCacheDiskCache);
-      disk_cache_->InitWithMemBackend(kMaxCacheSize, net::CompletionCallback());
+      disk_cache_->InitWithMemBackend(kMaxCacheSize,
+                                      net::CompletionOnceCallback());
     }
     return disk_cache_.get();
   }

content/public/browser/appcache_service.h

@@ -12,7 +12,7 @@
 #include "base/memory/ref_counted.h"
 #include "content/common/content_export.h"
 #include "content/public/common/appcache_info.h"
-#include "net/base/completion_callback.h"
+#include "net/base/completion_once_callback.h"
 #include "url/origin.h"
 
 namespace content {
@@ -46,7 +46,7 @@ class CONTENT_EXPORT AppCacheService {
   // subresource loads for pages associated with a deleted group
   // will fail. This method always completes asynchronously.
   virtual void DeleteAppCacheGroup(const GURL& manifest_url,
-                                   const net::CompletionCallback& callback) = 0;
+                                   net::CompletionOnceCallback callback) = 0;
 
  protected:
   virtual ~AppCacheService() {}

net/base/completion_callback.h

@@ -21,8 +21,6 @@ typedef base::Callback<void(int)> CompletionCallback;
 // error code.
 typedef base::Callback<void(int64_t)> Int64CompletionCallback;
 
-typedef base::CancelableCallback<void(int)> CancelableCompletionCallback;
-
 }  // namespace net
 
 #endif  // NET_BASE_COMPLETION_CALLBACK_H_