CacheStorage: Migrate to BindOnce/OnceCallback/OnceClosure

content/browser/cache_storage/cache_storage_cache_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/cache_storage/cache_storage_cache.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 67 matching lines @@
   }
 
   int CreateEntry(const std::string& key,
                   disk_cache::Entry** entry,
                   const CompletionCallback& callback) override {
     return backend_->CreateEntry(key, entry, callback);
   }
   int DoomEntry(const std::string& key,
                 const CompletionCallback& callback) override {
     if (delay_doom_) {
-      doom_entry_callback_ = base::Bind(&DelayableBackend::DoomEntryDelayedImpl,
-                                        base::Unretained(this), key, callback);
+      doom_entry_callback_ =
+          base::BindOnce(&DelayableBackend::DoomEntryDelayedImpl,
+                         base::Unretained(this), key, callback);
       return net::ERR_IO_PENDING;
     }
 
     return backend_->DoomEntry(key, callback);
   }
   int DoomAllEntries(const CompletionCallback& callback) override {
     return backend_->DoomAllEntries(callback);
   }
   int DoomEntriesBetween(base::Time initial_time,
                          base::Time end_time,
@@ skipping 21 matching lines @@
   size_t DumpMemoryStats(
       base::trace_event::ProcessMemoryDump* pmd,
       const std::string& parent_absolute_name) const override {
     NOTREACHED();
     return 0u;
   }
 
   // Call to continue a delayed doom.
   void DoomEntryContinue() {
     EXPECT_FALSE(doom_entry_callback_.is_null());
-    doom_entry_callback_.Run();
+    std::move(doom_entry_callback_).Run();
   }
 
   void set_delay_doom(bool value) { delay_doom_ = value; }
 
  private:
   void DoomEntryDelayedImpl(const std::string& key,
                             const CompletionCallback& callback) {
     int rv = backend_->DoomEntry(key, callback);
     if (rv != net::ERR_IO_PENDING)
       callback.Run(rv);
   }
 
   std::unique_ptr<disk_cache::Backend> backend_;
   bool delay_doom_;
-  base::Closure doom_entry_callback_;
+  base::OnceClosure doom_entry_callback_;
 };
 
 void CopyBody(const storage::BlobDataHandle& blob_handle, std::string* output) {
   *output = std::string();
   std::unique_ptr<storage::BlobDataSnapshot> data =
       blob_handle.CreateSnapshot();
   const auto& items = data->items();
   for (const auto& item : items) {
     switch (item->type()) {
       case storage::DataElement::TYPE_BYTES: {
@@ skipping 129 matching lines @@
       : CacheStorageCache(origin,
                           cache_name,
                           path,
                           cache_storage,
                           request_context_getter,
                           quota_manager_proxy,
                           blob_context,
                           0 /* cache_size */),
         delay_backend_creation_(false) {}
 
-  void CreateBackend(const ErrorCallback& callback) override {
-    backend_creation_callback_ = callback;
+  void CreateBackend(ErrorCallback callback) override {
+    backend_creation_callback_ = std::move(callback);
     if (delay_backend_creation_)
       return;
     ContinueCreateBackend();
   }
 
   void ContinueCreateBackend() {
-    CacheStorageCache::CreateBackend(backend_creation_callback_);
+    CacheStorageCache::CreateBackend(std::move(backend_creation_callback_));
   }
 
   void set_delay_backend_creation(bool delay) {
     delay_backend_creation_ = delay;
   }
 
   // Swap the existing backend with a delayable one. The backend must have been
   // created before calling this.
   DelayableBackend* UseDelayableBackend() {
     EXPECT_TRUE(backend_);
@@ skipping 142 matching lines @@
         request.url, request.method, request.headers, request.referrer,
         request.is_reload);
   }
 
   CacheStorageError BatchOperation(
       const std::vector<CacheStorageBatchOperation>& operations) {
     std::unique_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->BatchOperation(
         operations,
-        base::Bind(&CacheStorageCacheTest::ErrorTypeCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
+        base::BindOnce(&CacheStorageCacheTest::ErrorTypeCallback,
+                       base::Unretained(this), base::Unretained(loop.get())));
     // TODO(jkarlin): These functions should use base::RunLoop().RunUntilIdle()
     // once the cache uses a passed in task runner instead of the CACHE thread.
     loop->Run();
 
     return callback_error_;
   }
 
   bool Put(const ServiceWorkerFetchRequest& request,
            const ServiceWorkerResponse& response) {
     CacheStorageBatchOperation operation;
     operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
     operation.request = request;
     operation.response = response;
 
     CacheStorageError error =
         BatchOperation(std::vector<CacheStorageBatchOperation>(1, operation));
     return error == CACHE_STORAGE_OK;
   }
 
   bool Match(const ServiceWorkerFetchRequest& request,
              const CacheStorageCacheQueryParams& match_params =
                  CacheStorageCacheQueryParams()) {
     std::unique_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->Match(
         CopyFetchRequest(request), match_params,
-        base::Bind(&CacheStorageCacheTest::ResponseAndErrorCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
+        base::BindOnce(&CacheStorageCacheTest::ResponseAndErrorCallback,
+                       base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool MatchAll(
       const ServiceWorkerFetchRequest& request,
       const CacheStorageCacheQueryParams& match_params,
       std::unique_ptr<CacheStorageCache::Responses>* responses,
       std::unique_ptr<CacheStorageCache::BlobDataHandles>* body_handles) {
     base::RunLoop loop;
     cache_->MatchAll(
         CopyFetchRequest(request), match_params,
-        base::Bind(&CacheStorageCacheTest::ResponsesAndErrorCallback,
-                   base::Unretained(this), loop.QuitClosure(), responses,
-                   body_handles));
+        base::BindOnce(&CacheStorageCacheTest::ResponsesAndErrorCallback,
+                       base::Unretained(this), loop.QuitClosure(), responses,
+                       body_handles));
     loop.Run();
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool MatchAll(
       std::unique_ptr<CacheStorageCache::Responses>* responses,
       std::unique_ptr<CacheStorageCache::BlobDataHandles>* body_handles) {
     return MatchAll(ServiceWorkerFetchRequest(), CacheStorageCacheQueryParams(),
                     responses, body_handles);
   }
@@ skipping 12 matching lines @@
   }
 
   bool Keys(
       const ServiceWorkerFetchRequest& request = ServiceWorkerFetchRequest(),
       const CacheStorageCacheQueryParams& match_params =
           CacheStorageCacheQueryParams()) {
     std::unique_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->Keys(
         CopyFetchRequest(request), match_params,
-        base::Bind(&CacheStorageCacheTest::RequestsCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
+        base::BindOnce(&CacheStorageCacheTest::RequestsCallback,
+                       base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool Close() {
     std::unique_ptr<base::RunLoop> loop(new base::RunLoop());
 
-    cache_->Close(base::Bind(&CacheStorageCacheTest::CloseCallback,
-                             base::Unretained(this),
-                             base::Unretained(loop.get())));
+    cache_->Close(base::BindOnce(&CacheStorageCacheTest::CloseCallback,
+                                 base::Unretained(this),
+                                 base::Unretained(loop.get())));
     loop->Run();
     return callback_closed_;
   }
 
   bool WriteSideData(const GURL& url,
                      base::Time expected_response_time,
                      scoped_refptr<net::IOBuffer> buffer,
                      int buf_len) {
     base::RunLoop run_loop;
     cache_->WriteSideData(
-        base::Bind(&CacheStorageCacheTest::ErrorTypeCallback,
-                   base::Unretained(this), base::Unretained(&run_loop)),
+        base::BindOnce(&CacheStorageCacheTest::ErrorTypeCallback,
+                       base::Unretained(this), base::Unretained(&run_loop)),
         url, expected_response_time, buffer, buf_len);
     run_loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   int64_t Size() {
     // Storage notification happens after an operation completes. Let the any
     // notifications complete before calling Size.
     base::RunLoop().RunUntilIdle();
 
     base::RunLoop run_loop;
     bool callback_called = false;
-    cache_->Size(base::Bind(&CacheStorageCacheTest::SizeCallback,
-                            base::Unretained(this), &run_loop,
-                            &callback_called));
+    cache_->Size(base::BindOnce(&CacheStorageCacheTest::SizeCallback,
+                                base::Unretained(this), &run_loop,
+                                &callback_called));
     run_loop.Run();
     EXPECT_TRUE(callback_called);
     return callback_size_;
   }
 
   int64_t GetSizeThenClose() {
     base::RunLoop run_loop;
     bool callback_called = false;
-    cache_->GetSizeThenClose(base::Bind(&CacheStorageCacheTest::SizeCallback,
-                                        base::Unretained(this), &run_loop,
-                                        &callback_called));
+    cache_->GetSizeThenClose(
+        base::BindOnce(&CacheStorageCacheTest::SizeCallback,
+                       base::Unretained(this), &run_loop, &callback_called));
     run_loop.Run();
     EXPECT_TRUE(callback_called);
     return callback_size_;
   }
 
   void RequestsCallback(base::RunLoop* run_loop,
                         CacheStorageError error,
                         std::unique_ptr<CacheStorageCache::Requests> requests) {
     callback_error_ = error;
     callback_strings_.clear();
@@ skipping 30 matching lines @@
     callback_response_ = std::move(response);
     callback_response_data_.reset();
     if (error == CACHE_STORAGE_OK && !callback_response_->blob_uuid.empty())
       callback_response_data_ = std::move(body_handle);
 
     if (run_loop)
       run_loop->Quit();
   }
 
   void ResponsesAndErrorCallback(
-      const base::Closure& quit_closure,
+      base::OnceClosure quit_closure,
       std::unique_ptr<CacheStorageCache::Responses>* responses_out,
       std::unique_ptr<CacheStorageCache::BlobDataHandles>* body_handles_out,
       CacheStorageError error,
       std::unique_ptr<CacheStorageCache::Responses> responses,
       std::unique_ptr<CacheStorageCache::BlobDataHandles> body_handles) {
     callback_error_ = error;
     responses_out->swap(responses);
     body_handles_out->swap(body_handles);
-    quit_closure.Run();
+    std::move(quit_closure).Run();
   }
 
   void CloseCallback(base::RunLoop* run_loop) {
     EXPECT_FALSE(callback_closed_);
     callback_closed_ = true;
     if (run_loop)
       run_loop->Quit();
   }
 
   void SizeCallback(base::RunLoop* run_loop,
@@ skipping 192 matching lines @@
 
 TEST_F(CacheStorageCacheTest, PutBodyDropBlobRef) {
   CacheStorageBatchOperation operation;
   operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
   operation.request = body_request_;
   operation.response = body_response_;
 
   std::unique_ptr<base::RunLoop> loop(new base::RunLoop());
   cache_->BatchOperation(
       std::vector<CacheStorageBatchOperation>(1, operation),
-      base::Bind(&CacheStorageCacheTestP::ErrorTypeCallback,
-                 base::Unretained(this), base::Unretained(loop.get())));
+      base::BindOnce(&CacheStorageCacheTestP::ErrorTypeCallback,
+                     base::Unretained(this), base::Unretained(loop.get())));
   // The handle should be held by the cache now so the deref here should be
   // okay.
   blob_handle_.reset();
   loop->Run();
 
   EXPECT_EQ(CACHE_STORAGE_OK, callback_error_);
 }
 
 TEST_P(CacheStorageCacheTestP, PutReplace) {
   EXPECT_TRUE(Put(body_request_, no_body_response_));
@@ skipping 737 matching lines @@
   int sequence_out = -1;
 
   CacheStorageBatchOperation operation1;
   operation1.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
   operation1.request = body_request_;
   operation1.response = body_response_;
 
   std::unique_ptr<base::RunLoop> close_loop1(new base::RunLoop());
   cache_->BatchOperation(
       std::vector<CacheStorageBatchOperation>(1, operation1),
-      base::Bind(&CacheStorageCacheTest::SequenceCallback,
-                 base::Unretained(this), 1, &sequence_out, close_loop1.get()));
+      base::BindOnce(&CacheStorageCacheTest::SequenceCallback,
+                     base::Unretained(this), 1, &sequence_out,
+                     close_loop1.get()));
 
   // Blocks on creating the cache entry.
   base::RunLoop().RunUntilIdle();
 
   CacheStorageBatchOperation operation2;
   operation2.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
   operation2.request = body_request_;
   operation2.response = body_response_;
 
   delayable_backend->set_delay_doom(false);
   std::unique_ptr<base::RunLoop> close_loop2(new base::RunLoop());
   cache_->BatchOperation(
       std::vector<CacheStorageBatchOperation>(1, operation2),
-      base::Bind(&CacheStorageCacheTest::SequenceCallback,
-                 base::Unretained(this), 2, &sequence_out, close_loop2.get()));
+      base::BindOnce(&CacheStorageCacheTest::SequenceCallback,
+                     base::Unretained(this), 2, &sequence_out,
+                     close_loop2.get()));
 
   // The second put operation should wait for the first to complete.
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_response_);
 
   delayable_backend->DoomEntryContinue();
   close_loop1->Run();
   EXPECT_EQ(1, sequence_out);
   close_loop2->Run();
   EXPECT_EQ(2, sequence_out);
 }
 
 INSTANTIATE_TEST_CASE_P(CacheStorageCacheTest,
                         CacheStorageCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content