CacheStorage: Migrate to BindOnce/OnceCallback/OnceClosure

content/browser/cache_storage/cache_storage_dispatcher_host.cc

 // Copyright 2015 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_dispatcher_host.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 62 matching lines @@
     : BrowserMessageFilter(kFilteredMessageClasses,
                            arraysize(kFilteredMessageClasses)) {}
 
 CacheStorageDispatcherHost::~CacheStorageDispatcherHost() {
 }
 
 void CacheStorageDispatcherHost::Init(CacheStorageContextImpl* context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&CacheStorageDispatcherHost::CreateCacheListener, this,
-                 base::RetainedRef(context)));
+      base::BindOnce(&CacheStorageDispatcherHost::CreateCacheListener, this,
+                     base::RetainedRef(context)));
 }
 
 void CacheStorageDispatcherHost::OnDestruct() const {
   BrowserThread::DeleteOnIOThread::Destruct(this);
 }
 
 bool CacheStorageDispatcherHost::OnMessageReceived(
     const IPC::Message& message) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 31 matching lines @@
     int request_id,
     const url::Origin& origin,
     const base::string16& cache_name) {
   TRACE_EVENT0("CacheStorage", "CacheStorageDispatcherHost::OnCacheStorageHas");
   if (!OriginCanAccessCacheStorage(origin)) {
     bad_message::ReceivedBadMessage(this, bad_message::CSDH_INVALID_ORIGIN);
     return;
   }
   context_->cache_manager()->HasCache(
       origin.GetURL(), base::UTF16ToUTF8(cache_name),
-      base::Bind(&CacheStorageDispatcherHost::OnCacheStorageHasCallback, this,
-                 thread_id, request_id));
+      base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageHasCallback,
+                     this, thread_id, request_id));
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageOpen(
     int thread_id,
     int request_id,
     const url::Origin& origin,
     const base::string16& cache_name) {
   TRACE_EVENT0("CacheStorage",
                "CacheStorageDispatcherHost::OnCacheStorageOpen");
   if (!OriginCanAccessCacheStorage(origin)) {
     bad_message::ReceivedBadMessage(this, bad_message::CSDH_INVALID_ORIGIN);
     return;
   }
   context_->cache_manager()->OpenCache(
       origin.GetURL(), base::UTF16ToUTF8(cache_name),
-      base::Bind(&CacheStorageDispatcherHost::OnCacheStorageOpenCallback, this,
-                 thread_id, request_id));
+      base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageOpenCallback,
+                     this, thread_id, request_id));
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageDelete(
     int thread_id,
     int request_id,
     const url::Origin& origin,
     const base::string16& cache_name) {
   TRACE_EVENT0("CacheStorage",
                "CacheStorageDispatcherHost::OnCacheStorageDelete");
   if (!OriginCanAccessCacheStorage(origin)) {
     bad_message::ReceivedBadMessage(this, bad_message::CSDH_INVALID_ORIGIN);
     return;
   }
   context_->cache_manager()->DeleteCache(
       origin.GetURL(), base::UTF16ToUTF8(cache_name),
-      base::Bind(&CacheStorageDispatcherHost::OnCacheStorageDeleteCallback,
-                 this, thread_id, request_id));
+      base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageDeleteCallback,
+                     this, thread_id, request_id));
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageKeys(int thread_id,
                                                     int request_id,
                                                     const url::Origin& origin) {
   TRACE_EVENT0("CacheStorage",
                "CacheStorageDispatcherHost::OnCacheStorageKeys");
   if (!OriginCanAccessCacheStorage(origin)) {
     bad_message::ReceivedBadMessage(this, bad_message::CSDH_INVALID_ORIGIN);
     return;
   }
   context_->cache_manager()->EnumerateCaches(
       origin.GetURL(),
-      base::Bind(&CacheStorageDispatcherHost::OnCacheStorageKeysCallback, this,
-                 thread_id, request_id));
+      base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageKeysCallback,
+                     this, thread_id, request_id));
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageMatch(
     int thread_id,
     int request_id,
     const url::Origin& origin,
     const ServiceWorkerFetchRequest& request,
     const CacheStorageCacheQueryParams& match_params) {
   TRACE_EVENT0("CacheStorage",
                "CacheStorageDispatcherHost::OnCacheStorageMatch");
   if (!OriginCanAccessCacheStorage(origin)) {
     bad_message::ReceivedBadMessage(this, bad_message::CSDH_INVALID_ORIGIN);
     return;
   }
   std::unique_ptr<ServiceWorkerFetchRequest> scoped_request(
       new ServiceWorkerFetchRequest(request.url, request.method,
                                     request.headers, request.referrer,
                                     request.is_reload));
 
   if (match_params.cache_name.is_null()) {
     context_->cache_manager()->MatchAllCaches(
         origin.GetURL(), std::move(scoped_request), match_params,
-        base::Bind(&CacheStorageDispatcherHost::OnCacheStorageMatchCallback,
-                   this, thread_id, request_id));
+        base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageMatchCallback,
+                       this, thread_id, request_id));
     return;
   }
   context_->cache_manager()->MatchCache(
       origin.GetURL(), base::UTF16ToUTF8(match_params.cache_name.string()),
       std::move(scoped_request), match_params,
-      base::Bind(&CacheStorageDispatcherHost::OnCacheStorageMatchCallback, this,
-                 thread_id, request_id));
+      base::BindOnce(&CacheStorageDispatcherHost::OnCacheStorageMatchCallback,
+                     this, thread_id, request_id));
 }
 
 void CacheStorageDispatcherHost::OnCacheMatch(
     int thread_id,
     int request_id,
     int cache_id,
     const ServiceWorkerFetchRequest& request,
     const CacheStorageCacheQueryParams& match_params) {
   IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
   if (it == id_to_cache_map_.end() || !it->second->value()) {
     Send(new CacheStorageMsg_CacheMatchError(
         thread_id, request_id, blink::kWebServiceWorkerCacheErrorNotFound));
     return;
   }
 
   CacheStorageCache* cache = it->second->value();
   std::unique_ptr<ServiceWorkerFetchRequest> scoped_request(
       new ServiceWorkerFetchRequest(request.url, request.method,
                                     request.headers, request.referrer,
                                     request.is_reload));
   cache->Match(
       std::move(scoped_request), match_params,
-      base::Bind(&CacheStorageDispatcherHost::OnCacheMatchCallback, this,
-                 thread_id, request_id, base::Passed(it->second->Clone())));
+      base::BindOnce(&CacheStorageDispatcherHost::OnCacheMatchCallback, this,
+                     thread_id, request_id, base::Passed(it->second->Clone())));
 }
 
 void CacheStorageDispatcherHost::OnCacheMatchAll(
     int thread_id,
     int request_id,
     int cache_id,
     const ServiceWorkerFetchRequest& request,
     const CacheStorageCacheQueryParams& match_params) {
   IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
   if (it == id_to_cache_map_.end() || !it->second->value()) {
     Send(new CacheStorageMsg_CacheMatchError(
         thread_id, request_id, blink::kWebServiceWorkerCacheErrorNotFound));
     return;
   }
 
   CacheStorageCache* cache = it->second->value();
   if (request.url.is_empty()) {
     cache->MatchAll(
         std::unique_ptr<ServiceWorkerFetchRequest>(), match_params,
-        base::Bind(&CacheStorageDispatcherHost::OnCacheMatchAllCallback, this,
-                   thread_id, request_id, base::Passed(it->second->Clone())));
+        base::BindOnce(&CacheStorageDispatcherHost::OnCacheMatchAllCallback,
+                       this, thread_id, request_id,
+                       base::Passed(it->second->Clone())));
     return;
   }
 
   std::unique_ptr<ServiceWorkerFetchRequest> scoped_request(
       new ServiceWorkerFetchRequest(request.url, request.method,
                                     request.headers, request.referrer,
                                     request.is_reload));
   if (match_params.ignore_search) {
     cache->MatchAll(
         std::move(scoped_request), match_params,
-        base::Bind(&CacheStorageDispatcherHost::OnCacheMatchAllCallback, this,
-                   thread_id, request_id, base::Passed(it->second->Clone())));
+        base::BindOnce(&CacheStorageDispatcherHost::OnCacheMatchAllCallback,
+                       this, thread_id, request_id,
+                       base::Passed(it->second->Clone())));
     return;
   }
   cache->Match(
       std::move(scoped_request), match_params,
-      base::Bind(&CacheStorageDispatcherHost::OnCacheMatchAllCallbackAdapter,
-                 this, thread_id, request_id,
-                 base::Passed(it->second->Clone())));
+      base::BindOnce(
+          &CacheStorageDispatcherHost::OnCacheMatchAllCallbackAdapter, this,
+          thread_id, request_id, base::Passed(it->second->Clone())));
 }
 
 void CacheStorageDispatcherHost::OnCacheKeys(
     int thread_id,
     int request_id,
     int cache_id,
     const ServiceWorkerFetchRequest& request,
     const CacheStorageCacheQueryParams& match_params) {
   IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
   if (it == id_to_cache_map_.end() || !it->second->value()) {
     Send(new CacheStorageMsg_CacheKeysError(
         thread_id, request_id, blink::kWebServiceWorkerCacheErrorNotFound));
     return;
   }
 
   CacheStorageCache* cache = it->second->value();
   std::unique_ptr<ServiceWorkerFetchRequest> request_ptr(
       new ServiceWorkerFetchRequest(request.url, request.method,
                                     request.headers, request.referrer,
                                     request.is_reload));
   cache->Keys(
       std::move(request_ptr), match_params,
-      base::Bind(&CacheStorageDispatcherHost::OnCacheKeysCallback, this,
-                 thread_id, request_id, base::Passed(it->second->Clone())));
+      base::BindOnce(&CacheStorageDispatcherHost::OnCacheKeysCallback, this,
+                     thread_id, request_id, base::Passed(it->second->Clone())));
 }
 
 void CacheStorageDispatcherHost::OnCacheBatch(
     int thread_id,
     int request_id,
     int cache_id,
     const std::vector<CacheStorageBatchOperation>& operations) {
   IDToCacheMap::iterator it = id_to_cache_map_.find(cache_id);
   if (it == id_to_cache_map_.end() || !it->second->value()) {
     Send(new CacheStorageMsg_CacheBatchError(
         thread_id, request_id, blink::kWebServiceWorkerCacheErrorNotFound));
     return;
   }
 
   CacheStorageCache* cache = it->second->value();
   cache->BatchOperation(
       operations,
-      base::Bind(&CacheStorageDispatcherHost::OnCacheBatchCallback, this,
-                 thread_id, request_id, base::Passed(it->second->Clone())));
+      base::BindOnce(&CacheStorageDispatcherHost::OnCacheBatchCallback, this,
+                     thread_id, request_id, base::Passed(it->second->Clone())));
 }
 
 void CacheStorageDispatcherHost::OnCacheClosed(int cache_id) {
   DropCacheReference(cache_id);
 }
 
 void CacheStorageDispatcherHost::OnBlobDataHandled(const std::string& uuid) {
   DropBlobDataHandle(uuid);
 }
 
@@ skipping 23 matching lines @@
   if (error != CACHE_STORAGE_OK) {
     Send(new CacheStorageMsg_CacheStorageOpenError(
         thread_id, request_id, ToWebServiceWorkerCacheError(error)));
     return;
   }
 
   // Hang on to the cache for a few seconds. This way if the user quickly closes
   // and reopens it the cache backend won't have to be reinitialized.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&StopPreservingCache, base::Passed(cache_handle->Clone())),
+      base::BindOnce(&StopPreservingCache, base::Passed(cache_handle->Clone())),
       base::TimeDelta::FromSeconds(kCachePreservationSeconds));
 
   CacheID cache_id = StoreCacheReference(std::move(cache_handle));
   Send(new CacheStorageMsg_CacheStorageOpenSuccess(thread_id, request_id,
                                                    cache_id));
 }
 
 void CacheStorageDispatcherHost::OnCacheStorageDeleteCallback(
     int thread_id,
     int request_id,
@@ skipping 152 matching lines @@
   UUIDToBlobDataHandleList::iterator it = blob_handle_store_.find(uuid);
   if (it == blob_handle_store_.end())
     return;
   DCHECK(!it->second.empty());
   it->second.pop_front();
   if (it->second.empty())
     blob_handle_store_.erase(it);
 }
 
 }  // namespace content