CacheStorage: Migrate to BindOnce/OnceCallback/OnceClosure

content/browser/cache_storage/cache_storage_manager_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_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
@@ skipping 199 matching lines @@
         BrowserContext::GetDefaultStoragePartition(&browser_context_)
             ->GetURLRequestContext(),
         blob_storage_context->context()->AsWeakPtr());
   }
 
   bool FlushCacheStorageIndex(const GURL& origin) {
     callback_bool_ = false;
     base::RunLoop loop;
     bool write_was_scheduled =
         CacheStorageForOrigin(origin)->InitiateScheduledIndexWriteForTest(
-            base::Bind(&CacheStorageManagerTest::BoolCallback,
-                       base::Unretained(this), &loop));
+            base::BindOnce(&CacheStorageManagerTest::BoolCallback,
+                           base::Unretained(this), &loop));
     loop.Run();
     DCHECK(callback_bool_);
     return write_was_scheduled;
   }
 
   void DestroyStorageManager() {
     if (quota_manager_proxy_)
       quota_manager_proxy_->SimulateQuotaManagerDestroyed();
     base::RunLoop().RunUntilIdle();
     quota_manager_proxy_ = nullptr;
@@ skipping 11 matching lines @@
     callback_cache_index_ = CacheStorageIndex();
     callback_all_origins_usage_.clear();
 
     cache_manager_ = nullptr;
   }
 
   bool Open(const GURL& origin, const std::string& cache_name) {
     base::RunLoop loop;
     cache_manager_->OpenCache(
         origin, cache_name,
-        base::Bind(&CacheStorageManagerTest::CacheAndErrorCallback,
-                   base::Unretained(this), base::Unretained(&loop)));
+        base::BindOnce(&CacheStorageManagerTest::CacheAndErrorCallback,
+                       base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     bool error = callback_error_ != CACHE_STORAGE_OK;
     if (error)
       EXPECT_FALSE(callback_cache_handle_);
     else
       EXPECT_TRUE(callback_cache_handle_);
     return !error;
   }
 
   bool Has(const GURL& origin, const std::string& cache_name) {
     base::RunLoop loop;
     cache_manager_->HasCache(
         origin, cache_name,
-        base::Bind(&CacheStorageManagerTest::BoolAndErrorCallback,
-                   base::Unretained(this), base::Unretained(&loop)));
+        base::BindOnce(&CacheStorageManagerTest::BoolAndErrorCallback,
+                       base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_bool_;
   }
 
   bool Delete(const GURL& origin, const std::string& cache_name) {
     base::RunLoop loop;
     cache_manager_->DeleteCache(
         origin, cache_name,
-        base::Bind(&CacheStorageManagerTest::BoolAndErrorCallback,
-                   base::Unretained(this), base::Unretained(&loop)));
+        base::BindOnce(&CacheStorageManagerTest::BoolAndErrorCallback,
+                       base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_bool_;
   }
 
   size_t Keys(const GURL& origin) {
     base::RunLoop loop;
     cache_manager_->EnumerateCaches(
-        origin, base::Bind(&CacheStorageManagerTest::CacheMetadataCallback,
-                           base::Unretained(this), base::Unretained(&loop)));
+        origin,
+        base::BindOnce(&CacheStorageManagerTest::CacheMetadataCallback,
+                       base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
     return callback_cache_index_.num_entries();
   }
 
   bool StorageMatch(const GURL& origin,
                     const std::string& cache_name,
                     const GURL& url,
                     const CacheStorageCacheQueryParams& match_params =
                         CacheStorageCacheQueryParams()) {
     ServiceWorkerFetchRequest request;
     request.url = url;
     return StorageMatchWithRequest(origin, cache_name, request, match_params);
   }
 
   bool StorageMatchWithRequest(
       const GURL& origin,
       const std::string& cache_name,
       const ServiceWorkerFetchRequest& request,
       const CacheStorageCacheQueryParams& match_params =
           CacheStorageCacheQueryParams()) {
     std::unique_ptr<ServiceWorkerFetchRequest> unique_request =
         base::MakeUnique<ServiceWorkerFetchRequest>(request);
 
     base::RunLoop loop;
     cache_manager_->MatchCache(
         origin, cache_name, std::move(unique_request), match_params,
-        base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
-                   base::Unretained(this), base::Unretained(&loop)));
+        base::BindOnce(&CacheStorageManagerTest::CacheMatchCallback,
+                       base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool StorageMatchAll(const GURL& origin,
                        const GURL& url,
                        const CacheStorageCacheQueryParams& match_params =
                            CacheStorageCacheQueryParams()) {
     ServiceWorkerFetchRequest request;
     request.url = url;
     return StorageMatchAllWithRequest(origin, request, match_params);
   }
 
   bool StorageMatchAllWithRequest(
       const GURL& origin,
       const ServiceWorkerFetchRequest& request,
       const CacheStorageCacheQueryParams& match_params =
           CacheStorageCacheQueryParams()) {
     std::unique_ptr<ServiceWorkerFetchRequest> unique_request =
         base::MakeUnique<ServiceWorkerFetchRequest>(request);
     base::RunLoop loop;
     cache_manager_->MatchAllCaches(
         origin, std::move(unique_request), match_params,
-        base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
-                   base::Unretained(this), base::Unretained(&loop)));
+        base::BindOnce(&CacheStorageManagerTest::CacheMatchCallback,
+                       base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool CachePut(CacheStorageCache* cache, const GURL& url) {
     ServiceWorkerFetchRequest request;
     request.url = url;
 
     return CachePutWithStatusCode(cache, request, 200);
@@ skipping 32 matching lines @@
             ServiceWorkerHeaderList>() /* cors_exposed_header_names */);
 
     CacheStorageBatchOperation operation;
     operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
     operation.request = request;
     operation.response = response;
 
     base::RunLoop loop;
     cache->BatchOperation(
         std::vector<CacheStorageBatchOperation>(1, operation),
-        base::Bind(&CacheStorageManagerTest::CachePutCallback,
-                   base::Unretained(this), base::Unretained(&loop)));
+        base::BindOnce(&CacheStorageManagerTest::CachePutCallback,
+                       base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool CacheMatch(CacheStorageCache* cache, const GURL& url) {
     std::unique_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
     request->url = url;
     base::RunLoop loop;
-    cache->Match(std::move(request), CacheStorageCacheQueryParams(),
-                 base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
-                            base::Unretained(this), base::Unretained(&loop)));
+    cache->Match(
+        std::move(request), CacheStorageCacheQueryParams(),
+        base::BindOnce(&CacheStorageManagerTest::CacheMatchCallback,
+                       base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   CacheStorage* CacheStorageForOrigin(const GURL& origin) {
     return cache_manager_->FindOrCreateCacheStorage(origin);
   }
 
   int64_t GetOriginUsage(const GURL& origin) {
@@ skipping 23 matching lines @@
       base::RunLoop* run_loop,
       const std::vector<CacheStorageUsageInfo>& usage) {
     callback_all_origins_usage_ = usage;
     run_loop->Quit();
   }
 
   int64_t GetSizeThenCloseAllCaches(const GURL& origin) {
     base::RunLoop loop;
     CacheStorage* cache_storage = CacheStorageForOrigin(origin);
     cache_storage->GetSizeThenCloseAllCaches(
-        base::Bind(&CacheStorageManagerTest::UsageCallback,
-                   base::Unretained(this), &loop));
+        base::BindOnce(&CacheStorageManagerTest::UsageCallback,
+                       base::Unretained(this), &loop));
     loop.Run();
     return callback_usage_;
   }
 
   int64_t Size(const GURL& origin) {
     base::RunLoop loop;
     CacheStorage* cache_storage = CacheStorageForOrigin(origin);
-    cache_storage->Size(base::Bind(&CacheStorageManagerTest::UsageCallback,
-                                   base::Unretained(this), &loop));
+    cache_storage->Size(base::BindOnce(&CacheStorageManagerTest::UsageCallback,
+                                       base::Unretained(this), &loop));
     loop.Run();
     return callback_usage_;
   }
 
  protected:
   // Temporary directory must be allocated first so as to be destroyed last.
   base::ScopedTempDir temp_dir_;
 
   TestBrowserThreadBundle browser_thread_bundle_;
   TestBrowserContext browser_context_;
@@ skipping 460 matching lines @@
 }
 
 TEST_P(CacheStorageManagerTestP, OpenRunsSerially) {
   EXPECT_FALSE(Delete(origin1_, "tmp"));  // Init storage.
   CacheStorage* cache_storage = CacheStorageForOrigin(origin1_);
   cache_storage->StartAsyncOperationForTesting();
 
   base::RunLoop open_loop;
   cache_manager_->OpenCache(
       origin1_, "foo",
-      base::Bind(&CacheStorageManagerTest::CacheAndErrorCallback,
-                 base::Unretained(this), base::Unretained(&open_loop)));
+      base::BindOnce(&CacheStorageManagerTest::CacheAndErrorCallback,
+                     base::Unretained(this), base::Unretained(&open_loop)));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_cache_handle_);
 
   cache_storage->CompleteAsyncOperationForTesting();
   open_loop.Run();
   EXPECT_TRUE(callback_cache_handle_);
 }
 
 TEST_P(CacheStorageManagerTestP, GetOriginUsage) {
@@ skipping 543 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(CacheStorageManagerTests,
                         CacheStorageManagerTestP,
                         ::testing::Values(false, true));
 
 INSTANTIATE_TEST_CASE_P(CacheStorageQuotaClientTests,
                         CacheStorageQuotaClientTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content