0

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}
This commit is contained in:
Ayu Ishii
2025-02-28 11:05:45 -08:00
committed by Chromium LUCI CQ
parent 51b6662c40
commit 6ecd458052
30 changed files with 70 additions and 108 deletions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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