Quota: Rename QuotaClient callbacks to prepare for mojofication.

Bug: 1016065
Change-Id: I54c16b4ff463e7885ced521b66f65444c97028a4
Tbr: falken
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2301117
Commit-Queue: Victor Costan <pwnall@chromium.org>
Auto-Submit: Victor Costan <pwnall@chromium.org>
Reviewed-by: Jarryd Goodman <jarrydg@chromium.org>
Cr-Commit-Position: refs/heads/master@{#789723}

content/browser/appcache/appcache_quota_client.cc

@@ -69,7 +69,7 @@ void AppCacheQuotaClient::OnQuotaManagerDestroyed() {
 
 void AppCacheQuotaClient::GetOriginUsage(const url::Origin& origin,
                                          StorageType type,
-                                         GetUsageCallback callback) {
+                                         GetOriginUsageCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
   DCHECK(!callback.is_null());
@@ -106,8 +106,9 @@ void AppCacheQuotaClient::GetOriginUsage(const url::Origin& origin,
       std::move(callback));
 }
 
-void AppCacheQuotaClient::GetOriginsForType(StorageType type,
-                                            GetOriginsCallback callback) {
+void AppCacheQuotaClient::GetOriginsForType(
+    StorageType type,
+    GetOriginsForTypeCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
   DCHECK(!callback.is_null());
@@ -115,9 +116,10 @@ void AppCacheQuotaClient::GetOriginsForType(StorageType type,
   GetOriginsHelper(std::string(), std::move(callback));
 }
 
-void AppCacheQuotaClient::GetOriginsForHost(StorageType type,
-                                            const std::string& host,
-                                            GetOriginsCallback callback) {
+void AppCacheQuotaClient::GetOriginsForHost(
+    StorageType type,
+    const std::string& host,
+    GetOriginsForHostCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
   DCHECK(!callback.is_null());
@@ -131,7 +133,7 @@ void AppCacheQuotaClient::GetOriginsForHost(StorageType type,
 
 void AppCacheQuotaClient::DeleteOriginData(const url::Origin& origin,
                                            StorageType type,
-                                           DeletionCallback callback) {
+                                           DeleteOriginDataCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
   DCHECK(!callback.is_null());
@@ -183,7 +185,7 @@ void AppCacheQuotaClient::DidDeleteAppCachesForOrigin(int rv) {
 }
 
 void AppCacheQuotaClient::GetOriginsHelper(const std::string& opt_host,
-                                           GetOriginsCallback callback) {
+                                           GetOriginsForTypeCallback callback) {
   DCHECK(!callback.is_null());
 
   if (service_is_destroyed_) {

content/browser/appcache/appcache_quota_client.h

@@ -43,17 +43,17 @@ class AppCacheQuotaClient : public storage::QuotaClient {
   void OnQuotaManagerDestroyed() override;
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
-                      GetUsageCallback callback) override;
+                      GetOriginUsageCallback callback) override;
   void GetOriginsForType(blink::mojom::StorageType type,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForTypeCallback callback) override;
   void GetOriginsForHost(blink::mojom::StorageType type,
                          const std::string& host,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForHostCallback callback) override;
   void DeleteOriginData(const url::Origin& origin,
                         blink::mojom::StorageType type,
-                        DeletionCallback callback) override;
+                        DeleteOriginDataCallback callback) override;
   void PerformStorageCleanup(blink::mojom::StorageType type,
-                             base::OnceClosure callback) override;
+                             PerformStorageCleanupCallback callback) override;
 
  private:
   friend class content::AppCacheQuotaClientTest;
@@ -64,7 +64,7 @@ class AppCacheQuotaClient : public storage::QuotaClient {
 
   void DidDeleteAppCachesForOrigin(int rv);
   void GetOriginsHelper(const std::string& opt_host,
-                        GetOriginsCallback callback);
+                        GetOriginsForTypeCallback callback);
   void ProcessPendingRequests();
   void DeletePendingRequests();
   net::CancelableCompletionRepeatingCallback* GetServiceDeleteCallback();
@@ -80,7 +80,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_;
+  DeleteOriginDataCallback current_delete_request_callback_;
   std::unique_ptr<net::CancelableCompletionRepeatingCallback>
       service_delete_callback_;
 

content/browser/cache_storage/cache_storage_manager.h

@@ -53,18 +53,18 @@ class CONTENT_EXPORT CacheStorageManager
   virtual void GetOriginUsage(
       const url::Origin& origin_url,
       CacheStorageOwner owner,
-      storage::QuotaClient::GetUsageCallback callback) = 0;
+      storage::QuotaClient::GetOriginUsageCallback callback) = 0;
   virtual void GetOrigins(
       CacheStorageOwner owner,
-      storage::QuotaClient::GetOriginsCallback callback) = 0;
+      storage::QuotaClient::GetOriginsForTypeCallback callback) = 0;
   virtual void GetOriginsForHost(
       const std::string& host,
       CacheStorageOwner owner,
-      storage::QuotaClient::GetOriginsCallback callback) = 0;
+      storage::QuotaClient::GetOriginsForHostCallback callback) = 0;
   virtual void DeleteOriginData(
       const url::Origin& origin,
       CacheStorageOwner owner,
-      storage::QuotaClient::DeletionCallback callback) = 0;
+      storage::QuotaClient::DeleteOriginDataCallback callback) = 0;
   virtual void DeleteOriginData(const url::Origin& origin,
                                 CacheStorageOwner owner) = 0;
 

content/browser/cache_storage/cache_storage_quota_client.cc

@@ -23,7 +23,7 @@ void CacheStorageQuotaClient::OnQuotaManagerDestroyed() {}
 
 void CacheStorageQuotaClient::GetOriginUsage(const url::Origin& origin,
                                              blink::mojom::StorageType type,
-                                             GetUsageCallback callback) {
+                                             GetOriginUsageCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
 
@@ -35,26 +35,29 @@ void CacheStorageQuotaClient::GetOriginUsage(const url::Origin& origin,
   cache_manager_->GetOriginUsage(origin, owner_, std::move(callback));
 }
 
-void CacheStorageQuotaClient::GetOriginsForType(blink::mojom::StorageType type,
-                                                GetOriginsCallback callback) {
+void CacheStorageQuotaClient::GetOriginsForType(
+    blink::mojom::StorageType type,
+    GetOriginsForTypeCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
 
   cache_manager_->GetOrigins(owner_, std::move(callback));
 }
 
-void CacheStorageQuotaClient::GetOriginsForHost(blink::mojom::StorageType type,
-                                                const std::string& host,
-                                                GetOriginsCallback callback) {
+void CacheStorageQuotaClient::GetOriginsForHost(
+    blink::mojom::StorageType type,
+    const std::string& host,
+    GetOriginsForHostCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
 
   cache_manager_->GetOriginsForHost(host, owner_, std::move(callback));
 }
 
-void CacheStorageQuotaClient::DeleteOriginData(const url::Origin& origin,
-                                               blink::mojom::StorageType type,
-                                               DeletionCallback callback) {
+void CacheStorageQuotaClient::DeleteOriginData(
+    const url::Origin& origin,
+    blink::mojom::StorageType type,
+    DeleteOriginDataCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
 
@@ -68,7 +71,7 @@ void CacheStorageQuotaClient::DeleteOriginData(const url::Origin& origin,
 
 void CacheStorageQuotaClient::PerformStorageCleanup(
     blink::mojom::StorageType type,
-    base::OnceClosure callback) {
+    PerformStorageCleanupCallback callback) {
   std::move(callback).Run();
 }
 

content/browser/cache_storage/cache_storage_quota_client.h

@@ -30,17 +30,17 @@ class CONTENT_EXPORT CacheStorageQuotaClient : public storage::QuotaClient {
   void OnQuotaManagerDestroyed() override;
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
-                      GetUsageCallback callback) override;
+                      GetOriginUsageCallback callback) override;
   void GetOriginsForType(blink::mojom::StorageType type,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForTypeCallback callback) override;
   void GetOriginsForHost(blink::mojom::StorageType type,
                          const std::string& host,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForHostCallback callback) override;
   void DeleteOriginData(const url::Origin& origin,
                         blink::mojom::StorageType type,
-                        DeletionCallback callback) override;
+                        DeleteOriginDataCallback callback) override;
   void PerformStorageCleanup(blink::mojom::StorageType type,
-                             base::OnceClosure callback) override;
+                             PerformStorageCleanupCallback callback) override;
 
   static storage::QuotaClientType GetClientTypeFromOwner(
       CacheStorageOwner owner);

content/browser/cache_storage/cross_sequence/cross_sequence_cache_storage_manager.cc

@@ -33,27 +33,29 @@ class CrossSequenceCacheStorageManager::Inner {
 
   void GetOriginUsage(const url::Origin& origin_url,
                       CacheStorageOwner owner,
-                      storage::QuotaClient::GetUsageCallback callback) {
+                      storage::QuotaClient::GetOriginUsageCallback callback) {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     target_manager_->GetOriginUsage(origin_url, owner, std::move(callback));
   }
 
   void GetOrigins(CacheStorageOwner owner,
-                  storage::QuotaClient::GetOriginsCallback callback) {
+                  storage::QuotaClient::GetOriginsForTypeCallback callback) {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     target_manager_->GetOrigins(owner, std::move(callback));
   }
 
-  void GetOriginsForHost(const std::string& host,
-                         CacheStorageOwner owner,
-                         storage::QuotaClient::GetOriginsCallback callback) {
+  void GetOriginsForHost(
+      const std::string& host,
+      CacheStorageOwner owner,
+      storage::QuotaClient::GetOriginsForHostCallback callback) {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     target_manager_->GetOriginsForHost(host, owner, std::move(callback));
   }
 
-  void DeleteOriginData(const url::Origin& origin,
-                        CacheStorageOwner owner,
-                        storage::QuotaClient::DeletionCallback callback) {
+  void DeleteOriginData(
+      const url::Origin& origin,
+      CacheStorageOwner owner,
+      storage::QuotaClient::DeleteOriginDataCallback callback) {
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     target_manager_->DeleteOriginData(origin, owner, std::move(callback));
   }
@@ -94,7 +96,7 @@ void CrossSequenceCacheStorageManager::GetAllOriginsUsage(
 void CrossSequenceCacheStorageManager::GetOriginUsage(
     const url::Origin& origin_url,
     CacheStorageOwner owner,
-    storage::QuotaClient::GetUsageCallback callback) {
+    storage::QuotaClient::GetOriginUsageCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   inner_.Post(FROM_HERE, &Inner::GetOriginUsage, origin_url, owner,
               WrapCallbackForCurrentSequence(std::move(callback)));
@@ -102,7 +104,7 @@ void CrossSequenceCacheStorageManager::GetOriginUsage(
 
 void CrossSequenceCacheStorageManager::GetOrigins(
     CacheStorageOwner owner,
-    storage::QuotaClient::GetOriginsCallback callback) {
+    storage::QuotaClient::GetOriginsForTypeCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   inner_.Post(FROM_HERE, &Inner::GetOrigins, owner,
               WrapCallbackForCurrentSequence(std::move(callback)));
@@ -111,7 +113,7 @@ void CrossSequenceCacheStorageManager::GetOrigins(
 void CrossSequenceCacheStorageManager::GetOriginsForHost(
     const std::string& host,
     CacheStorageOwner owner,
-    storage::QuotaClient::GetOriginsCallback callback) {
+    storage::QuotaClient::GetOriginsForHostCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   inner_.Post(FROM_HERE, &Inner::GetOriginsForHost, host, owner,
               WrapCallbackForCurrentSequence(std::move(callback)));
@@ -120,7 +122,7 @@ void CrossSequenceCacheStorageManager::GetOriginsForHost(
 void CrossSequenceCacheStorageManager::DeleteOriginData(
     const url::Origin& origin,
     CacheStorageOwner owner,
-    storage::QuotaClient::DeletionCallback callback) {
+    storage::QuotaClient::DeleteOriginDataCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   inner_.Post(FROM_HERE, &Inner::DeleteOriginData, origin, owner,
               WrapCallbackForCurrentSequence(std::move(callback)));

content/browser/cache_storage/cross_sequence/cross_sequence_cache_storage_manager.h

@@ -33,19 +33,21 @@ class CONTENT_EXPORT CrossSequenceCacheStorageManager
   void GetAllOriginsUsage(
       CacheStorageOwner owner,
       CacheStorageContext::GetUsageInfoCallback callback) override;
-  void GetOriginUsage(const url::Origin& origin_url,
-                      CacheStorageOwner owner,
-                      storage::QuotaClient::GetUsageCallback callback) override;
-  void GetOrigins(CacheStorageOwner owner,
-                  storage::QuotaClient::GetOriginsCallback callback) override;
+  void GetOriginUsage(
+      const url::Origin& origin_url,
+      CacheStorageOwner owner,
+      storage::QuotaClient::GetOriginUsageCallback callback) override;
+  void GetOrigins(
+      CacheStorageOwner owner,
+      storage::QuotaClient::GetOriginsForTypeCallback callback) override;
   void GetOriginsForHost(
       const std::string& host,
       CacheStorageOwner owner,
-      storage::QuotaClient::GetOriginsCallback callback) override;
+      storage::QuotaClient::GetOriginsForHostCallback callback) override;
   void DeleteOriginData(
       const url::Origin& origin,
       CacheStorageOwner owner,
-      storage::QuotaClient::DeletionCallback callback) override;
+      storage::QuotaClient::DeleteOriginDataCallback callback) override;
   void DeleteOriginData(const url::Origin& origin,
                         CacheStorageOwner owner) override;
   void SetBlobParametersForCache(

content/browser/cache_storage/legacy/legacy_cache_storage_manager.cc

@@ -45,8 +45,9 @@ bool DeleteDir(const base::FilePath& path) {
   return base::DeletePathRecursively(path);
 }
 
-void DeleteOriginDidDeleteDir(storage::QuotaClient::DeletionCallback callback,
-                              bool rv) {
+void DeleteOriginDidDeleteDir(
+    storage::QuotaClient::DeleteOriginDataCallback callback,
+    bool rv) {
   // On scheduler sequence.
   base::SequencedTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
@@ -199,7 +200,7 @@ std::vector<url::Origin> ListOriginsOnTaskRunner(base::FilePath root_path,
 
 void GetOriginsForHostDidListOrigins(
     const std::string& host,
-    storage::QuotaClient::GetOriginsCallback callback,
+    storage::QuotaClient::GetOriginsForTypeCallback callback,
     const std::vector<url::Origin>& origins) {
   // On scheduler sequence.
   std::vector<url::Origin> out_origins;
@@ -401,7 +402,7 @@ void LegacyCacheStorageManager::GetAllOriginsUsageGetSizes(
 void LegacyCacheStorageManager::GetOriginUsage(
     const url::Origin& origin,
     CacheStorageOwner owner,
-    storage::QuotaClient::GetUsageCallback callback) {
+    storage::QuotaClient::GetOriginUsageCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   CacheStorageHandle cache_storage = OpenCacheStorage(origin, owner);
@@ -410,7 +411,7 @@ void LegacyCacheStorageManager::GetOriginUsage(
 
 void LegacyCacheStorageManager::GetOrigins(
     CacheStorageOwner owner,
-    storage::QuotaClient::GetOriginsCallback callback) {
+    storage::QuotaClient::GetOriginsForTypeCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (IsMemoryBacked()) {
@@ -433,7 +434,7 @@ void LegacyCacheStorageManager::GetOrigins(
 void LegacyCacheStorageManager::GetOriginsForHost(
     const std::string& host,
     CacheStorageOwner owner,
-    storage::QuotaClient::GetOriginsCallback callback) {
+    storage::QuotaClient::GetOriginsForHostCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (IsMemoryBacked()) {
@@ -459,7 +460,7 @@ void LegacyCacheStorageManager::GetOriginsForHost(
 void LegacyCacheStorageManager::DeleteOriginData(
     const url::Origin& origin,
     CacheStorageOwner owner,
-    storage::QuotaClient::DeletionCallback callback) {
+    storage::QuotaClient::DeleteOriginDataCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Create the CacheStorage for the origin if it hasn't been loaded yet.
@@ -486,7 +487,7 @@ void LegacyCacheStorageManager::DeleteOriginData(const url::Origin& origin,
 void LegacyCacheStorageManager::DeleteOriginDidClose(
     const url::Origin& origin,
     CacheStorageOwner owner,
-    storage::QuotaClient::DeletionCallback callback,
+    storage::QuotaClient::DeleteOriginDataCallback callback,
     std::unique_ptr<LegacyCacheStorage> cache_storage,
     int64_t origin_size) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);

content/browser/cache_storage/legacy/legacy_cache_storage_manager.h

@@ -66,19 +66,21 @@ class CONTENT_EXPORT LegacyCacheStorageManager : public CacheStorageManager {
   void GetAllOriginsUsage(
       CacheStorageOwner owner,
       CacheStorageContext::GetUsageInfoCallback callback) override;
-  void GetOriginUsage(const url::Origin& origin_url,
-                      CacheStorageOwner owner,
-                      storage::QuotaClient::GetUsageCallback callback) override;
-  void GetOrigins(CacheStorageOwner owner,
-                  storage::QuotaClient::GetOriginsCallback callback) override;
+  void GetOriginUsage(
+      const url::Origin& origin_url,
+      CacheStorageOwner owner,
+      storage::QuotaClient::GetOriginUsageCallback callback) override;
+  void GetOrigins(
+      CacheStorageOwner owner,
+      storage::QuotaClient::GetOriginsForTypeCallback callback) override;
   void GetOriginsForHost(
       const std::string& host,
       CacheStorageOwner owner,
-      storage::QuotaClient::GetOriginsCallback callback) override;
+      storage::QuotaClient::GetOriginsForHostCallback callback) override;
   void DeleteOriginData(
       const url::Origin& origin,
       CacheStorageOwner owner,
-      storage::QuotaClient::DeletionCallback callback) override;
+      storage::QuotaClient::DeleteOriginDataCallback callback) override;
   void DeleteOriginData(const url::Origin& origin,
                         CacheStorageOwner owner) override;
 
@@ -118,11 +120,12 @@ class CONTENT_EXPORT LegacyCacheStorageManager : public CacheStorageManager {
       std::unique_ptr<std::vector<StorageUsageInfo>> usage_info,
       CacheStorageContext::GetUsageInfoCallback callback);
 
-  void DeleteOriginDidClose(const url::Origin& origin,
-                            CacheStorageOwner owner,
-                            storage::QuotaClient::DeletionCallback callback,
-                            std::unique_ptr<LegacyCacheStorage> cache_storage,
-                            int64_t origin_size);
+  void DeleteOriginDidClose(
+      const url::Origin& origin,
+      CacheStorageOwner owner,
+      storage::QuotaClient::DeleteOriginDataCallback callback,
+      std::unique_ptr<LegacyCacheStorage> cache_storage,
+      int64_t origin_size);
 
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner() const {
     return cache_task_runner_;

content/browser/indexed_db/indexed_db_quota_client.cc

@@ -28,7 +28,7 @@ namespace content {
 namespace {
 
 void DidDeleteIDBData(scoped_refptr<base::SequencedTaskRunner> task_runner,
-                      IndexedDBQuotaClient::DeletionCallback callback,
+                      IndexedDBQuotaClient::DeleteOriginDataCallback callback,
                       bool) {
   task_runner->PostTask(
       FROM_HERE,
@@ -48,7 +48,7 @@ void GetAllOriginsOnIndexedDBThread(
   *origins_to_return = context->GetAllOrigins();
 }
 
-void DidGetOrigins(IndexedDBQuotaClient::GetOriginsCallback callback,
+void DidGetOrigins(IndexedDBQuotaClient::GetOriginsForTypeCallback callback,
                    const std::vector<url::Origin>* origins) {
   // Run on the same sequence that GetOriginsForType was called on,
   // which is likely the IO thread.
@@ -83,7 +83,7 @@ void IndexedDBQuotaClient::OnQuotaManagerDestroyed() {}
 
 void IndexedDBQuotaClient::GetOriginUsage(const url::Origin& origin,
                                           StorageType type,
-                                          GetUsageCallback callback) {
+                                          GetOriginUsageCallback callback) {
   DCHECK(!callback.is_null());
   DCHECK_EQ(type, StorageType::kTemporary);
 
@@ -94,8 +94,9 @@ void IndexedDBQuotaClient::GetOriginUsage(const url::Origin& origin,
       std::move(callback));
 }
 
-void IndexedDBQuotaClient::GetOriginsForType(StorageType type,
-                                             GetOriginsCallback callback) {
+void IndexedDBQuotaClient::GetOriginsForType(
+    StorageType type,
+    GetOriginsForTypeCallback callback) {
   DCHECK(!callback.is_null());
   DCHECK_EQ(type, StorageType::kTemporary);
 
@@ -109,9 +110,10 @@ void IndexedDBQuotaClient::GetOriginsForType(StorageType type,
                      base::Owned(origins_to_return)));
 }
 
-void IndexedDBQuotaClient::GetOriginsForHost(StorageType type,
-                                             const std::string& host,
-                                             GetOriginsCallback callback) {
+void IndexedDBQuotaClient::GetOriginsForHost(
+    StorageType type,
+    const std::string& host,
+    GetOriginsForHostCallback callback) {
   DCHECK(!callback.is_null());
   DCHECK_EQ(type, StorageType::kTemporary);
 
@@ -127,7 +129,7 @@ void IndexedDBQuotaClient::GetOriginsForHost(StorageType type,
 
 void IndexedDBQuotaClient::DeleteOriginData(const url::Origin& origin,
                                             StorageType type,
-                                            DeletionCallback callback) {
+                                            DeleteOriginDataCallback callback) {
   DCHECK(!callback.is_null());
   DCHECK_EQ(type, StorageType::kTemporary);
 
@@ -140,8 +142,9 @@ void IndexedDBQuotaClient::DeleteOriginData(const url::Origin& origin,
                                     std::move(callback))));
 }
 
-void IndexedDBQuotaClient::PerformStorageCleanup(blink::mojom::StorageType type,
-                                                 base::OnceClosure callback) {
+void IndexedDBQuotaClient::PerformStorageCleanup(
+    blink::mojom::StorageType type,
+    PerformStorageCleanupCallback callback) {
   std::move(callback).Run();
 }
 

content/browser/indexed_db/indexed_db_quota_client.h

@@ -33,17 +33,17 @@ class IndexedDBQuotaClient : public storage::QuotaClient {
   void OnQuotaManagerDestroyed() override;
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
-                      GetUsageCallback callback) override;
+                      GetOriginUsageCallback callback) override;
   void GetOriginsForType(blink::mojom::StorageType type,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForTypeCallback callback) override;
   void GetOriginsForHost(blink::mojom::StorageType type,
                          const std::string& host,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForHostCallback callback) override;
   void DeleteOriginData(const url::Origin& origin,
                         blink::mojom::StorageType type,
-                        DeletionCallback callback) override;
+                        DeleteOriginDataCallback callback) override;
   void PerformStorageCleanup(blink::mojom::StorageType type,
-                             base::OnceClosure callback) override;
+                             PerformStorageCleanupCallback callback) override;
 
  private:
   ~IndexedDBQuotaClient() override;

content/browser/service_worker/service_worker_quota_client.cc

@@ -20,12 +20,13 @@ using storage::QuotaClient;
 
 namespace content {
 namespace {
-void ReportToQuotaStatus(QuotaClient::DeletionCallback callback, bool status) {
+void ReportToQuotaStatus(QuotaClient::DeleteOriginDataCallback callback,
+                         bool status) {
   std::move(callback).Run(status ? blink::mojom::QuotaStatusCode::kOk
                                  : blink::mojom::QuotaStatusCode::kUnknown);
 }
 
-void FindUsageForOrigin(QuotaClient::GetUsageCallback callback,
+void FindUsageForOrigin(QuotaClient::GetOriginUsageCallback callback,
                         blink::ServiceWorkerStatusCode status,
                         int64_t usage) {
   std::move(callback).Run(usage);
@@ -42,28 +43,31 @@ ServiceWorkerQuotaClient::~ServiceWorkerQuotaClient() {
 
 void ServiceWorkerQuotaClient::GetOriginUsage(const url::Origin& origin,
                                               StorageType type,
-                                              GetUsageCallback callback) {
+                                              GetOriginUsageCallback callback) {
   DCHECK_EQ(type, StorageType::kTemporary);
   context_->GetStorageUsageForOrigin(
       origin, base::BindOnce(&FindUsageForOrigin, std::move(callback)));
 }
 
-void ServiceWorkerQuotaClient::GetOriginsForType(StorageType type,
-                                                 GetOriginsCallback callback) {
+void ServiceWorkerQuotaClient::GetOriginsForType(
+    StorageType type,
+    GetOriginsForTypeCallback callback) {
   DCHECK_EQ(type, StorageType::kTemporary);
   context_->GetInstalledRegistrationOrigins(base::nullopt, std::move(callback));
 }
 
-void ServiceWorkerQuotaClient::GetOriginsForHost(StorageType type,
-                                                 const std::string& host,
-                                                 GetOriginsCallback callback) {
+void ServiceWorkerQuotaClient::GetOriginsForHost(
+    StorageType type,
+    const std::string& host,
+    GetOriginsForHostCallback callback) {
   DCHECK_EQ(type, StorageType::kTemporary);
   context_->GetInstalledRegistrationOrigins(host, std::move(callback));
 }
 
-void ServiceWorkerQuotaClient::DeleteOriginData(const url::Origin& origin,
-                                                StorageType type,
-                                                DeletionCallback callback) {
+void ServiceWorkerQuotaClient::DeleteOriginData(
+    const url::Origin& origin,
+    StorageType type,
+    DeleteOriginDataCallback callback) {
   DCHECK_EQ(type, StorageType::kTemporary);
   context_->DeleteForOrigin(
       origin, base::BindOnce(&ReportToQuotaStatus, std::move(callback)));
@@ -71,7 +75,7 @@ void ServiceWorkerQuotaClient::DeleteOriginData(const url::Origin& origin,
 
 void ServiceWorkerQuotaClient::PerformStorageCleanup(
     blink::mojom::StorageType type,
-    base::OnceClosure callback) {
+    PerformStorageCleanupCallback callback) {
   DCHECK_EQ(type, StorageType::kTemporary);
   context_->PerformStorageCleanup(std::move(callback));
 }

content/browser/service_worker/service_worker_quota_client.h

@@ -29,17 +29,17 @@ class ServiceWorkerQuotaClient : public storage::QuotaClient {
   void OnQuotaManagerDestroyed() override {}
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
-                      GetUsageCallback callback) override;
+                      GetOriginUsageCallback callback) override;
   void GetOriginsForType(blink::mojom::StorageType type,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForTypeCallback callback) override;
   void GetOriginsForHost(blink::mojom::StorageType type,
                          const std::string& host,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForHostCallback callback) override;
   void DeleteOriginData(const url::Origin& origin,
                         blink::mojom::StorageType type,
-                        DeletionCallback callback) override;
+                        DeleteOriginDataCallback callback) override;
   void PerformStorageCleanup(blink::mojom::StorageType type,
-                             base::OnceClosure callback) override;
+                             PerformStorageCleanupCallback callback) override;
 
   static constexpr storage::QuotaClientType kType =
       storage::QuotaClientType::kServiceWorker;

storage/browser/database/database_quota_client.cc

@@ -62,13 +62,13 @@ void GetOriginsForHostOnDBThread(DatabaseTracker* db_tracker,
   }
 }
 
-void DidGetQuotaClientOrigins(QuotaClient::GetOriginsCallback callback,
+void DidGetQuotaClientOrigins(QuotaClient::GetOriginsForTypeCallback callback,
                               std::vector<url::Origin>* origins_ptr) {
   std::move(callback).Run(*origins_ptr);
 }
 
 void DidDeleteOriginData(base::SequencedTaskRunner* original_task_runner,
-                         QuotaClient::DeletionCallback callback,
+                         QuotaClient::DeleteOriginDataCallback callback,
                          int result) {
   if (result == net::ERR_IO_PENDING) {
     // The callback will be invoked via
@@ -102,7 +102,7 @@ void DatabaseQuotaClient::OnQuotaManagerDestroyed() {}
 
 void DatabaseQuotaClient::GetOriginUsage(const url::Origin& origin,
                                          StorageType type,
-                                         GetUsageCallback callback) {
+                                         GetOriginUsageCallback callback) {
   DCHECK(!callback.is_null());
   DCHECK(db_tracker_.get());
   DCHECK_EQ(type, StorageType::kTemporary);
@@ -114,8 +114,9 @@ void DatabaseQuotaClient::GetOriginUsage(const url::Origin& origin,
       std::move(callback));
 }
 
-void DatabaseQuotaClient::GetOriginsForType(StorageType type,
-                                            GetOriginsCallback callback) {
+void DatabaseQuotaClient::GetOriginsForType(
+    StorageType type,
+    GetOriginsForTypeCallback callback) {
   DCHECK(!callback.is_null());
   DCHECK(db_tracker_.get());
   DCHECK_EQ(type, StorageType::kTemporary);
@@ -129,9 +130,10 @@ void DatabaseQuotaClient::GetOriginsForType(StorageType type,
                      base::Owned(origins_ptr)));
 }
 
-void DatabaseQuotaClient::GetOriginsForHost(StorageType type,
-                                            const std::string& host,
-                                            GetOriginsCallback callback) {
+void DatabaseQuotaClient::GetOriginsForHost(
+    StorageType type,
+    const std::string& host,
+    GetOriginsForHostCallback callback) {
   DCHECK(!callback.is_null());
   DCHECK(db_tracker_.get());
   DCHECK_EQ(type, StorageType::kTemporary);
@@ -148,7 +150,7 @@ void DatabaseQuotaClient::GetOriginsForHost(StorageType type,
 
 void DatabaseQuotaClient::DeleteOriginData(const url::Origin& origin,
                                            StorageType type,
-                                           DeletionCallback callback) {
+                                           DeleteOriginDataCallback callback) {
   DCHECK(!callback.is_null());
   DCHECK(db_tracker_.get());
   DCHECK_EQ(type, StorageType::kTemporary);
@@ -169,8 +171,9 @@ void DatabaseQuotaClient::DeleteOriginData(const url::Origin& origin,
       net::CompletionOnceCallback(delete_callback));
 }
 
-void DatabaseQuotaClient::PerformStorageCleanup(blink::mojom::StorageType type,
-                                                base::OnceClosure callback) {
+void DatabaseQuotaClient::PerformStorageCleanup(
+    blink::mojom::StorageType type,
+    PerformStorageCleanupCallback callback) {
   DCHECK(!callback.is_null());
   DCHECK_EQ(type, StorageType::kTemporary);
   std::move(callback).Run();

storage/browser/database/database_quota_client.h

@@ -33,17 +33,17 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseQuotaClient
   void OnQuotaManagerDestroyed() override;
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
-                      GetUsageCallback callback) override;
+                      GetOriginUsageCallback callback) override;
   void GetOriginsForType(blink::mojom::StorageType type,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForTypeCallback callback) override;
   void GetOriginsForHost(blink::mojom::StorageType type,
                          const std::string& host,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForHostCallback callback) override;
   void DeleteOriginData(const url::Origin& origin,
                         blink::mojom::StorageType type,
-                        DeletionCallback callback) override;
+                        DeleteOriginDataCallback callback) override;
   void PerformStorageCleanup(blink::mojom::StorageType type,
-                             base::OnceClosure callback) override;
+                             PerformStorageCleanupCallback callback) override;
 
  private:
   ~DatabaseQuotaClient() override;

storage/browser/file_system/file_system_quota_client.cc

@@ -55,7 +55,7 @@ void GetOriginsForHostOnFileTaskRunner(FileSystemContext* context,
 }
 
 void DidGetFileSystemQuotaClientOrigins(
-    QuotaClient::GetOriginsCallback callback,
+    QuotaClient::GetOriginsForTypeCallback callback,
     std::vector<url::Origin>* origins_ptr) {
   std::move(callback).Run(*origins_ptr);
 }
@@ -94,7 +94,7 @@ FileSystemQuotaClient::~FileSystemQuotaClient() = default;
 
 void FileSystemQuotaClient::GetOriginUsage(const url::Origin& origin,
                                            StorageType storage_type,
-                                           GetUsageCallback callback) {
+                                           GetOriginUsageCallback callback) {
   DCHECK(!callback.is_null());
 
   FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type);
@@ -115,8 +115,9 @@ void FileSystemQuotaClient::GetOriginUsage(const url::Origin& origin,
       std::move(callback));
 }
 
-void FileSystemQuotaClient::GetOriginsForType(StorageType storage_type,
-                                              GetOriginsCallback callback) {
+void FileSystemQuotaClient::GetOriginsForType(
+    StorageType storage_type,
+    GetOriginsForTypeCallback callback) {
   DCHECK(!callback.is_null());
 
   auto* origins_ptr = new std::vector<url::Origin>();
@@ -129,9 +130,10 @@ void FileSystemQuotaClient::GetOriginsForType(StorageType storage_type,
                      base::Owned(origins_ptr)));
 }
 
-void FileSystemQuotaClient::GetOriginsForHost(StorageType storage_type,
-                                              const std::string& host,
-                                              GetOriginsCallback callback) {
+void FileSystemQuotaClient::GetOriginsForHost(
+    StorageType storage_type,
+    const std::string& host,
+    GetOriginsForHostCallback callback) {
   DCHECK(!callback.is_null());
 
   auto* origins_ptr = new std::vector<url::Origin>();
@@ -144,9 +146,10 @@ void FileSystemQuotaClient::GetOriginsForHost(StorageType storage_type,
                      base::Owned(origins_ptr)));
 }
 
-void FileSystemQuotaClient::DeleteOriginData(const url::Origin& origin,
-                                             StorageType type,
-                                             DeletionCallback callback) {
+void FileSystemQuotaClient::DeleteOriginData(
+    const url::Origin& origin,
+    StorageType type,
+    DeleteOriginDataCallback callback) {
   FileSystemType fs_type = QuotaStorageTypeToFileSystemType(type);
   DCHECK(fs_type != kFileSystemTypeUnknown);
 
@@ -157,8 +160,9 @@ void FileSystemQuotaClient::DeleteOriginData(const url::Origin& origin,
       std::move(callback));
 }
 
-void FileSystemQuotaClient::PerformStorageCleanup(StorageType type,
-                                                  base::OnceClosure callback) {
+void FileSystemQuotaClient::PerformStorageCleanup(
+    StorageType type,
+    PerformStorageCleanupCallback callback) {
   FileSystemType fs_type = QuotaStorageTypeToFileSystemType(type);
   DCHECK(fs_type != kFileSystemTypeUnknown);
   file_task_runner()->PostTaskAndReply(

storage/browser/file_system/file_system_quota_client.h

@@ -40,17 +40,17 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) FileSystemQuotaClient
   void OnQuotaManagerDestroyed() override {}
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
-                      GetUsageCallback callback) override;
+                      GetOriginUsageCallback callback) override;
   void GetOriginsForType(blink::mojom::StorageType type,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForTypeCallback callback) override;
   void GetOriginsForHost(blink::mojom::StorageType type,
                          const std::string& host,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForHostCallback callback) override;
   void DeleteOriginData(const url::Origin& origin,
                         blink::mojom::StorageType type,
-                        DeletionCallback callback) override;
+                        DeleteOriginDataCallback callback) override;
   void PerformStorageCleanup(blink::mojom::StorageType type,
-                             base::OnceClosure callback) override;
+                             PerformStorageCleanupCallback callback) override;
 
  private:
   ~FileSystemQuotaClient() override;

storage/browser/quota/quota_client.h

@@ -30,11 +30,16 @@ namespace storage {
 class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaClient
     : public base::RefCountedThreadSafe<QuotaClient> {
  public:
-  using GetUsageCallback = base::OnceCallback<void(int64_t usage)>;
-  using GetOriginsCallback =
+  // The callback aliases precisely follow mojo conventions, because this
+  // abstract class will become a mojo interface soon. See crbug.com/1016065.
+  using GetOriginUsageCallback = base::OnceCallback<void(int64_t usage)>;
+  using GetOriginsForTypeCallback =
       base::OnceCallback<void(const std::vector<url::Origin>& origins)>;
-  using DeletionCallback =
+  using GetOriginsForHostCallback =
+      base::OnceCallback<void(const std::vector<url::Origin>& origins)>;
+  using DeleteOriginDataCallback =
       base::OnceCallback<void(blink::mojom::QuotaStatusCode status)>;
+  using PerformStorageCleanupCallback = base::OnceClosure;
 
   // Called when the QuotaManager is destroyed.
   virtual void OnQuotaManagerDestroyed() = 0;
@@ -45,32 +50,33 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaClient
   // Note it is safe to fire the callback after the QuotaClient is destructed.
   virtual void GetOriginUsage(const url::Origin& origin,
                               blink::mojom::StorageType type,
-                              GetUsageCallback callback) = 0;
+                              GetOriginUsageCallback callback) = 0;
 
   // Called by the QuotaManager.
   // Returns a list of origins that has data in the |type| storage.
   // Note it is safe to fire the callback after the QuotaClient is destructed.
   virtual void GetOriginsForType(blink::mojom::StorageType type,
-                                 GetOriginsCallback callback) = 0;
+                                 GetOriginsForTypeCallback callback) = 0;
 
   // Called by the QuotaManager.
   // Returns a list of origins that match the |host|.
   // Note it is safe to fire the callback after the QuotaClient is destructed.
   virtual void GetOriginsForHost(blink::mojom::StorageType type,
                                  const std::string& host,
-                                 GetOriginsCallback callback) = 0;
+                                 GetOriginsForHostCallback callback) = 0;
 
   // Called by the QuotaManager.
   // Note it is safe to fire the callback after the QuotaClient is destructed.
   virtual void DeleteOriginData(const url::Origin& origin,
                                 blink::mojom::StorageType type,
-                                DeletionCallback callback) = 0;
+                                DeleteOriginDataCallback callback) = 0;
 
   // Called by the QuotaManager.
   // Gives the QuotaClient an opportunity to perform a cleanup step after major
   // deletions.
-  virtual void PerformStorageCleanup(blink::mojom::StorageType type,
-                                     base::OnceClosure callback) = 0;
+  virtual void PerformStorageCleanup(
+      blink::mojom::StorageType type,
+      PerformStorageCleanupCallback callback) = 0;
 
  protected:
   friend class RefCountedThreadSafe<QuotaClient>;

storage/browser/quota/usage_tracker_unittest.cc

@@ -45,7 +45,7 @@ class UsageTrackerTestQuotaClient : public QuotaClient {
 
   void GetOriginUsage(const url::Origin& origin,
                       StorageType type,
-                      GetUsageCallback callback) override {
+                      GetOriginUsageCallback callback) override {
     EXPECT_EQ(StorageType::kTemporary, type);
     int64_t usage = GetUsage(origin);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ -53,7 +53,7 @@ class UsageTrackerTestQuotaClient : public QuotaClient {
   }
 
   void GetOriginsForType(StorageType type,
-                         GetOriginsCallback callback) override {
+                         GetOriginsForTypeCallback callback) override {
     EXPECT_EQ(StorageType::kTemporary, type);
     std::vector<url::Origin> origins;
     for (const auto& origin_usage_pair : origin_usage_map_)
@@ -64,7 +64,7 @@ class UsageTrackerTestQuotaClient : public QuotaClient {
 
   void GetOriginsForHost(StorageType type,
                          const std::string& host,
-                         GetOriginsCallback callback) override {
+                         GetOriginsForHostCallback callback) override {
     EXPECT_EQ(StorageType::kTemporary, type);
     std::vector<url::Origin> origins;
     for (const auto& origin_usage_pair : origin_usage_map_) {
@@ -77,7 +77,7 @@ class UsageTrackerTestQuotaClient : public QuotaClient {
 
   void DeleteOriginData(const url::Origin& origin,
                         StorageType type,
-                        DeletionCallback callback) override {
+                        DeleteOriginDataCallback callback) override {
     EXPECT_EQ(StorageType::kTemporary, type);
     origin_usage_map_.erase(origin);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ -85,7 +85,7 @@ class UsageTrackerTestQuotaClient : public QuotaClient {
   }
 
   void PerformStorageCleanup(blink::mojom::StorageType type,
-                             base::OnceClosure callback) override {
+                             PerformStorageCleanupCallback callback) override {
     std::move(callback).Run();
   }
 

storage/browser/test/mock_quota_client.cc

@@ -83,7 +83,7 @@ void MockQuotaClient::OnQuotaManagerDestroyed() {}
 
 void MockQuotaClient::GetOriginUsage(const url::Origin& origin,
                                      blink::mojom::StorageType type,
-                                     GetUsageCallback callback) {
+                                     GetOriginUsageCallback callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(&MockQuotaClient::RunGetOriginUsage,
                                 weak_factory_.GetWeakPtr(), origin, type,
@@ -91,7 +91,7 @@ void MockQuotaClient::GetOriginUsage(const url::Origin& origin,
 }
 
 void MockQuotaClient::GetOriginsForType(blink::mojom::StorageType type,
-                                        GetOriginsCallback callback) {
+                                        GetOriginsForTypeCallback callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::BindOnce(&MockQuotaClient::RunGetOriginsForType,
@@ -100,7 +100,7 @@ void MockQuotaClient::GetOriginsForType(blink::mojom::StorageType type,
 
 void MockQuotaClient::GetOriginsForHost(blink::mojom::StorageType type,
                                         const std::string& host,
-                                        GetOriginsCallback callback) {
+                                        GetOriginsForHostCallback callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(&MockQuotaClient::RunGetOriginsForHost,
                                 weak_factory_.GetWeakPtr(), type, host,
@@ -109,21 +109,22 @@ void MockQuotaClient::GetOriginsForHost(blink::mojom::StorageType type,
 
 void MockQuotaClient::DeleteOriginData(const url::Origin& origin,
                                        blink::mojom::StorageType type,
-                                       DeletionCallback callback) {
+                                       DeleteOriginDataCallback callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(&MockQuotaClient::RunDeleteOriginData,
                                 weak_factory_.GetWeakPtr(), origin, type,
                                 std::move(callback)));
 }
 
-void MockQuotaClient::PerformStorageCleanup(blink::mojom::StorageType type,
-                                            base::OnceClosure callback) {
+void MockQuotaClient::PerformStorageCleanup(
+    blink::mojom::StorageType type,
+    PerformStorageCleanupCallback callback) {
   std::move(callback).Run();
 }
 
 void MockQuotaClient::RunGetOriginUsage(const url::Origin& origin,
                                         blink::mojom::StorageType type,
-                                        GetUsageCallback callback) {
+                                        GetOriginUsageCallback callback) {
   auto it = origin_data_.find(std::make_pair(origin, type));
   if (it == origin_data_.end()) {
     std::move(callback).Run(0);
@@ -133,7 +134,7 @@ void MockQuotaClient::RunGetOriginUsage(const url::Origin& origin,
 }
 
 void MockQuotaClient::RunGetOriginsForType(blink::mojom::StorageType type,
-                                           GetOriginsCallback callback) {
+                                           GetOriginsForTypeCallback callback) {
   std::vector<url::Origin> origins;
   for (const auto& origin_type_usage : origin_data_) {
     if (type == origin_type_usage.first.second)
@@ -144,7 +145,7 @@ void MockQuotaClient::RunGetOriginsForType(blink::mojom::StorageType type,
 
 void MockQuotaClient::RunGetOriginsForHost(blink::mojom::StorageType type,
                                            const std::string& host,
-                                           GetOriginsCallback callback) {
+                                           GetOriginsForHostCallback callback) {
   std::vector<url::Origin> origins;
   for (const auto& origin_type_usage : origin_data_) {
     if (type == origin_type_usage.first.second &&
@@ -158,7 +159,7 @@ void MockQuotaClient::RunGetOriginsForHost(blink::mojom::StorageType type,
 void MockQuotaClient::RunDeleteOriginData(
     const url::Origin& origin,
     blink::mojom::StorageType storage_type,
-    DeletionCallback callback) {
+    DeleteOriginDataCallback callback) {
   auto error_it = error_origins_.find(std::make_pair(origin, storage_type));
   if (error_it != error_origins_.end()) {
     std::move(callback).Run(

storage/browser/test/mock_quota_client.h

@@ -59,32 +59,32 @@ class MockQuotaClient : public QuotaClient {
   void OnQuotaManagerDestroyed() override;
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
-                      GetUsageCallback callback) override;
+                      GetOriginUsageCallback callback) override;
   void GetOriginsForType(blink::mojom::StorageType type,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForTypeCallback callback) override;
   void GetOriginsForHost(blink::mojom::StorageType type,
                          const std::string& host,
-                         GetOriginsCallback callback) override;
+                         GetOriginsForHostCallback callback) override;
   void DeleteOriginData(const url::Origin& origin,
                         blink::mojom::StorageType type,
-                        DeletionCallback callback) override;
+                        DeleteOriginDataCallback callback) override;
   void PerformStorageCleanup(blink::mojom::StorageType type,
-                             base::OnceClosure callback) override;
+                             PerformStorageCleanupCallback callback) override;
 
  private:
   ~MockQuotaClient() override;
 
   void RunGetOriginUsage(const url::Origin& origin,
                          blink::mojom::StorageType type,
-                         GetUsageCallback callback);
+                         GetOriginUsageCallback callback);
   void RunGetOriginsForType(blink::mojom::StorageType type,
-                            GetOriginsCallback callback);
+                            GetOriginsForTypeCallback callback);
   void RunGetOriginsForHost(blink::mojom::StorageType type,
                             const std::string& host,
-                            GetOriginsCallback callback);
+                            GetOriginsForTypeCallback callback);
   void RunDeleteOriginData(const url::Origin& origin,
                            blink::mojom::StorageType type,
-                           DeletionCallback callback);
+                           DeleteOriginDataCallback callback);
 
   const scoped_refptr<QuotaManagerProxy> quota_manager_proxy_;
   const QuotaClientType client_type_;