Revert "Reland "Use CompletionOnceCallback in //content/browser/appcache.""

This reverts commit 1df37f0e33c9cfb2337be2895d6f3c434aebdf17.

Reason for revert: We actually want this change reverted :). The original CL was bad, the revert was a manual thing done by the sheriff. The GoB fix then re-landed this, and now we want to reland it again.

Original change's description:
> Reland "Use CompletionOnceCallback in //content/browser/appcache."
> 
> This reverts commit dfc0e36093e5c5818a613dc7782aa15f8c171694.
> 
> Reason for revert: Due to Gerrit outage http://crbug.com/872722, we are reverting this CL. Please, re-land it after all clear is given. If you have questions, please ask on the bug. Sorry for the inconvenience.
> 
> Original change's description:
> > Revert "Use CompletionOnceCallback in //content/browser/appcache."
> > 
> > This reverts commit 6b2ace6e0bb70c5c5f6d35f84e62c84207059ac0.
> > 
> > Reason for revert: Inadvertently submitted without CQ.  New UI is confusing.
> > 
> > Change-Id: Ie9b9ca30b5f456cb75ca1813041b6cba9904dd27
> > Reviewed-on: https://chromium-review.googlesource.com/1169442
> > Reviewed-by: Bence Béky <bnc@chromium.org>
> 
> TBR=kinuko@chromium.org,bnc@chromium.org
> 
> Change-Id: I32f091e1d523965cd85f18eb527ae71e3fdf18dd
> No-Presubmit: true
> No-Tree-Checks: true
> No-Try: true
> Reviewed-on: https://chromium-review.googlesource.com/1169867
> Reviewed-by: Andrii Shyshkalov <tandrii@chromium.org>

TBR=kinuko@chromium.org,bnc@chromium.org,tandrii@chromium.org

Change-Id: If57f238de6a6d00a540ca2c241c290506becc863
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/1169929Reviewed-by: Dirk Pranke <dpranke@chromium.org>
Commit-Queue: Dirk Pranke <dpranke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#581910}

content/browser/appcache/appcache_disk_cache.h

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

content/browser/appcache/appcache_disk_cache_unittest.cc

@@ -10,7 +10,6 @@
 #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"
@@ -25,8 +24,9 @@ class AppCacheDiskCacheTest : public testing::Test {
 
   void SetUp() override {
     ASSERT_TRUE(directory_.CreateUniqueTempDir());
-    completion_callback_ = base::BindRepeating(
-        &AppCacheDiskCacheTest::OnComplete, base::Unretained(this));
+    completion_callback_ = base::Bind(
+        &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::CompletionRepeatingCallback completion_callback_;
+  net::CompletionCallback completion_callback_;
   std::vector<int> completion_results_;
 
   static const int k10MBytes = 10 * 1024 * 1024;

content/browser/appcache/appcache_quota_client.cc

@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <map>
 #include <set>
-#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ -208,16 +207,15 @@ const AppCacheStorage::UsageMap* AppCacheQuotaClient::GetUsageMap() {
   return service_->storage()->usage_map();
 }
 
-net::CancelableCompletionRepeatingCallback*
+net::CancelableCompletionCallback*
 AppCacheQuotaClient::GetServiceDeleteCallback() {
-  // Lazily created due to base::CancelableCallback's threading restrictions,
-  // there is no way to detach from the thread created on.
+  // Lazily created due to CancelableCompletionCallback's threading
+  // restrictions, there is no way to detach from the thread created on.
   if (!service_delete_callback_) {
-    service_delete_callback_ =
-        std::make_unique<net::CancelableCompletionRepeatingCallback>(
-            base::BindRepeating(
-                &AppCacheQuotaClient::DidDeleteAppCachesForOrigin,
-                base::Unretained(this)));
+    service_delete_callback_.reset(
+        new net::CancelableCompletionCallback(
+            base::Bind(&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_repeating_callback.h"
+#include "net/base/completion_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::CancelableCompletionRepeatingCallback* GetServiceDeleteCallback();
+  net::CancelableCompletionCallback* GetServiceDeleteCallback();
 
   // For use by appcache internals during initialization and shutdown.
   CONTENT_EXPORT void NotifyAppCacheReady();
@@ -81,8 +81,7 @@ 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::CancelableCompletionRepeatingCallback>
-      service_delete_callback_;
+  std::unique_ptr<net::CancelableCompletionCallback> 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::CompletionOnceCallback());
+    host_->service()->DeleteAppCacheGroup(
+        manifest_url, net::CompletionCallback());
     DeliverNetworkResponse();
     return;
   }

content/browser/appcache/appcache_response.cc

@@ -6,8 +6,6 @@
 
 #include <stddef.h>
 
-#include <utility>
-
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
@@ -19,7 +17,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_once_callback.h"
+#include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "storage/common/storage_histograms.h"
@@ -161,34 +159,28 @@ void AppCacheResponseIO::OpenEntryIfNeeded() {
     rv = net::ERR_FAILED;
   } else {
     entry_ptr = new AppCacheDiskCacheInterface::Entry*;
-    rv = disk_cache_->OpenEntry(
-        response_id_, entry_ptr,
-        base::BindOnce(&AppCacheResponseIO::OpenEntryCallback,
-                       weak_factory_.GetWeakPtr(), entry_ptr));
+    open_callback_ =
+        base::Bind(&AppCacheResponseIO::OpenEntryCallback,
+                   weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
+    rv = disk_cache_->OpenEntry(response_id_, entry_ptr, open_callback_);
   }
 
   if (rv != net::ERR_IO_PENDING)
-    OpenEntryCallback(weak_factory_.GetWeakPtr(), entry_ptr, rv);
+    OpenEntryCallback(entry_ptr, rv);
 }
 
-// static
 void AppCacheResponseIO::OpenEntryCallback(
-    base::WeakPtr<AppCacheResponseIO> response,
-    AppCacheDiskCacheInterface::Entry** entry,
-    int rv) {
-  if (!response) {
-    delete entry;
-    return;
-  }
-
-  DCHECK(response->info_buffer_.get() || response->buffer_.get());
+    AppCacheDiskCacheInterface::Entry** entry, int rv) {
+  DCHECK(info_buffer_.get() || buffer_.get());
 
-  if (!response->entry_ && rv == net::OK) {
-    DCHECK(entry);
-    response->entry_ = *entry;
+  if (!open_callback_.is_null()) {
+    if (rv == net::OK) {
+      DCHECK(entry);
+      entry_ = *entry;
+    }
+    open_callback_.Reset();
   }
-  delete entry;
-  response->OnOpenEntryComplete();
+  OnOpenEntryComplete();
 }
 
 
@@ -416,73 +408,55 @@ void AppCacheResponseWriter::CreateEntryIfNeededAndContinue() {
   } else {
     creation_phase_ = INITIAL_ATTEMPT;
     entry_ptr = new AppCacheDiskCacheInterface::Entry*;
-    rv = disk_cache_->CreateEntry(
-        response_id_, entry_ptr,
-        base::BindOnce(&AppCacheResponseWriter::OnCreateEntryComplete,
-                       weak_factory_.GetWeakPtr(), entry_ptr));
+    create_callback_ =
+        base::Bind(&AppCacheResponseWriter::OnCreateEntryComplete,
+                   weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
+    rv = disk_cache_->CreateEntry(response_id_, entry_ptr, create_callback_);
   }
   if (rv != net::ERR_IO_PENDING)
-    OnCreateEntryComplete(weak_factory_.GetWeakPtr(), entry_ptr, rv);
+    OnCreateEntryComplete(entry_ptr, rv);
 }
 
-// static
 void AppCacheResponseWriter::OnCreateEntryComplete(
-    base::WeakPtr<AppCacheResponseWriter> writer,
-    AppCacheDiskCacheInterface::Entry** entry,
-    int rv) {
-  if (!writer) {
-    if (entry) {
-      delete entry;
-    }
-    return;
-  }
+    AppCacheDiskCacheInterface::Entry** entry, int rv) {
+  DCHECK(info_buffer_.get() || buffer_.get());
 
-  DCHECK(writer->info_buffer_.get() || writer->buffer_.get());
-
-  if (!writer->disk_cache_) {
-    if (entry) {
-      delete entry;
-    }
-    writer->ScheduleIOCompletionCallback(net::ERR_FAILED);
+  if (!disk_cache_) {
+    ScheduleIOCompletionCallback(net::ERR_FAILED);
     return;
-  } else if (writer->creation_phase_ == INITIAL_ATTEMPT) {
+  } else if (creation_phase_ == INITIAL_ATTEMPT) {
     if (rv != net::OK) {
       // We may try to overwrite existing entries.
-      delete entry;
-      writer->creation_phase_ = DOOM_EXISTING;
-      rv = writer->disk_cache_->DoomEntry(
-          writer->response_id_,
-          base::BindOnce(&AppCacheResponseWriter::OnCreateEntryComplete, writer,
-                         nullptr));
+      creation_phase_ = DOOM_EXISTING;
+      rv = disk_cache_->DoomEntry(response_id_, create_callback_);
       if (rv != net::ERR_IO_PENDING)
-        OnCreateEntryComplete(writer, nullptr, rv);
+        OnCreateEntryComplete(nullptr, rv);
       return;
     }
-  } else if (writer->creation_phase_ == DOOM_EXISTING) {
-    DCHECK_EQ(nullptr, entry);
-    writer->creation_phase_ = SECOND_ATTEMPT;
+  } else if (creation_phase_ == DOOM_EXISTING) {
+    creation_phase_ = SECOND_ATTEMPT;
     AppCacheDiskCacheInterface::Entry** entry_ptr =
         new AppCacheDiskCacheInterface::Entry*;
-    rv = writer->disk_cache_->CreateEntry(
-        writer->response_id_, entry_ptr,
-        base::BindOnce(&AppCacheResponseWriter::OnCreateEntryComplete, writer,
-                       entry_ptr));
+    create_callback_ =
+        base::Bind(&AppCacheResponseWriter::OnCreateEntryComplete,
+                   weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
+    rv = disk_cache_->CreateEntry(response_id_, entry_ptr, create_callback_);
     if (rv != net::ERR_IO_PENDING)
-      OnCreateEntryComplete(writer, entry_ptr, rv);
+      OnCreateEntryComplete(entry_ptr, rv);
     return;
   }
 
-  if (!writer->entry_ && rv == net::OK) {
-    DCHECK(entry);
-    writer->entry_ = *entry;
-  }
+  if (!create_callback_.is_null()) {
+    if (rv == net::OK)
+      entry_ = *entry;
 
-  delete entry;
+    create_callback_.Reset();
+  }
 
-  if (writer->info_buffer_.get())
-    writer->ContinueWriteInfo();
+  if (info_buffer_.get())
+    ContinueWriteInfo();
   else
-    writer->ContinueWriteData();
+    ContinueWriteData();
 }
 
 // AppCacheResponseMetadataWriter ----------------------------------------------
@@ -500,7 +474,7 @@ AppCacheResponseMetadataWriter::~AppCacheResponseMetadataWriter() {
 void AppCacheResponseMetadataWriter::WriteMetadata(
     net::IOBuffer* buf,
     int buf_len,
-    net::CompletionOnceCallback callback) {
+    const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(!IsIOPending());
   DCHECK(buf);
@@ -509,7 +483,7 @@ void AppCacheResponseMetadataWriter::WriteMetadata(
 
   buffer_ = buf;
   write_amount_ = buf_len;
-  callback_ = std::move(callback);  // cleared on completion
+  callback_ = 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_once_callback.h"
+#include "net/base/completion_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,
-                     net::CompletionOnceCallback callback) = 0;
+                     const net::CompletionCallback& callback) = 0;
     virtual int Write(int index,
                       int64_t offset,
                       net::IOBuffer* buf,
                       int buf_len,
-                      net::CompletionOnceCallback callback) = 0;
+                      const net::CompletionCallback& callback) = 0;
     virtual int64_t GetSize(int index) = 0;
     virtual void Close() = 0;
    protected:
@@ -101,11 +101,12 @@ class CONTENT_EXPORT AppCacheDiskCacheInterface {
 
   virtual int CreateEntry(int64_t key,
                           Entry** entry,
-                          net::CompletionOnceCallback callback) = 0;
+                          const net::CompletionCallback& callback) = 0;
   virtual int OpenEntry(int64_t key,
                         Entry** entry,
-                        net::CompletionOnceCallback callback) = 0;
-  virtual int DoomEntry(int64_t key, net::CompletionOnceCallback callback) = 0;
+                        const net::CompletionCallback& callback) = 0;
+  virtual int DoomEntry(int64_t key,
+                        const net::CompletionCallback& callback) = 0;
 
   const char* uma_name() const { return uma_name_; }
   base::WeakPtr<AppCacheDiskCacheInterface> GetWeakPtr();
@@ -145,14 +146,12 @@ class CONTENT_EXPORT AppCacheResponseIO {
   scoped_refptr<net::IOBuffer> buffer_;
   int buffer_len_;
   OnceCompletionCallback callback_;
-  net::CompletionOnceCallback open_callback_;
+  net::CompletionCallback open_callback_;
   base::WeakPtrFactory<AppCacheResponseIO> weak_factory_;
 
  private:
   void OnRawIOComplete(int result);
-  static void OpenEntryCallback(base::WeakPtr<AppCacheResponseIO> response,
-                                AppCacheDiskCacheInterface::Entry** entry,
-                                int rv);
+  void OpenEntryCallback(AppCacheDiskCacheInterface::Entry** entry, int rv);
 };
 
 // Reads existing response data from storage. If the object is deleted
@@ -278,15 +277,13 @@ class CONTENT_EXPORT AppCacheResponseWriter
   void ContinueWriteInfo();
   void ContinueWriteData();
   void CreateEntryIfNeededAndContinue();
-  static void OnCreateEntryComplete(
-      base::WeakPtr<AppCacheResponseWriter> writer,
-      AppCacheDiskCacheInterface::Entry** entry,
-      int rv);
+  void OnCreateEntryComplete(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_;
 };
 
@@ -310,7 +307,7 @@ class CONTENT_EXPORT AppCacheResponseMetadataWriter
   // progress.
   void WriteMetadata(net::IOBuffer* buf,
                      int buf_len,
-                     net::CompletionOnceCallback callback);
+                     const net::CompletionCallback& callback);
 
   // Returns true if there is a write pending.
   bool IsWritePending() { return IsIOPending(); }

content/browser/appcache/appcache_service_impl.cc

@@ -25,6 +25,7 @@
 #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"
 
@@ -89,11 +90,11 @@ void AppCacheServiceImpl::AsyncHelper::Cancel() {
 
 class AppCacheServiceImpl::DeleteHelper : public AsyncHelper {
  public:
-  DeleteHelper(AppCacheServiceImpl* service,
-               const GURL& manifest_url,
-               net::CompletionOnceCallback callback)
-      : AsyncHelper(service, std::move(callback)),
-        manifest_url_(manifest_url) {}
+  DeleteHelper(
+      AppCacheServiceImpl* service, const GURL& manifest_url,
+      const net::CompletionCallback& callback)
+      : AsyncHelper(service, callback), manifest_url_(manifest_url) {
+  }
 
   void Start() override {
     service_->storage()->LoadOrCreateGroup(manifest_url_, this);
@@ -136,8 +137,8 @@ class AppCacheServiceImpl::DeleteOriginHelper : public AsyncHelper {
  public:
   DeleteOriginHelper(AppCacheServiceImpl* service,
                      const url::Origin& origin,
-                     net::CompletionOnceCallback callback)
-      : AsyncHelper(service, std::move(callback)),
+                     const net::CompletionCallback& callback)
+      : AsyncHelper(service, callback),
         origin_(origin),
         num_caches_to_delete_(0),
         successes_(0),
@@ -260,7 +261,7 @@ class AppCacheServiceImpl::CheckResponseHelper : AsyncHelper {
                       const GURL& manifest_url,
                       int64_t cache_id,
                       int64_t response_id)
-      : AsyncHelper(service, net::CompletionOnceCallback()),
+      : AsyncHelper(service, net::CompletionCallback()),
         manifest_url_(manifest_url),
         cache_id_(cache_id),
         response_id_(response_id),
@@ -319,8 +320,7 @@ void AppCacheServiceImpl::CheckResponseHelper::OnGroupLoaded(
     if (cache_->cache_id() == cache_id_) {
       AppCacheHistograms::CountCheckResponseResult(
           AppCacheHistograms::ENTRY_NOT_FOUND);
-      service_->DeleteAppCacheGroup(manifest_url_,
-                                    net::CompletionOnceCallback());
+      service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
     } 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::CompletionOnceCallback());
+    service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
     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::CompletionOnceCallback());
+    service_->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
   delete this;
 }
 
@@ -484,17 +484,15 @@ void AppCacheServiceImpl::GetAllAppCacheInfo(AppCacheInfoCollection* collection,
 
 void AppCacheServiceImpl::DeleteAppCacheGroup(
     const GURL& manifest_url,
-    net::CompletionOnceCallback callback) {
-  DeleteHelper* helper =
-      new DeleteHelper(this, manifest_url, std::move(callback));
+    const net::CompletionCallback& callback) {
+  DeleteHelper* helper = new DeleteHelper(this, manifest_url, callback);
   helper->Start();
 }
 
 void AppCacheServiceImpl::DeleteAppCachesForOrigin(
     const url::Origin& origin,
-    net::CompletionOnceCallback callback) {
-  DeleteOriginHelper* helper =
-      new DeleteOriginHelper(this, origin, std::move(callback));
+    const net::CompletionCallback& callback) {
+  DeleteOriginHelper* helper = new DeleteOriginHelper(this, origin, 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_once_callback.h"
+#include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 
@@ -105,13 +105,14 @@ class CONTENT_EXPORT AppCacheServiceImpl
   void GetAllAppCacheInfo(AppCacheInfoCollection* collection,
                           OnceCompletionCallback callback) override;
   void DeleteAppCacheGroup(const GURL& manifest_url,
-                           net::CompletionOnceCallback callback) override;
+                           const net::CompletionCallback& 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,
-                                        net::CompletionOnceCallback callback);
+  virtual void DeleteAppCachesForOrigin(
+      const url::Origin& origin,
+      const net::CompletionCallback& 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_once_callback.h"
+#include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -101,7 +101,10 @@ class AppCacheServiceImplTest : public testing::Test {
         kManifestUrl(kOriginURL.Resolve("manifest")),
         service_(new AppCacheServiceImpl(nullptr)),
         delete_result_(net::OK),
-        delete_completion_count_(0) {
+        delete_completion_count_(0),
+        deletion_callback_(
+            base::Bind(&AppCacheServiceImplTest::OnDeleteAppCachesComplete,
+                       base::Unretained(this))) {
     // Setup to use mock storage.
     service_->storage_.reset(new MockAppCacheStorage(service_.get()));
   }
@@ -180,11 +183,6 @@ 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;
@@ -193,11 +191,12 @@ 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_);
@@ -206,7 +205,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_);
@@ -228,7 +227,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_);
@@ -239,7 +238,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_);
@@ -248,7 +247,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,6 +18,7 @@
 #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,8 +893,7 @@ void AppCacheUpdateJob::CheckIfManifestChanged() {
                                GURL(), 0, false /*is_cross_origin*/),
           DB_ERROR, GURL());
       AppCacheHistograms::AddMissingManifestEntrySample();
-      service->DeleteAppCacheGroup(manifest_url_,
-                                   net::CompletionOnceCallback());
+      service->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
     }
     return;
   }

content/browser/appcache/appcache_update_job.h

@@ -26,6 +26,7 @@
 #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,8 +4,6 @@
 
 #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"
@@ -13,16 +11,17 @@
 
 namespace content {
 
-static void DeferredCallCallback(net::CompletionOnceCallback callback, int rv) {
-  std::move(callback).Run(rv);
+static void DeferredCallCallback(
+    const net::CompletionCallback& callback, int rv) {
+  callback.Run(rv);
 }
 
 void MockAppCacheService::DeleteAppCachesForOrigin(
     const url::Origin& origin,
-    net::CompletionOnceCallback callback) {
+    const net::CompletionCallback& callback) {
   ++delete_called_count_;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::BindOnce(&DeferredCallCallback, std::move(callback),
+      FROM_HERE, base::BindOnce(&DeferredCallCallback, callback,
                                 mock_delete_appcaches_for_origin_result_));
 }
 

content/browser/appcache/mock_appcache_service.h

@@ -24,8 +24,9 @@ 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,
-                                net::CompletionOnceCallback callback) override;
+  void DeleteAppCachesForOrigin(
+      const url::Origin& origin,
+      const net::CompletionCallback& callback) override;
 
   void set_quota_manager_proxy(storage::QuotaManagerProxy* proxy) {
     quota_manager_proxy_ = proxy;

content/browser/appcache/mock_appcache_storage.h

@@ -144,8 +144,7 @@ class MockAppCacheStorage : public AppCacheStorage {
     if (!disk_cache_) {
       const int kMaxCacheSize = 10 * 1024 * 1024;
       disk_cache_.reset(new AppCacheDiskCache);
-      disk_cache_->InitWithMemBackend(kMaxCacheSize,
-                                      net::CompletionOnceCallback());
+      disk_cache_->InitWithMemBackend(kMaxCacheSize, net::CompletionCallback());
     }
     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_once_callback.h"
+#include "net/base/completion_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,
-                                   net::CompletionOnceCallback callback) = 0;
+                                   const net::CompletionCallback& callback) = 0;
 
  protected:
   virtual ~AppCacheService() {}

net/base/completion_callback.h

@@ -21,6 +21,8 @@ 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_