BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

13 files changed, 602 insertions, 251 deletions

diff --git a/chromium/storage/browser/quota/quota_client.h b/chromium/storage/browser/quota/quota_client.h
index 642f52ea189..781e987fff1 100644
--- a/chromium/storage/browser/quota/quota_client.h
+++ b/chromium/storage/browser/quota/quota_client.h
@@ -36,8 +36,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaClient
   using DeletionCallback =
       base::OnceCallback<void(blink::mojom::QuotaStatusCode status)>;
 
-  virtual QuotaClientType type() const = 0;
-
   // Called when the QuotaManager is destroyed.
   virtual void OnQuotaManagerDestroyed() = 0;
 
@@ -74,8 +72,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaClient
   virtual void PerformStorageCleanup(blink::mojom::StorageType type,
                                      base::OnceClosure callback) = 0;
 
-  virtual bool DoesSupport(blink::mojom::StorageType type) const = 0;
-
  protected:
   friend class RefCountedThreadSafe<QuotaClient>;
 
diff --git a/chromium/storage/browser/quota/quota_client_type.cc b/chromium/storage/browser/quota/quota_client_type.cc
index b9e9f62a6af..a2daaa23b5e 100644
--- a/chromium/storage/browser/quota/quota_client_type.cc
+++ b/chromium/storage/browser/quota/quota_client_type.cc
@@ -9,7 +9,7 @@
 namespace storage {
 
 const QuotaClientTypes& AllQuotaClientTypes() {
-  static base::NoDestructor<QuotaClientTypes> all({
+  static base::NoDestructor<QuotaClientTypes> all{{
       QuotaClientType::kFileSystem,
       QuotaClientType::kDatabase,
       QuotaClientType::kAppcache,
@@ -17,7 +17,7 @@ const QuotaClientTypes& AllQuotaClientTypes() {
       QuotaClientType::kServiceWorkerCache,
       QuotaClientType::kServiceWorker,
       QuotaClientType::kBackgroundFetch,
-  });
+  }};
   return *all;
 }
 
diff --git a/chromium/storage/browser/quota/quota_device_info_helper.h b/chromium/storage/browser/quota/quota_device_info_helper.h
index b534d70529c..5a2fdd17e1a 100644
--- a/chromium/storage/browser/quota/quota_device_info_helper.h
+++ b/chromium/storage/browser/quota/quota_device_info_helper.h
@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "base/component_export.h"
+#include "base/macros.h"
 #include "base/no_destructor.h"
 #include "base/system/sys_info.h"
 
diff --git a/chromium/storage/browser/quota/quota_features.cc b/chromium/storage/browser/quota/quota_features.cc
index 7e3aae4ef6c..8e47aef9c49 100644
--- a/chromium/storage/browser/quota/quota_features.cc
+++ b/chromium/storage/browser/quota/quota_features.cc
@@ -17,13 +17,6 @@ constexpr base::FeatureParam<double> kExperimentalPoolSizeRatio{
 constexpr base::FeatureParam<double> kPerHostRatio{&kQuotaExpandPoolSize,
                                                    "PerHostRatio", 0.75};
 
-// StaticHostQuota enables a simpler per-host quota model, where the quota is
-// only based on disk capacity (partition size). When the flag is disabled, the
-// quota computation takes into account free disk space, in addition to the
-// disk's total capacity.
-const base::Feature kStaticHostQuota{"StaticHostQuota",
-                                     base::FEATURE_ENABLED_BY_DEFAULT};
-
 // QuotaUnlimitedPoolSize removes limitations around disk space consumption with
 // respect to client-side storage web platform APIs. When enabled, quota will
 // set no limit on how much space a single origin can consume, as well as
diff --git a/chromium/storage/browser/quota/quota_features.h b/chromium/storage/browser/quota/quota_features.h
index a55c2cb26b6..9ab69a6b955 100644
--- a/chromium/storage/browser/quota/quota_features.h
+++ b/chromium/storage/browser/quota/quota_features.h
@@ -19,9 +19,6 @@ extern const base::FeatureParam<double> kExperimentalPoolSizeRatio;
 extern const base::FeatureParam<double> kPerHostRatio;
 
 COMPONENT_EXPORT(STORAGE_BROWSER)
-extern const base::Feature kStaticHostQuota;
-
-COMPONENT_EXPORT(STORAGE_BROWSER)
 extern const base::Feature kQuotaUnlimitedPoolSize;
 
 COMPONENT_EXPORT(STORAGE_BROWSER)
diff --git a/chromium/storage/browser/quota/quota_manager.cc b/chromium/storage/browser/quota/quota_manager.cc
index a84b117d1c1..cc5ff3f632b 100644
--- a/chromium/storage/browser/quota/quota_manager.cc
+++ b/chromium/storage/browser/quota/quota_manager.cc
@@ -42,6 +42,7 @@
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/quota_temporary_storage_evictor.h"
 #include "storage/browser/quota/usage_tracker.h"
+#include "third_party/blink/public/mojom/quota/quota_types.mojom-shared.h"
 
 using blink::mojom::StorageType;
 
@@ -55,7 +56,7 @@ const int64_t kReportHistogramInterval = 60 * 60 * 1000;  // 1 hour
 
 // Take action on write errors if there is <= 2% disk space
 // available.
-const double kStoragePressureThresholdRatio = 2;
+constexpr double kStoragePressureThresholdPercent = 2;
 
 // Limit how frequently QuotaManager polls for free disk space when
 // only using that information to identify storage pressure.
@@ -289,8 +290,6 @@ class QuotaManager::UsageAndQuotaInfoGatherer : public QuotaTask {
     if (host_quota > temp_pool_free_space) {
       if (is_unlimited_) {
         host_quota = available_space_ + host_usage_;
-      } else if (!base::FeatureList::IsEnabled(features::kStaticHostQuota)) {
-        host_quota = temp_pool_free_space + host_usage_;
       }
     }
 
@@ -548,24 +547,29 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {
 
  protected:
   void Run() override {
-    error_count_ = 0;
-    remaining_clients_ = manager()->clients_.size();
-    for (const auto& client : manager()->clients_) {
-      if (quota_client_types_.contains(client->type())) {
+    DCHECK(manager()->client_types_.contains(type_));
+    remaining_clients_ = manager()->client_types_[type_].size();
+
+    for (const auto& client_and_type : manager()->client_types_[type_]) {
+      QuotaClient* client = client_and_type.first;
+      QuotaClientType client_type = client_and_type.second;
+      if (quota_client_types_.contains(client_type)) {
         static int tracing_id = 0;
         TRACE_EVENT_ASYNC_BEGIN2(
             "browsing_data", "QuotaManager::OriginDataDeleter", ++tracing_id,
-            "client_type", client->type(), "origin", origin_.Serialize());
+            "client_type", client_type, "origin", origin_.Serialize());
         client->DeleteOriginData(
             origin_, type_,
             base::BindOnce(&OriginDataDeleter::DidDeleteOriginData,
                            weak_factory_.GetWeakPtr(), tracing_id));
       } else {
         ++skipped_clients_;
-        if (--remaining_clients_ == 0)
-          CallCompleted();
+        --remaining_clients_;
       }
     }
+
+    if (remaining_clients_ == 0)
+      CallCompleted();
   }
 
   void Completed() override {
@@ -635,10 +639,11 @@ class QuotaManager::HostDataDeleter : public QuotaTask {
 
  protected:
   void Run() override {
-    error_count_ = 0;
-    remaining_clients_ = manager()->clients_.size();
-    for (const auto& client : manager()->clients_) {
-      client->GetOriginsForHost(
+    DCHECK(manager()->client_types_.contains(type_));
+    remaining_clients_ = manager()->client_types_[type_].size();
+
+    for (const auto& client_and_type : manager()->client_types_[type_]) {
+      client_and_type.first->GetOriginsForHost(
           type_, host_,
           base::BindOnce(&HostDataDeleter::DidGetOriginsForHost,
                          weak_factory_.GetWeakPtr()));
@@ -722,19 +727,24 @@ class QuotaManager::StorageCleanupHelper : public QuotaTask {
       : QuotaTask(manager),
         type_(type),
         quota_client_types_(std::move(quota_client_types)),
-        callback_(std::move(callback)) {}
+        callback_(std::move(callback)) {
+    DCHECK(manager->client_types_.contains(type_));
+  }
 
  protected:
   void Run() override {
+    DCHECK(manager()->client_types_.contains(type_));
     base::RepeatingClosure barrier = base::BarrierClosure(
-        manager()->clients_.size(),
+        manager()->client_types_[type_].size(),
         base::BindOnce(&StorageCleanupHelper::CallCompleted,
                        weak_factory_.GetWeakPtr()));
 
     // This may synchronously trigger |callback_| at the end of the for loop,
     // make sure we do nothing after this block.
-    for (const auto& client : manager()->clients_) {
-      if (quota_client_types_.contains(client->type())) {
+    for (const auto& client_and_type : manager()->client_types_[type_]) {
+      QuotaClient* client = client_and_type.first;
+      QuotaClientType client_type = client_and_type.second;
+      if (quota_client_types_.contains(client_type)) {
         client->PerformStorageCleanup(type_, barrier);
       } else {
         barrier.Run();
@@ -1068,7 +1078,9 @@ void QuotaManager::DeleteHostData(const std::string& host,
                                   StatusCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   LazyInitialize();
-  if (host.empty() || clients_.empty()) {
+
+  DCHECK(client_types_.contains(type));
+  if (host.empty() || client_types_[type].empty()) {
     std::move(callback).Run(blink::mojom::QuotaStatusCode::kOk);
     return;
   }
@@ -1213,18 +1225,18 @@ bool QuotaManager::ResetUsageTracker(StorageType type) {
   DCHECK(GetUsageTracker(type));
   if (GetUsageTracker(type)->IsWorking())
     return false;
+
+  auto usage_tracker = std::make_unique<UsageTracker>(
+      client_types_[type], type, special_storage_policy_.get());
   switch (type) {
     case StorageType::kTemporary:
-      temporary_usage_tracker_.reset(new UsageTracker(
-          clients_, StorageType::kTemporary, special_storage_policy_.get()));
+      temporary_usage_tracker_ = std::move(usage_tracker);
       return true;
     case StorageType::kPersistent:
-      persistent_usage_tracker_.reset(new UsageTracker(
-          clients_, StorageType::kPersistent, special_storage_policy_.get()));
+      persistent_usage_tracker_ = std::move(usage_tracker);
       return true;
     case StorageType::kSyncable:
-      syncable_usage_tracker_.reset(new UsageTracker(
-          clients_, StorageType::kSyncable, special_storage_policy_.get()));
+      syncable_usage_tracker_ = std::move(usage_tracker);
       return true;
     default:
       NOTREACHED();
@@ -1234,8 +1246,12 @@ bool QuotaManager::ResetUsageTracker(StorageType type) {
 
 QuotaManager::~QuotaManager() {
   proxy_->manager_ = nullptr;
-  for (const auto& client : clients_)
+
+  // Iterating over |clients_for_ownership_| is correct here because we want to
+  // call OnQuotaManagerDestroyed() once per QuotaClient.
+  for (const auto& client : clients_for_ownership_)
     client->OnQuotaManagerDestroyed();
+
   if (database_)
     db_runner_->DeleteSoon(FROM_HERE, database_.release());
 }
@@ -1253,16 +1269,20 @@ void QuotaManager::LazyInitialize() {
     return;
   }
 
-  // Use an empty path to open an in-memory only databse for incognito.
-  database_.reset(new QuotaDatabase(is_incognito_ ? base::FilePath() :
-      profile_path_.AppendASCII(kDatabaseName)));
+  // Use an empty path to open an in-memory only database for incognito.
+  database_ = std::make_unique<QuotaDatabase>(
+      is_incognito_ ? base::FilePath()
+                    : profile_path_.AppendASCII(kDatabaseName));
 
-  temporary_usage_tracker_.reset(new UsageTracker(
-      clients_, StorageType::kTemporary, special_storage_policy_.get()));
-  persistent_usage_tracker_.reset(new UsageTracker(
-      clients_, StorageType::kPersistent, special_storage_policy_.get()));
-  syncable_usage_tracker_.reset(new UsageTracker(
-      clients_, StorageType::kSyncable, special_storage_policy_.get()));
+  temporary_usage_tracker_ = std::make_unique<UsageTracker>(
+      client_types_[StorageType::kTemporary], StorageType::kTemporary,
+      special_storage_policy_.get());
+  persistent_usage_tracker_ = std::make_unique<UsageTracker>(
+      client_types_[StorageType::kPersistent], StorageType::kPersistent,
+      special_storage_policy_.get());
+  syncable_usage_tracker_ = std::make_unique<UsageTracker>(
+      client_types_[StorageType::kSyncable], StorageType::kSyncable,
+      special_storage_policy_.get());
 
   if (!is_incognito_) {
     histogram_timer_.Start(
@@ -1309,10 +1329,18 @@ void QuotaManager::DidBootstrapDatabase(
   GetLRUOrigin(StorageType::kTemporary, std::move(did_get_origin_callback));
 }
 
-void QuotaManager::RegisterClient(scoped_refptr<QuotaClient> client) {
+void QuotaManager::RegisterClient(
+    scoped_refptr<QuotaClient> client,
+    QuotaClientType client_type,
+    const std::vector<blink::mojom::StorageType>& storage_types) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  DCHECK(!database_.get());
-  clients_.push_back(std::move(client));
+  DCHECK(!database_.get())
+      << "All clients must be registered before the database is initialized";
+  DCHECK(client.get());
+
+  for (blink::mojom::StorageType storage_type : storage_types)
+    client_types_[storage_type].insert({client.get(), client_type});
+  clients_for_ownership_.push_back(std::move(client));
 }
 
 UsageTracker* QuotaManager::GetUsageTracker(StorageType type) const {
@@ -1409,8 +1437,8 @@ void QuotaManager::StartEviction() {
   DCHECK(!temporary_storage_evictor_.get());
   if (eviction_disabled_)
     return;
-  temporary_storage_evictor_.reset(new QuotaTemporaryStorageEvictor(
-      this, kEvictionIntervalInMilliSeconds));
+  temporary_storage_evictor_ = std::make_unique<QuotaTemporaryStorageEvictor>(
+      this, kEvictionIntervalInMilliSeconds);
   temporary_storage_evictor_->Start();
 }
 
@@ -1451,11 +1479,6 @@ void QuotaManager::DeleteOriginDataInternal(const url::Origin& origin,
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   LazyInitialize();
 
-  if (clients_.empty()) {
-    std::move(callback).Run(blink::mojom::QuotaStatusCode::kOk);
-    return;
-  }
-
   OriginDataDeleter* deleter =
       new OriginDataDeleter(this, origin, type, std::move(quota_client_types),
                             is_eviction, std::move(callback));
@@ -1477,7 +1500,8 @@ void QuotaManager::MaybeRunStoragePressureCallback(const url::Origin& origin,
     origin_for_pending_storage_pressure_callback_ = std::move(origin);
     return;
   }
-  if (100 * (available_space / total_space) < kStoragePressureThresholdRatio) {
+
+  if (100 * available_space < kStoragePressureThresholdPercent * total_space) {
     storage_pressure_callback_.Run(std::move(origin));
   }
 }
diff --git a/chromium/storage/browser/quota/quota_manager.h b/chromium/storage/browser/quota/quota_manager.h
index 7554d3615d6..5d7458b6046 100644
--- a/chromium/storage/browser/quota/quota_manager.h
+++ b/chromium/storage/browser/quota/quota_manager.h
@@ -150,36 +150,40 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
       blink::mojom::StorageType type,
       UsageAndQuotaWithBreakdownCallback callback);
 
-  // Called by StorageClients.
-  // This method is declared as virtual to allow test code to override it.
+  // Called by storage backends.
   //
   // For UnlimitedStorage origins, this version skips usage and quota handling
-  // to avoid extra query cost.
-  // Do not call this method for apps/user-facing code.
+  // to avoid extra query cost. Do not call this method for apps/user-facing
+  // code.
+  //
+  // This method is declared as virtual to allow test code to override it.
   virtual void GetUsageAndQuota(const url::Origin& origin,
                                 blink::mojom::StorageType type,
                                 UsageAndQuotaCallback callback);
 
-  // Called by clients via proxy.
-  // Client storage should call this method when storage is accessed.
-  // Used to maintain LRU ordering.
+  // Called by storage backends via proxy.
+  //
+  // Quota-managed storage backends should call this method when storage is
+  // accessed. Used to maintain LRU ordering.
   void NotifyStorageAccessed(const url::Origin& origin,
                              blink::mojom::StorageType type);
 
-  // Called by clients via proxy.
-  // Client storage must call this method whenever they have made any
-  // modifications that change the amount of data stored in their storage.
+  // Called by storage backends via proxy.
+  //
+  // Quota-managed storage backends must call this method when they have made
+  // any modifications that change the amount of data stored in their storage.
   void NotifyStorageModified(QuotaClientType client_id,
                              const url::Origin& origin,
                              blink::mojom::StorageType type,
                              int64_t delta);
 
-  // Called by clients via proxy.
-  // This method is declared as virtual to allow test code to override it.
+  // Called by storage backends via proxy.
   //
   // Client storage must call this method whenever they run into disk
   // write errors. Used as a hint to determine if the storage partition is out
   // of space, and trigger actions if deemed appropriate.
+  //
+  // This method is declared as virtual to allow test code to override it.
   virtual void NotifyWriteFailed(const url::Origin& origin);
 
   // Used to avoid evicting origins with open pages.
@@ -315,10 +319,10 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
     StatusCallback evict_origin_data_callback;
   };
 
-  // This initialization method is lazily called on the IO thread
-  // when the first quota manager API is called.
-  // Initialize must be called after all quota clients are added to the
-  // manager by RegisterStorage.
+  // Lazily called on the IO thread when the first quota manager API is called.
+  //
+  // Initialize() must be called after all quota clients are added to the
+  // manager by RegisterClient.
   void LazyInitialize();
   void FinishLazyInitialize(bool is_database_bootstraped);
   void BootstrapDatabaseForEviction(GetOriginCallback did_get_origin_callback,
@@ -329,7 +333,10 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
 
   // Called by clients via proxy.
   // Registers a quota client to the manager.
-  void RegisterClient(scoped_refptr<QuotaClient> client);
+  void RegisterClient(
+      scoped_refptr<QuotaClient> client,
+      QuotaClientType client_type,
+      const std::vector<blink::mojom::StorageType>& storage_types);
 
   UsageTracker* GetUsageTracker(blink::mojom::StorageType type) const;
 
@@ -455,7 +462,18 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
   GetOriginCallback lru_origin_callback_;
   std::set<url::Origin> access_notified_origins_;
 
-  std::vector<scoped_refptr<QuotaClient>> clients_;
+  // Owns the QuotaClient instances registered via RegisterClient().
+  //
+  // Iterating over this list is almost always incorrect. Most algorithms should
+  // iterate over an entry in |client_types_|.
+  std::vector<scoped_refptr<QuotaClient>> clients_for_ownership_;
+  // Maps QuotaClient instances to client types.
+  //
+  // The QuotaClient instances pointed to by the map keys are guaranteed to be
+  // alive, because they are owned by |clients_for_ownership_|.
+  base::flat_map<blink::mojom::StorageType,
+                 base::flat_map<QuotaClient*, QuotaClientType>>
+      client_types_;
 
   std::unique_ptr<UsageTracker> temporary_usage_tracker_;
   std::unique_ptr<UsageTracker> persistent_usage_tracker_;
diff --git a/chromium/storage/browser/quota/quota_manager_proxy.cc b/chromium/storage/browser/quota/quota_manager_proxy.cc
index 892566064d7..1cb5cd62b7a 100644
--- a/chromium/storage/browser/quota/quota_manager_proxy.cc
+++ b/chromium/storage/browser/quota/quota_manager_proxy.cc
@@ -13,6 +13,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
 
 namespace storage {
@@ -36,18 +37,23 @@ void DidGetUsageAndQuota(base::SequencedTaskRunner* original_task_runner,
 
 }  // namespace
 
-void QuotaManagerProxy::RegisterClient(scoped_refptr<QuotaClient> client) {
+void QuotaManagerProxy::RegisterClient(
+    scoped_refptr<QuotaClient> client,
+    QuotaClientType client_type,
+    const std::vector<blink::mojom::StorageType>& storage_types) {
   if (!io_thread_->BelongsToCurrentThread() &&
       io_thread_->PostTask(
-          FROM_HERE, base::BindOnce(&QuotaManagerProxy::RegisterClient, this,
-                                    std::move(client)))) {
+          FROM_HERE,
+          base::BindOnce(&QuotaManagerProxy::RegisterClient, this,
+                         std::move(client), client_type, storage_types))) {
     return;
   }
 
-  if (manager_)
-    manager_->RegisterClient(std::move(client));
-  else
+  if (manager_) {
+    manager_->RegisterClient(std::move(client), client_type, storage_types);
+  } else {
     client->OnQuotaManagerDestroyed();
+  }
 }
 
 void QuotaManagerProxy::NotifyStorageAccessed(const url::Origin& origin,
diff --git a/chromium/storage/browser/quota/quota_manager_proxy.h b/chromium/storage/browser/quota/quota_manager_proxy.h
index 2d1cfee778a..235ee5a784c 100644
--- a/chromium/storage/browser/quota/quota_manager_proxy.h
+++ b/chromium/storage/browser/quota/quota_manager_proxy.h
@@ -8,6 +8,7 @@
 #include <stdint.h>
 
 #include <memory>
+#include <vector>
 
 #include "base/callback.h"
 #include "base/component_export.h"
@@ -18,6 +19,7 @@
 #include "base/sequenced_task_runner_helpers.h"
 #include "storage/browser/quota/quota_callbacks.h"
 #include "storage/browser/quota/quota_client.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "storage/browser/quota/quota_database.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "storage/browser/quota/quota_task.h"
@@ -38,7 +40,10 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerProxy
  public:
   using UsageAndQuotaCallback = QuotaManager::UsageAndQuotaCallback;
 
-  virtual void RegisterClient(scoped_refptr<QuotaClient> client);
+  virtual void RegisterClient(
+      scoped_refptr<QuotaClient> client,
+      QuotaClientType client_type,
+      const std::vector<blink::mojom::StorageType>& storage_types);
   virtual void NotifyStorageAccessed(const url::Origin& origin,
                                      blink::mojom::StorageType type);
   virtual void NotifyStorageModified(QuotaClientType client_id,
diff --git a/chromium/storage/browser/quota/quota_manager_unittest.cc b/chromium/storage/browser/quota/quota_manager_unittest.cc
index e64135a246c..947c2533ed7 100644
--- a/chromium/storage/browser/quota/quota_manager_unittest.cc
+++ b/chromium/storage/browser/quota/quota_manager_unittest.cc
@@ -18,6 +18,7 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
@@ -35,6 +36,7 @@
 #include "storage/browser/test/mock_quota_client.h"
 #include "storage/browser/test/mock_special_storage_policy.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/public/mojom/quota/quota_types.mojom-shared.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
@@ -86,7 +88,8 @@ class QuotaManagerTest : public testing::Test {
 
   void SetUp() override {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
-    mock_special_storage_policy_ = new MockSpecialStoragePolicy;
+    mock_special_storage_policy_ =
+        base::MakeRefCounted<MockSpecialStoragePolicy>();
     ResetQuotaManager(false /* is_incognito */);
   }
 
@@ -98,10 +101,10 @@ class QuotaManagerTest : public testing::Test {
 
  protected:
   void ResetQuotaManager(bool is_incognito) {
-    quota_manager_ = new QuotaManager(is_incognito, data_dir_.GetPath(),
-                                      base::ThreadTaskRunnerHandle::Get().get(),
-                                      mock_special_storage_policy_.get(),
-                                      GetQuotaSettingsFunc());
+    quota_manager_ = base::MakeRefCounted<QuotaManager>(
+        is_incognito, data_dir_.GetPath(),
+        base::ThreadTaskRunnerHandle::Get().get(),
+        mock_special_storage_policy_.get(), GetQuotaSettingsFunc());
     SetQuotaSettings(kDefaultPoolSize, kDefaultPerHostQuota,
                      is_incognito ? INT64_C(0) : kMustRemainAvailableForSystem);
 
@@ -112,12 +115,14 @@ class QuotaManagerTest : public testing::Test {
     additional_callback_count_ = 0;
   }
 
-  MockQuotaClient* CreateAndRegisterClient(
+  scoped_refptr<MockQuotaClient> CreateAndRegisterClient(
       base::span<const MockOriginData> mock_data,
-      QuotaClientType client_type) {
-    MockQuotaClient* client =
-        new MockQuotaClient(quota_manager_->proxy(), mock_data, client_type);
-    quota_manager_->proxy()->RegisterClient(client);
+      QuotaClientType client_type,
+      const std::vector<blink::mojom::StorageType> storage_types) {
+    scoped_refptr<MockQuotaClient> client =
+        base::MakeRefCounted<MockQuotaClient>(quota_manager_->proxy(),
+                                              mock_data, client_type);
+    quota_manager_->proxy()->RegisterClient(client, client_type, storage_types);
     return client;
   }
 
@@ -421,6 +426,17 @@ class QuotaManagerTest : public testing::Test {
 
   void GetUsage_WithModifyTestBody(const StorageType type);
 
+  void SetStoragePressureCallback(
+      base::RepeatingCallback<void(url::Origin)> callback) {
+    quota_manager_->SetStoragePressureCallback(std::move(callback));
+  }
+
+  void MaybeRunStoragePressureCallback(const url::Origin& origin,
+                                       int64_t total,
+                                       int64_t available) {
+    quota_manager_->MaybeRunStoragePressureCallback(origin, total, available);
+  }
+
   void set_additional_callback_count(int c) { additional_callback_count_ = c; }
   int additional_callback_count() const { return additional_callback_count_; }
   void DidGetUsageAndQuotaAdditional(QuotaStatusCode status,
@@ -522,8 +538,12 @@ TEST_F(QuotaManagerTest, GetUsageInfo) {
     { "http://bar.com/",       kPerm,  40 },
     { "http://example.com/",   kPerm,  40 },
   };
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetUsageInfo();
   task_environment_.RunUntilIdle();
@@ -550,7 +570,9 @@ TEST_F(QuotaManagerTest, GetUsageAndQuota_Simple) {
     { "http://foo.com/", kTemp, 10 },
     { "http://foo.com/", kPerm, 80 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kPerm);
   task_environment_.RunUntilIdle();
@@ -604,7 +626,9 @@ TEST_F(QuotaManagerTest, GetUsage_NoClient) {
 
 TEST_F(QuotaManagerTest, GetUsage_EmptyClient) {
   CreateAndRegisterClient(base::span<MockOriginData>(),
-                          QuotaClientType::kFileSystem);
+                          QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(QuotaStatusCode::kOk, status());
@@ -643,7 +667,9 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_MultiOrigins) {
     { "http://baz.com/",        kTemp,  30 },
     { "http://foo.com/",        kPerm,  40 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   // This time explicitly sets a temporary global quota.
   const int kPoolSize = 100;
@@ -680,8 +706,12 @@ TEST_F(QuotaManagerTest, GetUsage_MultipleClients) {
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
   GetStorageCapacity();
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   const int64_t kPoolSize = GetAvailableDiskSpaceForTest();
   const int64_t kPerHostQuota = kPoolSize / 5;
@@ -736,9 +766,13 @@ TEST_F(QuotaManagerTest, GetUsageWithBreakdown_Simple) {
   static const MockOriginData kData3[] = {
       {"http://foo.com/", kTemp, 8},
   };
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
-  CreateAndRegisterClient(kData3, QuotaClientType::kAppcache);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData3, QuotaClientType::kAppcache,
+                          {blink::mojom::StorageType::kTemporary});
 
   GetUsageAndQuotaWithBreakdown(ToOrigin("http://foo.com/"), kPerm);
   task_environment_.RunUntilIdle();
@@ -803,7 +837,9 @@ TEST_F(QuotaManagerTest, GetUsageWithBreakdown_MultiOrigins) {
       {"http://bar.com/", kTemp, 5},  {"https://bar.com/", kTemp, 7},
       {"http://baz.com/", kTemp, 30}, {"http://foo.com/", kPerm, 40},
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetUsageAndQuotaWithBreakdown(ToOrigin("http://foo.com/"), kTemp);
   task_environment_.RunUntilIdle();
@@ -835,8 +871,12 @@ TEST_F(QuotaManagerTest, GetUsageWithBreakdown_MultipleClients) {
       {"http://unlimited/", kTemp, 512},
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetUsageAndQuotaWithBreakdown(ToOrigin("http://foo.com/"), kTemp);
   task_environment_.RunUntilIdle();
@@ -876,8 +916,8 @@ void QuotaManagerTest::GetUsage_WithModifyTestBody(const StorageType type) {
     { "http://foo.com/",   type,  10 },
     { "http://foo.com:1/", type,  20 },
   };
-  MockQuotaClient* client =
-      CreateAndRegisterClient(data, QuotaClientType::kFileSystem);
+  scoped_refptr<MockQuotaClient> client =
+      CreateAndRegisterClient(data, QuotaClientType::kFileSystem, {type});
 
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), type);
   task_environment_.RunUntilIdle();
@@ -917,7 +957,9 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_WithAdditionalTasks) {
     { "http://bar.com/",        kTemp, 13 },
     { "http://foo.com/",        kPerm, 40 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   const int kPoolSize = 100;
   const int kPerHostQuota = 20;
@@ -949,7 +991,9 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_NukeManager) {
     { "http://bar.com/",        kTemp, 13 },
     { "http://foo.com/",        kPerm, 40 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
   const int kPoolSize = 100;
   const int kPerHostQuota = 20;
   SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailableForSystem);
@@ -974,7 +1018,8 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Overbudget) {
     { "http://usage10/",   kTemp,  10 },
     { "http://usage200/",  kTemp, 200 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary});
   const int kPoolSize = 100;
   const int kPerHostQuota = 20;
   SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailableForSystem);
@@ -1013,7 +1058,8 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Unlimited) {
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
   GetStorageCapacity();
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary});
 
   // Test when not overbugdet.
   const int kPerHostQuotaFor1000 = 200;
@@ -1133,7 +1179,9 @@ TEST_F(QuotaManagerTest, OriginInUse) {
 
 TEST_F(QuotaManagerTest, GetAndSetPerststentHostQuota) {
   CreateAndRegisterClient(base::span<MockOriginData>(),
-                          QuotaClientType::kFileSystem);
+                          QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetPersistentHostQuota("foo.com");
   task_environment_.RunUntilIdle();
@@ -1162,7 +1210,9 @@ TEST_F(QuotaManagerTest, GetAndSetPerststentHostQuota) {
 TEST_F(QuotaManagerTest, GetAndSetPersistentUsageAndQuota) {
   GetStorageCapacity();
   CreateAndRegisterClient(base::span<MockOriginData>(),
-                          QuotaClientType::kFileSystem);
+                          QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kPerm);
   task_environment_.RunUntilIdle();
@@ -1197,7 +1247,8 @@ TEST_F(QuotaManagerTest, GetQuotaLowAvailableDiskSpace) {
       {"http://unlimited/", kTemp, 4000000},
   };
 
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary});
 
   const int kPoolSize = 10000000;
   const int kPerHostQuota = kPoolSize / 5;
@@ -1217,42 +1268,11 @@ TEST_F(QuotaManagerTest, GetQuotaLowAvailableDiskSpace) {
   EXPECT_EQ(kPerHostQuota, quota());
 }
 
-TEST_F(QuotaManagerTest,
-       GetQuotaLowAvailableDiskSpace_StaticHostQuotaDisabled) {
-  // This test is the same as the previous but with the kStaticHostQuota Finch
-  // feature disabled.
-  // Simulating a low available disk space scenario by making
-  // kMustRemainAvailable 64KB less than GetAvailableDiskSpaceForTest(), which
-  // means there is 64KB of storage quota that can be used before triggering
-  // the low available space logic branch in quota_manager.cc. From the
-  // perspective of QuotaManager, there are 64KB of free space in the temporary
-  // pool, so it should return (64KB + usage) as quota since the sum is less
-  // than the default host quota.
-  scoped_feature_list_.InitAndDisableFeature(features::kStaticHostQuota);
-  static const MockOriginData kData[] = {
-      {"http://foo.com/", kTemp, 100000},
-      {"http://unlimited/", kTemp, 4000000},
-  };
-
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
-
-  const int kPoolSize = 10000000;
-  const int kPerHostQuota = kPoolSize / 5;
-  const int kMustRemainAvailable =
-      static_cast<int>(GetAvailableDiskSpaceForTest() - 65536);
-  SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailable);
-
-  GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kTemp);
-  task_environment_.RunUntilIdle();
-  EXPECT_EQ(QuotaStatusCode::kOk, status());
-  EXPECT_EQ(100000, usage());
-  EXPECT_GT(kPerHostQuota, quota());
-  EXPECT_EQ(65536 + usage(), quota());
-}
-
 TEST_F(QuotaManagerTest, GetSyncableQuota) {
   CreateAndRegisterClient(base::span<MockOriginData>(),
-                          QuotaClientType::kFileSystem);
+                          QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kSyncable});
 
   // Pre-condition check: available disk space (for testing) is less than
   // the default quota for syncable storage.
@@ -1284,7 +1304,9 @@ TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_MultiOrigins) {
     { "http://baz.com/",        kPerm, 30 },
     { "http://foo.com/",        kTemp, 40 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   SetPersistentHostQuota("foo.com", 100);
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kPerm);
@@ -1305,7 +1327,9 @@ TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_WithAdditionalTasks) {
     { "http://bar.com/",        kPerm,  13 },
     { "http://foo.com/",        kTemp,  40 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
   SetPersistentHostQuota("foo.com", 100);
 
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kPerm);
@@ -1333,7 +1357,9 @@ TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_NukeManager) {
     { "http://bar.com/",        kPerm,  13 },
     { "http://foo.com/",        kTemp,  40 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
   SetPersistentHostQuota("foo.com", 100);
 
   set_additional_callback_count(0);
@@ -1357,7 +1383,9 @@ TEST_F(QuotaManagerTest, GetUsage_Simple) {
     { "http://bar.com:1/", kPerm,  600000 },
     { "http://foo.com/",   kTemp, 7000000 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetGlobalUsage(kPerm);
   task_environment_.RunUntilIdle();
@@ -1389,8 +1417,10 @@ TEST_F(QuotaManagerTest, GetUsage_WithModification) {
     { "http://foo.com/",   kTemp, 7000000 },
   };
 
-  MockQuotaClient* client =
-      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  scoped_refptr<MockQuotaClient> client =
+      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                              {blink::mojom::StorageType::kTemporary,
+                               blink::mojom::StorageType::kPersistent});
 
   GetGlobalUsage(kPerm);
   task_environment_.RunUntilIdle();
@@ -1434,8 +1464,10 @@ TEST_F(QuotaManagerTest, GetUsage_WithDeleteOrigin) {
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
-  MockQuotaClient* client =
-      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  scoped_refptr<MockQuotaClient> client =
+      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                              {blink::mojom::StorageType::kTemporary,
+                               blink::mojom::StorageType::kPersistent});
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1449,7 +1481,7 @@ TEST_F(QuotaManagerTest, GetUsage_WithDeleteOrigin) {
   task_environment_.RunUntilIdle();
   int64_t predelete_host_pers = usage();
 
-  DeleteClientOriginData(client, ToOrigin("http://foo.com/"), kTemp);
+  DeleteClientOriginData(client.get(), ToOrigin("http://foo.com/"), kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(QuotaStatusCode::kOk, status());
 
@@ -1487,8 +1519,12 @@ TEST_F(QuotaManagerTest, EvictOriginData) {
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1543,8 +1579,9 @@ TEST_F(QuotaManagerTest, EvictOriginDataHistogram) {
   };
 
   base::HistogramTester histograms;
-  MockQuotaClient* client =
-      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  scoped_refptr<MockQuotaClient> client =
+      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                              {blink::mojom::StorageType::kTemporary});
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1608,8 +1645,10 @@ TEST_F(QuotaManagerTest, EvictOriginDataWithDeletionError) {
     { "http://bar.com/",   kTemp,    4000 },
   };
   static const int kNumberOfTemporaryOrigins = 3;
-  MockQuotaClient* client =
-      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  scoped_refptr<MockQuotaClient> client =
+      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                              {blink::mojom::StorageType::kTemporary,
+                               blink::mojom::StorageType::kPersistent});
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1690,7 +1729,9 @@ TEST_F(QuotaManagerTest, GetEvictionRoundInfo) {
   };
 
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   const int kPoolSize = 10000000;
   const int kPerHostQuota = kPoolSize / 5;
@@ -1704,11 +1745,19 @@ TEST_F(QuotaManagerTest, GetEvictionRoundInfo) {
   EXPECT_LE(0, available_space());
 }
 
+TEST_F(QuotaManagerTest, DeleteHostDataNoClients) {
+  DeleteHostData(std::string(), kTemp, AllQuotaClientTypes());
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(QuotaStatusCode::kOk, status());
+}
+
 TEST_F(QuotaManagerTest, DeleteHostDataSimple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,     1 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1769,8 +1818,12 @@ TEST_F(QuotaManagerTest, DeleteHostDataMultiple) {
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1835,6 +1888,101 @@ TEST_F(QuotaManagerTest, DeleteHostDataMultiple) {
   EXPECT_EQ(predelete_bar_pers, usage());
 }
 
+TEST_F(QuotaManagerTest, DeleteHostDataMultipleClientsDifferentTypes) {
+  static const MockOriginData kData1[] = {
+      {"http://foo.com/", kPerm, 1},
+      {"http://foo.com:1/", kPerm, 10},
+      {"http://foo.com/", kTemp, 100},
+      {"http://bar.com/", kPerm, 1000},
+  };
+  static const MockOriginData kData2[] = {
+      {"http://foo.com/", kTemp, 10000},
+      {"http://foo.com:1/", kTemp, 100000},
+      {"https://foo.com/", kTemp, 1000000},
+      {"http://bar.com/", kTemp, 10000000},
+  };
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary});
+
+  GetGlobalUsage(kTemp);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_global_tmp = usage();
+
+  GetHostUsageBreakdown("foo.com", kTemp);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_foo_tmp = usage();
+
+  GetHostUsageBreakdown("bar.com", kTemp);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_bar_tmp = usage();
+
+  GetGlobalUsage(kPerm);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_global_pers = usage();
+
+  GetHostUsageBreakdown("foo.com", kPerm);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_foo_pers = usage();
+
+  GetHostUsageBreakdown("bar.com", kPerm);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_bar_pers = usage();
+
+  reset_status_callback_count();
+  DeleteHostData("foo.com", kPerm, AllQuotaClientTypes());
+  DeleteHostData("bar.com", kPerm, AllQuotaClientTypes());
+  task_environment_.RunUntilIdle();
+
+  EXPECT_EQ(2, status_callback_count());
+
+  DumpOriginInfoTable();
+  task_environment_.RunUntilIdle();
+
+  for (const auto& entry : origin_info_entries()) {
+    if (entry.type != kTemp)
+      continue;
+
+    EXPECT_NE(std::string("http://foo.com/"), entry.origin.GetURL().spec());
+    EXPECT_NE(std::string("http://foo.com:1/"), entry.origin.GetURL().spec());
+    EXPECT_NE(std::string("https://foo.com/"), entry.origin.GetURL().spec());
+    EXPECT_NE(std::string("http://bar.com/"), entry.origin.GetURL().spec());
+  }
+
+  GetGlobalUsage(kTemp);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_global_tmp, usage());
+
+  GetHostUsageBreakdown("foo.com", kTemp);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_foo_tmp, usage());
+
+  GetHostUsageBreakdown("bar.com", kTemp);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_bar_tmp, usage());
+
+  GetGlobalUsage(kPerm);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_global_pers - (1 + 10 + 1000), usage());
+
+  GetHostUsageBreakdown("foo.com", kPerm);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_foo_pers - (1 + 10), usage());
+
+  GetHostUsageBreakdown("bar.com", kPerm);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_bar_pers - 1000, usage());
+}
+
+TEST_F(QuotaManagerTest, DeleteOriginDataNoClients) {
+  DeleteOriginData(url::Origin::Create(GURL("http://foo.com/")), kTemp,
+                   AllQuotaClientTypes());
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(QuotaStatusCode::kOk, status());
+}
+
 // Single-run DeleteOriginData cases must be well covered by
 // EvictOriginData tests.
 TEST_F(QuotaManagerTest, DeleteOriginDataMultiple) {
@@ -1851,8 +1999,12 @@ TEST_F(QuotaManagerTest, DeleteOriginDataMultiple) {
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1924,6 +2076,102 @@ TEST_F(QuotaManagerTest, DeleteOriginDataMultiple) {
   EXPECT_EQ(predelete_bar_pers, usage());
 }
 
+TEST_F(QuotaManagerTest, DeleteOriginDataMultipleClientsDifferentTypes) {
+  static const MockOriginData kData1[] = {
+      {"http://foo.com/", kPerm, 1},
+      {"http://foo.com:1/", kPerm, 10},
+      {"http://foo.com/", kTemp, 100},
+      {"http://bar.com/", kPerm, 1000},
+  };
+  static const MockOriginData kData2[] = {
+      {"http://foo.com/", kTemp, 10000},
+      {"http://foo.com:1/", kTemp, 100000},
+      {"https://foo.com/", kTemp, 1000000},
+      {"http://bar.com/", kTemp, 10000000},
+  };
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary});
+
+  GetGlobalUsage(kTemp);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_global_tmp = usage();
+
+  GetHostUsageBreakdown("foo.com", kTemp);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_foo_tmp = usage();
+
+  GetHostUsageBreakdown("bar.com", kTemp);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_bar_tmp = usage();
+
+  GetGlobalUsage(kPerm);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_global_pers = usage();
+
+  GetHostUsageBreakdown("foo.com", kPerm);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_foo_pers = usage();
+
+  GetHostUsageBreakdown("bar.com", kPerm);
+  task_environment_.RunUntilIdle();
+  const int64_t predelete_bar_pers = usage();
+
+  for (const MockOriginData& data : kData1) {
+    quota_manager()->NotifyStorageAccessed(
+        url::Origin::Create(GURL(data.origin)), data.type);
+  }
+  for (const MockOriginData& data : kData2) {
+    quota_manager()->NotifyStorageAccessed(
+        url::Origin::Create(GURL(data.origin)), data.type);
+  }
+  task_environment_.RunUntilIdle();
+
+  reset_status_callback_count();
+  DeleteOriginData(ToOrigin("http://foo.com/"), kPerm, AllQuotaClientTypes());
+  DeleteOriginData(ToOrigin("http://bar.com/"), kPerm, AllQuotaClientTypes());
+  task_environment_.RunUntilIdle();
+
+  EXPECT_EQ(2, status_callback_count());
+
+  DumpOriginInfoTable();
+  task_environment_.RunUntilIdle();
+
+  for (const auto& entry : origin_info_entries()) {
+    if (entry.type != kPerm)
+      continue;
+
+    EXPECT_NE(std::string("http://foo.com/"), entry.origin.GetURL().spec());
+    EXPECT_NE(std::string("http://bar.com/"), entry.origin.GetURL().spec());
+  }
+
+  GetGlobalUsage(kTemp);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_global_tmp, usage());
+
+  GetHostUsageBreakdown("foo.com", kTemp);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_foo_tmp, usage());
+
+  GetHostUsageBreakdown("bar.com", kTemp);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_bar_tmp, usage());
+
+  GetGlobalUsage(kPerm);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_global_pers - (1 + 1000), usage());
+
+  GetHostUsageBreakdown("foo.com", kPerm);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_foo_pers - 1, usage());
+
+  GetHostUsageBreakdown("bar.com", kPerm);
+  task_environment_.RunUntilIdle();
+  EXPECT_EQ(predelete_bar_pers - 1000, usage());
+}
+
 TEST_F(QuotaManagerTest, GetCachedOrigins) {
   static const MockOriginData kData[] = {
     { "http://a.com/",   kTemp,       1 },
@@ -1931,7 +2179,9 @@ TEST_F(QuotaManagerTest, GetCachedOrigins) {
     { "http://b.com/",   kPerm,     300 },
     { "http://c.com/",   kTemp,    4000 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   // TODO(kinuko): Be careful when we add cache pruner.
 
@@ -1975,7 +2225,9 @@ TEST_F(QuotaManagerTest, NotifyAndLRUOrigin) {
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GURL origin;
   GetEvictionOrigin(kTemp);
@@ -2013,7 +2265,9 @@ TEST_F(QuotaManagerTest, GetLRUOriginWithOriginInUse) {
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   GURL origin;
   GetEvictionOrigin(kTemp);
@@ -2066,8 +2320,10 @@ TEST_F(QuotaManagerTest, GetOriginsModifiedSince) {
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  MockQuotaClient* client =
-      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  scoped_refptr<MockQuotaClient> client =
+      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                              {blink::mojom::StorageType::kTemporary,
+                               blink::mojom::StorageType::kPersistent});
 
   GetOriginsModifiedSince(kTemp, base::Time());
   task_environment_.RunUntilIdle();
@@ -2192,10 +2448,14 @@ TEST_F(QuotaManagerTest, DeleteSpecificClientTypeSingleOrigin) {
   static const MockOriginData kData4[] = {
     { "http://foo.com/",   kTemp, 8 },
   };
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache);
-  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase);
-  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase,
+                          {blink::mojom::StorageType::kTemporary});
 
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
@@ -2243,10 +2503,14 @@ TEST_F(QuotaManagerTest, DeleteSpecificClientTypeSingleHost) {
   static const MockOriginData kData4[] = {
     { "http://foo.com:4444/",   kTemp, 8 },
   };
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache);
-  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase);
-  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase,
+                          {blink::mojom::StorageType::kTemporary});
 
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
@@ -2290,10 +2554,14 @@ TEST_F(QuotaManagerTest, DeleteMultipleClientTypesSingleOrigin) {
   static const MockOriginData kData4[] = {
     { "http://foo.com/",   kTemp, 8 },
   };
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache);
-  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase);
-  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase,
+                          {blink::mojom::StorageType::kTemporary});
 
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
@@ -2328,10 +2596,14 @@ TEST_F(QuotaManagerTest, DeleteMultipleClientTypesSingleHost) {
   static const MockOriginData kData4[] = {
     { "http://foo.com:4444/",   kTemp, 8 },
   };
-  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
-  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache);
-  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase);
-  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase,
+                          {blink::mojom::StorageType::kTemporary});
+  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase,
+                          {blink::mojom::StorageType::kTemporary});
 
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
@@ -2360,7 +2632,9 @@ TEST_F(QuotaManagerTest, GetUsageAndQuota_Incognito) {
     { "http://foo.com/", kTemp, 10 },
     { "http://foo.com/", kPerm, 80 },
   };
-  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem,
+                          {blink::mojom::StorageType::kTemporary,
+                           blink::mojom::StorageType::kPersistent});
 
   // Query global usage to warmup the usage tracker caching.
   GetGlobalUsage(kTemp);
@@ -2415,4 +2689,22 @@ TEST_F(QuotaManagerTest, GetUsageAndQuota_SessionOnly) {
   EXPECT_EQ(0, quota());
 }
 
+TEST_F(QuotaManagerTest, MaybeRunStoragePressureCallback) {
+  bool callback_ran = false;
+  auto cb = base::BindRepeating(
+      [](bool* callback_ran, url::Origin origin) { *callback_ran = true; },
+      &callback_ran);
+
+  SetStoragePressureCallback(std::move(cb));
+
+  const int64_t kGBytes = 1024 * 1024 * 1024;
+  MaybeRunStoragePressureCallback(url::Origin(), 100 * kGBytes, 2 * kGBytes);
+  task_environment_.RunUntilIdle();
+  EXPECT_FALSE(callback_ran);
+
+  MaybeRunStoragePressureCallback(url::Origin(), 100 * kGBytes, kGBytes);
+  task_environment_.RunUntilIdle();
+  EXPECT_TRUE(callback_ran);
+}
+
 }  // namespace storage
diff --git a/chromium/storage/browser/quota/usage_tracker.cc b/chromium/storage/browser/quota/usage_tracker.cc
index 319dece4680..3ad871707ad 100644
--- a/chromium/storage/browser/quota/usage_tracker.cc
+++ b/chromium/storage/browser/quota/usage_tracker.cc
@@ -12,6 +12,7 @@
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "storage/browser/quota/client_usage_tracker.h"
+#include "storage/browser/quota/quota_client_type.h"
 
 namespace storage {
 
@@ -44,17 +45,21 @@ struct UsageTracker::AccumulateInfo {
 };
 
 UsageTracker::UsageTracker(
-    const std::vector<scoped_refptr<QuotaClient>>& clients,
+    const base::flat_map<QuotaClient*, QuotaClientType>& client_types,
     blink::mojom::StorageType type,
     SpecialStoragePolicy* special_storage_policy)
     : type_(type) {
-  for (const auto& client : clients) {
-    if (client->DoesSupport(type)) {
-      client_tracker_map_[client->type()] =
-          std::make_unique<ClientUsageTracker>(this, client, type,
-                                               special_storage_policy);
-    }
+  size_t client_count = 0;
+
+  for (const auto& client_and_type : client_types) {
+    QuotaClient* client = client_and_type.first;
+    QuotaClientType client_type = client_and_type.second;
+    client_tracker_map_[client_type].push_back(
+        std::make_unique<ClientUsageTracker>(this, client, type,
+                                             special_storage_policy));
+    ++client_count;
   }
+  client_count_ = client_count;
 }
 
 UsageTracker::~UsageTracker() {
@@ -86,8 +91,10 @@ void UsageTracker::GetGlobalLimitedUsage(UsageCallback callback) {
       base::BindRepeating(&UsageTracker::AccumulateClientGlobalLimitedUsage,
                           weak_factory_.GetWeakPtr(), base::Owned(info));
 
-  for (const auto& client_type_and_tracker : client_tracker_map_)
-    client_type_and_tracker.second->GetGlobalLimitedUsage(accumulator);
+  for (const auto& client_type_and_trackers : client_tracker_map_) {
+    for (const auto& client_tracker : client_type_and_trackers.second)
+      client_tracker->GetGlobalLimitedUsage(accumulator);
+  }
 
   // Fire the sentinel as we've now called GetGlobalUsage for all clients.
   accumulator.Run(0);
@@ -112,8 +119,10 @@ void UsageTracker::GetGlobalUsage(GlobalUsageCallback callback) {
       base::BindRepeating(&UsageTracker::AccumulateClientGlobalUsage,
                           weak_factory_.GetWeakPtr(), base::Owned(info));
 
-  for (const auto& client_type_and_tracker : client_tracker_map_)
-    client_type_and_tracker.second->GetGlobalUsage(accumulator);
+  for (const auto& client_type_and_trackers : client_tracker_map_) {
+    for (const auto& client_tracker : client_type_and_trackers.second)
+      client_tracker->GetGlobalUsage(accumulator);
+  }
 
   // Fire the sentinel as we've now called GetGlobalUsage for all clients.
   accumulator.Run(0, 0);
@@ -144,11 +153,13 @@ void UsageTracker::GetHostUsageWithBreakdown(
       base::BindOnce(&UsageTracker::FinallySendHostUsageWithBreakdown,
                      weak_factory_.GetWeakPtr(), base::Owned(info), host));
 
-  for (const auto& client_type_and_tracker : client_tracker_map_) {
-    client_type_and_tracker.second->GetHostUsage(
-        host, base::BindOnce(&UsageTracker::AccumulateClientHostUsage,
-                             weak_factory_.GetWeakPtr(), barrier, info, host,
-                             client_type_and_tracker.first));
+  for (const auto& client_type_and_trackers : client_tracker_map_) {
+    for (const auto& client_tracker : client_type_and_trackers.second) {
+      client_tracker->GetHostUsage(
+          host, base::BindOnce(&UsageTracker::AccumulateClientHostUsage,
+                               weak_factory_.GetWeakPtr(), barrier, info, host,
+                               client_type_and_trackers.first));
+    }
   }
 }
 
@@ -157,26 +168,30 @@ void UsageTracker::UpdateUsageCache(QuotaClientType client_type,
                                     int64_t delta) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(client_tracker_map_.count(client_type));
-  ClientUsageTracker* client_tracker = client_tracker_map_[client_type].get();
-  client_tracker->UpdateUsageCache(origin, delta);
+  for (const auto& client_tracker : client_tracker_map_[client_type])
+    client_tracker->UpdateUsageCache(origin, delta);
 }
 
 int64_t UsageTracker::GetCachedUsage() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   int64_t usage = 0;
-  for (const auto& client_type_and_tracker : client_tracker_map_)
-    usage += client_type_and_tracker.second->GetCachedUsage();
+  for (const auto& client_type_and_trackers : client_tracker_map_) {
+    for (const auto& client_tracker : client_type_and_trackers.second)
+      usage += client_tracker->GetCachedUsage();
+  }
   return usage;
 }
 
 std::map<std::string, int64_t> UsageTracker::GetCachedHostsUsage() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   std::map<std::string, int64_t> host_usage;
-  for (const auto& client_type_and_tracker : client_tracker_map_) {
-    std::map<std::string, int64_t> client_host_usage =
-        client_type_and_tracker.second->GetCachedHostsUsage();
-    for (const auto& host_and_usage : client_host_usage)
-      host_usage[host_and_usage.first] += host_and_usage.second;
+  for (const auto& client_type_and_trackers : client_tracker_map_) {
+    for (const auto& client_tracker : client_type_and_trackers.second) {
+      std::map<std::string, int64_t> client_host_usage =
+          client_tracker->GetCachedHostsUsage();
+      for (const auto& host_and_usage : client_host_usage)
+        host_usage[host_and_usage.first] += host_and_usage.second;
+    }
   }
   return host_usage;
 }
@@ -184,11 +199,13 @@ std::map<std::string, int64_t> UsageTracker::GetCachedHostsUsage() const {
 std::map<url::Origin, int64_t> UsageTracker::GetCachedOriginsUsage() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   std::map<url::Origin, int64_t> origin_usage;
-  for (const auto& client_type_and_tracker : client_tracker_map_) {
-    std::map<url::Origin, int64_t> client_origin_usage =
-        client_type_and_tracker.second->GetCachedOriginsUsage();
-    for (const auto& origin_and_usage : client_origin_usage)
-      origin_usage[origin_and_usage.first] += origin_and_usage.second;
+  for (const auto& client_type_and_trackers : client_tracker_map_) {
+    for (const auto& client_tracker : client_type_and_trackers.second) {
+      std::map<url::Origin, int64_t> client_origin_usage =
+          client_tracker->GetCachedOriginsUsage();
+      for (const auto& origin_and_usage : client_origin_usage)
+        origin_usage[origin_and_usage.first] += origin_and_usage.second;
+    }
   }
   return origin_usage;
 }
@@ -196,11 +213,12 @@ std::map<url::Origin, int64_t> UsageTracker::GetCachedOriginsUsage() const {
 std::set<url::Origin> UsageTracker::GetCachedOrigins() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   std::set<url::Origin> origins;
-  for (const auto& client_type_and_tracker : client_tracker_map_) {
-    std::set<url::Origin> client_origins =
-        client_type_and_tracker.second->GetCachedOrigins();
-    for (const auto& client_origin : client_origins)
-      origins.insert(client_origin);
+  for (const auto& client_type_and_trackers : client_tracker_map_) {
+    for (const auto& client_tracker : client_type_and_trackers.second) {
+      std::set<url::Origin> client_origins = client_tracker->GetCachedOrigins();
+      for (const auto& client_origin : client_origins)
+        origins.insert(client_origin);
+    }
   }
   return origins;
 }
@@ -210,9 +228,8 @@ void UsageTracker::SetUsageCacheEnabled(QuotaClientType client_type,
                                         bool enabled) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(client_tracker_map_.count(client_type));
-  ClientUsageTracker* client_tracker = client_tracker_map_[client_type].get();
-
-  client_tracker->SetUsageCacheEnabled(origin, enabled);
+  for (const auto& client_tracker : client_tracker_map_[client_type])
+    client_tracker->SetUsageCacheEnabled(origin, enabled);
 }
 
 void UsageTracker::AccumulateClientGlobalLimitedUsage(AccumulateInfo* info,
diff --git a/chromium/storage/browser/quota/usage_tracker.h b/chromium/storage/browser/quota/usage_tracker.h
index dc5446f9eab..aae13835c90 100644
--- a/chromium/storage/browser/quota/usage_tracker.h
+++ b/chromium/storage/browser/quota/usage_tracker.h
@@ -15,10 +15,12 @@
 
 #include "base/callback.h"
 #include "base/component_export.h"
+#include "base/containers/flat_map.h"
 #include "base/macros.h"
 #include "base/sequence_checker.h"
 #include "storage/browser/quota/quota_callbacks.h"
 #include "storage/browser/quota/quota_client.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "storage/browser/quota/quota_task.h"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
@@ -38,9 +40,10 @@ class ClientUsageTracker;
 class COMPONENT_EXPORT(STORAGE_BROWSER) UsageTracker
     : public QuotaTaskObserver {
  public:
-  UsageTracker(const std::vector<scoped_refptr<QuotaClient>>& clients,
-               blink::mojom::StorageType type,
-               SpecialStoragePolicy* special_storage_policy);
+  UsageTracker(
+      const base::flat_map<QuotaClient*, QuotaClientType>& client_types,
+      blink::mojom::StorageType type,
+      SpecialStoragePolicy* special_storage_policy);
   ~UsageTracker() override;
 
   blink::mojom::StorageType type() const {
@@ -87,8 +90,10 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) UsageTracker
                                          const std::string& host);
 
   const blink::mojom::StorageType type_;
-  std::map<QuotaClientType, std::unique_ptr<ClientUsageTracker>>
+  base::flat_map<QuotaClientType,
+                 std::vector<std::unique_ptr<ClientUsageTracker>>>
       client_tracker_map_;
+  size_t client_count_;
 
   std::vector<UsageCallback> global_limited_usage_callbacks_;
   std::vector<GlobalUsageCallback> global_usage_callbacks_;
diff --git a/chromium/storage/browser/quota/usage_tracker_unittest.cc b/chromium/storage/browser/quota/usage_tracker_unittest.cc
index 1b07b48c97b..d734070963d 100644
--- a/chromium/storage/browser/quota/usage_tracker_unittest.cc
+++ b/chromium/storage/browser/quota/usage_tracker_unittest.cc
@@ -48,8 +48,6 @@ class UsageTrackerTestQuotaClient : public QuotaClient {
  public:
   UsageTrackerTestQuotaClient() = default;
 
-  QuotaClientType type() const override { return QuotaClientType::kFileSystem; }
-
   void OnQuotaManagerDestroyed() override {}
 
   void GetOriginUsage(const url::Origin& origin,
@@ -98,10 +96,6 @@ class UsageTrackerTestQuotaClient : public QuotaClient {
     std::move(callback).Run();
   }
 
-  bool DoesSupport(StorageType type) const override {
-    return type == StorageType::kTemporary;
-  }
-
   int64_t GetUsage(const url::Origin& origin) {
     auto found = origin_usage_map_.find(origin);
     if (found == origin_usage_map_.end())
@@ -132,7 +126,7 @@ class UsageTrackerTest : public testing::Test {
   UsageTrackerTest()
       : storage_policy_(new MockSpecialStoragePolicy()),
         quota_client_(base::MakeRefCounted<UsageTrackerTestQuotaClient>()),
-        usage_tracker_(GetUsageTrackerList(),
+        usage_tracker_(GetQuotaClientMap(),
                        StorageType::kTemporary,
                        storage_policy_.get()) {}
 
@@ -156,7 +150,8 @@ class UsageTrackerTest : public testing::Test {
 
   void UpdateUsage(const url::Origin& origin, int64_t delta) {
     quota_client_->UpdateUsage(origin, delta);
-    usage_tracker_.UpdateUsageCache(quota_client_->type(), origin, delta);
+    usage_tracker_.UpdateUsageCache(QuotaClientType::kFileSystem, origin,
+                                    delta);
     base::RunLoop().RunUntilIdle();
   }
 
@@ -223,14 +218,16 @@ class UsageTrackerTest : public testing::Test {
   }
 
   void SetUsageCacheEnabled(const url::Origin& origin, bool enabled) {
-    usage_tracker_.SetUsageCacheEnabled(quota_client_->type(), origin, enabled);
+    usage_tracker_.SetUsageCacheEnabled(QuotaClientType::kFileSystem, origin,
+                                        enabled);
   }
 
  private:
-  std::vector<scoped_refptr<QuotaClient>> GetUsageTrackerList() {
-    std::vector<scoped_refptr<QuotaClient>> client_list;
-    client_list.push_back(quota_client_);
-    return client_list;
+  base::flat_map<QuotaClient*, QuotaClientType> GetQuotaClientMap() {
+    base::flat_map<QuotaClient*, QuotaClientType> client_map;
+    client_map.insert(
+        std::make_pair(quota_client_.get(), QuotaClientType::kFileSystem));
+    return client_map;
   }
 
   base::test::TaskEnvironment task_environment_;