Quota: Cleanup StorageType in QuotaManagerProxy

This change removes some usages of StorageType in QuotaManagerProxy.
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 from QuotaManager,
QuotaDatabase, etc. will follow.

Bug: 40211051
Change-Id: Iba5caa5aefcc346cbcf9e7aac3f05ab33ca53d61
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6306646
Reviewed-by: Bo Liu <boliu@chromium.org>
Commit-Queue: Ayu Ishii <ayui@chromium.org>
Reviewed-by: Tsuyoshi Horo <horo@chromium.org>
Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1426466}

chrome/browser/browsing_data/browsing_data_remover_browsertest.cc

@@ -1064,19 +1064,17 @@ IN_PROC_BROWSER_TEST_F(BrowsingDataRemoverStorageBucketsBrowserTest,
   auto* quota_manager_proxy = quota_manager->proxy();
 
   quota_manager_proxy->CreateBucketForTesting(
-      storage_key, "drafts", blink::mojom::StorageType::kTemporary,
-      base::SequencedTaskRunner::GetCurrentDefault(),
+      storage_key, "drafts", base::SequencedTaskRunner::GetCurrentDefault(),
       base::BindOnce(
           [](storage::QuotaErrorOr<storage::BucketInfo> error_or_bucket_info) {
           }));
   quota_manager_proxy->CreateBucketForTesting(
-      storage_key, "inbox", blink::mojom::StorageType::kTemporary,
-      base::SequencedTaskRunner::GetCurrentDefault(),
+      storage_key, "inbox", base::SequencedTaskRunner::GetCurrentDefault(),
       base::BindOnce(
           [](storage::QuotaErrorOr<storage::BucketInfo> error_or_bucket_info) {
           }));
   quota_manager_proxy->CreateBucketForTesting(
-      storage_key, "attachments", blink::mojom::StorageType::kTemporary,
+      storage_key, "attachments",
       base::SequencedTaskRunner::GetCurrentDefault(),
       base::BindOnce(
           [](storage::QuotaErrorOr<storage::BucketInfo> error_or_bucket_info) {

chrome/browser/sync_file_system/local/local_file_sync_context_unittest.cc

@@ -434,18 +434,17 @@ TEST_F(LocalFileSyncContextTest, CreateDefaultTemporaryBucket) {
   EXPECT_EQ(SYNC_STATUS_OK,
             file_system.MaybeInitializeFileSystemContext(sync_context_.get()));
 
-  // Opens the file_system, to verify a kTemporary bucket is created.
+  // Opens the file_system, to verify a bucket is created.
   EXPECT_EQ(base::File::FILE_OK, file_system.OpenFileSystem());
 
   base::test::TestFuture<storage::QuotaErrorOr<storage::BucketInfo>> future;
   file_system.quota_manager()->proxy()->GetBucketByNameUnsafe(
       blink::StorageKey::CreateFromStringForTesting(kOrigin1),
-      storage::kDefaultBucketName, blink::mojom::StorageType::kTemporary,
+      storage::kDefaultBucketName,
       base::SequencedTaskRunner::GetCurrentDefault(), future.GetCallback());
 
   ASSERT_OK_AND_ASSIGN(const auto result, future.Take());
   EXPECT_EQ(result.name, storage::kDefaultBucketName);
-  EXPECT_EQ(result.type, blink::mojom::StorageType::kTemporary);
   EXPECT_GT(result.id.value(), 0);
 
   // Finishing the test.

content/browser/background_fetch/background_fetch_test_data_manager.cc

@@ -42,7 +42,6 @@ class MockBGFQuotaManagerProxy : public storage::MockQuotaManagerProxy {
 
   void GetUsageAndQuota(
       const blink::StorageKey& storage_key,
-      blink::mojom::StorageType type,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       UsageAndQuotaCallback callback) override {
     DCHECK(callback_task_runner);

content/browser/background_fetch/storage/database_task.cc

@@ -90,8 +90,7 @@ void DatabaseTask::IsQuotaAvailable(const blink::StorageKey& storage_key,
   DCHECK_GT(size, 0);
 
   quota_manager_proxy()->GetUsageAndQuota(
-      storage_key, blink::mojom::StorageType::kTemporary,
-      base::SingleThreadTaskRunner::GetCurrentDefault(),
+      storage_key, base::SingleThreadTaskRunner::GetCurrentDefault(),
       base::BindOnce(&DidGetUsageAndQuota, std::move(callback), size));
 }
 

content/browser/browsing_data/storage_bucket_clear_site_data_tester.cc

@@ -16,7 +16,6 @@
 #include "content/public/browser/storage_partition.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "third_party/blink/public/common/storage_key/storage_key.h"
-#include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
 
 namespace content {
 
@@ -32,7 +31,7 @@ void StorageBucketClearSiteDataTester::CreateBucketForTesting(
         callback) {
   storage_partition_impl_->GetQuotaManagerProxy()
       ->CreateBucketForTesting(  // IN-TEST
-          storage_key, bucket_name, blink::mojom::StorageType::kTemporary,
+          storage_key, bucket_name,
           base::SequencedTaskRunner::GetCurrentDefault(), std::move(callback));
 }
 

content/browser/buckets/bucket_manager_host.cc

@@ -135,8 +135,7 @@ void BucketManagerHost::GetBucketForDevtools(
     const std::string& name,
     mojo::PendingReceiver<blink::mojom::BucketHost> receiver) {
   GetQuotaManagerProxy()->GetBucketByNameUnsafe(
-      storage_key_, name, blink::mojom::StorageType::kTemporary,
-      base::SequencedTaskRunner::GetCurrentDefault(),
+      storage_key_, name, base::SequencedTaskRunner::GetCurrentDefault(),
       base::BindOnce(&BucketManagerHost::DidGetBucketForDevtools,
                      weak_factory_.GetWeakPtr(), receivers_.current_context(),
                      std::move(receiver)));

content/browser/cache_storage/cache_storage_context_unittest.cc

@@ -122,7 +122,7 @@ TEST_F(CacheStorageContextTest, DefaultBucketCreatedOnAddReceiver) {
       storage::BucketInfo result,
       quota_manager_proxy_sync.GetBucket(
           blink::StorageKey::CreateFromStringForTesting(kExampleStorageKey),
-          storage::kDefaultBucketName, blink::mojom::StorageType::kTemporary));
+          storage::kDefaultBucketName));
   EXPECT_EQ(result.name, storage::kDefaultBucketName);
   EXPECT_EQ(result.storage_key,
             blink::StorageKey::CreateFromStringForTesting(kExampleStorageKey));
@@ -133,7 +133,7 @@ TEST_F(CacheStorageContextTest, DefaultBucketCreatedOnAddReceiver) {
       result,
       quota_manager_proxy_sync.GetBucket(
           blink::StorageKey::CreateFromStringForTesting(kGoogleStorageKey),
-          storage::kDefaultBucketName, blink::mojom::StorageType::kTemporary));
+          storage::kDefaultBucketName));
   EXPECT_EQ(result.name, storage::kDefaultBucketName);
   EXPECT_EQ(result.storage_key,
             blink::StorageKey::CreateFromStringForTesting(kGoogleStorageKey));

content/browser/cache_storage/cache_storage_manager_unittest.cc

@@ -818,8 +818,7 @@ class CacheStorageManagerTest : public testing::Test {
     int64_t usage(CacheStorage::kSizeUnknown);
     base::RunLoop loop;
     quota_manager_proxy_->GetUsageAndQuota(
-        storage_key, StorageType::kTemporary,
-        base::SingleThreadTaskRunner::GetCurrentDefault(),
+        storage_key, base::SingleThreadTaskRunner::GetCurrentDefault(),
         base::BindOnce(&CacheStorageManagerTest::DidGetQuotaOriginUsage,
                        base::Unretained(this), base::Unretained(&usage),
                        &loop));

content/browser/file_system_access/file_system_access_file_handle_impl_unittest.cc

@@ -142,7 +142,6 @@ class FileSystemAccessFileHandleImplTest : public testing::Test {
         bucket_future;
     quota_manager_proxy_->CreateBucketForTesting(
         test_src_storage_key_, "custom_bucket",
-        blink::mojom::StorageType::kTemporary,
         base::SequencedTaskRunner::GetCurrentDefault(),
         bucket_future.GetCallback());
     return bucket_future.Take().transform(

content/browser/file_system_access/file_system_access_file_modification_host_impl.cc

@@ -89,8 +89,7 @@ void FileSystemAccessFileModificationHostImpl::RequestCapacityChange(
   }
 
   quota_manager_proxy()->GetUsageAndQuota(
-      url_.storage_key(), blink::mojom::StorageType::kTemporary,
-      base::SequencedTaskRunner::GetCurrentDefault(),
+      url_.storage_key(), base::SequencedTaskRunner::GetCurrentDefault(),
       base::BindOnce(
           &FileSystemAccessFileModificationHostImpl::DidGetUsageAndQuota,
           weak_factory_.GetWeakPtr(), capacity_delta, std::move(callback)));

content/browser/file_system_access/file_system_access_file_writer_impl_unittest.cc

@@ -356,8 +356,7 @@ class FileSystemAccessFileWriterImplTest : public testing::Test {
 
     // Check default bucket exists.
     return quota_manager_proxy_sync
-        .GetBucket(kTestStorageKey, storage::kDefaultBucketName,
-                   blink::mojom::StorageType::kTemporary)
+        .GetBucket(kTestStorageKey, storage::kDefaultBucketName)
         .transform([&](storage::BucketInfo result) {
           EXPECT_EQ(result.name, storage::kDefaultBucketName);
           EXPECT_EQ(result.storage_key, kTestStorageKey);

content/browser/file_system_access/file_system_access_manager_impl_unittest.cc

@@ -358,7 +358,7 @@ class FileSystemAccessManagerImplTest : public testing::Test {
     base::test::TestFuture<storage::QuotaErrorOr<storage::BucketInfo>>
         bucket_future;
     quota_manager_proxy_->CreateBucketForTesting(
-        kTestStorageKey, "custom_bucket", blink::mojom::StorageType::kTemporary,
+        kTestStorageKey, "custom_bucket",
         base::SequencedTaskRunner::GetCurrentDefault(),
         bucket_future.GetCallback());
     return bucket_future.Take().transform(
@@ -386,8 +386,7 @@ class FileSystemAccessManagerImplTest : public testing::Test {
 
     // Check default bucket exists.
     return quota_manager_proxy_sync
-        .GetBucket(kTestStorageKey, storage::kDefaultBucketName,
-                   blink::mojom::StorageType::kTemporary)
+        .GetBucket(kTestStorageKey, storage::kDefaultBucketName)
         .transform([&](storage::BucketInfo result) {
           EXPECT_EQ(result.name, storage::kDefaultBucketName);
           EXPECT_EQ(result.storage_key, kTestStorageKey);
@@ -467,7 +466,7 @@ TEST_F(FileSystemAccessManagerImplTest, GetSandboxedFileSystem_CustomBucket) {
   base::test::TestFuture<storage::QuotaErrorOr<storage::BucketInfo>>
       bucket_future;
   quota_manager_proxy_->CreateBucketForTesting(
-      kTestStorageKey, "custom_bucket", blink::mojom::StorageType::kTemporary,
+      kTestStorageKey, "custom_bucket",
       base::SequencedTaskRunner::GetCurrentDefault(),
       bucket_future.GetCallback());
   ASSERT_OK_AND_ASSIGN(auto bucket, bucket_future.Take());
@@ -526,7 +525,7 @@ TEST_F(FileSystemAccessManagerImplTest,
   base::test::TestFuture<storage::QuotaErrorOr<storage::BucketInfo>>
       bucket_future;
   quota_manager_proxy_->CreateBucketForTesting(
-      kTestStorageKey, "custom_bucket", blink::mojom::StorageType::kTemporary,
+      kTestStorageKey, "custom_bucket",
       base::SequencedTaskRunner::GetCurrentDefault(),
       bucket_future.GetCallback());
   ASSERT_OK_AND_ASSIGN(auto bucket, bucket_future.Take());

content/browser/file_system_access/file_system_access_watcher_manager_unittest.cc

@@ -380,8 +380,7 @@ class FileSystemAccessWatcherManagerTest : public testing::Test {
 
     // Check default bucket exists.
     return quota_manager_proxy_sync
-        .GetBucket(kTestStorageKey, storage::kDefaultBucketName,
-                   blink::mojom::StorageType::kTemporary)
+        .GetBucket(kTestStorageKey, storage::kDefaultBucketName)
         .transform([&](storage::BucketInfo result) {
           EXPECT_EQ(result.name, storage::kDefaultBucketName);
           EXPECT_EQ(result.storage_key, kTestStorageKey);

content/browser/indexed_db/indexed_db_context_unittest.cc

@@ -139,17 +139,15 @@ TEST_F(IndexedDBContextTest, DefaultBucketCreatedOnBindIndexedDB) {
   // Check default bucket exists for https://example.com.
   ASSERT_OK_AND_ASSIGN(storage::BucketInfo result,
                        quota_manager_proxy_sync.GetBucket(
-                           example_storage_key_, storage::kDefaultBucketName,
-                           blink::mojom::StorageType::kTemporary));
+                           example_storage_key_, storage::kDefaultBucketName));
   EXPECT_EQ(result.name, storage::kDefaultBucketName);
   EXPECT_EQ(result.storage_key, example_storage_key_);
   EXPECT_GT(result.id.value(), 0);
 
   // Check default bucket exists for https://google.com.
-  ASSERT_OK_AND_ASSIGN(result,
-                       quota_manager_proxy_sync.GetBucket(
-                           google_storage_key_, storage::kDefaultBucketName,
-                           blink::mojom::StorageType::kTemporary));
+  ASSERT_OK_AND_ASSIGN(
+      result, quota_manager_proxy_sync.GetBucket(google_storage_key_,
+                                                 storage::kDefaultBucketName));
   EXPECT_EQ(result.name, storage::kDefaultBucketName);
   EXPECT_EQ(result.storage_key, google_storage_key_);
   EXPECT_GT(result.id.value(), 0);

content/browser/service_worker/service_worker_registry_unittest.cc

@@ -709,10 +709,9 @@ TEST_F(ServiceWorkerRegistryTest, CreateNewRegistration) {
   loop.Run();
 
   // Check default bucket exists.com.
-  ASSERT_OK_AND_ASSIGN(storage::BucketInfo result,
-                       quota_manager_proxy_sync.GetBucket(
-                           kKey, storage::kDefaultBucketName,
-                           blink::mojom::StorageType::kTemporary));
+  ASSERT_OK_AND_ASSIGN(
+      storage::BucketInfo result,
+      quota_manager_proxy_sync.GetBucket(kKey, storage::kDefaultBucketName));
   EXPECT_EQ(result.name, storage::kDefaultBucketName);
   EXPECT_EQ(result.storage_key, kKey);
   EXPECT_GT(result.id.value(), 0);
@@ -2355,10 +2354,9 @@ TEST_F(ServiceWorkerRegistryTest,
     EXPECT_EQ(inflight_call_count(), 0U);
 
     // Check default bucket exists.com.
-    ASSERT_OK_AND_ASSIGN(storage::BucketInfo result,
-                         quota_manager_proxy_sync.GetBucket(
-                             kKey, storage::kDefaultBucketName,
-                             blink::mojom::StorageType::kTemporary));
+    ASSERT_OK_AND_ASSIGN(
+        storage::BucketInfo result,
+        quota_manager_proxy_sync.GetBucket(kKey, storage::kDefaultBucketName));
     EXPECT_EQ(result.name, storage::kDefaultBucketName);
     EXPECT_EQ(result.storage_key, kKey);
     EXPECT_GT(result.id.value(), 0);

content/browser/web_database/web_database_host_impl.cc

@@ -249,8 +249,7 @@ void WebDatabaseHostImpl::GetSpaceAvailableValidated(
 
   DCHECK(db_tracker_->quota_manager_proxy());
   db_tracker_->quota_manager_proxy()->GetUsageAndQuota(
-      blink::StorageKey::CreateFirstParty(origin),
-      blink::mojom::StorageType::kTemporary, db_tracker_->task_runner(),
+      blink::StorageKey::CreateFirstParty(origin), db_tracker_->task_runner(),
       base::BindOnce(
           [](GetSpaceAvailableCallback callback,
              blink::mojom::QuotaStatusCode status, int64_t usage,

content/browser/web_database/web_database_host_impl_unittest.cc

@@ -204,7 +204,7 @@ TEST_F(WebDatabaseHostImplTest, OpenFileCreatesBucket) {
       storage::BucketInfo result,
       quota_manager_proxy_sync.GetBucket(
           blink::StorageKey::CreateFromStringForTesting(example_url),
-          storage::kDefaultBucketName, blink::mojom::StorageType::kTemporary));
+          storage::kDefaultBucketName));
   EXPECT_EQ(result.name, storage::kDefaultBucketName);
   EXPECT_EQ(result.storage_key,
             blink::StorageKey::CreateFromStringForTesting(example_url));

storage/browser/database/database_quota_client_unittest.cc

@@ -178,12 +178,11 @@ class DatabaseQuotaClientTest : public testing::TestWithParam<bool> {
 
   storage::QuotaErrorOr<BucketLocator> CreateBucketForTesting(
       const blink::StorageKey& storage_key,
-      const std::string& name,
-      blink::mojom::StorageType type) {
+      const std::string& name) {
     base::test::TestFuture<storage::QuotaErrorOr<storage::BucketInfo>>
         bucket_future;
     quota_manager_->proxy()->CreateBucketForTesting(
-        storage_key, name, type, base::SequencedTaskRunner::GetCurrentDefault(),
+        storage_key, name, base::SequencedTaskRunner::GetCurrentDefault(),
         bucket_future.GetCallback());
     return bucket_future.Take().transform(
         &storage::BucketInfo::ToBucketLocator);
@@ -231,11 +230,9 @@ class DatabaseQuotaClientTest : public testing::TestWithParam<bool> {
 TEST_P(DatabaseQuotaClientTest, GetBucketUsage) {
   DatabaseQuotaClient client(*mock_tracker_);
   ASSERT_OK_AND_ASSIGN(
-      auto bucket_a,
-      CreateBucketForTesting(kStorageKeyA, kDefaultBucketName, kTemp));
+      auto bucket_a, CreateBucketForTesting(kStorageKeyA, kDefaultBucketName));
   ASSERT_OK_AND_ASSIGN(
-      auto bucket_b,
-      CreateBucketForTesting(kStorageKeyB, kDefaultBucketName, kTemp));
+      auto bucket_b, CreateBucketForTesting(kStorageKeyB, kDefaultBucketName));
 
   EXPECT_EQ(0, GetBucketUsage(client, bucket_a));
 
@@ -260,8 +257,7 @@ TEST_P(DatabaseQuotaClientTest, GetStorageKeysForType) {
 TEST_P(DatabaseQuotaClientTest, DeleteBucketData) {
   DatabaseQuotaClient client(*mock_tracker_);
   ASSERT_OK_AND_ASSIGN(
-      auto bucket_a,
-      CreateBucketForTesting(kStorageKeyA, kDefaultBucketName, kTemp));
+      auto bucket_a, CreateBucketForTesting(kStorageKeyA, kDefaultBucketName));
 
   mock_tracker_->set_async_delete(false);
   EXPECT_EQ(blink::mojom::QuotaStatusCode::kOk,
@@ -276,8 +272,8 @@ TEST_P(DatabaseQuotaClientTest, DeleteBucketData) {
 
 TEST_P(DatabaseQuotaClientTest, NonDefaultBucket) {
   DatabaseQuotaClient client(*mock_tracker_);
-  ASSERT_OK_AND_ASSIGN(
-      auto bucket, CreateBucketForTesting(kStorageKeyA, "inbox_bucket", kTemp));
+  ASSERT_OK_AND_ASSIGN(auto bucket,
+                       CreateBucketForTesting(kStorageKeyA, "inbox_bucket"));
   ASSERT_FALSE(bucket.is_default);
 
   EXPECT_EQ(0, GetBucketUsage(client, bucket));

storage/browser/database/database_tracker_unittest.cc

@@ -139,7 +139,6 @@ class TestQuotaManagerProxy : public QuotaManagerProxy {
                             bool enabled) override {}
   void GetUsageAndQuota(
       const blink::StorageKey& storage_key,
-      blink::mojom::StorageType type,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       UsageAndQuotaCallback callback) override {}
 

storage/browser/file_system/file_system_context_unittest.cc

@@ -219,7 +219,7 @@ TEST_F(FileSystemContextTest, ResolveURLOnOpenFileSystem_CustomBucket) {
   base::test::TestFuture<storage::QuotaErrorOr<storage::BucketInfo>>
       bucket_future;
   proxy()->CreateBucketForTesting(
-      storage_key, "custom_bucket", blink::mojom::StorageType::kTemporary,
+      storage_key, "custom_bucket",
       base::SequencedTaskRunner::GetCurrentDefault(),
       bucket_future.GetCallback());
   ASSERT_OK_AND_ASSIGN(auto bucket, bucket_future.Take());

storage/browser/file_system/quota/quota_backend_impl.cc

@@ -51,8 +51,7 @@ void QuotaBackendImpl::ReserveQuota(const url::Origin& origin,
   }
   DCHECK(quota_manager_proxy_.get());
   quota_manager_proxy_->GetUsageAndQuota(
-      blink::StorageKey::CreateFirstParty(origin),
-      FileSystemTypeToQuotaStorageType(type), file_task_runner_,
+      blink::StorageKey::CreateFirstParty(origin), file_task_runner_,
       base::BindOnce(&QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota,
                      weak_ptr_factory_.GetWeakPtr(),
                      QuotaReservationInfo(origin, type, delta),

storage/browser/file_system/quota/quota_backend_impl_unittest.cc

@@ -78,7 +78,6 @@ class MockQuotaManagerProxy : public QuotaManagerProxy {
 
   void GetUsageAndQuota(
       const blink::StorageKey& storage_key,
-      blink::mojom::StorageType type,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       UsageAndQuotaCallback callback) override {
     DCHECK(callback_task_runner);

storage/browser/file_system/sandbox_file_stream_writer_unittest.cc

@@ -201,7 +201,7 @@ class SandboxFileStreamWriterTest : public FileStreamWriterTest {
         BucketInfo result,
         quota_manager_proxy_sync.GetBucket(
             blink::StorageKey::CreateFromStringForTesting(kURLOrigin),
-            kDefaultBucketName, blink::mojom::StorageType::kTemporary));
+            kDefaultBucketName));
     EXPECT_EQ(result.name, kDefaultBucketName);
     EXPECT_EQ(result.storage_key,
               blink::StorageKey::CreateFromStringForTesting(kURLOrigin));

storage/browser/quota/quota_manager_proxy.cc

@@ -184,7 +184,6 @@ QuotaErrorOr<BucketInfo> QuotaManagerProxy::GetOrCreateBucketSync(
 void QuotaManagerProxy::CreateBucketForTesting(
     const StorageKey& storage_key,
     const std::string& bucket_name,
-    blink::mojom::StorageType storage_type,
     scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
     base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) {
   DCHECK(callback_task_runner);
@@ -194,7 +193,7 @@ void QuotaManagerProxy::CreateBucketForTesting(
     quota_manager_impl_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&QuotaManagerProxy::CreateBucketForTesting, this,
-                       storage_key, bucket_name, storage_type,
+                       storage_key, bucket_name,
                        std::move(callback_task_runner), std::move(callback)));
     return;
   }
@@ -209,13 +208,13 @@ void QuotaManagerProxy::CreateBucketForTesting(
   }
 
   quota_manager_impl_->CreateBucketForTesting(  // IN-TEST
-      storage_key, bucket_name, storage_type, std::move(respond));
+      storage_key, bucket_name, blink::mojom::StorageType::kTemporary,
+      std::move(respond));
 }
 
 void QuotaManagerProxy::GetBucketByNameUnsafe(
     const StorageKey& storage_key,
     const std::string& bucket_name,
-    blink::mojom::StorageType type,
     scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
     base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) {
   DCHECK(callback_task_runner);
@@ -225,7 +224,7 @@ void QuotaManagerProxy::GetBucketByNameUnsafe(
     quota_manager_impl_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&QuotaManagerProxy::GetBucketByNameUnsafe, this,
-                       storage_key, bucket_name, type,
+                       storage_key, bucket_name,
                        std::move(callback_task_runner), std::move(callback)));
     return;
   }
@@ -240,7 +239,8 @@ void QuotaManagerProxy::GetBucketByNameUnsafe(
   }
 
   quota_manager_impl_->GetBucketByNameUnsafe(  // IN-TEST
-      storage_key, bucket_name, type, std::move(respond));
+      storage_key, bucket_name, blink::mojom::StorageType::kTemporary,
+      std::move(respond));
 }
 
 void QuotaManagerProxy::GetBucketsForStorageKey(
@@ -471,7 +471,6 @@ void QuotaManagerProxy::SetUsageCacheEnabled(QuotaClientType client_id,
 
 void QuotaManagerProxy::GetUsageAndQuota(
     const StorageKey& storage_key,
-    blink::mojom::StorageType type,
     scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
     UsageAndQuotaCallback callback) {
   DCHECK(callback_task_runner);
@@ -481,8 +480,7 @@ void QuotaManagerProxy::GetUsageAndQuota(
     quota_manager_impl_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&QuotaManagerProxy::GetUsageAndQuota, this, storage_key,
-                       type, std::move(callback_task_runner),
-                       std::move(callback)));
+                       std::move(callback_task_runner), std::move(callback)));
     return;
   }
 
@@ -495,7 +493,8 @@ void QuotaManagerProxy::GetUsageAndQuota(
     return;
   }
 
-  quota_manager_impl_->GetUsageAndQuota(storage_key, type, std::move(respond));
+  quota_manager_impl_->GetUsageAndQuota(
+      storage_key, blink::mojom::StorageType::kTemporary, std::move(respond));
 }
 
 void QuotaManagerProxy::GetBucketUsageAndReportedQuota(

storage/browser/quota/quota_manager_proxy.h

@@ -87,12 +87,12 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerProxy
                                      QuotaClientType client_type);
 
   // Gets the bucket with the name, storage key, quota and expiration
-  // specified in `bucket_params` for StorageType kTemporary and returns a
-  // BucketInfo with all fields filled in. This will also update the bucket's
-  // policies to match `bucket_params` for those parameters which may be
-  // updated, but only if it's a user created bucket (not the default bucket).
-  // If one doesn't exist, it creates a new bucket with the specified policies.
-  // Returns a QuotaError if the operation has failed.
+  // specified in `bucket_params` and returns a BucketInfo with all fields
+  // filled in. This will also update the bucket's policies to match
+  // `bucket_params` for those parameters which may be updated, but only if
+  // it's a user created bucket (not the default bucket). If one doesn't exist,
+  // it creates a new bucket with the specified policies. Returns a QuotaError
+  // if the operation has failed.
   virtual void UpdateOrCreateBucket(
       const BucketInitParams& bucket_params,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
@@ -107,13 +107,9 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerProxy
   // Creates a bucket for `origin` with `bucket_name` and returns the
   // BucketInfo to the callback. Returns a QuotaError to the callback
   // on operation failure.
-  //
-  // TODO(crbug.com/40181609): Remove `storage_type` when the only supported
-  // StorageType is kTemporary.
   virtual void CreateBucketForTesting(
       const blink::StorageKey& storage_key,
       const std::string& bucket_name,
-      blink::mojom::StorageType storage_type,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback);
 
@@ -133,7 +129,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerProxy
   virtual void GetBucketByNameUnsafe(
       const blink::StorageKey& storage_key,
       const std::string& bucket_name,
-      blink::mojom::StorageType type,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback);
 
@@ -146,10 +141,10 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerProxy
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       base::OnceCallback<void(QuotaErrorOr<std::set<BucketInfo>>)> callback);
 
-  // Deletes bucket with `bucket_name` for `storage_key` for
-  // StorageType::kTemporary for all registered QuotaClients if a bucket exists.
-  // Will return QuotaStatusCode to the callback. Called by Storage Buckets API
-  // for deleting buckets via StorageBucketManager.
+  // Deletes bucket with `bucket_name` for `storage_key` for all registered
+  // QuotaClients if a bucket exists. Will return QuotaStatusCode to the
+  // callback. Called by Storage Buckets API for deleting buckets via
+  // StorageBucketManager.
   virtual void DeleteBucket(
       const blink::StorageKey& storage_key,
       const std::string& bucket_name,
@@ -196,7 +191,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerProxy
                                     bool enabled);
   virtual void GetUsageAndQuota(
       const blink::StorageKey& storage_key,
-      blink::mojom::StorageType type,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       UsageAndQuotaCallback callback);
 

storage/browser/test/async_file_test_helper.cc

@@ -311,8 +311,7 @@ blink::mojom::QuotaStatusCode AsyncFileTestHelper::GetUsageAndQuota(
       blink::mojom::QuotaStatusCode::kUnknown;
   base::RunLoop run_loop;
   quota_manager_proxy->GetUsageAndQuota(
-      storage_key, FileSystemTypeToQuotaStorageType(type),
-      base::SequencedTaskRunner::GetCurrentDefault(),
+      storage_key, base::SequencedTaskRunner::GetCurrentDefault(),
       base::BindOnce(&DidGetUsageAndQuota, &status, usage, quota,
                      run_loop.QuitWhenIdleClosure()));
   run_loop.Run();

storage/browser/test/mock_quota_manager_proxy.cc

@@ -43,24 +43,24 @@ QuotaErrorOr<BucketInfo> MockQuotaManagerProxy::GetOrCreateBucketSync(
 void MockQuotaManagerProxy::CreateBucketForTesting(
     const blink::StorageKey& storage_key,
     const std::string& bucket_name,
-    blink::mojom::StorageType storage_type,
     scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
     base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) {
   if (mock_quota_manager_) {
     mock_quota_manager_->CreateBucketForTesting(
-        storage_key, bucket_name, storage_type, std::move(callback));
+        storage_key, bucket_name, blink::mojom::StorageType::kTemporary,
+        std::move(callback));
   }
 }
 
 void MockQuotaManagerProxy::GetBucketByNameUnsafe(
     const blink::StorageKey& storage_key,
     const std::string& bucket_name,
-    blink::mojom::StorageType type,
     scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
     base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) {
   if (mock_quota_manager_) {
-    mock_quota_manager_->GetBucketByNameUnsafe(storage_key, bucket_name, type,
-                                               std::move(callback));
+    mock_quota_manager_->GetBucketByNameUnsafe(
+        storage_key, bucket_name, blink::mojom::StorageType::kTemporary,
+        std::move(callback));
   }
 }
 
@@ -89,11 +89,11 @@ void MockQuotaManagerProxy::GetBucketsForStorageKey(
 
 void MockQuotaManagerProxy::GetUsageAndQuota(
     const blink::StorageKey& storage_key,
-    blink::mojom::StorageType type,
     scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
     QuotaManager::UsageAndQuotaCallback callback) {
   if (mock_quota_manager_) {
-    mock_quota_manager_->GetUsageAndQuota(storage_key, type,
+    mock_quota_manager_->GetUsageAndQuota(storage_key,
+                                          blink::mojom::StorageType::kTemporary,
                                           std::move(callback));
   }
 }

storage/browser/test/mock_quota_manager_proxy.h

@@ -50,7 +50,6 @@ class MockQuotaManagerProxy : public QuotaManagerProxy {
   void GetBucketByNameUnsafe(
       const blink::StorageKey& storage_key,
       const std::string& bucket_name,
-      blink::mojom::StorageType type,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       base::OnceCallback<void(QuotaErrorOr<BucketInfo>)>) override;
 
@@ -72,7 +71,6 @@ class MockQuotaManagerProxy : public QuotaManagerProxy {
                             bool enabled) override {}
   void GetUsageAndQuota(
       const blink::StorageKey& storage_key,
-      blink::mojom::StorageType type,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       UsageAndQuotaCallback callback) override;
 
@@ -102,7 +100,6 @@ class MockQuotaManagerProxy : public QuotaManagerProxy {
   void CreateBucketForTesting(
       const blink::StorageKey& storage_key,
       const std::string& bucket_name,
-      blink::mojom::StorageType storage_type,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) override;
 

storage/browser/test/quota_manager_proxy_sync.cc

@@ -23,12 +23,11 @@ QuotaManagerProxySync::~QuotaManagerProxySync() = default;
 
 QuotaErrorOr<BucketInfo> QuotaManagerProxySync::GetBucket(
     const blink::StorageKey& storage_key,
-    const std::string& bucket_name,
-    blink::mojom::StorageType storage_type) {
+    const std::string& bucket_name) {
   QuotaErrorOr<BucketInfo> result;
   base::RunLoop run_loop;
   proxy_->GetBucketByNameUnsafe(
-      storage_key, bucket_name, storage_type,
+      storage_key, bucket_name,
       base::SingleThreadTaskRunner::GetCurrentDefault().get(),
       base::BindLambdaForTesting([&](QuotaErrorOr<BucketInfo> bucket_info) {
         result = std::move(bucket_info);

storage/browser/test/quota_manager_proxy_sync.h

@@ -31,8 +31,7 @@ class QuotaManagerProxySync {
   QuotaManagerProxySync& operator=(const QuotaManagerProxySync&) = delete;
 
   QuotaErrorOr<BucketInfo> GetBucket(const blink::StorageKey& storage_key,
-                                     const std::string& bucket_name,
-                                     blink::mojom::StorageType storage_type);
+                                     const std::string& bucket_name);
 
  private:
   const raw_ptr<QuotaManagerProxy> proxy_;