Quota: Cleanup some StorageType usage from QuotaManager

This change removes some usages of StorageType in QuotaManager.
After StorageType::kSyncable deprecation, all other storage types
except kTemporary are deprecated. So we no longer need to specify
StorageType. Further cleanup to remove usage in QuotaManager,
QuotaDatabase, etc. will follow.

Bug: 40211051
Change-Id: I8428a51ffc2a25781dacfffabae48de3032c6bf9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6336951
Reviewed-by: Tsuyoshi Horo <horo@chromium.org>
Commit-Queue: Ayu Ishii <ayui@chromium.org>
Reviewed-by: Nate Fischer <ntfschr@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1431654}

android_webview/browser/aw_quota_manager_bridge.cc

@@ -115,8 +115,7 @@ void GetStorageKeysTask::Run() {
   content::GetIOThreadTaskRunner({})->PostTask(
       FROM_HERE,
       base::BindOnce(
-          &QuotaManager::GetStorageKeysForType, quota_manager_,
-          blink::mojom::StorageType::kTemporary,
+          &QuotaManager::GetAllStorageKeys, quota_manager_,
           base::BindOnce(&GetStorageKeysTask::OnStorageKeysObtained, this,
                          blink::mojom::StorageType::kTemporary)));
 }

chrome/browser/sync_file_system/local/syncable_file_system_unittest.cc

@@ -97,11 +97,10 @@ class SyncableFileSystemTest : public testing::Test {
   }
 
   storage::QuotaErrorOr<storage::BucketLocator> GetOrCreateBucket(
-      const std::string& name,
-      StorageType type) {
+      const std::string& name) {
     base::test::TestFuture<storage::QuotaErrorOr<storage::BucketInfo>> future;
-    file_system_.quota_manager()->GetOrCreateBucketDeprecated(
-        {storage_key(), name}, type, future.GetCallback());
+    file_system_.quota_manager()->UpdateOrCreateBucket({storage_key(), name},
+                                                       future.GetCallback());
     return future.Take().transform(&storage::BucketInfo::ToBucketLocator);
   }
 
@@ -171,47 +170,43 @@ TEST_F(SyncableFileSystemTest, SyncableLocalSandboxCombined) {
   FileSystemURL temp_url = URL(storage::kFileSystemTypeTemporary, "dir/foo");
   storage::AsyncFileTestHelper::CreateFile(file_system_context(), temp_url);
 
-  file_system_.quota_manager()->SetQuota(
-      storage_key(), file_system_.storage_type(), /*quota=*/12345 * 1024);
+  file_system_.quota_manager()->SetQuota(storage_key(), /*quota=*/12345 * 1024);
 
-  ASSERT_OK_AND_ASSIGN(
-      auto temp_bucket,
-      GetOrCreateBucket(storage::kDefaultBucketName, StorageType::kTemporary));
+  ASSERT_OK_AND_ASSIGN(auto bucket,
+                       GetOrCreateBucket(storage::kDefaultBucketName));
 
   // Changes in the syncable files should be reflected in the temporary bucket.
-  int64_t temp_usage = GetBucketUsage(temp_bucket);
-  EXPECT_GT(temp_usage, 0);
+  int64_t usage = GetBucketUsage(bucket);
+  EXPECT_GT(usage, 0);
 
   // Truncating existing syncable file should update usage for the temporary
   // bucket.
   const int64_t kFileSizeToExtend = 333;
   storage::AsyncFileTestHelper::TruncateFile(file_system_context(), sync_url,
                                              kFileSizeToExtend);
-  int64_t new_temp_usage = GetBucketUsage(temp_bucket);
-  EXPECT_EQ(kFileSizeToExtend, new_temp_usage - temp_usage);
+  int64_t new_usage = GetBucketUsage(bucket);
+  EXPECT_EQ(kFileSizeToExtend, new_usage - usage);
 
-  // Shrinking the quota to the current usage for temporary quota storage,
-  // should make extending the file further fail.
-  file_system_.quota_manager()->SetQuota(storage_key(), StorageType::kTemporary,
-                                         new_temp_usage);
+  // Shrinking the quota to the current usage, should make extending the file
+  // further fail.
+  file_system_.quota_manager()->SetQuota(storage_key(), new_usage);
 
   EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE,
             storage::AsyncFileTestHelper::TruncateFile(
                 file_system_context(), sync_url, kFileSizeToExtend + 1));
-  temp_usage = new_temp_usage;
-  new_temp_usage = GetBucketUsage(temp_bucket);
-  EXPECT_EQ(new_temp_usage, temp_usage);
+  usage = new_usage;
+  new_usage = GetBucketUsage(bucket);
+  EXPECT_EQ(new_usage, usage);
 
   // Must delete both file types to delete all temporary bucket storage.
   DeleteFileSystem(storage::kFileSystemTypeTemporary);
-  EXPECT_GT(GetBucketUsage(temp_bucket), 0);
+  EXPECT_GT(GetBucketUsage(bucket), 0);
   DeleteFileSystem(storage::kFileSystemTypeSyncable);
-  EXPECT_EQ(GetBucketUsage(temp_bucket), 0);
+  EXPECT_EQ(GetBucketUsage(bucket), 0);
 
   // Restore the system default quota.
   file_system_.quota_manager()->SetQuota(
-      storage_key(), file_system_.storage_type(),
-      QuotaManager::kSyncableStorageDefaultStorageKeyQuota);
+      storage_key(), QuotaManager::kSyncableStorageDefaultStorageKeyQuota);
 }
 
 TEST_F(SyncableFileSystemTest, BucketDeletion) {
@@ -229,15 +224,14 @@ TEST_F(SyncableFileSystemTest, BucketDeletion) {
   FileSystemURL temp_url = URL(storage::kFileSystemTypeTemporary, "dir/foo");
   storage::AsyncFileTestHelper::CreateFile(file_system_context(), temp_url);
 
-  ASSERT_OK_AND_ASSIGN(
-      auto temp_bucket,
-      GetOrCreateBucket(storage::kDefaultBucketName, StorageType::kTemporary));
+  ASSERT_OK_AND_ASSIGN(auto bucket,
+                       GetOrCreateBucket(storage::kDefaultBucketName));
 
-  EXPECT_GT(GetBucketUsage(temp_bucket), 0);
+  EXPECT_GT(GetBucketUsage(bucket), 0);
 
   // Deleting the temporary bucket is enough to delete files for both
   // kFileSystemTypeTemporary and kFileSystemTypeSyncable.
-  DeleteBucketData(temp_bucket);
+  DeleteBucketData(bucket);
   EXPECT_FALSE(storage::AsyncFileTestHelper::FileExists(
       file_system_context(), temp_url,
       storage::AsyncFileTestHelper::kDontCheckSize));

components/browsing_data/content/browsing_data_quota_helper_impl.cc

@@ -66,8 +66,7 @@ void BrowsingDataQuotaHelperImpl::FetchQuotaInfoOnIOThread(
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Query for storage keys. When complete, process the collected quota info.
-  quota_manager_->GetStorageKeysForType(
-      StorageType::kTemporary,
+  quota_manager_->GetAllStorageKeys(
       base::BindOnce(&BrowsingDataQuotaHelperImpl::GotStorageKeys,
                      weak_factory_.GetWeakPtr(), std::move(callback)));
 }
@@ -130,7 +129,7 @@ void BrowsingDataQuotaHelperImpl::DeleteStorageKeyDataOnIOThread(
     base::OnceClosure completed) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   quota_manager_->DeleteStorageKeyData(
-      storage_key, StorageType::kTemporary,
+      storage_key,
       base::BindOnce(
           &BrowsingDataQuotaHelperImpl::OnStorageKeyDeletionCompleted,
           weak_factory_.GetWeakPtr(), std::move(completed)));

content/browser/cache_storage/cache_storage_cache_unittest.cc

@@ -1010,7 +1010,7 @@ class CacheStorageCacheTest : public testing::Test {
   void SetQuota(uint64_t quota) {
     mock_quota_manager_->SetQuota(
         blink::StorageKey::CreateFirstParty(url::Origin::Create(kTestUrl)),
-        blink::mojom::StorageType::kTemporary, quota);
+        quota);
   }
 
   void SetMaxQuerySizeBytes(size_t max_bytes) {

content/browser/cache_storage/cache_storage_manager_unittest.cc

@@ -388,10 +388,8 @@ class CacheStorageManagerTest : public testing::Test {
         MemoryOnly(), temp_dir_path,
         base::SingleThreadTaskRunner::GetCurrentDefault().get(),
         quota_policy_.get());
-    mock_quota_manager_->SetQuota(storage_key1_, StorageType::kTemporary,
-                                  1024 * 1024 * 100);
-    mock_quota_manager_->SetQuota(storage_key2_, StorageType::kTemporary,
-                                  1024 * 1024 * 100);
+    mock_quota_manager_->SetQuota(storage_key1_, 1024 * 1024 * 100);
+    mock_quota_manager_->SetQuota(storage_key2_, 1024 * 1024 * 100);
 
     quota_manager_proxy_ =
         base::MakeRefCounted<MockCacheStorageQuotaManagerProxy>(

content/browser/file_system_access/file_system_access_file_writer_impl_unittest.cc

@@ -554,9 +554,7 @@ TEST_F(FileSystemAccessSandboxedFileWriterImplTest, SkipQuarantine) {
 
 TEST_F(FileSystemAccessSandboxedFileWriterImplTest, QuotaError) {
   ASSERT_TRUE(quota_manager_);
-  quota_manager_->SetQuota(kTestStorageKey,
-                           blink::mojom::StorageType::kTemporary,
-                           /*quota=*/1);
+  quota_manager_->SetQuota(kTestStorageKey, /*quota=*/1);
 
   uint64_t bytes_written;
   FileSystemAccessStatus result = WriteSync(0, "abc", &bytes_written);

content/browser/indexed_db/instance/bucket_context_unittest.cc

@@ -62,7 +62,6 @@ class BucketContextTest : public testing::Test {
 
   void SetQuotaLeft(int64_t quota_manager_response) {
     quota_manager_->SetQuota(bucket_context_->bucket_locator().storage_key,
-                             blink::mojom::StorageType::kTemporary,
                              quota_manager_response);
   }
 

storage/browser/file_system/copy_or_move_operation_delegate_unittest.cc

@@ -350,10 +350,8 @@ class CopyOrMoveOperationTestHelper {
 
     // Grant relatively big quota initially.
     quota_manager_->SetQuota(blink::StorageKey::CreateFirstParty(origin_),
-                             FileSystemTypeToQuotaStorageType(src_type_),
                              1024 * 1024);
     quota_manager_->SetQuota(blink::StorageKey::CreateFirstParty(origin_),
-                             FileSystemTypeToQuotaStorageType(dest_type_),
                              1024 * 1024);
   }
 

storage/browser/file_system/file_system_operation_impl_unittest.cc

@@ -269,8 +269,7 @@ class FileSystemOperationImplTest : public testing::Test {
   void GrantQuotaForCurrentUsage() {
     int64_t usage;
     GetUsageAndQuota(&usage, nullptr);
-    quota_manager()->SetQuota(sandbox_file_system_.storage_key(),
-                              sandbox_file_system_.storage_type(), usage);
+    quota_manager()->SetQuota(sandbox_file_system_.storage_key(), usage);
   }
 
   int64_t GetUsage() {
@@ -283,7 +282,6 @@ class FileSystemOperationImplTest : public testing::Test {
     int64_t quota;
     GetUsageAndQuota(nullptr, &quota);
     quota_manager()->SetQuota(sandbox_file_system_.storage_key(),
-                              sandbox_file_system_.storage_type(),
                               quota + quota_delta);
   }
 

storage/browser/file_system/file_system_operation_impl_write_unittest.cc

@@ -266,8 +266,7 @@ TEST_F(FileSystemOperationImplWriteTest, TestWriteFailureByQuota) {
   ScopedTextBlob blob(blob_storage_context(), "blob:success",
                       "Hello, world!\n");
   quota_manager_->SetQuota(
-      blink::StorageKey::CreateFromStringForTesting(kOrigin),
-      FileSystemTypeToQuotaStorageType(kFileSystemType), 10);
+      blink::StorageKey::CreateFromStringForTesting(kOrigin), 10);
   file_system_context_->operation_runner()->Write(URLForPath(virtual_path_),
                                                   blob.GetBlobDataHandle(), 0,
                                                   RecordWriteCallback());

storage/browser/file_system/file_system_quota_client_unittest.cc

@@ -165,10 +165,8 @@ class FileSystemQuotaClientTest : public testing::Test {
       if (file.isDirectory) {
         ASSERT_OK_AND_ASSIGN(
             auto bucket,
-            GetOrCreateBucket(file.origin_url, kDefaultBucketName,
-                              FileSystemTypeToQuotaStorageType(file.type)));
-        quota_manager_->SetQuota(bucket.storage_key, bucket.type,
-                                 1024 * 1024 * 100);
+            GetOrCreateBucket(file.origin_url, kDefaultBucketName));
+        quota_manager_->SetQuota(bucket.storage_key, 1024 * 1024 * 100);
         ASSERT_TRUE(
             CreateFileSystemDirectory(path, file.origin_url, file.type));
         if (path.empty()) {
@@ -215,11 +213,10 @@ class FileSystemQuotaClientTest : public testing::Test {
 
   storage::QuotaErrorOr<BucketLocator> GetOrCreateBucket(
       const std::string& origin,
-      const std::string& name,
-      StorageType type) {
+      const std::string& name) {
     base::test::TestFuture<storage::QuotaErrorOr<storage::BucketInfo>> future;
-    quota_manager_->GetOrCreateBucketDeprecated(
-        {blink::StorageKey::CreateFromStringForTesting(origin), name}, type,
+    quota_manager_->UpdateOrCreateBucket(
+        {blink::StorageKey::CreateFromStringForTesting(origin), name},
         future.GetCallback());
     return future.Take().transform(&storage::BucketInfo::ToBucketLocator);
   }
@@ -270,9 +267,8 @@ class FileSystemQuotaClientTest : public testing::Test {
 TEST_F(FileSystemQuotaClientTest, NoFileSystemTest) {
   FileSystemQuotaClient quota_client(GetFileSystemContext());
 
-  ASSERT_OK_AND_ASSIGN(
-      auto bucket,
-      GetOrCreateBucket(kDummyURL1, kDefaultBucketName, kTemporary));
+  ASSERT_OK_AND_ASSIGN(auto bucket,
+                       GetOrCreateBucket(kDummyURL1, kDefaultBucketName));
   EXPECT_EQ(0, GetBucketUsage(quota_client, bucket));
 }
 
@@ -282,9 +278,8 @@ TEST_F(FileSystemQuotaClientTest, NoFileTest) {
   InitializeOriginFiles(quota_client,
                         {{true, "", 0, kDummyURL1, kFileSystemTypeTemporary}});
 
-  ASSERT_OK_AND_ASSIGN(
-      auto bucket,
-      GetOrCreateBucket(kDummyURL1, kDefaultBucketName, kTemporary));
+  ASSERT_OK_AND_ASSIGN(auto bucket,
+                       GetOrCreateBucket(kDummyURL1, kDefaultBucketName));
   for (int i = 0; i < 2; i++) {
     EXPECT_EQ(0, GetBucketUsage(quota_client, bucket));
   }
@@ -292,8 +287,8 @@ TEST_F(FileSystemQuotaClientTest, NoFileTest) {
 
 TEST_F(FileSystemQuotaClientTest, NonDefaultBucket) {
   FileSystemQuotaClient quota_client(GetFileSystemContext());
-  ASSERT_OK_AND_ASSIGN(
-      auto bucket, GetOrCreateBucket(kDummyURL1, "logs_bucket", kTemporary));
+  ASSERT_OK_AND_ASSIGN(auto bucket,
+                       GetOrCreateBucket(kDummyURL1, "logs_bucket"));
   ASSERT_FALSE(bucket.is_default);
   EXPECT_EQ(0, GetBucketUsage(quota_client, bucket));
   DeleteBucketData(&quota_client, bucket);
@@ -542,7 +537,7 @@ TEST_F(FileSystemQuotaClientTest, DeleteOriginTest) {
 
   ASSERT_OK_AND_ASSIGN(
       auto buz_temp_bucket,
-      GetOrCreateBucket("http://buz.com/", kDefaultBucketName, kTemporary));
+      GetOrCreateBucket("http://buz.com/", kDefaultBucketName));
   DeleteBucketData(&quota_client, buz_temp_bucket);
 
   EXPECT_EQ(0, GetBucketUsage(quota_client, foo_temp_bucket));

storage/browser/file_system/sandbox_file_stream_writer_unittest.cc

@@ -176,8 +176,7 @@ class SandboxFileStreamWriterTest : public FileStreamWriterTest {
 
   void SetQuota(int64_t quota) {
     quota_manager_->SetQuota(
-        blink::StorageKey::CreateFromStringForTesting(kURLOrigin),
-        blink::mojom::StorageType::kTemporary, quota);
+        blink::StorageKey::CreateFromStringForTesting(kURLOrigin), quota);
   }
 
   int64_t GetFreeQuota() {

storage/browser/quota/quota_manager_impl.cc

@@ -1153,8 +1153,7 @@ void QuotaManagerImpl::GetBucketById(
                      std::move(callback)));
 }
 
-void QuotaManagerImpl::GetStorageKeysForType(blink::mojom::StorageType type,
-                                             GetStorageKeysCallback callback) {
+void QuotaManagerImpl::GetAllStorageKeys(GetStorageKeysCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(callback);
   EnsureDatabaseOpened();
@@ -1164,12 +1163,10 @@ void QuotaManagerImpl::GetStorageKeysForType(blink::mojom::StorageType type,
     return;
   }
   PostTaskAndReplyWithResultForDBThread(
-      base::BindOnce(
-          [](blink::mojom::StorageType type, QuotaDatabase* database) {
-            DCHECK(database);
-            return database->GetStorageKeysForType(type);
-          },
-          type),
+      base::BindOnce([](QuotaDatabase* database) {
+        DCHECK(database);
+        return database->GetStorageKeysForType(StorageType::kTemporary);
+      }),
       base::BindOnce(&QuotaManagerImpl::DidGetStorageKeys,
                      weak_factory_.GetWeakPtr(), std::move(callback)));
 }
@@ -1479,12 +1476,11 @@ void QuotaManagerImpl::OnClientWriteFailed(const StorageKey& storage_key) {
 
 void QuotaManagerImpl::SetUsageCacheEnabled(QuotaClientType client_id,
                                             const StorageKey& storage_key,
-                                            StorageType type,
                                             bool enabled) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   EnsureDatabaseOpened();
 
-  UsageTracker* usage_tracker = GetUsageTracker(type);
+  UsageTracker* usage_tracker = GetUsageTracker(StorageType::kTemporary);
   DCHECK(usage_tracker);
 
   usage_tracker->SetUsageCacheEnabled(client_id, storage_key, enabled);
@@ -1612,13 +1608,12 @@ void QuotaManagerImpl::DeleteHostData(const std::string& host,
 
 void QuotaManagerImpl::DeleteStorageKeyData(
     const blink::StorageKey& storage_key,
-    blink::mojom::StorageType type,
     StatusCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   EnsureDatabaseOpened();
 
-  DCHECK(client_types_.contains(type));
-  if (client_types_[type].empty()) {
+  DCHECK(client_types_.contains(StorageType::kTemporary));
+  if (client_types_[StorageType::kTemporary].empty()) {
     std::move(callback).Run(blink::mojom::QuotaStatusCode::kOk);
     return;
   }
@@ -1627,7 +1622,7 @@ void QuotaManagerImpl::DeleteStorageKeyData(
                            weak_factory_.GetWeakPtr(), std::move(callback)));
   auto* buckets_deleter_ptr = buckets_deleter.get();
   bucket_set_data_deleters_[buckets_deleter_ptr] = std::move(buckets_deleter);
-  GetBucketsForStorageKey(storage_key, type,
+  GetBucketsForStorageKey(storage_key, StorageType::kTemporary,
                           buckets_deleter_ptr->GetBucketDeletionCallback());
 }
 

storage/browser/quota/quota_manager_impl.h

@@ -240,10 +240,9 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerImpl
       const BucketId& bucket_id,
       base::OnceCallback<void(QuotaErrorOr<BucketInfo>)>);
 
-  // Retrieves all storage keys for `type` that are in the buckets table.
+  // Retrieves all storage keys that are in the buckets table.
   // Used for listing storage keys when showing storage key quota usage.
-  void GetStorageKeysForType(blink::mojom::StorageType type,
-                             GetStorageKeysCallback callback);
+  void GetAllStorageKeys(GetStorageKeysCallback callback);
 
   // Retrieves all buckets for `type` that are in the buckets table.
   // Used for retrieving global usage data in the UsageTracker.
@@ -331,7 +330,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerImpl
 
   void SetUsageCacheEnabled(QuotaClientType client_id,
                             const blink::StorageKey& storage_key,
-                            blink::mojom::StorageType type,
                             bool enabled);
 
   // Deletes `bucket` data for the specified `quota_client_types`. Pass in
@@ -357,7 +355,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerImpl
 
   // Deletes buckets of a particular blink::StorageKey.
   void DeleteStorageKeyData(const blink::StorageKey& storage_key,
-                            blink::mojom::StorageType type,
                             StatusCallback callback);
 
   // Queries QuotaDatabase for the bucket with `storage_key` and `bucket_name`

storage/browser/quota/quota_manager_proxy.cc

@@ -463,8 +463,7 @@ void QuotaManagerProxy::SetUsageCacheEnabled(QuotaClientType client_id,
 
   DCHECK_CALLED_ON_VALID_SEQUENCE(quota_manager_impl_sequence_checker_);
   if (quota_manager_impl_) {
-    quota_manager_impl_->SetUsageCacheEnabled(
-        client_id, storage_key, blink::mojom::StorageType::kTemporary, enabled);
+    quota_manager_impl_->SetUsageCacheEnabled(client_id, storage_key, enabled);
   }
 }
 

storage/browser/quota/quota_manager_unittest.cc

@@ -266,11 +266,10 @@ class QuotaManagerImplTest : public testing::Test {
     return future.Take();
   }
 
-  std::set<StorageKey> GetStorageKeysForType(
-      blink::mojom::StorageType storage_type) {
+  std::set<StorageKey> GetAllStorageKeys() {
     base::test::TestFuture<std::set<StorageKey>> future;
-    quota_manager_impl_->GetStorageKeysForType(
-        storage_type, future.GetCallback<const std::set<StorageKey>&>());
+    quota_manager_impl_->GetAllStorageKeys(
+        future.GetCallback<const std::set<StorageKey>&>());
     return future.Take();
   }
 
@@ -1039,10 +1038,9 @@ TEST_F(QuotaManagerImplTest, GetBucketById) {
   ASSERT_FALSE(is_db_disabled());
 }
 
-TEST_F(QuotaManagerImplTest, GetStorageKeysForType) {
+TEST_F(QuotaManagerImplTest, GetAllStorageKeys) {
   StorageKey storage_key_a = ToStorageKey("http://a.com/");
   StorageKey storage_key_b = ToStorageKey("http://b.com/");
-  StorageKey storage_key_c = ToStorageKey("http://c.com/");
 
   ASSERT_OK_AND_ASSIGN(
       BucketInfo bucket_a,
@@ -1052,18 +1050,11 @@ TEST_F(QuotaManagerImplTest, GetStorageKeysForType) {
       BucketInfo bucket_b,
       CreateBucketForTesting(storage_key_b, "bucket_b", kTemp));
 
-  ASSERT_OK_AND_ASSIGN(
-      BucketInfo bucket_c,
-      CreateBucketForTesting(storage_key_c, kDefaultBucketName, kSync));
-
-  EXPECT_THAT(GetStorageKeysForType(kTemp),
+  EXPECT_THAT(GetAllStorageKeys(),
               testing::UnorderedElementsAre(storage_key_a, storage_key_b));
-
-  EXPECT_THAT(GetStorageKeysForType(kSync),
-              testing::UnorderedElementsAre(storage_key_c));
 }
 
-TEST_F(QuotaManagerImplTest, GetStorageKeysForTypeWithDatabaseError) {
+TEST_F(QuotaManagerImplTest, GetAllStorageKeysWithDatabaseError) {
   disable_database_bootstrap(true);
   OpenDatabase();
 
@@ -1071,7 +1062,7 @@ TEST_F(QuotaManagerImplTest, GetStorageKeysForTypeWithDatabaseError) {
   DisableQuotaDatabase();
 
   // Return empty set when error is encountered.
-  EXPECT_TRUE(GetStorageKeysForType(kTemp).empty());
+  EXPECT_TRUE(GetAllStorageKeys().empty());
 }
 
 TEST_F(QuotaManagerImplTest, QuotaDatabaseResultHistogram) {

storage/browser/test/mock_quota_manager.cc

@@ -160,9 +160,9 @@ void MockQuotaManager::GetBucketsForStorageKey(
 }
 
 void MockQuotaManager::GetUsageAndQuota(const StorageKey& storage_key,
-                                        StorageType type,
+                                        blink::mojom::StorageType type,
                                         UsageAndQuotaCallback callback) {
-  int64_t quota = quota_map_[std::make_pair(storage_key, type)].quota;
+  int64_t quota = quota_map_[storage_key].quota;
   int64_t usage = 0;
 
   if (usage_map_.empty()) {
@@ -178,8 +178,7 @@ void MockQuotaManager::GetUsageAndQuota(const StorageKey& storage_key,
   for (const auto& entry : usage_map_) {
     std::ignore = FindBucket(entry.first).transform([&](BucketInfo result) {
       storage::BucketLocator bucket_locator = result.ToBucketLocator();
-      if (bucket_locator.storage_key == storage_key &&
-          bucket_locator.type == type) {
+      if (bucket_locator.storage_key == storage_key) {
         usage += usage_map_[bucket_locator].usage;
       }
     });
@@ -191,18 +190,16 @@ int64_t MockQuotaManager::GetQuotaForStorageKey(
     const blink::StorageKey& storage_key,
     blink::mojom::StorageType type,
     const QuotaSettings& settings) const {
-  auto quota = quota_map_.find(std::make_pair(storage_key, type));
+  auto quota = quota_map_.find(storage_key);
   if (quota != quota_map_.end()) {
     return quota->second.quota;
   }
-
   return QuotaManager::GetQuotaForStorageKey(storage_key, type, settings);
 }
 
 void MockQuotaManager::SetQuota(const StorageKey& storage_key,
-                                StorageType type,
                                 int64_t quota) {
-  quota_map_[std::make_pair(storage_key, type)].quota = quota;
+  quota_map_[storage_key].quota = quota;
 }
 
 bool MockQuotaManager::AddBucket(const BucketInfo& bucket,

storage/browser/test/mock_quota_manager.h

@@ -142,7 +142,6 @@ class MockQuotaManager : public QuotaManager {
 
   // Helper method for updating internal quota info.
   void SetQuota(const blink::StorageKey& storage_key,
-                blink::mojom::StorageType type,
                 int64_t quota);
 
   // Helper methods for timed-deletion testing:
@@ -246,9 +245,7 @@ class MockQuotaManager : public QuotaManager {
 
   // The list of stored buckets that have been added via AddBucket.
   std::vector<BucketData> buckets_;
-  std::map<std::pair<blink::StorageKey, blink::mojom::StorageType>,
-           StorageKeyQuota>
-      quota_map_;
+  std::map<blink::StorageKey, StorageKeyQuota> quota_map_;
   std::map<BucketLocator, BucketUsage, CompareBucketLocators> usage_map_;
 
   // Tracks number of times NotifyFailedWrite has been called per storage key.

storage/browser/test/mock_quota_manager_unittest.cc

@@ -84,23 +84,6 @@ class MockQuotaManagerTest : public testing::Test {
     return result;
   }
 
-  QuotaErrorOr<BucketInfo> GetOrCreateBucketDeprecated(
-      const blink::StorageKey& storage_key,
-      blink::mojom::StorageType type,
-      const std::string& bucket_name) {
-    QuotaErrorOr<BucketInfo> result;
-    base::RunLoop run_loop;
-    BucketInitParams params(storage_key, bucket_name);
-    manager_->GetOrCreateBucketDeprecated(
-        params, type,
-        base::BindLambdaForTesting([&](QuotaErrorOr<BucketInfo> bucket) {
-          result = std::move(bucket);
-          run_loop.Quit();
-        }));
-    run_loop.Run();
-    return result;
-  }
-
   QuotaErrorOr<BucketInfo> GetBucket(const blink::StorageKey& storage_key,
                                      const std::string& bucket_name,
                                      blink::mojom::StorageType type) {
@@ -159,12 +142,11 @@ class MockQuotaManagerTest : public testing::Test {
   }
 
   void CheckUsageAndQuota(const blink::StorageKey& storage_key,
-                          StorageType type,
                           const int64_t expected_usage,
                           const int64_t expected_quota) {
     base::test::TestFuture<blink::mojom::QuotaStatusCode, int64_t, int64_t>
         future;
-    manager()->GetUsageAndQuota(storage_key, type, future.GetCallback());
+    manager()->GetUsageAndQuota(storage_key, kTemporary, future.GetCallback());
 
     blink::mojom::QuotaStatusCode status = future.Get<0>();
     int64_t usage = future.Get<1>();
@@ -485,58 +467,35 @@ TEST_F(MockQuotaManagerTest, QuotaAndUsage) {
       StorageKey::CreateFromStringForTesting("http://host2:1/");
 
   ASSERT_OK_AND_ASSIGN(BucketInfo result,
-                       GetOrCreateBucketDeprecated(storage_key1, kTemporary,
-                                                   kDefaultBucketName));
-  const BucketLocator storage_key1_temp_default_bucket =
-      result.ToBucketLocator();
+                       GetOrCreateBucket(storage_key1, kDefaultBucketName));
+  const BucketLocator storage_key1_default_bucket = result.ToBucketLocator();
 
-  ASSERT_OK_AND_ASSIGN(result, GetOrCreateBucketDeprecated(
-                                   storage_key1, kTemporary, "non-default"));
-  const BucketLocator storage_key1_temp_named_bucket = result.ToBucketLocator();
-
-  ASSERT_OK_AND_ASSIGN(
-      result,
-      GetOrCreateBucketDeprecated(storage_key1, kSyncable, kDefaultBucketName));
-  const BucketLocator storage_key1_sync_default_bucket =
-      result.ToBucketLocator();
+  ASSERT_OK_AND_ASSIGN(result, GetOrCreateBucket(storage_key1, "non-default"));
+  const BucketLocator storage_key1_named_bucket = result.ToBucketLocator();
 
   ASSERT_OK_AND_ASSIGN(result,
-                       GetOrCreateBucketDeprecated(storage_key2, kTemporary,
-                                                   kDefaultBucketName));
-  const BucketLocator storage_key2_temp_default_bucket =
-      result.ToBucketLocator();
+                       GetOrCreateBucket(storage_key2, kDefaultBucketName));
+  const BucketLocator storage_key2_default_bucket = result.ToBucketLocator();
 
-  SCOPED_TRACE(
-      "Checking default usage and quota for storage_key1 (kTemporary)");
-  CheckUsageAndQuota(storage_key1, kTemporary, 0,
-                     std::numeric_limits<int64_t>::max());
+  SCOPED_TRACE("Checking default usage and quota for storage_key1");
+  CheckUsageAndQuota(storage_key1, 0, std::numeric_limits<int64_t>::max());
 
-  manager()->SetQuota(storage_key1, kTemporary, 1000);
+  manager()->SetQuota(storage_key1, 1000);
   // Add usages in different buckets for the same storage key so that we can
   // ensure that these get added together correctly.
-  manager()->UpdateUsage(storage_key1_temp_default_bucket, 10);
-  manager()->UpdateUsage(storage_key1_temp_named_bucket, 100);
-
-  // Set a quota for the same storage key using a different type to test that
-  // these quotas don't affect one another.
-  manager()->SetQuota(storage_key1, kSyncable, 2000);
-  // Add usages for buckets tied to the same storage key but using a different
-  // type to test that these don't affect one another.
-  manager()->UpdateUsage(storage_key1_sync_default_bucket, 20);
+  manager()->UpdateUsage(storage_key1_default_bucket, 10);
+  manager()->UpdateUsage(storage_key1_named_bucket, 100);
 
   // Set a quota and add usage for a different storage key to test that this
   // doesn't affect the quota and usage of the other storage key.
-  manager()->SetQuota(storage_key2, kTemporary, 3000);
-  manager()->UpdateUsage(storage_key2_temp_default_bucket, 30);
+  manager()->SetQuota(storage_key2, 3000);
+  manager()->UpdateUsage(storage_key2_default_bucket, 30);
 
-  SCOPED_TRACE("Checking usage and quota for storage_key1 (kTemporary)");
-  CheckUsageAndQuota(storage_key1, kTemporary, 110, 1000);
+  SCOPED_TRACE("Checking usage and quota for storage_key1");
+  CheckUsageAndQuota(storage_key1, 110, 1000);
 
-  SCOPED_TRACE("Checking usage and quota for storage_key1 (kSyncable)");
-  CheckUsageAndQuota(storage_key1, kSyncable, 20, 2000);
-
-  SCOPED_TRACE("Checking usage and quota for storage_key2 (kTemporary)");
-  CheckUsageAndQuota(storage_key2, kTemporary, 30, 3000);
+  SCOPED_TRACE("Checking usage and quota for storage_key2");
+  CheckUsageAndQuota(storage_key2, 30, 3000);
 }
 
 }  // namespace storage