0

Quota: Cleanup StorageType from QuotaDatabase

This change removes usages of StorageType in QuotaDatabase methods.
After StorageType::kSyncable deprecation, all other storage types
except kTemporary are deprecated. So we no longer need to specify
StorageType. Data that was previously associated with kSyncable
is now part of kTemporary.

Further cleanup from BucketInfo/BucketLocator will be done in
a follow-up.

Change-Id: If9406ec5bb9e94640fe9bfd105686ab87597c354
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/6380194
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Tsuyoshi Horo <horo@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1442498}
This commit is contained in:
Ayu Ishii
2025-04-03 16:35:51 -07:00
committed by Chromium LUCI CQ
parent ae25b59dd8
commit d276aba977
7 changed files with 255 additions and 433 deletions

@ -57,6 +57,13 @@ static const int kDaysInTenYears = 10 * 365;
// Version 8 - 2021-09-01 - https://crrev.com/c/3119831
// Version 9 - 2022-05-13 - https://crrev.com/c/3601253
// Version 10 - 2023-04-10 - https://crrev.com/c/4412082
//
// TODO(crbug.com/40211051): Remove field `type` and all rows that are not of
// `type` 0 (Temporary) with the next migration. All other types have been
// deprecated and no data is associated with any other type. Therefore they
// should be removed. Until this is done, queries without 'WHERE type=0' might
// return buckets of other types so this should always be included until this is
// complete.
const int kQuotaDatabaseCurrentSchemaVersion = 10;
const int kQuotaDatabaseCompatibleVersion = 10;
@ -83,27 +90,25 @@ void RecordDatabaseResetHistogram(const DatabaseResetReason reason) {
#define BUCKETS_FIELDS_INSERTER \
" (storage_key, host, type, name, use_count, last_accessed, last_modified," \
" expiration, quota, persistent, durability) " \
" VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) "
" VALUES (?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?) "
void BindBucketInitParamsToInsertStatement(const BucketInitParams& params,
StorageType type,
int use_count,
const base::Time& last_accessed,
const base::Time& last_modified,
sql::Statement& statement) {
statement.BindString(0, params.storage_key.Serialize());
statement.BindString(1, params.storage_key.origin().host());
statement.BindInt(2, static_cast<int>(type));
statement.BindString(3, params.name);
statement.BindInt(4, use_count);
statement.BindTime(5, last_accessed);
statement.BindTime(6, last_modified);
statement.BindTime(7, params.expiration);
statement.BindInt64(8, params.quota);
statement.BindBool(9, params.persistent.value_or(false));
statement.BindString(2, params.name);
statement.BindInt(3, use_count);
statement.BindTime(4, last_accessed);
statement.BindTime(5, last_modified);
statement.BindTime(6, params.expiration);
statement.BindInt64(7, params.quota);
statement.BindBool(8, params.persistent.value_or(false));
int durability = static_cast<int>(
params.durability.value_or(blink::mojom::BucketDurability::kRelaxed));
statement.BindInt(10, durability);
statement.BindInt(9, durability);
}
// Fields to be retrieved from the database and stored in a
@ -113,10 +118,12 @@ void BindBucketInitParamsToInsertStatement(const BucketInitParams& params,
mojom::BucketTableEntryPtr BucketTableEntryFromSqlStatement(
sql::Statement& statement) {
// Should only ever return type Temporary. All other types are deprecated.
CHECK_EQ(statement.ColumnInt(2), 0);
mojom::BucketTableEntryPtr entry = mojom::BucketTableEntry::New();
entry->bucket_id = statement.ColumnInt64(0);
entry->storage_key = statement.ColumnString(1);
entry->type = static_cast<blink::mojom::StorageType>(statement.ColumnInt(2));
entry->name = statement.ColumnString(3);
entry->use_count = statement.ColumnInt(4);
entry->last_accessed = statement.ColumnTime(5);
@ -140,6 +147,8 @@ QuotaErrorOr<BucketInfo> BucketInfoFromSqlStatement(sql::Statement& statement) {
return base::unexpected(QuotaError::kStorageKeyError);
}
// Should only ever return type Temporary. All other types are deprecated.
CHECK_EQ(statement.ColumnInt(2), 0);
BucketInfo bucket_info(
BucketId(statement.ColumnInt64(0)), storage_key.value(),
static_cast<StorageType>(statement.ColumnInt(2)),
@ -226,12 +235,11 @@ QuotaErrorOr<BucketInfo> QuotaDatabase::UpdateOrCreateBucket(
sqlite_error_code_ = 0;
QuotaErrorOr<BucketInfo> bucket_result =
GetBucket(params.storage_key, params.name, StorageType::kTemporary);
GetBucket(params.storage_key, params.name);
if (!bucket_result.has_value()) {
if (bucket_result.error() == QuotaError::kNotFound) {
bucket_result = CreateBucketInternal(params, StorageType::kTemporary,
max_bucket_count);
bucket_result = CreateBucketInternal(params, max_bucket_count);
}
if (!bucket_result.has_value()) {
bucket_result.error().sqlite_error = sqlite_error_code_;
@ -266,18 +274,16 @@ QuotaErrorOr<BucketInfo> QuotaDatabase::UpdateOrCreateBucket(
QuotaErrorOr<BucketInfo> QuotaDatabase::CreateBucketForTesting(
const StorageKey& storage_key,
const std::string& bucket_name,
StorageType storage_type) {
const std::string& bucket_name) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
BucketInitParams params(storage_key, bucket_name);
return CreateBucketInternal(params, storage_type);
return CreateBucketInternal(params);
}
QuotaErrorOr<BucketInfo> QuotaDatabase::GetBucket(
const StorageKey& storage_key,
const std::string& bucket_name,
blink::mojom::StorageType storage_type) {
const std::string& bucket_name) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
QuotaError open_error = EnsureOpened();
if (open_error != QuotaError::kNone) {
@ -288,13 +294,12 @@ QuotaErrorOr<BucketInfo> QuotaDatabase::GetBucket(
// clang-format off
"SELECT " BUCKET_INFO_FIELDS_SELECTOR
"FROM buckets "
"WHERE storage_key = ? AND type = ? AND name = ?";
"WHERE storage_key = ? AND type = 0 AND name = ?";
// clang-format on
last_operation_ = "GetBucket";
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
statement.BindString(0, storage_key.Serialize());
statement.BindInt(1, static_cast<int>(storage_type));
statement.BindString(2, bucket_name);
statement.BindString(1, bucket_name);
return BucketInfoFromSqlStatement(statement);
}
@ -369,8 +374,7 @@ QuotaErrorOr<BucketInfo> QuotaDatabase::GetBucketById(BucketId bucket_id) {
return BucketInfoFromSqlStatement(statement);
}
QuotaErrorOr<std::set<BucketInfo>> QuotaDatabase::GetBucketsForType(
StorageType type) {
QuotaErrorOr<std::set<BucketInfo>> QuotaDatabase::GetAllBuckets() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
QuotaError open_error = EnsureOpened();
if (open_error != QuotaError::kNone) {
@ -381,18 +385,16 @@ QuotaErrorOr<std::set<BucketInfo>> QuotaDatabase::GetBucketsForType(
// clang-format off
"SELECT " BUCKET_INFO_FIELDS_SELECTOR
"FROM buckets "
"WHERE type = ?";
"WHERE type = 0";
// clang-format on
last_operation_ = "GetBucketsForType";
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
statement.BindInt(0, static_cast<int>(type));
return BucketInfosFromSqlStatement(statement);
}
QuotaErrorOr<std::set<BucketInfo>> QuotaDatabase::GetBucketsForHost(
const std::string& host,
StorageType type) {
const std::string& host) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
QuotaError open_error = EnsureOpened();
if (open_error != QuotaError::kNone) {
@ -403,19 +405,17 @@ QuotaErrorOr<std::set<BucketInfo>> QuotaDatabase::GetBucketsForHost(
// clang-format off
"SELECT " BUCKET_INFO_FIELDS_SELECTOR
"FROM buckets "
"WHERE host = ? AND type = ?";
"WHERE host = ? AND type = 0";
// clang-format on
last_operation_ = "GetBucketsForHost";
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
statement.BindString(0, host);
statement.BindInt(1, static_cast<int>(type));
return BucketInfosFromSqlStatement(statement);
}
QuotaErrorOr<std::set<BucketInfo>> QuotaDatabase::GetBucketsForStorageKey(
const StorageKey& storage_key,
StorageType type) {
const StorageKey& storage_key) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
QuotaError open_error = EnsureOpened();
if (open_error != QuotaError::kNone) {
@ -426,19 +426,17 @@ QuotaErrorOr<std::set<BucketInfo>> QuotaDatabase::GetBucketsForStorageKey(
// clang-format off
"SELECT " BUCKET_INFO_FIELDS_SELECTOR
"FROM buckets "
"WHERE storage_key = ? AND type = ?";
"WHERE storage_key = ? AND type = 0";
// clang-format on
last_operation_ = "GetBucketsForStorageKey";
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
statement.BindString(0, storage_key.Serialize());
statement.BindInt(1, static_cast<int>(type));
return BucketInfosFromSqlStatement(statement);
}
QuotaError QuotaDatabase::SetStorageKeyLastAccessTime(
const StorageKey& storage_key,
StorageType type,
base::Time last_accessed) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
QuotaError open_error = EnsureOpened();
@ -449,14 +447,13 @@ QuotaError QuotaDatabase::SetStorageKeyLastAccessTime(
// clang-format off
static constexpr char kSqlReadLastAccessed[] =
"SELECT last_accessed FROM buckets "
"WHERE storage_key = ? AND type = ? AND name = ?";
"WHERE storage_key = ? AND type = 0 AND name = ?";
// clang-format on
last_operation_ = "ReadStorageKeyLastAccessTime";
sql::Statement statement_read(
db_->GetCachedStatement(SQL_FROM_HERE, kSqlReadLastAccessed));
statement_read.BindString(0, storage_key.Serialize());
statement_read.BindInt(1, static_cast<int>(type));
statement_read.BindString(2, kDefaultBucketName);
statement_read.BindString(1, kDefaultBucketName);
if (statement_read.Step()) {
base::Time earlier_last_accessed = statement_read.ColumnTime(0);
@ -482,15 +479,14 @@ QuotaError QuotaDatabase::SetStorageKeyLastAccessTime(
static constexpr char kSqlSetLastAccessed[] =
"UPDATE buckets "
"SET use_count = use_count + 1, last_accessed = ? "
"WHERE storage_key = ? AND type = ? AND name = ?";
"WHERE storage_key = ? AND type = 0 AND name = ?";
// clang-format on
last_operation_ = "SetStorageKeyLastAccessTime";
sql::Statement statement_set(
db_->GetCachedStatement(SQL_FROM_HERE, kSqlSetLastAccessed));
statement_set.BindTime(0, last_accessed);
statement_set.BindString(1, storage_key.Serialize());
statement_set.BindInt(2, static_cast<int>(type));
statement_set.BindString(3, kDefaultBucketName);
statement_set.BindString(2, kDefaultBucketName);
if (!statement_set.Run()) {
return QuotaError::kDatabaseError;
@ -553,30 +549,27 @@ QuotaError QuotaDatabase::SetBucketLastModifiedTime(BucketId bucket_id,
}
QuotaError QuotaDatabase::RegisterInitialStorageKeyInfo(
base::flat_map<StorageType, std::set<StorageKey>> storage_keys_by_type) {
std::set<StorageKey> storage_keys) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
QuotaError open_error = EnsureOpened();
if (open_error != QuotaError::kNone) {
return open_error;
}
for (const auto& type_and_storage_keys : storage_keys_by_type) {
StorageType storage_type = type_and_storage_keys.first;
for (const auto& storage_key : type_and_storage_keys.second) {
static constexpr char kSql[] =
"INSERT OR IGNORE INTO buckets" BUCKETS_FIELDS_INSERTER;
last_operation_ = "BootstrapDefaultBucket";
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
BucketInitParams init_params =
BucketInitParams::ForDefaultBucket(storage_key);
BindBucketInitParamsToInsertStatement(
init_params, storage_type, /*use_count=*/0,
/*last_accessed=*/base::Time(),
/*last_modified=*/base::Time(), statement);
for (const auto& storage_key : storage_keys) {
static constexpr char kSql[] =
"INSERT OR IGNORE INTO buckets" BUCKETS_FIELDS_INSERTER;
last_operation_ = "BootstrapDefaultBucket";
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
BucketInitParams init_params =
BucketInitParams::ForDefaultBucket(storage_key);
BindBucketInitParamsToInsertStatement(init_params, /*use_count=*/0,
/*last_accessed=*/base::Time(),
/*last_modified=*/base::Time(),
statement);
if (!statement.Run()) {
return QuotaError::kDatabaseError;
}
if (!statement.Run()) {
return QuotaError::kDatabaseError;
}
}
ScheduleCommit();
@ -664,7 +657,6 @@ QuotaErrorOr<mojom::BucketTableEntryPtr> QuotaDatabase::DeleteBucketData(
}
QuotaErrorOr<std::set<BucketLocator>> QuotaDatabase::GetBucketsForEviction(
StorageType type,
int64_t target_usage,
const std::map<BucketLocator, int64_t>& usage_map,
const std::set<BucketId>& bucket_exceptions,
@ -680,13 +672,12 @@ QuotaErrorOr<std::set<BucketLocator>> QuotaDatabase::GetBucketsForEviction(
// clang-format off
static constexpr char kSql[] =
"SELECT id, storage_key, name FROM buckets "
"WHERE type = ? AND persistent = 0 "
"WHERE type = 0 AND persistent = 0 "
"ORDER BY last_accessed";
// clang-format on
last_operation_ = "GetBucketsForEviction";
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
statement.BindInt(0, static_cast<int>(type));
// The total space used by all buckets marked for eviction.
int64_t total_usage = 0;
@ -714,7 +705,7 @@ QuotaErrorOr<std::set<BucketLocator>> QuotaDatabase::GetBucketsForEviction(
}
BucketLocator locator(read_bucket_id, std::move(read_storage_key).value(),
type, is_default);
StorageType::kTemporary, is_default);
const auto& bucket_usage = usage_map.find(locator);
total_usage += (bucket_usage == usage_map.end()) ? 1 : bucket_usage->second;
buckets_to_evict.insert(locator);
@ -728,8 +719,7 @@ QuotaErrorOr<std::set<BucketLocator>> QuotaDatabase::GetBucketsForEviction(
return buckets_to_evict;
}
QuotaErrorOr<std::set<StorageKey>> QuotaDatabase::GetStorageKeysForType(
StorageType type) {
QuotaErrorOr<std::set<StorageKey>> QuotaDatabase::GetAllStorageKeys() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
QuotaError open_error = EnsureOpened();
if (open_error != QuotaError::kNone) {
@ -737,11 +727,10 @@ QuotaErrorOr<std::set<StorageKey>> QuotaDatabase::GetStorageKeysForType(
}
static constexpr char kSql[] =
"SELECT DISTINCT storage_key FROM buckets WHERE type = ?";
"SELECT DISTINCT storage_key FROM buckets WHERE type = 0";
last_operation_ = "GetStorageKeys";
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
statement.BindInt(0, static_cast<int>(type));
std::set<StorageKey> storage_keys;
while (statement.Step()) {
@ -756,7 +745,6 @@ QuotaErrorOr<std::set<StorageKey>> QuotaDatabase::GetStorageKeysForType(
}
QuotaErrorOr<std::set<BucketLocator>> QuotaDatabase::GetBucketsModifiedBetween(
StorageType type,
base::Time begin,
base::Time end) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
@ -770,14 +758,13 @@ QuotaErrorOr<std::set<BucketLocator>> QuotaDatabase::GetBucketsModifiedBetween(
// clang-format off
static constexpr char kSql[] =
"SELECT id, storage_key, name FROM buckets "
"WHERE type = ? AND last_modified >= ? AND last_modified < ?";
"WHERE type = 0 AND last_modified >= ? AND last_modified < ?";
// clang-format on
last_operation_ = "GetBucketsModifiedBetween";
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
statement.BindInt(0, static_cast<int>(type));
statement.BindTime(1, begin);
statement.BindTime(2, end);
statement.BindTime(0, begin);
statement.BindTime(1, end);
std::set<BucketLocator> buckets;
while (statement.Step()) {
@ -787,7 +774,7 @@ QuotaErrorOr<std::set<BucketLocator>> QuotaDatabase::GetBucketsModifiedBetween(
continue;
}
buckets.emplace(BucketId(statement.ColumnInt64(0)),
read_storage_key.value(), type,
read_storage_key.value(), StorageType::kTemporary,
statement.ColumnStringView(2) == kDefaultBucketName);
}
return buckets;
@ -826,7 +813,7 @@ QuotaErrorOr<std::set<BucketInfo>> QuotaDatabase::GetExpiredBuckets(
"SELECT " BUCKET_INFO_FIELDS_SELECTOR
"FROM buckets "
"WHERE (expiration > 0 AND expiration < ?) OR "
" (type = ? AND persistent = 0 AND "
" (type = 0 AND persistent = 0 AND "
" last_accessed < ? AND last_modified < ?) OR "
" (storage_key REGEXP '.*\\^(1|4).*' AND "
" last_accessed < ? AND last_modified < ?)";
@ -837,13 +824,12 @@ QuotaErrorOr<std::set<BucketInfo>> QuotaDatabase::GetExpiredBuckets(
db_->GetCachedStatement(SQL_FROM_HERE, kSqlExpiredAndStaleAndOrphan));
base::Time expiration_cutoff = GetNow();
statement.BindTime(0, expiration_cutoff);
statement.BindInt(1, static_cast<int>(blink::mojom::StorageType::kTemporary));
base::Time stale_cutoff = GetNow() - base::Days(400);
statement.BindTime(1, stale_cutoff);
statement.BindTime(2, stale_cutoff);
statement.BindTime(3, stale_cutoff);
base::Time orphan_cutoff = GetNow() - base::Days(1);
statement.BindTime(3, orphan_cutoff);
statement.BindTime(4, orphan_cutoff);
statement.BindTime(5, orphan_cutoff);
// Filter and count returned buckets.
QuotaErrorOr<BucketInfo> bucket;
@ -1285,7 +1271,8 @@ QuotaError QuotaDatabase::DumpBucketTable(const BucketTableCallback& callback) {
static constexpr char kSql[] =
// clang-format off
"SELECT " BUCKET_TABLE_ENTRY_FIELDS_SELECTOR
"FROM buckets";
"FROM buckets "
"WHERE type = 0 ";
// clang-format on
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
@ -1307,7 +1294,6 @@ QuotaError QuotaDatabase::DumpBucketTable(const BucketTableCallback& callback) {
QuotaErrorOr<BucketInfo> QuotaDatabase::CreateBucketInternal(
const BucketInitParams& params,
StorageType type,
int max_bucket_count) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// TODO(crbug.com/40182349): Add DCHECKs for input validation.
@ -1327,12 +1313,11 @@ QuotaErrorOr<BucketInfo> QuotaDatabase::CreateBucketInternal(
// clang-format off
"SELECT count(*) "
"FROM buckets "
"WHERE storage_key = ? AND type = ?";
"WHERE storage_key = ? AND type = 0";
// clang-format on
last_operation_ = "CountBuckets";
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
statement.BindString(0, params.storage_key.Serialize());
statement.BindInt(1, static_cast<int>(type));
if (!statement.Step()) {
return base::unexpected(QuotaError::kDatabaseError);
@ -1356,7 +1341,8 @@ QuotaErrorOr<BucketInfo> QuotaDatabase::CreateBucketInternal(
const base::Time now = GetNow();
sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
BindBucketInitParamsToInsertStatement(params, type, /*use_count=*/0,
BindBucketInitParamsToInsertStatement(params,
/*use_count=*/0,
/*last_accessed=*/now,
/*last_modified=*/now, statement);
QuotaErrorOr<BucketInfo> result = BucketInfoFromSqlStatement(statement);

@ -90,49 +90,33 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaDatabase {
QuotaErrorOr<BucketInfo> UpdateOrCreateBucket(const BucketInitParams& params,
int max_bucket_count);
// Same as UpdateOrCreateBucket but takes in StorageType. This should only
// be used by FileSystem, and is expected to be removed when
// StorageType::kSyncable and StorageType::kPersistent are deprecated.
// (crbug.com/1233525, crbug.com/1286964).
QuotaErrorOr<BucketInfo> GetOrCreateBucketDeprecated(
const BucketInitParams& params,
blink::mojom::StorageType type);
// TODO(crbug.com/40181609): Remove `storage_type` when the only supported
// StorageType is kTemporary.
QuotaErrorOr<BucketInfo> CreateBucketForTesting(
const blink::StorageKey& storage_key,
const std::string& bucket_name,
blink::mojom::StorageType storage_type);
const std::string& bucket_name);
// Retrieves BucketInfo of the bucket with `bucket_name` for `storage_key`.
// Returns a QuotaError::kEntryNotFound if the bucket does not exist, or
// a QuotaError::kDatabaseError if the operation has failed.
QuotaErrorOr<BucketInfo> GetBucket(const blink::StorageKey& storage_key,
const std::string& bucket_name,
blink::mojom::StorageType storage_type);
const std::string& bucket_name);
// Retrieves BucketInfo of the bucket with `bucket_id`.
// Returns a QuotaError::kEntryNotFound if the bucket does not exist, or
// a QuotaError::kDatabaseError if the operation has failed.
QuotaErrorOr<BucketInfo> GetBucketById(BucketId bucket_id);
// Returns all buckets for `type` in the buckets table. Returns a QuotaError
// if the operation has failed.
QuotaErrorOr<std::set<BucketInfo>> GetBucketsForType(
blink::mojom::StorageType type);
// Retrieves all buckets for `host` and `type`. Returns a QuotaError if the
// Returns all buckets in the buckets table. Returns a QuotaError if the
// operation has failed.
QuotaErrorOr<std::set<BucketInfo>> GetBucketsForHost(
const std::string& host,
blink::mojom::StorageType type);
QuotaErrorOr<std::set<BucketInfo>> GetAllBuckets();
// Retrieves all buckets for `host`. Returns a QuotaError if the operation
// has failed.
QuotaErrorOr<std::set<BucketInfo>> GetBucketsForHost(const std::string& host);
// Returns all buckets for `storage_key` in the buckets table. Returns a
// QuotaError if the operation has failed.
QuotaErrorOr<std::set<BucketInfo>> GetBucketsForStorageKey(
const blink::StorageKey& storage_key,
blink::mojom::StorageType type);
const blink::StorageKey& storage_key);
// Updates the expiration for the designated bucket.
QuotaErrorOr<BucketInfo> UpdateBucketExpiration(BucketId bucket,
@ -145,7 +129,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaDatabase {
// SetBucketLastAccessTime.
[[nodiscard]] QuotaError SetStorageKeyLastAccessTime(
const blink::StorageKey& storage_key,
blink::mojom::StorageType type,
base::Time last_accessed);
// Called by QuotaClient implementers to update when the bucket was last
@ -160,12 +143,11 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaDatabase {
[[nodiscard]] QuotaError SetBucketLastModifiedTime(BucketId bucket_id,
base::Time last_modified);
// Register initial `storage_keys_by_type` into the database.
// Register initial `storage_keys` into the database.
// This method is assumed to be called only after the installation or
// the database schema reset.
QuotaError RegisterInitialStorageKeyInfo(
base::flat_map<blink::mojom::StorageType, std::set<blink::StorageKey>>
storage_keys_by_type);
std::set<blink::StorageKey> storage_keys);
// Returns the BucketTableEntry for `bucket` if one exists. Returns a
// QuotaError if not found or the operation has failed.
@ -184,20 +166,17 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaDatabase {
// failed. `usage_map` describes the amount of space used by each bucket; any
// bucket missing from this map will be considered to use only 1b.
QuotaErrorOr<std::set<BucketLocator>> GetBucketsForEviction(
blink::mojom::StorageType type,
int64_t target_usage,
const std::map<BucketLocator, int64_t>& usage_map,
const std::set<BucketId>& bucket_exceptions,
SpecialStoragePolicy* special_storage_policy);
// Returns all storage keys for `type` in the buckets table.
QuotaErrorOr<std::set<blink::StorageKey>> GetStorageKeysForType(
blink::mojom::StorageType type);
// Returns all storage keys in the buckets table.
QuotaErrorOr<std::set<blink::StorageKey>> GetAllStorageKeys();
// Returns a set of buckets that have been modified since the `begin` and
// until the `end`. Returns a QuotaError if the operations has failed.
QuotaErrorOr<std::set<BucketLocator>> GetBucketsModifiedBetween(
blink::mojom::StorageType type,
base::Time begin,
base::Time end);
@ -301,7 +280,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaDatabase {
// bucket would cause the count of buckets for that storage key and type to
// exceed `max_bucket_count`, if `max_bucket_count` is greater than zero.
QuotaErrorOr<BucketInfo> CreateBucketInternal(const BucketInitParams& params,
blink::mojom::StorageType type,
int max_bucket_count = 0);
SEQUENCE_CHECKER(sequence_checker_);

@ -58,13 +58,6 @@ namespace {
// Declared to shorten the line lengths.
static const blink::mojom::StorageType kTemp =
blink::mojom::StorageType::kTemporary;
static const blink::mojom::StorageType kSync =
blink::mojom::StorageType::kSyncable;
static const blink::mojom::StorageType kStorageTemp =
blink::mojom::StorageType::kTemporary;
static const blink::mojom::StorageType kStorageSync =
blink::mojom::StorageType::kSyncable;
static constexpr char kDatabaseName[] = "QuotaManager";
@ -165,7 +158,7 @@ class QuotaDatabaseTest : public testing::TestWithParam<bool> {
"quota,"
"persistent,"
"durability) "
"VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, 0, 0, 0)";
"VALUES (?, ?, ?, 0, ?, ?, ?, ?, 0, 0, 0, 0)";
// clang-format on
sql::Statement statement;
statement.Assign(
@ -179,11 +172,10 @@ class QuotaDatabaseTest : public testing::TestWithParam<bool> {
statement.BindInt64(0, entry->bucket_id);
statement.BindString(1, entry->storage_key);
statement.BindString(2, std::move(storage_key).value().origin().host());
statement.BindInt(3, static_cast<int>(entry->type));
statement.BindString(4, entry->name);
statement.BindInt(5, static_cast<int>(entry->use_count));
statement.BindTime(6, entry->last_accessed);
statement.BindTime(7, entry->last_modified);
statement.BindString(3, entry->name);
statement.BindInt(4, static_cast<int>(entry->use_count));
statement.BindTime(5, entry->last_accessed);
statement.BindTime(6, entry->last_modified);
EXPECT_TRUE(statement.Run());
}
quota_database->Commit();
@ -300,29 +292,28 @@ TEST_P(QuotaDatabaseTest, GetBucket) {
StorageKey storage_key =
StorageKey::CreateFromStringForTesting("http://google/");
std::string bucket_name = "google_bucket";
ASSERT_OK_AND_ASSIGN(
BucketInfo created_bucket,
db->CreateBucketForTesting(storage_key, bucket_name, kTemp));
ASSERT_OK_AND_ASSIGN(BucketInfo created_bucket,
db->CreateBucketForTesting(storage_key, bucket_name));
ASSERT_GT(created_bucket.id.value(), 0);
ASSERT_EQ(created_bucket.name, bucket_name);
ASSERT_EQ(created_bucket.storage_key, storage_key);
ASSERT_EQ(created_bucket.type, kTemp);
ASSERT_OK_AND_ASSIGN(BucketInfo queried_bucket,
db->GetBucket(storage_key, bucket_name, kTemp));
db->GetBucket(storage_key, bucket_name));
EXPECT_EQ(queried_bucket.id, created_bucket.id);
EXPECT_EQ(queried_bucket.name, created_bucket.name);
EXPECT_EQ(queried_bucket.storage_key, created_bucket.storage_key);
ASSERT_EQ(queried_bucket.type, created_bucket.type);
// Can't retrieve buckets with name mismatch.
EXPECT_THAT(db->GetBucket(storage_key, "does_not_exist", kTemp),
EXPECT_THAT(db->GetBucket(storage_key, "does_not_exist"),
base::test::ErrorIs(QuotaError::kNotFound));
// Can't retrieve buckets with StorageKey mismatch.
EXPECT_THAT(
db->GetBucket(StorageKey::CreateFromStringForTesting("http://example/"),
bucket_name, kTemp),
bucket_name),
base::test::ErrorIs(QuotaError::kNotFound));
}
@ -334,9 +325,8 @@ TEST_P(QuotaDatabaseTest, GetBucketById) {
StorageKey storage_key =
StorageKey::CreateFromStringForTesting("http://google/");
std::string bucket_name = "google_bucket";
ASSERT_OK_AND_ASSIGN(
BucketInfo created_bucket,
db->CreateBucketForTesting(storage_key, bucket_name, kTemp));
ASSERT_OK_AND_ASSIGN(BucketInfo created_bucket,
db->CreateBucketForTesting(storage_key, bucket_name));
ASSERT_GT(created_bucket.id.value(), 0);
ASSERT_EQ(created_bucket.name, bucket_name);
ASSERT_EQ(created_bucket.storage_key, storage_key);
@ -353,7 +343,7 @@ TEST_P(QuotaDatabaseTest, GetBucketById) {
base::test::ErrorIs(QuotaError::kNotFound));
}
TEST_P(QuotaDatabaseTest, GetBucketsForType) {
TEST_P(QuotaDatabaseTest, GetAllBuckets) {
auto db = CreateDatabase(use_in_memory_db());
EXPECT_TRUE(EnsureOpened(db.get()));
@ -364,34 +354,22 @@ TEST_P(QuotaDatabaseTest, GetBucketsForType) {
const StorageKey storage_key3 =
StorageKey::CreateFromStringForTesting("http://example-c/");
ASSERT_OK_AND_ASSIGN(
BucketInfo temp_bucket1,
db->CreateBucketForTesting(storage_key1, "temp_bucket", kTemp));
ASSERT_OK_AND_ASSIGN(BucketInfo bucket1,
db->CreateBucketForTesting(storage_key1, "data"));
ASSERT_OK_AND_ASSIGN(BucketInfo bucket2,
db->CreateBucketForTesting(storage_key2, "logs"));
ASSERT_OK_AND_ASSIGN(
BucketInfo temp_bucket2,
db->CreateBucketForTesting(storage_key2, "temp_bucket", kTemp));
BucketInfo bucket3,
db->CreateBucketForTesting(storage_key3, kDefaultBucketName));
ASSERT_OK_AND_ASSIGN(
BucketInfo sync_bucket1,
db->CreateBucketForTesting(storage_key1, kDefaultBucketName, kSync));
ASSERT_OK_AND_ASSIGN(
BucketInfo sync_bucket2,
db->CreateBucketForTesting(storage_key3, kDefaultBucketName, kSync));
ASSERT_OK_AND_ASSIGN(std::set<BucketInfo> result,
db->GetBucketsForType(kTemp));
ASSERT_OK_AND_ASSIGN(std::set<BucketInfo> result, db->GetAllBuckets());
std::set<BucketLocator> buckets = BucketInfosToBucketLocators(result);
ASSERT_EQ(2U, buckets.size());
EXPECT_TRUE(ContainsBucket(buckets, temp_bucket1));
EXPECT_TRUE(ContainsBucket(buckets, temp_bucket2));
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForType(kSync));
buckets = BucketInfosToBucketLocators(result);
ASSERT_EQ(2U, buckets.size());
EXPECT_TRUE(ContainsBucket(buckets, sync_bucket1));
EXPECT_TRUE(ContainsBucket(buckets, sync_bucket2));
ASSERT_EQ(3U, buckets.size());
EXPECT_TRUE(ContainsBucket(buckets, bucket1));
EXPECT_TRUE(ContainsBucket(buckets, bucket2));
EXPECT_TRUE(ContainsBucket(buckets, bucket3));
}
TEST_P(QuotaDatabaseTest, GetBucketsForHost) {
@ -399,42 +377,30 @@ TEST_P(QuotaDatabaseTest, GetBucketsForHost) {
EXPECT_TRUE(EnsureOpened(db.get()));
ASSERT_OK_AND_ASSIGN(
BucketInfo temp_example_bucket1,
BucketInfo example_bucket1,
db->CreateBucketForTesting(
StorageKey::CreateFromStringForTesting("https://example.com/"),
kDefaultBucketName, kTemp));
kDefaultBucketName));
ASSERT_OK_AND_ASSIGN(
BucketInfo temp_example_bucket2,
BucketInfo example_bucket2,
db->CreateBucketForTesting(
StorageKey::CreateFromStringForTesting("http://example.com:123/"),
kDefaultBucketName, kTemp));
kDefaultBucketName));
ASSERT_OK_AND_ASSIGN(
BucketInfo perm_google_bucket1,
BucketInfo google_bucket,
db->CreateBucketForTesting(
StorageKey::CreateFromStringForTesting("http://google.com/"),
kDefaultBucketName, kSync));
ASSERT_OK_AND_ASSIGN(
BucketInfo temp_google_bucket2,
db->CreateBucketForTesting(
StorageKey::CreateFromStringForTesting("http://google.com:123/"),
kDefaultBucketName, kTemp));
kDefaultBucketName));
ASSERT_OK_AND_ASSIGN(std::set<BucketInfo> result,
db->GetBucketsForHost("example.com", kTemp));
db->GetBucketsForHost("example.com"));
ASSERT_EQ(result.size(), 2U);
EXPECT_TRUE(base::Contains(result, temp_example_bucket1));
EXPECT_TRUE(base::Contains(result, temp_example_bucket2));
EXPECT_TRUE(base::Contains(result, example_bucket1));
EXPECT_TRUE(base::Contains(result, example_bucket2));
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForHost("example.com", kSync));
ASSERT_EQ(result.size(), 0U);
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForHost("google.com", kSync));
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForHost("google.com"));
ASSERT_EQ(result.size(), 1U);
EXPECT_TRUE(base::Contains(result, perm_google_bucket1));
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForHost("google.com", kTemp));
ASSERT_EQ(result.size(), 1U);
EXPECT_TRUE(base::Contains(result, temp_google_bucket2));
EXPECT_TRUE(base::Contains(result, google_bucket));
}
TEST_P(QuotaDatabaseTest, GetBucketsForStorageKey) {
@ -446,34 +412,27 @@ TEST_P(QuotaDatabaseTest, GetBucketsForStorageKey) {
const StorageKey storage_key2 =
StorageKey::CreateFromStringForTesting("http://example-b/");
ASSERT_OK_AND_ASSIGN(
BucketInfo temp_bucket1,
db->CreateBucketForTesting(storage_key1, "temp_test1", kTemp));
ASSERT_OK_AND_ASSIGN(BucketInfo bucket1,
db->CreateBucketForTesting(storage_key1, "test1"));
ASSERT_OK_AND_ASSIGN(BucketInfo bucket2,
db->CreateBucketForTesting(storage_key1, "test2"));
ASSERT_OK_AND_ASSIGN(
BucketInfo temp_bucket2,
db->CreateBucketForTesting(storage_key1, "temp_test2", kTemp));
ASSERT_OK_AND_ASSIGN(
BucketInfo sync_bucket1,
db->CreateBucketForTesting(storage_key1, kDefaultBucketName, kSync));
ASSERT_OK_AND_ASSIGN(
BucketInfo sync_bucket2,
db->CreateBucketForTesting(storage_key2, kDefaultBucketName, kSync));
BucketInfo bucket3,
db->CreateBucketForTesting(storage_key2, kDefaultBucketName));
ASSERT_OK_AND_ASSIGN(std::set<BucketInfo> result,
db->GetBucketsForStorageKey(storage_key1, kTemp));
db->GetBucketsForStorageKey(storage_key1));
std::set<BucketLocator> buckets = BucketInfosToBucketLocators(result);
ASSERT_EQ(2U, buckets.size());
EXPECT_TRUE(ContainsBucket(buckets, temp_bucket1));
EXPECT_TRUE(ContainsBucket(buckets, temp_bucket2));
EXPECT_TRUE(ContainsBucket(buckets, bucket1));
EXPECT_TRUE(ContainsBucket(buckets, bucket2));
ASSERT_OK_AND_ASSIGN(result,
db->GetBucketsForStorageKey(storage_key2, kSync));
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForStorageKey(storage_key2));
buckets = BucketInfosToBucketLocators(result);
ASSERT_EQ(1U, buckets.size());
EXPECT_TRUE(ContainsBucket(buckets, sync_bucket2));
EXPECT_TRUE(ContainsBucket(buckets, bucket3));
}
TEST_P(QuotaDatabaseTest, BucketLastAccessTimeLRU) {
@ -481,9 +440,8 @@ TEST_P(QuotaDatabaseTest, BucketLastAccessTimeLRU) {
EXPECT_TRUE(EnsureOpened(db.get()));
std::set<BucketId> bucket_exceptions;
EXPECT_THAT(
db->GetBucketsForEviction(kTemp, 1, {}, bucket_exceptions, nullptr),
base::test::ErrorIs(QuotaError::kNotFound));
EXPECT_THAT(db->GetBucketsForEviction(1, {}, bucket_exceptions, nullptr),
base::test::ErrorIs(QuotaError::kNotFound));
// Insert bucket entries into BucketTable.
base::Time now = base::Time::Now();
@ -500,25 +458,21 @@ TEST_P(QuotaDatabaseTest, BucketLastAccessTimeLRU) {
BucketId bucket_id1 = BucketId(1);
BucketId bucket_id2 = BucketId(2);
BucketId bucket_id3 = BucketId(3);
BucketId bucket_id4 = BucketId(4);
Entry bucket1 = mojom::BucketTableEntry::New(
bucket_id1.value(), storage_key1.Serialize(), kStorageTemp,
kDefaultBucketName, -1, 99, now, now);
Entry bucket2 = mojom::BucketTableEntry::New(
bucket_id2.value(), storage_key2.Serialize(), kStorageTemp,
kDefaultBucketName, -1, 0, now, now);
Entry bucket1 =
mojom::BucketTableEntry::New(bucket_id1.value(), storage_key1.Serialize(),
kDefaultBucketName, -1, 99, now, now);
Entry bucket2 =
mojom::BucketTableEntry::New(bucket_id2.value(), storage_key2.Serialize(),
kDefaultBucketName, -1, 0, now, now);
Entry bucket3 =
mojom::BucketTableEntry::New(bucket_id3.value(), storage_key3.Serialize(),
kStorageTemp, "bucket_c", -1, 1, now, now);
Entry bucket4 =
mojom::BucketTableEntry::New(bucket_id4.value(), storage_key4.Serialize(),
kStorageSync, "bucket_d", -1, 5, now, now);
Entry kTableEntries[] = {bucket1->Clone(), bucket2->Clone(), bucket3->Clone(),
bucket4->Clone()};
"bucket_c", -1, 1, now, now);
Entry kTableEntries[] = {bucket1->Clone(), bucket2->Clone(),
bucket3->Clone()};
AssignBucketTable(db.get(), kTableEntries);
// Update access time for three temporary storages, and
// Update access time for three temporary buckets.
EXPECT_EQ(db->SetBucketLastAccessTime(
bucket_id1, base::Time::FromMillisecondsSinceUnixEpoch(10)),
QuotaError::kNone);
@ -529,11 +483,6 @@ TEST_P(QuotaDatabaseTest, BucketLastAccessTimeLRU) {
bucket_id3, base::Time::FromMillisecondsSinceUnixEpoch(30)),
QuotaError::kNone);
// One persistent.
EXPECT_EQ(db->SetBucketLastAccessTime(
bucket_id4, base::Time::FromMillisecondsSinceUnixEpoch(40)),
QuotaError::kNone);
// One non-existent.
EXPECT_EQ(db->SetBucketLastAccessTime(
BucketId(777), base::Time::FromMillisecondsSinceUnixEpoch(40)),
@ -541,7 +490,7 @@ TEST_P(QuotaDatabaseTest, BucketLastAccessTimeLRU) {
ASSERT_OK_AND_ASSIGN(
std::set<BucketLocator> result,
db->GetBucketsForEviction(kTemp, 1, {}, bucket_exceptions, nullptr));
db->GetBucketsForEviction(1, {}, bucket_exceptions, nullptr));
ASSERT_EQ(1U, result.size());
EXPECT_EQ(bucket_id1, result.begin()->id);
@ -550,45 +499,40 @@ TEST_P(QuotaDatabaseTest, BucketLastAccessTimeLRU) {
auto policy = base::MakeRefCounted<MockSpecialStoragePolicy>();
policy->AddUnlimited(storage_key1.origin().GetURL());
policy->AddProtected(storage_key2.origin().GetURL());
ASSERT_OK_AND_ASSIGN(
result,
db->GetBucketsForEviction(kTemp, 1, {}, bucket_exceptions, policy.get()));
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForEviction(
1, {}, bucket_exceptions, policy.get()));
ASSERT_EQ(1U, result.size());
EXPECT_EQ(bucket_id2, result.begin()->id);
// Test that durable origins are excluded from eviction.
policy->AddDurable(storage_key2.origin().GetURL());
ASSERT_OK_AND_ASSIGN(
result,
db->GetBucketsForEviction(kTemp, 1, {}, bucket_exceptions, policy.get()));
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForEviction(
1, {}, bucket_exceptions, policy.get()));
ASSERT_EQ(1U, result.size());
EXPECT_EQ(bucket_id3, result.begin()->id);
// Bucket exceptions exclude specified buckets.
bucket_exceptions.insert(bucket_id1);
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForEviction(
kTemp, 1, {}, bucket_exceptions, nullptr));
ASSERT_OK_AND_ASSIGN(
result, db->GetBucketsForEviction(1, {}, bucket_exceptions, nullptr));
ASSERT_EQ(1U, result.size());
EXPECT_EQ(bucket_id2, result.begin()->id);
bucket_exceptions.insert(bucket_id2);
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForEviction(
kTemp, 1, {}, bucket_exceptions, nullptr));
ASSERT_OK_AND_ASSIGN(
result, db->GetBucketsForEviction(1, {}, bucket_exceptions, nullptr));
ASSERT_EQ(1U, result.size());
EXPECT_EQ(bucket_id3, result.begin()->id);
bucket_exceptions.insert(bucket_id3);
EXPECT_THAT(
db->GetBucketsForEviction(kTemp, 1, {}, bucket_exceptions, nullptr),
base::test::ErrorIs(QuotaError::kNotFound));
EXPECT_THAT(db->GetBucketsForEviction(1, {}, bucket_exceptions, nullptr),
base::test::ErrorIs(QuotaError::kNotFound));
EXPECT_EQ(db->SetBucketLastAccessTime(bucket_id1, base::Time::Now()),
QuotaError::kNone);
BucketLocator bucket_locator =
BucketLocator(bucket_id3, storage_key3,
static_cast<blink::mojom::StorageType>(bucket3->type),
bucket3->name == kDefaultBucketName);
BucketLocator bucket_locator = BucketLocator(
bucket_id3, storage_key3, kTemp, bucket3->name == kDefaultBucketName);
// Delete storage_key/type last access time information.
ASSERT_OK_AND_ASSIGN(auto deleted, db->DeleteBucketData(bucket_locator));
@ -596,16 +540,15 @@ TEST_P(QuotaDatabaseTest, BucketLastAccessTimeLRU) {
// Querying again to see if the deletion has worked.
bucket_exceptions.clear();
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForEviction(
kTemp, 1, {}, bucket_exceptions, nullptr));
ASSERT_OK_AND_ASSIGN(
result, db->GetBucketsForEviction(1, {}, bucket_exceptions, nullptr));
ASSERT_EQ(1U, result.size());
EXPECT_EQ(bucket_id2, result.begin()->id);
bucket_exceptions.insert(bucket_id1);
bucket_exceptions.insert(bucket_id2);
EXPECT_THAT(
db->GetBucketsForEviction(kTemp, 1, {}, bucket_exceptions, nullptr),
base::test::ErrorIs(QuotaError::kNotFound));
EXPECT_THAT(db->GetBucketsForEviction(1, {}, bucket_exceptions, nullptr),
base::test::ErrorIs(QuotaError::kNotFound));
}
TEST_P(QuotaDatabaseTest, BucketPersistence) {
@ -613,9 +556,8 @@ TEST_P(QuotaDatabaseTest, BucketPersistence) {
EXPECT_TRUE(EnsureOpened(db.get()));
std::set<BucketId> bucket_exceptions;
EXPECT_THAT(
db->GetBucketsForEviction(kTemp, 1, {}, bucket_exceptions, nullptr),
base::test::ErrorIs(QuotaError::kNotFound));
EXPECT_THAT(db->GetBucketsForEviction(1, {}, bucket_exceptions, nullptr),
base::test::ErrorIs(QuotaError::kNotFound));
// Insert bucket entries into BucketTable.
base::Time now = base::Time::Now();
@ -629,12 +571,12 @@ TEST_P(QuotaDatabaseTest, BucketPersistence) {
BucketId bucket_id1 = BucketId(1);
BucketId bucket_id2 = BucketId(2);
Entry bucket1 = mojom::BucketTableEntry::New(
bucket_id1.value(), storage_key1.Serialize(), kStorageTemp,
kDefaultBucketName, -1, 99, now, now);
Entry bucket2 = mojom::BucketTableEntry::New(
bucket_id2.value(), storage_key2.Serialize(), kStorageTemp,
kDefaultBucketName, -1, 0, now, now);
Entry bucket1 =
mojom::BucketTableEntry::New(bucket_id1.value(), storage_key1.Serialize(),
kDefaultBucketName, -1, 99, now, now);
Entry bucket2 =
mojom::BucketTableEntry::New(bucket_id2.value(), storage_key2.Serialize(),
kDefaultBucketName, -1, 0, now, now);
Entry kTableEntries[] = {bucket1->Clone(), bucket2->Clone()};
AssignBucketTable(db.get(), kTableEntries);
@ -647,13 +589,13 @@ TEST_P(QuotaDatabaseTest, BucketPersistence) {
ASSERT_OK_AND_ASSIGN(
std::set<BucketLocator> result,
db->GetBucketsForEviction(kTemp, 1, {}, bucket_exceptions, nullptr));
db->GetBucketsForEviction(1, {}, bucket_exceptions, nullptr));
ASSERT_EQ(1U, result.size());
EXPECT_EQ(bucket_id1, result.begin()->id);
ASSERT_TRUE(db->UpdateBucketPersistence(bucket_id1, true).has_value());
ASSERT_OK_AND_ASSIGN(result, db->GetBucketsForEviction(
kTemp, 1, {}, bucket_exceptions, nullptr));
ASSERT_OK_AND_ASSIGN(
result, db->GetBucketsForEviction(1, {}, bucket_exceptions, nullptr));
ASSERT_EQ(1U, result.size());
EXPECT_EQ(bucket_id2, result.begin()->id);
}
@ -667,14 +609,13 @@ TEST_P(QuotaDatabaseTest, SetStorageKeyLastAccessTime) {
base::Time now = base::Time::Now();
// Doesn't error if bucket doesn't exist.
EXPECT_EQ(db->SetStorageKeyLastAccessTime(storage_key, kTemp, now),
EXPECT_EQ(db->SetStorageKeyLastAccessTime(storage_key, now),
QuotaError::kNone);
ASSERT_OK_AND_ASSIGN(
BucketInfo bucket,
db->CreateBucketForTesting(storage_key, kDefaultBucketName, kTemp));
ASSERT_OK_AND_ASSIGN(BucketInfo bucket, db->CreateBucketForTesting(
storage_key, kDefaultBucketName));
EXPECT_EQ(db->SetStorageKeyLastAccessTime(storage_key, kTemp, now),
EXPECT_EQ(db->SetStorageKeyLastAccessTime(storage_key, now),
QuotaError::kNone);
ASSERT_OK_AND_ASSIGN(mojom::BucketTableEntryPtr info,
@ -683,7 +624,7 @@ TEST_P(QuotaDatabaseTest, SetStorageKeyLastAccessTime) {
EXPECT_EQ(1, info->use_count);
}
TEST_P(QuotaDatabaseTest, GetStorageKeysForType) {
TEST_P(QuotaDatabaseTest, GetAllStorageKeys) {
auto db = CreateDatabase(use_in_memory_db());
EXPECT_TRUE(EnsureOpened(db.get()));
@ -691,26 +632,13 @@ TEST_P(QuotaDatabaseTest, GetStorageKeysForType) {
StorageKey::CreateFromStringForTesting("http://example-a/");
const StorageKey storage_key2 =
StorageKey::CreateFromStringForTesting("http://example-b/");
const StorageKey storage_key3 =
StorageKey::CreateFromStringForTesting("http://example-c/");
std::ignore = db->CreateBucketForTesting(storage_key1, "bucket_a", kTemp);
std::ignore = db->CreateBucketForTesting(storage_key2, "bucket_b", kTemp);
std::ignore =
db->CreateBucketForTesting(storage_key2, kDefaultBucketName, kSync);
std::ignore =
db->CreateBucketForTesting(storage_key3, kDefaultBucketName, kSync);
std::ignore = db->CreateBucketForTesting(storage_key1, "bucket_a");
std::ignore = db->CreateBucketForTesting(storage_key2, "bucket_b");
ASSERT_OK_AND_ASSIGN(std::set<StorageKey> result,
db->GetStorageKeysForType(kTemp));
ASSERT_OK_AND_ASSIGN(std::set<StorageKey> result, db->GetAllStorageKeys());
ASSERT_TRUE(base::Contains(result, storage_key1));
ASSERT_TRUE(base::Contains(result, storage_key2));
ASSERT_FALSE(base::Contains(result, storage_key3));
ASSERT_OK_AND_ASSIGN(result, db->GetStorageKeysForType(kSync));
ASSERT_FALSE(base::Contains(result, storage_key1));
ASSERT_TRUE(base::Contains(result, storage_key2));
ASSERT_TRUE(base::Contains(result, storage_key3));
}
TEST_P(QuotaDatabaseTest, BucketLastModifiedBetween) {
@ -719,29 +647,24 @@ TEST_P(QuotaDatabaseTest, BucketLastModifiedBetween) {
ASSERT_OK_AND_ASSIGN(
std::set<BucketLocator> buckets,
db->GetBucketsModifiedBetween(kTemp, base::Time(), base::Time::Max()));
db->GetBucketsModifiedBetween(base::Time(), base::Time::Max()));
EXPECT_TRUE(buckets.empty());
ASSERT_OK_AND_ASSIGN(
BucketInfo bucket1,
db->CreateBucketForTesting(
StorageKey::CreateFromStringForTesting("http://example-a/"),
"bucket_a", kTemp));
"bucket_a"));
ASSERT_OK_AND_ASSIGN(
BucketInfo bucket2,
db->CreateBucketForTesting(
StorageKey::CreateFromStringForTesting("http://example-b/"),
"bucket_b", kTemp));
"bucket_b"));
ASSERT_OK_AND_ASSIGN(
BucketInfo bucket3,
db->CreateBucketForTesting(
StorageKey::CreateFromStringForTesting("http://example-c/"),
"bucket_c", kTemp));
ASSERT_OK_AND_ASSIGN(
BucketInfo bucket4,
db->CreateBucketForTesting(
StorageKey::CreateFromStringForTesting("http://example-d/"),
kDefaultBucketName, kSync));
"bucket_c"));
// Report last modified time for the buckets.
EXPECT_EQ(db->SetBucketLastModifiedTime(
@ -753,115 +676,89 @@ TEST_P(QuotaDatabaseTest, BucketLastModifiedBetween) {
EXPECT_EQ(db->SetBucketLastModifiedTime(
bucket3.id, base::Time::FromMillisecondsSinceUnixEpoch(20)),
QuotaError::kNone);
EXPECT_EQ(db->SetBucketLastModifiedTime(
bucket4.id, base::Time::FromMillisecondsSinceUnixEpoch(30)),
QuotaError::kNone);
// Non-existent bucket.
EXPECT_EQ(db->SetBucketLastModifiedTime(
BucketId(777), base::Time::FromMillisecondsSinceUnixEpoch(0)),
QuotaError::kNone);
ASSERT_OK_AND_ASSIGN(buckets, db->GetBucketsModifiedBetween(
kTemp, base::Time(), base::Time::Max()));
ASSERT_OK_AND_ASSIGN(
buckets, db->GetBucketsModifiedBetween(base::Time(), base::Time::Max()));
EXPECT_EQ(3U, buckets.size());
EXPECT_TRUE(ContainsBucket(buckets, bucket1));
EXPECT_TRUE(ContainsBucket(buckets, bucket2));
EXPECT_TRUE(ContainsBucket(buckets, bucket3));
EXPECT_FALSE(ContainsBucket(buckets, bucket4));
ASSERT_OK_AND_ASSIGN(buckets,
db->GetBucketsModifiedBetween(
kTemp, base::Time::FromMillisecondsSinceUnixEpoch(5),
base::Time::Max()));
ASSERT_OK_AND_ASSIGN(
buckets,
db->GetBucketsModifiedBetween(
base::Time::FromMillisecondsSinceUnixEpoch(5), base::Time::Max()));
EXPECT_EQ(2U, buckets.size());
EXPECT_FALSE(ContainsBucket(buckets, bucket1));
EXPECT_TRUE(ContainsBucket(buckets, bucket2));
EXPECT_TRUE(ContainsBucket(buckets, bucket3));
EXPECT_FALSE(ContainsBucket(buckets, bucket4));
ASSERT_OK_AND_ASSIGN(
buckets, db->GetBucketsModifiedBetween(
kTemp, base::Time::FromMillisecondsSinceUnixEpoch(15),
base::Time::Max()));
buckets,
db->GetBucketsModifiedBetween(
base::Time::FromMillisecondsSinceUnixEpoch(15), base::Time::Max()));
EXPECT_EQ(1U, buckets.size());
EXPECT_FALSE(ContainsBucket(buckets, bucket1));
EXPECT_FALSE(ContainsBucket(buckets, bucket2));
EXPECT_TRUE(ContainsBucket(buckets, bucket3));
EXPECT_FALSE(ContainsBucket(buckets, bucket4));
ASSERT_OK_AND_ASSIGN(
buckets, db->GetBucketsModifiedBetween(
kTemp, base::Time::FromMillisecondsSinceUnixEpoch(25),
base::Time::Max()));
buckets,
db->GetBucketsModifiedBetween(
base::Time::FromMillisecondsSinceUnixEpoch(25), base::Time::Max()));
EXPECT_TRUE(buckets.empty());
ASSERT_OK_AND_ASSIGN(buckets,
db->GetBucketsModifiedBetween(
kTemp, base::Time::FromMillisecondsSinceUnixEpoch(5),
base::Time::FromMillisecondsSinceUnixEpoch(5),
base::Time::FromMillisecondsSinceUnixEpoch(15)));
EXPECT_EQ(1U, buckets.size());
EXPECT_FALSE(ContainsBucket(buckets, bucket1));
EXPECT_TRUE(ContainsBucket(buckets, bucket2));
EXPECT_FALSE(ContainsBucket(buckets, bucket3));
EXPECT_FALSE(ContainsBucket(buckets, bucket4));
ASSERT_OK_AND_ASSIGN(buckets,
db->GetBucketsModifiedBetween(
kTemp, base::Time::FromMillisecondsSinceUnixEpoch(0),
base::Time::FromMillisecondsSinceUnixEpoch(0),
base::Time::FromMillisecondsSinceUnixEpoch(20)));
EXPECT_EQ(2U, buckets.size());
EXPECT_TRUE(ContainsBucket(buckets, bucket1));
EXPECT_TRUE(ContainsBucket(buckets, bucket2));
EXPECT_FALSE(ContainsBucket(buckets, bucket3));
EXPECT_FALSE(ContainsBucket(buckets, bucket4));
ASSERT_OK_AND_ASSIGN(buckets,
db->GetBucketsModifiedBetween(
kSync, base::Time::FromMillisecondsSinceUnixEpoch(0),
base::Time::FromMillisecondsSinceUnixEpoch(35)));
EXPECT_EQ(1U, buckets.size());
EXPECT_FALSE(ContainsBucket(buckets, bucket1));
EXPECT_FALSE(ContainsBucket(buckets, bucket2));
EXPECT_FALSE(ContainsBucket(buckets, bucket3));
EXPECT_TRUE(ContainsBucket(buckets, bucket4));
}
TEST_P(QuotaDatabaseTest, RegisterInitialStorageKeyInfo) {
auto db = CreateDatabase(use_in_memory_db());
base::flat_map<blink::mojom::StorageType, std::set<StorageKey>>
storage_keys_by_type;
const StorageKey kStorageKeys[] = {
std::set<StorageKey> storage_keys = {
StorageKey::CreateFromStringForTesting("http://a/"),
StorageKey::CreateFromStringForTesting("http://b/"),
StorageKey::CreateFromStringForTesting("http://c/")};
storage_keys_by_type.emplace(
kTemp, std::set<StorageKey>(kStorageKeys, std::end(kStorageKeys)));
storage_keys_by_type.emplace(
kSync, std::set<StorageKey>(kStorageKeys, std::end(kStorageKeys)));
EXPECT_EQ(db->RegisterInitialStorageKeyInfo(storage_keys_by_type),
QuotaError::kNone);
EXPECT_EQ(db->RegisterInitialStorageKeyInfo(storage_keys), QuotaError::kNone);
ASSERT_OK_AND_ASSIGN(
BucketInfo bucket_result,
db->GetBucket(StorageKey::CreateFromStringForTesting("http://a/"),
kDefaultBucketName, kTemp));
kDefaultBucketName));
ASSERT_OK_AND_ASSIGN(mojom::BucketTableEntryPtr info,
db->GetBucketInfoForTest(bucket_result.id));
EXPECT_EQ(0, info->use_count);
EXPECT_EQ(db->SetStorageKeyLastAccessTime(
StorageKey::CreateFromStringForTesting("http://a/"), kTemp,
StorageKey::CreateFromStringForTesting("http://a/"),
base::Time::FromSecondsSinceUnixEpoch(1.0)),
QuotaError::kNone);
ASSERT_OK_AND_ASSIGN(info, db->GetBucketInfoForTest(bucket_result.id));
EXPECT_EQ(1, info->use_count);
EXPECT_EQ(db->RegisterInitialStorageKeyInfo(storage_keys_by_type),
QuotaError::kNone);
EXPECT_EQ(db->RegisterInitialStorageKeyInfo(storage_keys), QuotaError::kNone);
ASSERT_OK_AND_ASSIGN(info, db->GetBucketInfoForTest(bucket_result.id));
EXPECT_EQ(1, info->use_count);
@ -879,12 +776,12 @@ TEST_P(QuotaDatabaseTest, DumpBucketTable) {
StorageKey::CreateFromStringForTesting("http://gle/");
Entry kTableEntries[] = {
mojom::BucketTableEntry::New(1, storage_key1.Serialize(), kStorageTemp,
mojom::BucketTableEntry::New(1, storage_key1.Serialize(),
kDefaultBucketName, -1, 2147483647, now,
now),
mojom::BucketTableEntry::New(2, storage_key2.Serialize(), kStorageTemp,
mojom::BucketTableEntry::New(2, storage_key2.Serialize(),
kDefaultBucketName, -1, 0, now, now),
mojom::BucketTableEntry::New(3, storage_key3.Serialize(), kStorageTemp,
mojom::BucketTableEntry::New(3, storage_key3.Serialize(),
kDefaultBucketName, -1, 1, now, now),
};
@ -910,9 +807,8 @@ TEST_P(QuotaDatabaseTest, DeleteBucketData) {
{
auto db = CreateDatabase(/*is_incognito=*/false);
EXPECT_TRUE(EnsureOpened(db.get()));
ASSERT_OK_AND_ASSIGN(
BucketInfo result,
db->CreateBucketForTesting(storage_key, bucket_name, kTemp));
ASSERT_OK_AND_ASSIGN(BucketInfo result,
db->CreateBucketForTesting(storage_key, bucket_name));
BucketLocator bucket = result.ToBucketLocator();
const base::FilePath idb_bucket_path = CreateClientBucketPath(
@ -927,7 +823,7 @@ TEST_P(QuotaDatabaseTest, DeleteBucketData) {
auto db = CreateDatabase(/*is_incognito=*/false);
EXPECT_TRUE(EnsureOpened(db.get()));
ASSERT_OK_AND_ASSIGN(BucketInfo result,
db->GetBucket(storage_key, bucket_name, kTemp));
db->GetBucket(storage_key, bucket_name));
BucketLocator bucket = result.ToBucketLocator();
const base::FilePath bucket_path = CreateBucketPath(ProfilePath(), bucket);
@ -1006,8 +902,7 @@ TEST_P(QuotaDatabaseTest, QuotaDatabasePathMigration) {
// Reopen database, check that db is migrated to new path with bucket data.
{
auto db = CreateDatabase(/*is_incognito=*/false);
EXPECT_TRUE(
db->GetBucket(params.storage_key, params.name, kTemp).has_value());
EXPECT_TRUE(db->GetBucket(params.storage_key, params.name).has_value());
EXPECT_FALSE(base::PathExists(kLegacyFilePath));
EXPECT_TRUE(base::PathExists(DbPath()));
}
@ -1031,8 +926,7 @@ TEST_P(QuotaDatabaseTest, QuotaDatabasePathBadMigration) {
// Reopen database, check that db is migrated and is in a good state.
{
auto db = CreateDatabase(/*is_incognito=*/false);
EXPECT_TRUE(
db->GetBucket(params.storage_key, params.name, kTemp).has_value());
EXPECT_TRUE(db->GetBucket(params.storage_key, params.name).has_value());
EXPECT_TRUE(base::PathExists(DbPath()));
}
}
@ -1451,17 +1345,16 @@ TEST_P(QuotaDatabaseTest, PersistentPolicy) {
// Get evictable bucket --- should be the default one.
auto policy = base::MakeRefCounted<MockSpecialStoragePolicy>();
ASSERT_OK_AND_ASSIGN(
std::set<BucketLocator> lru_result,
db.GetBucketsForEviction(kTemp, 1, {}, {}, policy.get()));
ASSERT_OK_AND_ASSIGN(std::set<BucketLocator> lru_result,
db.GetBucketsForEviction(1, {}, {}, policy.get()));
ASSERT_EQ(1U, lru_result.size());
EXPECT_EQ(default_id, lru_result.begin()->id);
// Check that durable policy applies to the default bucket but not the non
// default (non default buckets use the persist columnn in the database).
policy->AddDurable(storage_key.origin().GetURL());
ASSERT_OK_AND_ASSIGN(
lru_result, db.GetBucketsForEviction(kTemp, 1, {}, {}, policy.get()));
ASSERT_OK_AND_ASSIGN(lru_result,
db.GetBucketsForEviction(1, {}, {}, policy.get()));
ASSERT_EQ(1U, lru_result.size());
EXPECT_EQ(non_default_id, lru_result.begin()->id);
}

@ -12,7 +12,6 @@ import "third_party/blink/public/mojom/quota/quota_types.mojom";
struct BucketTableEntry {
int64 bucket_id;
string storage_key;
blink.mojom.StorageType type;
string name;
int64 usage = -1;
int64 use_count;

@ -104,10 +104,6 @@ constexpr base::TimeDelta kStoragePressureCheckDiskStatsInterval =
constexpr base::FilePath::CharType kMediaLicenseDirectory[] =
FILE_PATH_LITERAL("Media Licenses");
bool IsSupportedType(StorageType type) {
return type == StorageType::kTemporary || type == StorageType::kSyncable;
}
void ReportDatabaseDisabledReason(DatabaseDisabledReason reason) {
base::UmaHistogramEnumeration("Quota.QuotaDatabaseDisabled", reason);
}
@ -509,8 +505,9 @@ class QuotaManagerImpl::GetUsageInfoTask : public QuotaTask {
class QuotaManagerImpl::StorageKeyGathererTask {
public:
StorageKeyGathererTask(QuotaManagerImpl* manager,
base::OnceCallback<void(StorageKeysByType)> callback)
StorageKeyGathererTask(
QuotaManagerImpl* manager,
base::OnceCallback<void(std::set<StorageKey>)> callback)
: manager_(manager), callback_(std::move(callback)) {
DCHECK(manager_);
DCHECK(callback_);
@ -540,8 +537,7 @@ class QuotaManagerImpl::StorageKeyGathererTask {
const std::vector<StorageKey>& storage_keys) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(callback);
storage_keys_by_type_[StorageType::kTemporary].insert(storage_keys.begin(),
storage_keys.end());
storage_keys_.insert(storage_keys.begin(), storage_keys.end());
std::move(callback).Run();
}
@ -553,14 +549,14 @@ class QuotaManagerImpl::StorageKeyGathererTask {
#endif // DCHECK_IS_ON()
// Deletes `this`.
std::move(callback_).Run(storage_keys_by_type_);
std::move(callback_).Run(storage_keys_);
}
SEQUENCE_CHECKER(sequence_checker_);
raw_ptr<QuotaManagerImpl> manager_ GUARDED_BY_CONTEXT(sequence_checker_);
base::OnceCallback<void(StorageKeysByType)> callback_
base::OnceCallback<void(std::set<StorageKey>)> callback_
GUARDED_BY_CONTEXT(sequence_checker_);
StorageKeysByType storage_keys_by_type_ GUARDED_BY_CONTEXT(sequence_checker_);
std::set<StorageKey> storage_keys_ GUARDED_BY_CONTEXT(sequence_checker_);
#if DCHECK_IS_ON()
bool run_called_ = false;
@ -1033,7 +1029,7 @@ void QuotaManagerImpl::CreateBucketForTesting(
QuotaDatabase* database) {
DCHECK(database);
return database->CreateBucketForTesting( // IN-TEST
storage_key, bucket_name, StorageType::kTemporary);
storage_key, bucket_name);
},
storage_key, bucket_name),
base::BindOnce(&QuotaManagerImpl::DidGetBucket,
@ -1058,8 +1054,7 @@ void QuotaManagerImpl::GetBucketByNameUnsafe(
[](const StorageKey& storage_key, const std::string& bucket_name,
QuotaDatabase* database) {
DCHECK(database);
return database->GetBucket(storage_key, bucket_name,
StorageType::kTemporary);
return database->GetBucket(storage_key, bucket_name);
},
storage_key, bucket_name),
base::BindOnce(&QuotaManagerImpl::DidGetBucket,
@ -1102,7 +1097,7 @@ void QuotaManagerImpl::GetAllStorageKeys(GetStorageKeysCallback callback) {
PostTaskAndReplyWithResultForDBThread(
base::BindOnce([](QuotaDatabase* database) {
DCHECK(database);
return database->GetStorageKeysForType(StorageType::kTemporary);
return database->GetAllStorageKeys();
}),
base::BindOnce(&QuotaManagerImpl::DidGetStorageKeys,
weak_factory_.GetWeakPtr(), std::move(callback)));
@ -1121,7 +1116,7 @@ void QuotaManagerImpl::GetAllBuckets(
PostTaskAndReplyWithResultForDBThread(
base::BindOnce([](QuotaDatabase* database) {
DCHECK(database);
return database->GetBucketsForType(StorageType::kTemporary);
return database->GetAllBuckets();
}),
base::BindOnce(&QuotaManagerImpl::DidGetBuckets,
weak_factory_.GetWeakPtr(), std::move(callback)));
@ -1142,7 +1137,7 @@ void QuotaManagerImpl::GetBucketsForHost(
base::BindOnce(
[](const std::string& host, QuotaDatabase* database) {
DCHECK(database);
return database->GetBucketsForHost(host, StorageType::kTemporary);
return database->GetBucketsForHost(host);
},
host),
base::BindOnce(&QuotaManagerImpl::DidGetBuckets,
@ -1175,8 +1170,7 @@ void QuotaManagerImpl::GetBucketsForStorageKey(
base::BindOnce(
[](const StorageKey& storage_key, QuotaDatabase* database) {
DCHECK(database);
return database->GetBucketsForStorageKey(storage_key,
StorageType::kTemporary);
return database->GetBucketsForStorageKey(storage_key);
},
storage_key),
std::move(reply));
@ -1436,11 +1430,11 @@ void QuotaManagerImpl::FindAndDeleteBucketData(const StorageKey& storage_key,
PostTaskAndReplyWithResultForDBThread(
base::BindOnce(
[](const StorageKey& storage_key, const std::string& bucket_name,
blink::mojom::StorageType type, QuotaDatabase* database) {
QuotaDatabase* database) {
DCHECK(database);
return database->GetBucket(storage_key, bucket_name, type);
return database->GetBucket(storage_key, bucket_name);
},
storage_key, bucket_name, StorageType::kTemporary),
storage_key, bucket_name),
base::BindOnce(&QuotaManagerImpl::DidGetBucketForDeletion,
weak_factory_.GetWeakPtr(), std::move(callback)));
}
@ -1725,8 +1719,7 @@ void QuotaManagerImpl::GetBucketsModifiedBetween(base::Time begin,
base::BindOnce(
[](base::Time begin, base::Time end, QuotaDatabase* database) {
DCHECK(database);
return database->GetBucketsModifiedBetween(StorageType::kTemporary,
begin, end);
return database->GetBucketsModifiedBetween(begin, end);
},
begin, end),
base::BindOnce(&QuotaManagerImpl::DidGetModifiedBetween,
@ -1860,21 +1853,19 @@ void QuotaManagerImpl::BootstrapDatabase() {
}
void QuotaManagerImpl::DidGetStorageKeysForBootstrap(
StorageKeysByType storage_keys_by_type) {
std::set<StorageKey> storage_keys) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(storage_key_gatherer_);
storage_key_gatherer_.reset();
PostTaskAndReplyWithResultForDBThread(
base::BindOnce(
[](base::flat_map<StorageType, std::set<StorageKey>>
storage_keys_by_type,
QuotaDatabase* database) {
[](std::set<StorageKey> storage_keys, QuotaDatabase* database) {
DCHECK(database);
return database->RegisterInitialStorageKeyInfo(
std::move(storage_keys_by_type));
std::move(storage_keys));
},
std::move(storage_keys_by_type)),
std::move(storage_keys)),
base::BindOnce(&QuotaManagerImpl::DidBootstrapDatabase,
weak_factory_.GetWeakPtr()),
FROM_HERE,
@ -1972,8 +1963,8 @@ void QuotaManagerImpl::NotifyBucketAccessed(const BucketLocator& bucket,
QuotaDatabase* database) {
DCHECK(database);
if (bucket.is_default) {
return database->SetStorageKeyLastAccessTime(
bucket.storage_key, bucket.type, accessed_time);
return database->SetStorageKeyLastAccessTime(bucket.storage_key,
accessed_time);
} else {
return database->SetBucketLastAccessTime(bucket.id,
accessed_time);
@ -2005,8 +1996,8 @@ void QuotaManagerImpl::NotifyBucketModified(QuotaClientType client_id,
BucketId id = bucket.id;
if (!id) {
CHECK(bucket.is_default);
QuotaErrorOr<BucketInfo> result = database->GetBucket(
bucket.storage_key, kDefaultBucketName, bucket.type);
QuotaErrorOr<BucketInfo> result =
database->GetBucket(bucket.storage_key, kDefaultBucketName);
if (!result.has_value()) {
return QuotaError::kNotFound;
}
@ -2059,13 +2050,6 @@ void QuotaManagerImpl::RetrieveBucketUsageForBucketTable(
base::ConcurrentCallbacks<mojom::BucketTableEntryPtr> concurrent;
for (auto& entry : entries) {
StorageType type = static_cast<StorageType>(entry->type);
// TODO(crbug.com/40167820): Change to DCHECK once persistent type is
// removed from QuotaDatabase.
if (!IsSupportedType(type)) {
continue;
}
std::optional<StorageKey> storage_key =
StorageKey::Deserialize(entry->storage_key);
// If the serialization format changes keys may not deserialize.
@ -2075,9 +2059,9 @@ void QuotaManagerImpl::RetrieveBucketUsageForBucketTable(
BucketId bucket_id = BucketId(entry->bucket_id);
BucketLocator bucket_locator =
BucketLocator(bucket_id, std::move(storage_key).value(), type,
entry->name == kDefaultBucketName);
BucketLocator bucket_locator = BucketLocator(
bucket_id, std::move(storage_key).value(), StorageType::kTemporary,
entry->name == kDefaultBucketName);
GetBucketUsageWithBreakdown(
bucket_locator,
@ -2517,10 +2501,6 @@ void QuotaManagerImpl::DidDumpBucketTableForHistogram(
GetUsageTracker()->GetCachedStorageKeysUsage();
base::Time now = QuotaDatabase::GetNow();
for (const auto& info : entries) {
if (info->type != blink::mojom::StorageType::kTemporary) {
continue;
}
std::optional<StorageKey> storage_key =
StorageKey::Deserialize(info->storage_key);
if (!storage_key.has_value()) {
@ -2690,9 +2670,8 @@ void QuotaManagerImpl::GetBucketsForEvictionFromDatabase(
const std::set<BucketId>& bucket_exceptions,
SpecialStoragePolicy* policy, QuotaDatabase* database) {
DCHECK(database);
return database->GetBucketsForEviction(
blink::mojom::StorageType::kTemporary, target_usage, usage_map,
bucket_exceptions, policy);
return database->GetBucketsForEviction(target_usage, usage_map,
bucket_exceptions, policy);
},
target_usage, std::move(usage_map), GetEvictionBucketExceptions(),
base::RetainedRef(special_storage_policy_)),
@ -2835,16 +2814,13 @@ void QuotaManagerImpl::OnBucketDeleted(
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (result.has_value()) {
const mojom::BucketTableEntryPtr& entry = result.value();
StorageType type = static_cast<StorageType>(entry->type);
if (IsSupportedType(type)) {
auto storage_key = blink::StorageKey::Deserialize(entry->storage_key);
if (storage_key) {
storage::BucketLocator bucket_locator(
BucketId(entry->bucket_id), storage_key.value(), type,
entry->name == kDefaultBucketName);
for (auto& observer : observers_) {
observer->OnDeleteBucket(bucket_locator);
}
auto storage_key = blink::StorageKey::Deserialize(entry->storage_key);
if (storage_key) {
storage::BucketLocator bucket_locator(
BucketId(entry->bucket_id), storage_key.value(),
StorageType::kTemporary, entry->name == kDefaultBucketName);
for (auto& observer : observers_) {
observer->OnDeleteBucket(bucket_locator);
}
}
}

@ -540,8 +540,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerImpl
};
using BucketTableEntries = std::vector<mojom::BucketTableEntryPtr>;
using StorageKeysByType =
base::flat_map<blink::mojom::StorageType, std::set<blink::StorageKey>>;
using QuotaSettingsCallback = base::OnceCallback<void(const QuotaSettings&)>;
@ -575,7 +573,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerImpl
// is complete.
void BootstrapDatabase();
void DidGetBootstrapFlag(bool is_database_bootstrapped);
void DidGetStorageKeysForBootstrap(StorageKeysByType storage_keys_by_type);
void DidGetStorageKeysForBootstrap(std::set<blink::StorageKey> storage_keys_);
void DidBootstrapDatabase(QuotaError error);
void DidSetDatabaseBootstrapped(QuotaError error);
// Runs all callbacks to QuotaDatabase that have been queued during bootstrap.

@ -66,10 +66,6 @@ namespace storage {
namespace {
// For shorter names.
const blink::mojom::StorageType kStorageTemp =
blink::mojom::StorageType::kTemporary;
// Values in bytes.
const int64_t kAvailableSpaceForApp = 13377331U;
const int64_t kMustRemainAvailableForSystem = kAvailableSpaceForApp / 2;
@ -137,10 +133,9 @@ const storage::mojom::BucketTableEntry* FindBucketTableEntry(
return it->get();
}
MATCHER_P3(MatchesBucketTableEntry, storage_key, type, use_count, "") {
MATCHER_P2(MatchesBucketTableEntry, storage_key, use_count, "") {
return testing::ExplainMatchResult(storage_key, arg->storage_key,
result_listener) &&
testing::ExplainMatchResult(type, arg->type, result_listener) &&
testing::ExplainMatchResult(use_count, arg->use_count,
result_listener);
}
@ -2581,11 +2576,10 @@ TEST_F(QuotaManagerImplTest, DumpBucketTable) {
task_environment_.RunUntilIdle();
const BucketTableEntries& entries = DumpBucketTable();
EXPECT_THAT(
entries,
testing::UnorderedElementsAre(
MatchesBucketTableEntry(kStorageKey1.Serialize(), kStorageTemp, 1),
MatchesBucketTableEntry(kStorageKey2.Serialize(), kStorageTemp, 2)));
EXPECT_THAT(entries,
testing::UnorderedElementsAre(
MatchesBucketTableEntry(kStorageKey1.Serialize(), 1),
MatchesBucketTableEntry(kStorageKey2.Serialize(), 2)));
}
TEST_F(QuotaManagerImplTest, RetrieveBucketsTable) {
@ -2615,7 +2609,6 @@ TEST_F(QuotaManagerImplTest, RetrieveBucketsTable) {
auto* entry1 = FindBucketTableEntry(bucket_table_entries, bucket1->id);
EXPECT_TRUE(entry1);
EXPECT_EQ(entry1->storage_key, kStorageKey1.Serialize());
EXPECT_EQ(entry1->type, kStorageTemp);
EXPECT_EQ(entry1->name, kDefaultBucketName);
EXPECT_EQ(entry1->use_count, 1);
EXPECT_EQ(entry1->last_accessed, kAccessTime);
@ -2626,7 +2619,6 @@ TEST_F(QuotaManagerImplTest, RetrieveBucketsTable) {
auto* entry2 = FindBucketTableEntry(bucket_table_entries, bucket2->id);
EXPECT_TRUE(entry2);
EXPECT_EQ(entry2->storage_key, kStorageKey2.Serialize());
EXPECT_EQ(entry2->type, kStorageTemp);
EXPECT_EQ(entry2->name, kDefaultBucketName);
EXPECT_EQ(entry2->use_count, 1);
EXPECT_EQ(entry2->last_accessed, kAccessTime);