StorageBuckets: Add GetOrCreateBucket and Update GetBucket

This change adds 3 changes.

1. Adds GetOrCreateBucket(). This is to be used by StorageBuckets
API as well as by integrating Storage APIs querying for bucket
id upon binding receivers at AddReceiver(). More details on the
design doc [1]

2. Adds StorageType param to GetBucket & CreateBucket(ForTesting)
method. Although StorageType should almost always be Temporary,
we may need to query for Persistent type storage when migrating
UsageTracker and QuotaClient to be integrated with buckets.
We expect StorageTypes to be entirely removed as a part of
crbug.com/1208141.

3. Renames CreateBucket -> CreateBucketForTesting. It also
allows for creating a bucket that is not of StorageType kTemporary.
This should not happen outside of test. Therefore name has
been updated to make that clear.

[1]https://docs.google.com/document/d/1VDm8M4vRyxCpvp_m3Ojs18W9g1WpqvSOsKf0A6hnAFM/edit?ts=60bfa3c1&pli=1#heading=h.xhaoskid7wdx

Bug: 1203788
Change-Id: Ia4ef0fb2ed937e60b0c9c726e7dd7df9395ff2ac
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2965135
Commit-Queue: Ayu Ishii <ayui@chromium.org>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#895766}

storage/browser/quota/quota_database.cc

@@ -166,28 +166,50 @@ bool QuotaDatabase::SetHostQuota(const std::string& host,
   return true;
 }
 
-QuotaErrorOr<BucketInfo> QuotaDatabase::CreateBucket(
+QuotaErrorOr<BucketInfo> QuotaDatabase::GetOrCreateBucket(
     const StorageKey& storage_key,
     const std::string& bucket_name) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  // TODO(crbug/1210252): Update to not execute 2 sql statements on creation.
-  QuotaErrorOr<BucketInfo> bucket_result = GetBucket(storage_key, bucket_name);
-  if (bucket_result.ok()) {
-    return QuotaError::kEntryExistsError;
-  } else if (bucket_result.error() != QuotaError::kNotFound) {
+  QuotaErrorOr<BucketInfo> bucket_result =
+      GetBucket(storage_key, bucket_name, StorageType::kTemporary);
+
+  if (bucket_result.ok())
+    return bucket_result;
+
+  if (bucket_result.error() != QuotaError::kNotFound)
     return bucket_result.error();
-  }
 
   base::Time now = base::Time::Now();
-  // Bucket usage is only for temporary storage types.
   return CreateBucketInternal(storage_key, StorageType::kTemporary, bucket_name,
                               /*use_count=*/0, now, now);
 }
 
+QuotaErrorOr<BucketInfo> QuotaDatabase::CreateBucketForTesting(
+    const StorageKey& storage_key,
+    const std::string& bucket_name,
+    blink::mojom::StorageType storage_type) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  // TODO(crbug/1210252): Update to not execute 2 sql statements on creation.
+  QuotaErrorOr<BucketInfo> bucket_result =
+      GetBucket(storage_key, bucket_name, storage_type);
+
+  if (bucket_result.ok())
+    return QuotaError::kEntryExistsError;
+
+  if (bucket_result.error() != QuotaError::kNotFound)
+    return bucket_result.error();
+
+  base::Time now = base::Time::Now();
+  return CreateBucketInternal(storage_key, storage_type, bucket_name,
+                              /*use_count=*/0, now, now);
+}
+
 QuotaErrorOr<BucketInfo> QuotaDatabase::GetBucket(
     const StorageKey& storage_key,
-    const std::string& bucket_name) {
+    const std::string& bucket_name,
+    blink::mojom::StorageType storage_type) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   QuotaError open_error = LazyOpen(LazyOpenMode::kFailIfNotFound);
   if (open_error != QuotaError::kNone)
@@ -201,8 +223,7 @@ QuotaErrorOr<BucketInfo> QuotaDatabase::GetBucket(
   // clang-format on
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindString(0, storage_key.Serialize());
-  // Bucket usage is only for temporary storage types.
-  statement.BindInt(1, static_cast<int>(StorageType::kTemporary));
+  statement.BindInt(1, static_cast<int>(storage_type));
   statement.BindString(2, bucket_name);
 
   if (!statement.Step()) {
@@ -211,8 +232,8 @@ QuotaErrorOr<BucketInfo> QuotaDatabase::GetBucket(
   }
 
   return BucketInfo(BucketId(statement.ColumnInt64(0)), storage_key,
-                    StorageType::kTemporary, bucket_name,
-                    statement.ColumnTime(1), statement.ColumnInt(2));
+                    storage_type, bucket_name, statement.ColumnTime(1),
+                    statement.ColumnInt(2));
 }
 
 bool QuotaDatabase::SetStorageKeyLastAccessTime(const StorageKey& storage_key,

storage/browser/quota/quota_database.h

@@ -85,18 +85,28 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaDatabase {
                     int64_t quota);
   bool DeleteHostQuota(const std::string& host, blink::mojom::StorageType type);
 
-  // Creates a bucket with `bucket_name` for the `storage_key` and returns the
-  // BucketInfo for the new bucket. Returns a QuotaError if a bucket
-  // already exists or if the operation has failed.
+  // Gets the bucket with `bucket_name` for the `storage_key` for StorageType
+  // kTemporary and returns the BucketInfo. If one doesn't exist, it creates
+  // a new bucket with the specified policies. Returns a QuotaError if the
+  // operation has failed.
   // TODO(crbug/1203467): Include more policies when supported.
-  QuotaErrorOr<BucketInfo> CreateBucket(const blink::StorageKey& storage_key,
-                                        const std::string& bucket_name);
+  QuotaErrorOr<BucketInfo> GetOrCreateBucket(
+      const blink::StorageKey& storage_key,
+      const std::string& bucket_name);
+
+  // TODO(crbug.com/1208141): 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);
 
   // 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);
+                                     const std::string& bucket_name,
+                                     blink::mojom::StorageType storage_type);
 
   // TODO(crbug.com/1202167): Remove once all usages have updated to use
   // SetBucketLastAccessTime.

storage/browser/quota/quota_database_unittest.cc

@@ -197,25 +197,32 @@ TEST_P(QuotaDatabaseTest, HostQuota) {
   EXPECT_FALSE(db.GetHostQuota(kHost, kPerm, &quota));
 }
 
-TEST_P(QuotaDatabaseTest, CreateBucket) {
+TEST_P(QuotaDatabaseTest, GetOrCreateBucket) {
   QuotaDatabase db(use_in_memory_db() ? base::FilePath() : DbPath());
   EXPECT_TRUE(LazyOpen(&db, LazyOpenMode::kCreateIfNotFound));
   StorageKey storage_key =
       StorageKey::CreateFromStringForTesting("http://google/");
   std::string bucket_name = "google_bucket";
 
-  QuotaErrorOr<BucketInfo> result = db.CreateBucket(storage_key, bucket_name);
+  QuotaErrorOr<BucketInfo> result =
+      db.GetOrCreateBucket(storage_key, bucket_name);
   ASSERT_TRUE(result.ok());
 
-  BucketInfo bucket = result.value();
-  ASSERT_GT(bucket.id.value(), 0);
-  ASSERT_EQ(bucket.name, bucket_name);
-  ASSERT_EQ(bucket.storage_key, storage_key);
+  BucketInfo created_bucket = result.value();
+  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);
 
-  // Trying to create an existing bucket should return false.
-  result = db.CreateBucket(storage_key, bucket_name);
-  ASSERT_FALSE(result.ok());
-  EXPECT_EQ(result.error(), QuotaError::kEntryExistsError);
+  // Should return the same bucket when querying again.
+  result = db.GetOrCreateBucket(storage_key, bucket_name);
+  ASSERT_TRUE(result.ok());
+
+  BucketInfo retrieved_bucket = result.value();
+  ASSERT_EQ(retrieved_bucket.id, created_bucket.id);
+  ASSERT_EQ(retrieved_bucket.name, created_bucket.name);
+  ASSERT_EQ(retrieved_bucket.storage_key, created_bucket.storage_key);
+  ASSERT_EQ(retrieved_bucket.type, created_bucket.type);
 }
 
 TEST_P(QuotaDatabaseTest, GetBucket) {
@@ -226,28 +233,32 @@ TEST_P(QuotaDatabaseTest, GetBucket) {
   StorageKey storage_key =
       StorageKey::CreateFromStringForTesting("http://google/");
   std::string bucket_name = "google_bucket";
-  QuotaErrorOr<BucketInfo> result = db.CreateBucket(storage_key, bucket_name);
+  QuotaErrorOr<BucketInfo> result =
+      db.CreateBucketForTesting(storage_key, bucket_name, kPerm);
   ASSERT_TRUE(result.ok());
 
   BucketInfo created_bucket = result.value();
   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, kPerm);
 
-  result = db.GetBucket(storage_key, bucket_name);
+  result = db.GetBucket(storage_key, bucket_name, kPerm);
   ASSERT_TRUE(result.ok());
   EXPECT_EQ(result.value().id, created_bucket.id);
   EXPECT_EQ(result.value().name, created_bucket.name);
   EXPECT_EQ(result.value().storage_key, created_bucket.storage_key);
+  ASSERT_EQ(result.value().type, created_bucket.type);
 
   // Can't retrieve buckets with name mismatch.
-  result = db.GetBucket(storage_key, "does_not_exist");
+  result = db.GetBucket(storage_key, "does_not_exist", kPerm);
   ASSERT_FALSE(result.ok());
   EXPECT_EQ(result.error(), QuotaError::kNotFound);
 
   // Can't retrieve buckets with StorageKey mismatch.
-  result = db.GetBucket(
-      StorageKey::CreateFromStringForTesting("http://example/"), bucket_name);
+  result =
+      db.GetBucket(StorageKey::CreateFromStringForTesting("http://example/"),
+                   bucket_name, kPerm);
   ASSERT_FALSE(result.ok());
   EXPECT_EQ(result.error(), QuotaError::kNotFound);
 }
@@ -259,7 +270,8 @@ TEST_P(QuotaDatabaseTest, GetBucketWithNoDb) {
   StorageKey storage_key =
       StorageKey::CreateFromStringForTesting("http://google/");
   std::string bucket_name = "google_bucket";
-  QuotaErrorOr<BucketInfo> result = db.GetBucket(storage_key, bucket_name);
+  QuotaErrorOr<BucketInfo> result =
+      db.GetBucket(storage_key, bucket_name, kTemp);
   ASSERT_FALSE(result.ok());
   EXPECT_EQ(result.error(), QuotaError::kNotFound);
 }
@@ -278,7 +290,8 @@ TEST_F(QuotaDatabaseTest, GetBucketWithOpenDatabaseError) {
   StorageKey storage_key =
       StorageKey::CreateFromStringForTesting("http://google/");
   std::string bucket_name = "google_bucket";
-  QuotaErrorOr<BucketInfo> result = db.GetBucket(storage_key, bucket_name);
+  QuotaErrorOr<BucketInfo> result =
+      db.GetBucket(storage_key, bucket_name, kTemp);
   ASSERT_FALSE(result.ok());
   EXPECT_EQ(result.error(), QuotaError::kDatabaseError);
 

storage/browser/quota/quota_manager_impl.cc

@@ -92,18 +92,30 @@ bool IsSupportedIncognitoType(StorageType type) {
   return type == StorageType::kTemporary || type == StorageType::kPersistent;
 }
 
-QuotaErrorOr<BucketInfo> CreateBucketOnDBThread(const StorageKey& storage_key,
-                                                const std::string& bucket_name,
-                                                QuotaDatabase* database) {
+QuotaErrorOr<BucketInfo> GetOrCreateBucketOnDBThread(
+    const StorageKey& storage_key,
+    const std::string& bucket_name,
+    QuotaDatabase* database) {
   DCHECK(database);
-  return database->CreateBucket(storage_key, bucket_name);
+  return database->GetOrCreateBucket(storage_key, bucket_name);
+}
+
+QuotaErrorOr<BucketInfo> CreateBucketOnDBThread(
+    const StorageKey& storage_key,
+    const std::string& bucket_name,
+    blink::mojom::StorageType storage_type,
+    QuotaDatabase* database) {
+  DCHECK(database);
+  return database->CreateBucketForTesting(storage_key, bucket_name,  // IN-TEST
+                                          storage_type);
 }
 
 QuotaErrorOr<BucketInfo> GetBucketOnDBThread(const StorageKey& storage_key,
                                              const std::string& bucket_name,
+                                             blink::mojom::StorageType type,
                                              QuotaDatabase* database) {
   DCHECK(database);
-  return database->GetBucket(storage_key, bucket_name);
+  return database->GetBucket(storage_key, bucket_name, type);
 }
 
 bool GetPersistentHostQuotaOnDBThread(const std::string& host,
@@ -944,7 +956,7 @@ void QuotaManagerImpl::SetQuotaSettings(const QuotaSettings& settings) {
   settings_timestamp_ = base::TimeTicks::Now();
 }
 
-void QuotaManagerImpl::CreateBucket(
+void QuotaManagerImpl::GetOrCreateBucket(
     const StorageKey& storage_key,
     const std::string& bucket_name,
     base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) {
@@ -952,7 +964,22 @@ void QuotaManagerImpl::CreateBucket(
   LazyInitialize();
 
   PostTaskAndReplyWithResultForDBThread(
-      base::BindOnce(&CreateBucketOnDBThread, storage_key, bucket_name),
+      base::BindOnce(&GetOrCreateBucketOnDBThread, storage_key, bucket_name),
+      base::BindOnce(&QuotaManagerImpl::DidGetBucket,
+                     weak_factory_.GetWeakPtr(), std::move(callback)));
+}
+
+void QuotaManagerImpl::CreateBucketForTesting(
+    const StorageKey& storage_key,
+    const std::string& bucket_name,
+    blink::mojom::StorageType storage_type,
+    base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  LazyInitialize();
+
+  PostTaskAndReplyWithResultForDBThread(
+      base::BindOnce(&CreateBucketOnDBThread, storage_key, bucket_name,
+                     storage_type),
       base::BindOnce(&QuotaManagerImpl::DidGetBucket,
                      weak_factory_.GetWeakPtr(), std::move(callback)));
 }
@@ -960,12 +987,13 @@ void QuotaManagerImpl::CreateBucket(
 void QuotaManagerImpl::GetBucket(
     const StorageKey& storage_key,
     const std::string& bucket_name,
+    blink::mojom::StorageType type,
     base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   LazyInitialize();
 
   PostTaskAndReplyWithResultForDBThread(
-      base::BindOnce(&GetBucketOnDBThread, storage_key, bucket_name),
+      base::BindOnce(&GetBucketOnDBThread, storage_key, bucket_name, type),
       base::BindOnce(&QuotaManagerImpl::DidGetBucket,
                      weak_factory_.GetWeakPtr(), std::move(callback)));
 }

storage/browser/quota/quota_manager_impl.h

@@ -160,18 +160,32 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerImpl
   // Returns a proxy object that can be used on any thread.
   QuotaManagerProxy* proxy() { return proxy_.get(); }
 
-  // Creates a bucket for `storage_key` with `bucket_name` and returns the
-  // BucketInfo to the callback. Will return a QuotaError to the callback on
-  // operation failure.
-  void CreateBucket(const blink::StorageKey& storage_key,
-                    const std::string& bucket_name,
-                    base::OnceCallback<void(QuotaErrorOr<BucketInfo>)>);
+  // Gets the bucket with `bucket_name` for the `storage_key` for StorageType
+  // kTemporary and returns the BucketInfo. If one doesn't exist, it creates
+  // a new bucket with the specified policies. Returns a QuotaError if the
+  // operation has failed.
+  void GetOrCreateBucket(const blink::StorageKey& storage_key,
+                         const std::string& bucket_name,
+                         base::OnceCallback<void(QuotaErrorOr<BucketInfo>)>);
+
+  // Creates a bucket for `origin` with `bucket_name` and returns BucketInfo
+  // to the callback. Will return a QuotaError to the callback on operation
+  // failure.
+  //
+  // TODO(crbug.com/1208141): Remove `storage_type` when the only supported
+  // StorageType is kTemporary.
+  void CreateBucketForTesting(
+      const blink::StorageKey& storage_key,
+      const std::string& bucket_name,
+      blink::mojom::StorageType storage_type,
+      base::OnceCallback<void(QuotaErrorOr<BucketInfo>)>);
 
   // Retrieves the BucketInfo of the bucket with `bucket_name` for `storage_key`
   // and returns it to the callback. Will return a QuotaError if the bucket does
   // not exist or on operation failure.
   void GetBucket(const blink::StorageKey& storage_key,
                  const std::string& bucket_name,
+                 blink::mojom::StorageType type,
                  base::OnceCallback<void(QuotaErrorOr<BucketInfo>)>);
 
   // Called by clients or webapps. Returns usage per host.

storage/browser/quota/quota_manager_proxy.cc

@@ -75,7 +75,7 @@ void QuotaManagerProxy::RegisterClient(
   }
 }
 
-void QuotaManagerProxy::CreateBucket(
+void QuotaManagerProxy::GetOrCreateBucket(
     const StorageKey& storage_key,
     const std::string& bucket_name,
     scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
@@ -83,7 +83,7 @@ void QuotaManagerProxy::CreateBucket(
   if (!quota_manager_impl_task_runner_->RunsTasksInCurrentSequence()) {
     quota_manager_impl_task_runner_->PostTask(
         FROM_HERE,
-        base::BindOnce(&QuotaManagerProxy::CreateBucket, this, storage_key,
+        base::BindOnce(&QuotaManagerProxy::GetOrCreateBucket, this, storage_key,
                        bucket_name, std::move(callback_task_runner),
                        std::move(callback)));
     return;
@@ -96,22 +96,51 @@ void QuotaManagerProxy::CreateBucket(
     return;
   }
 
-  quota_manager_impl_->CreateBucket(
+  quota_manager_impl_->GetOrCreateBucket(
       storage_key, bucket_name,
       base::BindOnce(&DidGetBucket, std::move(callback_task_runner),
                      std::move(callback)));
 }
 
+void QuotaManagerProxy::CreateBucketForTesting(
+    const StorageKey& storage_key,
+    const std::string& bucket_name,
+    blink::mojom::StorageType storage_type,
+    scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
+    base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) {
+  if (!quota_manager_impl_task_runner_->RunsTasksInCurrentSequence()) {
+    quota_manager_impl_task_runner_->PostTask(
+        FROM_HERE,
+        base::BindOnce(&QuotaManagerProxy::CreateBucketForTesting, this,
+                       storage_key, bucket_name, storage_type,
+                       std::move(callback_task_runner), std::move(callback)));
+    return;
+  }
+
+  DCHECK_CALLED_ON_VALID_SEQUENCE(quota_manager_impl_sequence_checker_);
+  if (!quota_manager_impl_) {
+    DidGetBucket(std::move(callback_task_runner), std::move(callback),
+                 QuotaErrorOr<BucketInfo>(QuotaError::kUnknownError));
+    return;
+  }
+
+  quota_manager_impl_->CreateBucketForTesting(  // IN-TEST
+      storage_key, bucket_name, storage_type,
+      base::BindOnce(&DidGetBucket, std::move(callback_task_runner),
+                     std::move(callback)));
+}
+
 void QuotaManagerProxy::GetBucket(
     const StorageKey& storage_key,
     const std::string& bucket_name,
+    blink::mojom::StorageType type,
     scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
     base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) {
   if (!quota_manager_impl_task_runner_->RunsTasksInCurrentSequence()) {
     quota_manager_impl_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&QuotaManagerProxy::GetBucket, this, storage_key,
-                       bucket_name, std::move(callback_task_runner),
+                       bucket_name, type, std::move(callback_task_runner),
                        std::move(callback)));
     return;
   }
@@ -124,7 +153,7 @@ void QuotaManagerProxy::GetBucket(
   }
 
   quota_manager_impl_->GetBucket(
-      storage_key, bucket_name,
+      storage_key, bucket_name, type,
       base::BindOnce(&DidGetBucket, std::move(callback_task_runner),
                      std::move(callback)));
 }

storage/browser/quota/quota_manager_proxy.h

@@ -66,21 +66,36 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerProxy
       QuotaClientType client_type,
       const std::vector<blink::mojom::StorageType>& storage_types);
 
-  // Creates a bucket for `storage_key` with `bucket_name` and returns the
-  // BucketInfo to the callback. Will return a QuotaError to the callback
-  // on operation failure.
-  virtual void CreateBucket(
+  // Gets the bucket with `bucket_name` for the `storage_key` for StorageType
+  // kTemporary and returns the BucketInfo. If one doesn't exist, it creates
+  // a new bucket with the specified policies. Returns a QuotaError if the
+  // operation has failed.
+  virtual void GetOrCreateBucket(
       const blink::StorageKey& storage_key,
       const std::string& bucket_name,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback);
 
+  // Creates a bucket for `origin` with `bucket_name` and returns the
+  // BucketInfo to the callback. Returns a QuotaError to the callback
+  // on operation failure.
+  //
+  // TODO(crbug.com/1208141): Remove `storage_type` when the only supported
+  // StorageType is kTemporary.
+  virtual void CreateBucketForTesting(
+      const blink::StorageKey& storage_key,
+      const std::string& bucket_name,
+      blink::mojom::StorageType storage_type,
+      scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
+      base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback);
+
   // Retrieves the BucketInfo of the bucket with `bucket_name` for
   // `storage_key` and returns it to the callback. Will return a QuotaError if a
   // bucket does not exist or on operation failure.
   virtual void GetBucket(
       const blink::StorageKey& storage_key,
       const std::string& bucket_name,
+      blink::mojom::StorageType type,
       scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
       base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback);
 

storage/browser/quota/quota_manager_unittest.cc

@@ -139,18 +139,28 @@ class QuotaManagerImplTest : public testing::Test {
     return mock_quota_client_ptr;
   }
 
-  void CreateBucket(const StorageKey& storage_key,
-                    const std::string& bucket_name) {
-    quota_manager_impl_->CreateBucket(
+  void GetOrCreateBucket(const StorageKey& storage_key,
+                         const std::string& bucket_name) {
+    quota_manager_impl_->GetOrCreateBucket(
         storage_key, bucket_name,
         base::BindOnce(&QuotaManagerImplTest::DidGetBucket,
                        weak_factory_.GetWeakPtr()));
   }
 
+  void CreateBucketForTesting(const StorageKey& storage_key,
+                              const std::string& bucket_name,
+                              blink::mojom::StorageType storage_type) {
+    quota_manager_impl_->CreateBucketForTesting(
+        storage_key, bucket_name, storage_type,
+        base::BindOnce(&QuotaManagerImplTest::DidGetBucket,
+                       weak_factory_.GetWeakPtr()));
+  }
+
   void GetBucket(const StorageKey& storage_key,
-                 const std::string& bucket_name) {
+                 const std::string& bucket_name,
+                 blink::mojom::StorageType storage_type) {
     quota_manager_impl_->GetBucket(
-        storage_key, bucket_name,
+        storage_key, bucket_name, storage_type,
         base::BindOnce(&QuotaManagerImplTest::DidGetBucket,
                        weak_factory_.GetWeakPtr()));
   }
@@ -615,36 +625,38 @@ TEST_F(QuotaManagerImplTest, GetUsageInfo) {
   }
 }
 
-TEST_F(QuotaManagerImplTest, CreateBucket) {
+TEST_F(QuotaManagerImplTest, GetOrCreateBucket) {
   StorageKey storage_key = ToStorageKey("http://a.com/");
   std::string bucket_name = "bucket_a";
 
-  CreateBucket(storage_key, bucket_name);
+  GetOrCreateBucket(storage_key, bucket_name);
   task_environment_.RunUntilIdle();
   ASSERT_TRUE(bucket_.ok());
 
-  // Try creating a bucket with the same name.
-  CreateBucket(storage_key, bucket_name);
+  BucketId created_bucket_id = bucket_.value().id;
+
+  GetOrCreateBucket(storage_key, bucket_name);
   task_environment_.RunUntilIdle();
-  EXPECT_FALSE(bucket_.ok());
+  EXPECT_TRUE(bucket_.ok());
+  EXPECT_EQ(bucket_.value().id, created_bucket_id);
 }
 
 TEST_F(QuotaManagerImplTest, GetBucket) {
   StorageKey storage_key = ToStorageKey("http://a.com/");
   std::string bucket_name = "bucket_a";
 
-  CreateBucket(storage_key, bucket_name);
+  CreateBucketForTesting(storage_key, bucket_name, kTemp);
   task_environment_.RunUntilIdle();
   ASSERT_TRUE(bucket_.ok());
   BucketInfo created_bucket = bucket_.value();
 
-  GetBucket(storage_key, bucket_name);
+  GetBucket(storage_key, bucket_name, kTemp);
   task_environment_.RunUntilIdle();
   ASSERT_TRUE(bucket_.ok());
   BucketInfo retrieved_bucket = bucket_.value();
   EXPECT_EQ(created_bucket.id, retrieved_bucket.id);
 
-  GetBucket(storage_key, "bucket_b");
+  GetBucket(storage_key, "bucket_b", kTemp);
   task_environment_.RunUntilIdle();
   ASSERT_FALSE(bucket_.ok());
   EXPECT_EQ(bucket_.error(), QuotaError::kNotFound);