BASELINE: Update Chromium to 84.0.4147.141

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

59 files changed, 1048 insertions, 1073 deletions

diff --git a/chromium/storage/browser/BUILD.gn b/chromium/storage/browser/BUILD.gn
index 07a8634218a..4a47ff31e64 100644
--- a/chromium/storage/browser/BUILD.gn
+++ b/chromium/storage/browser/BUILD.gn
@@ -195,6 +195,8 @@ jumbo_component("browser") {
     "quota/padding_key.h",
     "quota/quota_callbacks.h",
     "quota/quota_client.h",
+    "quota/quota_client_type.cc",
+    "quota/quota_client_type.h",
     "quota/quota_database.cc",
     "quota/quota_database.h",
     "quota/quota_device_info_helper.cc",
@@ -363,14 +365,14 @@ jumbo_static_library("test_support") {
     "test/mock_file_change_observer.h",
     "test/mock_file_update_observer.cc",
     "test/mock_file_update_observer.h",
+    "test/mock_quota_client.cc",
+    "test/mock_quota_client.h",
     "test/mock_quota_manager.cc",
     "test/mock_quota_manager.h",
     "test/mock_quota_manager_proxy.cc",
     "test/mock_quota_manager_proxy.h",
     "test/mock_special_storage_policy.cc",
     "test/mock_special_storage_policy.h",
-    "test/mock_storage_client.cc",
-    "test/mock_storage_client.h",
     "test/sandbox_database_test_helper.cc",
     "test/sandbox_database_test_helper.h",
     "test/sandbox_file_system_test_helper.cc",
diff --git a/chromium/storage/browser/blob/blob_data_builder_unittest.cc b/chromium/storage/browser/blob/blob_data_builder_unittest.cc
index 3beeef7a217..ea1bb06946c 100644
--- a/chromium/storage/browser/blob/blob_data_builder_unittest.cc
+++ b/chromium/storage/browser/blob/blob_data_builder_unittest.cc
@@ -6,7 +6,6 @@
 
 #include <string>
 
-#include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace storage {
diff --git a/chromium/storage/browser/blob/blob_data_handle.cc b/chromium/storage/browser/blob/blob_data_handle.cc
index 2dc1699de71..8252545442a 100644
--- a/chromium/storage/browser/blob/blob_data_handle.cc
+++ b/chromium/storage/browser/blob/blob_data_handle.cc
@@ -10,8 +10,8 @@
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/check.h"
 #include "base/location.h"
-#include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
diff --git a/chromium/storage/browser/blob/blob_data_item.cc b/chromium/storage/browser/blob/blob_data_item.cc
index 291ca759405..f5e06824930 100644
--- a/chromium/storage/browser/blob/blob_data_item.cc
+++ b/chromium/storage/browser/blob/blob_data_item.cc
@@ -54,17 +54,6 @@ class MojoDataItem : public BlobDataItem::DataHandle {
     *os << "<MojoDataItem>";
   }
 
-  const char* BytesReadHistogramLabel() const override {
-    switch (item_->type) {
-      case mojom::BlobDataItemType::kUnknown:
-        return nullptr;
-      case mojom::BlobDataItemType::kCacheStorage:
-        return "DiskCache.CacheStorage";
-      case mojom::BlobDataItemType::kIndexedDB:
-        return "IndexedDB";
-    }
-  }
-
  protected:
   ~MojoDataItem() override = default;
 
diff --git a/chromium/storage/browser/blob/blob_data_item.h b/chromium/storage/browser/blob/blob_data_item.h
index 0468984756f..9ec2e5a9ae0 100644
--- a/chromium/storage/browser/blob/blob_data_item.h
+++ b/chromium/storage/browser/blob/blob_data_item.h
@@ -71,10 +71,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) BlobDataItem
     // Print a description of the readable DataHandle for debugging.
     virtual void PrintTo(::std::ostream* os) const = 0;
 
-    // Return the histogram label to use when calling RecordBytesRead().  If
-    // nullptr is returned then nothing will be recorded.
-    virtual const char* BytesReadHistogramLabel() const = 0;
-
    protected:
     virtual ~DataHandle();
 
diff --git a/chromium/storage/browser/blob/blob_reader.cc b/chromium/storage/browser/blob/blob_reader.cc
index 51538da2237..8bed5a695b5 100644
--- a/chromium/storage/browser/blob/blob_reader.cc
+++ b/chromium/storage/browser/blob/blob_reader.cc
@@ -26,7 +26,6 @@
 #include "storage/browser/file_system/file_stream_reader.h"
 #include "storage/browser/file_system/file_system_context.h"
 #include "storage/browser/file_system/file_system_url.h"
-#include "storage/common/storage_histograms.h"
 #include "third_party/blink/public/common/blob/blob_utils.h"
 
 namespace storage {
@@ -826,9 +825,6 @@ void BlobReader::RecordBytesReadFromDataHandle(int item_index, int result) {
   const auto& items = blob_data_->items();
   BlobDataItem& item = *items.at(item_index);
   DCHECK_EQ(item.type(), BlobDataItem::Type::kReadableDataHandle);
-  if (item.data_handle()->BytesReadHistogramLabel()) {
-    RecordBytesRead(item.data_handle()->BytesReadHistogramLabel(), result);
-  }
 }
 
 }  // namespace storage
diff --git a/chromium/storage/browser/blob/blob_storage_constants.cc b/chromium/storage/browser/blob/blob_storage_constants.cc
index 4348e72ace4..96143d9b4f9 100644
--- a/chromium/storage/browser/blob/blob_storage_constants.cc
+++ b/chromium/storage/browser/blob/blob_storage_constants.cc
@@ -4,8 +4,8 @@
 
 #include "storage/browser/blob/blob_storage_constants.h"
 
+#include "base/check.h"
 #include "base/command_line.h"
-#include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 
 namespace storage {
diff --git a/chromium/storage/browser/blob/blob_storage_context_mojo_unittest.cc b/chromium/storage/browser/blob/blob_storage_context_mojo_unittest.cc
index 72047c0ef8a..adb36e3e85d 100644
--- a/chromium/storage/browser/blob/blob_storage_context_mojo_unittest.cc
+++ b/chromium/storage/browser/blob/blob_storage_context_mojo_unittest.cc
@@ -122,9 +122,7 @@ class BlobStorageContextMojoTest : public testing::Test {
                   std::string data,
                   base::Optional<base::Time> modification_time) {
     base::ScopedAllowBlockingForTesting allow_blocking;
-    int size = base::WriteFile(path, data.data(), data.size());
-    ASSERT_GE(size, 0);
-    EXPECT_EQ(size, static_cast<int>(data.size()));
+    EXPECT_TRUE(base::WriteFile(path, data));
     if (modification_time) {
       ASSERT_TRUE(base::TouchFile(path, modification_time.value(),
                                   modification_time.value()));
diff --git a/chromium/storage/browser/blob/blob_storage_registry.cc b/chromium/storage/browser/blob/blob_storage_registry.cc
index b282a4393c0..989ac9fb177 100644
--- a/chromium/storage/browser/blob/blob_storage_registry.cc
+++ b/chromium/storage/browser/blob/blob_storage_registry.cc
@@ -9,8 +9,8 @@
 #include <memory>
 
 #include "base/bind.h"
+#include "base/check.h"
 #include "base/location.h"
-#include "base/logging.h"
 #include "storage/browser/blob/blob_entry.h"
 #include "storage/browser/blob/blob_url_utils.h"
 #include "url/gurl.h"
diff --git a/chromium/storage/browser/blob/blob_url_loader.cc b/chromium/storage/browser/blob/blob_url_loader.cc
index 1330ca744a8..a2e31303d90 100644
--- a/chromium/storage/browser/blob/blob_url_loader.cc
+++ b/chromium/storage/browser/blob/blob_url_loader.cc
@@ -7,11 +7,12 @@
 #include <stddef.h>
 #include <utility>
 #include "base/bind.h"
+#include "base/check_op.h"
 #include "base/format_macros.h"
-#include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram_functions.h"
+#include "base/notreached.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ -45,34 +46,30 @@ scoped_refptr<net::HttpResponseHeaders> GenerateHeaders(
   status.append(net::GetHttpReasonPhrase(status_code));
   status.append("\0\0", 2);
   scoped_refptr<net::HttpResponseHeaders> headers =
-      new net::HttpResponseHeaders(status);
+      base::MakeRefCounted<net::HttpResponseHeaders>(status);
 
   if (status_code == net::HTTP_OK || status_code == net::HTTP_PARTIAL_CONTENT) {
-    std::string content_length_header(net::HttpRequestHeaders::kContentLength);
-    content_length_header.append(": ");
-    content_length_header.append(base::NumberToString(content_size));
-    headers->AddHeader(content_length_header);
+    headers->SetHeader(net::HttpRequestHeaders::kContentLength,
+                       base::NumberToString(content_size));
     if (status_code == net::HTTP_PARTIAL_CONTENT) {
       DCHECK(byte_range->IsValid());
-      std::string content_range_header(net::HttpResponseHeaders::kContentRange);
-      content_range_header.append(": bytes ");
+      std::string content_range_header;
+      content_range_header.append("bytes ");
       content_range_header.append(base::StringPrintf(
           "%" PRId64 "-%" PRId64, byte_range->first_byte_position(),
           byte_range->last_byte_position()));
       content_range_header.append("/");
       content_range_header.append(base::StringPrintf("%" PRId64, total_size));
-      headers->AddHeader(content_range_header);
+      headers->SetHeader(net::HttpResponseHeaders::kContentRange,
+                         content_range_header);
     }
     if (!blob_handle->content_type().empty()) {
-      std::string content_type_header(net::HttpRequestHeaders::kContentType);
-      content_type_header.append(": ");
-      content_type_header.append(blob_handle->content_type());
-      headers->AddHeader(content_type_header);
+      headers->SetHeader(net::HttpRequestHeaders::kContentType,
+                         blob_handle->content_type());
     }
     if (!blob_handle->content_disposition().empty()) {
-      std::string content_disposition_header("Content-Disposition: ");
-      content_disposition_header.append(blob_handle->content_disposition());
-      headers->AddHeader(content_disposition_header);
+      headers->SetHeader("Content-Disposition",
+                         blob_handle->content_disposition());
     }
   }
 
@@ -162,6 +159,7 @@ void BlobURLLoader::Start(const network::ResourceRequest& request) {
 void BlobURLLoader::FollowRedirect(
     const std::vector<std::string>& removed_headers,
     const net::HttpRequestHeaders& modified_headers,
+    const net::HttpRequestHeaders& modified_cors_exempt_headers,
     const base::Optional<GURL>& new_url) {
   NOTREACHED();
 }
diff --git a/chromium/storage/browser/blob/blob_url_loader.h b/chromium/storage/browser/blob/blob_url_loader.h
index 0b252d0c34a..c3d4a0993e7 100644
--- a/chromium/storage/browser/blob/blob_url_loader.h
+++ b/chromium/storage/browser/blob/blob_url_loader.h
@@ -48,9 +48,11 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) BlobURLLoader
   void Start(const network::ResourceRequest& request);
 
   // network::mojom::URLLoader implementation:
-  void FollowRedirect(const std::vector<std::string>& removed_headers,
-                      const net::HttpRequestHeaders& modified_request_headers,
-                      const base::Optional<GURL>& new_url) override;
+  void FollowRedirect(
+      const std::vector<std::string>& removed_headers,
+      const net::HttpRequestHeaders& modified_request_headers,
+      const net::HttpRequestHeaders& modified_cors_exempt_request_headers,
+      const base::Optional<GURL>& new_url) override;
   void SetPriority(net::RequestPriority priority,
                    int32_t intra_priority_value) override {}
   void PauseReadingBodyFromNet() override {}
diff --git a/chromium/storage/browser/blob/view_blob_internals_job.cc b/chromium/storage/browser/blob/view_blob_internals_job.cc
index 5c4efbb1e99..67ab95b5fe5 100644
--- a/chromium/storage/browser/blob/view_blob_internals_job.cc
+++ b/chromium/storage/browser/blob/view_blob_internals_job.cc
@@ -14,7 +14,7 @@
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/time_formatting.h"
 #include "base/location.h"
-#include "base/logging.h"
+#include "base/notreached.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
diff --git a/chromium/storage/browser/database/database_quota_client.cc b/chromium/storage/browser/database/database_quota_client.cc
index 74bd2ec8a42..3d2cd6d6436 100644
--- a/chromium/storage/browser/database/database_quota_client.cc
+++ b/chromium/storage/browser/database/database_quota_client.cc
@@ -21,6 +21,7 @@
 #include "net/base/url_util.h"
 #include "storage/browser/database/database_tracker.h"
 #include "storage/browser/database/database_util.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "storage/common/database/database_identifier.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
 
@@ -97,8 +98,8 @@ DatabaseQuotaClient::~DatabaseQuotaClient() {
   }
 }
 
-QuotaClient::ID DatabaseQuotaClient::id() const {
-  return kDatabase;
+storage::QuotaClientType DatabaseQuotaClient::type() const {
+  return storage::QuotaClientType::kDatabase;
 }
 
 void DatabaseQuotaClient::OnQuotaManagerDestroyed() {}
diff --git a/chromium/storage/browser/database/database_quota_client.h b/chromium/storage/browser/database/database_quota_client.h
index 79826702d57..12375de9b9e 100644
--- a/chromium/storage/browser/database/database_quota_client.h
+++ b/chromium/storage/browser/database/database_quota_client.h
@@ -13,6 +13,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "storage/browser/quota/quota_client.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
 #include "url/origin.h"
 
@@ -29,7 +30,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseQuotaClient
   explicit DatabaseQuotaClient(scoped_refptr<DatabaseTracker> tracker);
 
   // QuotaClient method overrides
-  ID id() const override;
+  storage::QuotaClientType type() const override;
   void OnQuotaManagerDestroyed() override;
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
diff --git a/chromium/storage/browser/database/database_quota_client_unittest.cc b/chromium/storage/browser/database/database_quota_client_unittest.cc
index 4e56e2fa59c..b14a36dbaf1 100644
--- a/chromium/storage/browser/database/database_quota_client_unittest.cc
+++ b/chromium/storage/browser/database/database_quota_client_unittest.cc
@@ -15,8 +15,9 @@
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/bind_test_util.h"
 #include "base/test/task_environment.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "net/base/completion_once_callback.h"
 #include "net/base/net_errors.h"
 #include "storage/browser/database/database_quota_client.h"
@@ -41,7 +42,6 @@ class MockDatabaseTracker : public DatabaseTracker {
       : DatabaseTracker(base::FilePath(), false, nullptr, nullptr),
         delete_called_count_(0),
         async_delete_(false) {
-    set_task_runner_for_testing(base::ThreadTaskRunnerHandle::Get());
   }
 
   bool GetOriginInfo(const std::string& origin_identifier,
@@ -71,7 +71,7 @@ class MockDatabaseTracker : public DatabaseTracker {
                           net::CompletionOnceCallback callback) override {
     ++delete_called_count_;
     if (async_delete()) {
-      base::ThreadTaskRunnerHandle::Get()->PostTask(
+      base::SequencedTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::BindOnce(&MockDatabaseTracker::AsyncDeleteDataForOrigin, this,
                          std::move(callback)));
@@ -136,10 +136,9 @@ class DatabaseQuotaClientTest : public testing::Test {
     usage_ = 0;
     client->GetOriginUsage(
         origin, type,
-        base::AdaptCallbackForRepeating(
-            base::BindOnce(&DatabaseQuotaClientTest::OnGetOriginUsageComplete,
-                           weak_factory_.GetWeakPtr())));
-    base::RunLoop().RunUntilIdle();
+        base::BindOnce(&DatabaseQuotaClientTest::OnGetOriginUsageComplete,
+                       weak_factory_.GetWeakPtr()));
+    task_environment_.RunUntilIdle();
     return usage_;
   }
 
@@ -148,10 +147,9 @@ class DatabaseQuotaClientTest : public testing::Test {
       blink::mojom::StorageType type) {
     origins_.clear();
     client->GetOriginsForType(
-        type, base::AdaptCallbackForRepeating(
-                  base::BindOnce(&DatabaseQuotaClientTest::OnGetOriginsComplete,
-                                 weak_factory_.GetWeakPtr())));
-    base::RunLoop().RunUntilIdle();
+        type, base::BindOnce(&DatabaseQuotaClientTest::OnGetOriginsComplete,
+                             weak_factory_.GetWeakPtr()));
+    task_environment_.RunUntilIdle();
     return origins_;
   }
 
@@ -162,10 +160,9 @@ class DatabaseQuotaClientTest : public testing::Test {
     origins_.clear();
     client->GetOriginsForHost(
         type, host,
-        base::AdaptCallbackForRepeating(
-            base::BindOnce(&DatabaseQuotaClientTest::OnGetOriginsComplete,
-                           weak_factory_.GetWeakPtr())));
-    base::RunLoop().RunUntilIdle();
+        base::BindOnce(&DatabaseQuotaClientTest::OnGetOriginsComplete,
+                       weak_factory_.GetWeakPtr()));
+    task_environment_.RunUntilIdle();
     return origins_;
   }
 
@@ -175,10 +172,9 @@ class DatabaseQuotaClientTest : public testing::Test {
     delete_status_ = blink::mojom::QuotaStatusCode::kUnknown;
     client->DeleteOriginData(
         origin, type,
-        base::AdaptCallbackForRepeating(
-            base::BindOnce(&DatabaseQuotaClientTest::OnDeleteOriginDataComplete,
-                           weak_factory_.GetWeakPtr())));
-    base::RunLoop().RunUntilIdle();
+        base::BindOnce(&DatabaseQuotaClientTest::OnDeleteOriginDataComplete,
+                       weak_factory_.GetWeakPtr()));
+    task_environment_.RunUntilIdle();
     return delete_status_ == blink::mojom::QuotaStatusCode::kOk;
   }
 
diff --git a/chromium/storage/browser/database/database_tracker.cc b/chromium/storage/browser/database/database_tracker.cc
index 41dc6c9ac18..ecc6a0d2b8e 100644
--- a/chromium/storage/browser/database/database_tracker.cc
+++ b/chromium/storage/browser/database/database_tracker.cc
@@ -33,8 +33,8 @@ namespace storage {
 
 const base::FilePath::CharType kDatabaseDirectoryName[] =
     FILE_PATH_LITERAL("databases");
-const base::FilePath::CharType kIncognitoDatabaseDirectoryName[] =
-    FILE_PATH_LITERAL("databases-incognito");
+const base::FilePath::CharType kOffTheRecordDatabaseDirectoryName[] =
+    FILE_PATH_LITERAL("databases-off-the-record");
 const base::FilePath::CharType kTrackerDatabaseFileName[] =
     FILE_PATH_LITERAL("Databases.db");
 static const int kDatabaseTrackerCurrentSchemaVersion = 2;
@@ -85,13 +85,13 @@ OriginInfo::OriginInfo(const std::string& origin_identifier, int64_t total_size)
     : origin_identifier_(origin_identifier), total_size_(total_size) {}
 
 DatabaseTracker::DatabaseTracker(const base::FilePath& profile_path,
-                                 bool is_incognito,
+                                 bool is_off_the_record,
                                  SpecialStoragePolicy* special_storage_policy,
                                  QuotaManagerProxy* quota_manager_proxy)
-    : is_incognito_(is_incognito),
+    : is_off_the_record_(is_off_the_record),
       profile_path_(profile_path),
-      db_dir_(is_incognito_
-                  ? profile_path_.Append(kIncognitoDatabaseDirectoryName)
+      db_dir_(is_off_the_record_
+                  ? profile_path_.Append(kOffTheRecordDatabaseDirectoryName)
                   : profile_path_.Append(kDatabaseDirectoryName)),
       db_(new sql::Database()),
       special_storage_policy_(special_storage_policy),
@@ -257,7 +257,7 @@ void DatabaseTracker::CloseTrackerDatabaseAndClearCaches() {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   ClearAllCachedOriginInfo();
 
-  if (!is_incognito_) {
+  if (!is_off_the_record_) {
     meta_table_.reset(nullptr);
     databases_table_.reset(nullptr);
     db_->Close();
@@ -271,16 +271,16 @@ base::FilePath DatabaseTracker::GetOriginDirectory(
 
   base::string16 origin_directory;
 
-  if (!is_incognito_) {
+  if (!is_off_the_record_) {
     origin_directory = base::UTF8ToUTF16(origin_identifier);
   } else {
-    auto it = incognito_origin_directories_.find(origin_identifier);
-    if (it != incognito_origin_directories_.end()) {
+    auto it = off_the_record_origin_directories_.find(origin_identifier);
+    if (it != off_the_record_origin_directories_.end()) {
       origin_directory = it->second;
     } else {
-      origin_directory =
-          base::NumberToString16(incognito_origin_directories_generator_++);
-      incognito_origin_directories_[origin_identifier] = origin_directory;
+      origin_directory = base::NumberToString16(
+          off_the_record_origin_directories_generator_++);
+      off_the_record_origin_directories_[origin_identifier] = origin_directory;
     }
   }
 
@@ -370,7 +370,7 @@ bool DatabaseTracker::DeleteClosedDatabase(
 
   if (quota_manager_proxy_.get() && db_file_size)
     quota_manager_proxy_->NotifyStorageModified(
-        QuotaClient::kDatabase, GetOriginFromIdentifier(origin_identifier),
+        QuotaClientType::kDatabase, GetOriginFromIdentifier(origin_identifier),
         blink::mojom::StorageType::kTemporary, -db_file_size);
 
   // Clean up the main database and invalidate the cached record.
@@ -425,18 +425,18 @@ bool DatabaseTracker::DeleteOrigin(const std::string& origin_identifier,
   base::DeleteFileRecursively(origin_dir);
   base::DeleteFileRecursively(new_origin_dir);  // Might fail on windows.
 
-  if (is_incognito_) {
-    incognito_origin_directories_.erase(origin_identifier);
+  if (is_off_the_record_) {
+    off_the_record_origin_directories_.erase(origin_identifier);
 
     // TODO(jsbell): Consider alternate data structures to avoid this
     // linear scan.
-    for (auto it = incognito_file_handles_.begin();
-         it != incognito_file_handles_.end();) {
+    for (auto it = off_the_record_file_handles_.begin();
+         it != off_the_record_file_handles_.end();) {
       std::string id;
       if (DatabaseUtil::CrackVfsFileName(it->first, &id, nullptr, nullptr) &&
           id == origin_identifier) {
         delete it->second;
-        it = incognito_file_handles_.erase(it);
+        it = off_the_record_file_handles_.erase(it);
       } else {
         ++it;
       }
@@ -447,7 +447,7 @@ bool DatabaseTracker::DeleteOrigin(const std::string& origin_identifier,
 
   if (quota_manager_proxy_.get() && deleted_size) {
     quota_manager_proxy_->NotifyStorageModified(
-        QuotaClient::kDatabase, GetOriginFromIdentifier(origin_identifier),
+        QuotaClientType::kDatabase, GetOriginFromIdentifier(origin_identifier),
         blink::mojom::StorageType::kTemporary, -deleted_size);
   }
 
@@ -508,8 +508,8 @@ bool DatabaseTracker::LazyInit() {
     is_initialized_ =
         base::CreateDirectory(db_dir_) &&
         (db_->is_open() ||
-         (is_incognito_ ? db_->OpenInMemory() :
-          db_->Open(kTrackerDatabaseFullPath))) &&
+         (is_off_the_record_ ? db_->OpenInMemory()
+                             : db_->Open(kTrackerDatabaseFullPath))) &&
         UpgradeToCurrentVersion();
     if (!is_initialized_) {
       databases_table_.reset(nullptr);
@@ -654,7 +654,7 @@ int64_t DatabaseTracker::UpdateOpenDatabaseInfoAndNotify(
       info->SetDatabaseSize(name, new_size);
     if (quota_manager_proxy_.get())
       quota_manager_proxy_->NotifyStorageModified(
-          QuotaClient::kDatabase, GetOriginFromIdentifier(origin_id),
+          QuotaClientType::kDatabase, GetOriginFromIdentifier(origin_id),
           blink::mojom::StorageType::kTemporary, new_size - old_size);
     for (auto& observer : observers_)
       observer.OnDatabaseSizeChanged(origin_id, name, new_size);
@@ -786,64 +786,64 @@ int DatabaseTracker::DeleteDataForOrigin(const url::Origin& origin,
   return net::OK;
 }
 
-const base::File* DatabaseTracker::GetIncognitoFile(
+const base::File* DatabaseTracker::GetOffTheRecordFile(
     const base::string16& vfs_file_name) const {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(is_incognito_);
-  auto it = incognito_file_handles_.find(vfs_file_name);
-  if (it != incognito_file_handles_.end())
+  DCHECK(is_off_the_record_);
+  auto it = off_the_record_file_handles_.find(vfs_file_name);
+  if (it != off_the_record_file_handles_.end())
     return it->second;
 
   return nullptr;
 }
 
-const base::File* DatabaseTracker::SaveIncognitoFile(
+const base::File* DatabaseTracker::SaveOffTheRecordFile(
     const base::string16& vfs_file_name,
     base::File file) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(is_incognito_);
+  DCHECK(is_off_the_record_);
   if (!file.IsValid())
     return nullptr;
 
   base::File* to_insert = new base::File(std::move(file));
-  auto rv =
-      incognito_file_handles_.insert(std::make_pair(vfs_file_name, to_insert));
+  auto rv = off_the_record_file_handles_.insert(
+      std::make_pair(vfs_file_name, to_insert));
   DCHECK(rv.second);
   return rv.first->second;
 }
 
-void DatabaseTracker::CloseIncognitoFileHandle(
+void DatabaseTracker::CloseOffTheRecordFileHandle(
     const base::string16& vfs_file_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(is_incognito_);
-  DCHECK(incognito_file_handles_.find(vfs_file_name) !=
-         incognito_file_handles_.end());
+  DCHECK(is_off_the_record_);
+  DCHECK(off_the_record_file_handles_.find(vfs_file_name) !=
+         off_the_record_file_handles_.end());
 
-  auto it = incognito_file_handles_.find(vfs_file_name);
-  if (it != incognito_file_handles_.end()) {
+  auto it = off_the_record_file_handles_.find(vfs_file_name);
+  if (it != off_the_record_file_handles_.end()) {
     delete it->second;
-    incognito_file_handles_.erase(it);
+    off_the_record_file_handles_.erase(it);
   }
 }
 
-bool DatabaseTracker::HasSavedIncognitoFileHandle(
+bool DatabaseTracker::HasSavedOffTheRecordFileHandle(
     const base::string16& vfs_file_name) const {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
-  return (incognito_file_handles_.find(vfs_file_name) !=
-          incognito_file_handles_.end());
+  return (off_the_record_file_handles_.find(vfs_file_name) !=
+          off_the_record_file_handles_.end());
 }
 
-void DatabaseTracker::DeleteIncognitoDBDirectory() {
+void DatabaseTracker::DeleteOffTheRecordDBDirectory() {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   is_initialized_ = false;
 
-  for (auto& pair : incognito_file_handles_)
+  for (auto& pair : off_the_record_file_handles_)
     delete pair.second;
 
-  base::FilePath incognito_db_dir =
-      profile_path_.Append(kIncognitoDatabaseDirectoryName);
-  if (base::DirectoryExists(incognito_db_dir))
-    base::DeleteFileRecursively(incognito_db_dir);
+  base::FilePath off_the_record_db_dir =
+      profile_path_.Append(kOffTheRecordDatabaseDirectoryName);
+  if (base::DirectoryExists(off_the_record_db_dir))
+    base::DeleteFileRecursively(off_the_record_db_dir);
 }
 
 void DatabaseTracker::ClearSessionOnlyOrigins() {
@@ -891,8 +891,8 @@ void DatabaseTracker::Shutdown() {
     return;
   }
   shutting_down_ = true;
-  if (is_incognito_)
-    DeleteIncognitoDBDirectory();
+  if (is_off_the_record_)
+    DeleteOffTheRecordDBDirectory();
   else if (!force_keep_session_state_)
     ClearSessionOnlyOrigins();
   CloseTrackerDatabaseAndClearCaches();
diff --git a/chromium/storage/browser/database/database_tracker.h b/chromium/storage/browser/database/database_tracker.h
index 19517385d63..1898fac9d34 100644
--- a/chromium/storage/browser/database/database_tracker.h
+++ b/chromium/storage/browser/database/database_tracker.h
@@ -98,7 +98,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   };
 
   DatabaseTracker(const base::FilePath& profile_path,
-                  bool is_incognito,
+                  bool is_off_the_record,
                   SpecialStoragePolicy* special_storage_policy,
                   QuotaManagerProxy* quota_manager_proxy);
 
@@ -164,28 +164,24 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   virtual int DeleteDataForOrigin(const url::Origin& origin,
                                   net::CompletionOnceCallback callback);
 
-  bool IsIncognitoProfile() const { return is_incognito_; }
+  bool IsOffTheRecordProfile() const { return is_off_the_record_; }
 
-  const base::File* GetIncognitoFile(const base::string16& vfs_file_path) const;
-  const base::File* SaveIncognitoFile(const base::string16& vfs_file_path,
-                                      base::File file);
-  void CloseIncognitoFileHandle(const base::string16& vfs_file_path);
-  bool HasSavedIncognitoFileHandle(const base::string16& vfs_file_path) const;
+  const base::File* GetOffTheRecordFile(
+      const base::string16& vfs_file_path) const;
+  const base::File* SaveOffTheRecordFile(const base::string16& vfs_file_path,
+                                         base::File file);
+  void CloseOffTheRecordFileHandle(const base::string16& vfs_file_path);
+  bool HasSavedOffTheRecordFileHandle(
+      const base::string16& vfs_file_path) const;
 
   // Shutdown the database tracker, deleting database files if the tracker is
-  // used for an incognito profile.
+  // used for an OffTheRecord profile.
   void Shutdown();
   // Disables the exit-time deletion of session-only data.
   void SetForceKeepSessionState();
 
   base::SequencedTaskRunner* task_runner() const { return task_runner_.get(); }
 
-  // TODO(jsbell): Remove this; tests should use the normal task runner.
-  void set_task_runner_for_testing(
-      scoped_refptr<base::SequencedTaskRunner> task_runner) {
-    task_runner_ = std::move(task_runner);
-  }
-
  private:
   friend class base::RefCountedThreadSafe<DatabaseTracker>;
   friend class DatabaseTracker_TestHelper_Test;
@@ -223,8 +219,9 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   // virtual for unit-testing only.
   virtual ~DatabaseTracker();
 
-  // Deletes the directory that stores all DBs in incognito mode, if it exists.
-  void DeleteIncognitoDBDirectory();
+  // Deletes the directory that stores all DBs in OffTheRecord mode, if it
+  // exists.
+  void DeleteOffTheRecordDBDirectory();
 
   // Deletes session-only databases. Blocks databases from being created/opened.
   void ClearSessionOnlyOrigins();
@@ -282,7 +279,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   base::FilePath GetOriginDirectory(const std::string& origin_identifier);
 
   bool is_initialized_ = false;
-  const bool is_incognito_;
+  const bool is_off_the_record_;
   bool force_keep_session_state_ = false;
   bool shutting_down_ = false;
   const base::FilePath profile_path_;
@@ -315,19 +312,20 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   // The database tracker thread we're supposed to run file IO on.
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
-  // When in incognito mode, store a DELETE_ON_CLOSE handle to each
-  // main DB and journal file that was accessed. When the incognito profile
+  // When in OffTheRecord mode, store a DELETE_ON_CLOSE handle to each
+  // main DB and journal file that was accessed. When the OffTheRecord profile
   // goes away (or when the browser crashes), all these handles will be
   // closed, and the files will be deleted.
-  std::map<base::string16, base::File*> incognito_file_handles_;
-
-  // In a non-incognito profile, all DBs in an origin are stored in a directory
-  // named after the origin. In an incognito profile though, we do not want the
-  // directory structure to reveal the origins visited by the user (in case the
-  // browser process crashes and those directories are not deleted). So we use
-  // this map to assign directory names that do not reveal this information.
-  std::map<std::string, base::string16> incognito_origin_directories_;
-  int incognito_origin_directories_generator_ = 0;
+  std::map<base::string16, base::File*> off_the_record_file_handles_;
+
+  // In a non-OffTheRecord profile, all DBs in an origin are stored in a
+  // directory named after the origin. In an OffTheRecord profile though, we do
+  // not want the directory structure to reveal the origins visited by the user
+  // (in case the browser process crashes and those directories are not
+  // deleted). So we use this map to assign directory names that do not reveal
+  // this information.
+  std::map<std::string, base::string16> off_the_record_origin_directories_;
+  int off_the_record_origin_directories_generator_ = 0;
 
   FRIEND_TEST_ALL_PREFIXES(DatabaseTracker, TestHelper);
 };
diff --git a/chromium/storage/browser/database/database_tracker_unittest.cc b/chromium/storage/browser/database/database_tracker_unittest.cc
index 4d73cd533d7..5293254e3fb 100644
--- a/chromium/storage/browser/database/database_tracker_unittest.cc
+++ b/chromium/storage/browser/database/database_tracker_unittest.cc
@@ -7,12 +7,15 @@
 
 #include <memory>
 
+#include "base/callback_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/bind_test_util.h"
 #include "base/test/task_environment.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/time/time.h"
@@ -108,11 +111,11 @@ class TestQuotaManagerProxy : public QuotaManagerProxy {
     accesses_[origin] += 1;
   }
 
-  void NotifyStorageModified(QuotaClient::ID client_id,
+  void NotifyStorageModified(QuotaClientType client_id,
                              const url::Origin& origin,
                              blink::mojom::StorageType type,
                              int64_t delta) override {
-    EXPECT_EQ(QuotaClient::kDatabase, client_id);
+    EXPECT_EQ(QuotaClientType::kDatabase, client_id);
     EXPECT_EQ(blink::mojom::StorageType::kTemporary, type);
     modifications_[origin].first += 1;
     modifications_[origin].second += delta;
@@ -121,7 +124,7 @@ class TestQuotaManagerProxy : public QuotaManagerProxy {
   // Not needed for our tests.
   void NotifyOriginInUse(const url::Origin& origin) override {}
   void NotifyOriginNoLongerInUse(const url::Origin& origin) override {}
-  void SetUsageCacheEnabled(QuotaClient::ID client_id,
+  void SetUsageCacheEnabled(QuotaClientType client_id,
                             const url::Origin& origin,
                             blink::mojom::StorageType type,
                             bool enabled) override {}
@@ -190,86 +193,107 @@ class DatabaseTracker_TestHelper_Test {
         base::MakeRefCounted<DatabaseTracker>(
             temp_dir.GetPath(), incognito_mode, special_storage_policy.get(),
             nullptr));
-    tracker->set_task_runner_for_testing(
-        base::SequencedTaskRunnerHandle::Get());
 
-    // Create and open three databases.
-    int64_t database_size = 0;
-    const std::string kOrigin1 = GetIdentifierFromOrigin(GURL(kOrigin1Url));
-    const std::string kOrigin2 = GetIdentifierFromOrigin(GURL(kOrigin2Url));
-    const base::string16 kDB1 = ASCIIToUTF16("db1");
-    const base::string16 kDB2 = ASCIIToUTF16("db2");
-    const base::string16 kDB3 = ASCIIToUTF16("db3");
-    const base::string16 kDescription = ASCIIToUTF16("database_description");
-
-    tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, &database_size);
-    tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0, &database_size);
-    tracker->DatabaseOpened(kOrigin2, kDB3, kDescription, 0, &database_size);
-
-    EXPECT_TRUE(base::CreateDirectory(tracker->GetOriginDirectory(kOrigin1)));
-    EXPECT_TRUE(base::CreateDirectory(tracker->GetOriginDirectory(kOrigin2)));
-    EXPECT_EQ(
-        1, base::WriteFile(tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
-    EXPECT_EQ(2, base::WriteFile(tracker->GetFullDBFilePath(kOrigin2, kDB2),
-                                 "aa", 2));
-    EXPECT_EQ(3, base::WriteFile(tracker->GetFullDBFilePath(kOrigin2, kDB3),
-                                 "aaa", 3));
-    tracker->DatabaseModified(kOrigin1, kDB1);
-    tracker->DatabaseModified(kOrigin2, kDB2);
-    tracker->DatabaseModified(kOrigin2, kDB3);
-
-    // Delete db1. Should also delete origin1.
-    TestObserver observer;
-    tracker->AddObserver(&observer);
-    net::TestCompletionCallback callback1;
-    int result = tracker->DeleteDatabase(kOrigin1, kDB1, callback1.callback());
-    EXPECT_EQ(net::ERR_IO_PENDING, result);
-    ASSERT_FALSE(callback1.have_result());
-    EXPECT_TRUE(observer.DidReceiveNewNotification());
-    EXPECT_EQ(kOrigin1, observer.GetNotificationOriginIdentifier());
-    EXPECT_EQ(kDB1, observer.GetNotificationDatabaseName());
-    tracker->DatabaseClosed(kOrigin1, kDB1);
-    result = callback1.GetResult(result);
-    EXPECT_EQ(net::OK, result);
-    EXPECT_FALSE(base::PathExists(tracker->GetOriginDirectory(kOrigin1)));
-
-    // Recreate db1.
-    tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, &database_size);
-    EXPECT_TRUE(base::CreateDirectory(tracker->GetOriginDirectory(kOrigin1)));
-    EXPECT_EQ(
-        1, base::WriteFile(tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
-    tracker->DatabaseModified(kOrigin1, kDB1);
-
-    // Setup file modification times.  db1 and db2 are modified now, db3 three
-    // days ago.
-    base::Time now = base::Time::Now();
-    EXPECT_TRUE(
-        base::TouchFile(tracker->GetFullDBFilePath(kOrigin1, kDB1), now, now));
-    EXPECT_TRUE(
-        base::TouchFile(tracker->GetFullDBFilePath(kOrigin2, kDB2), now, now));
-    base::Time three_days_ago = now - base::TimeDelta::FromDays(3);
-    EXPECT_TRUE(base::TouchFile(tracker->GetFullDBFilePath(kOrigin2, kDB3),
-                                three_days_ago, three_days_ago));
-
-    // Delete databases modified since yesterday. db2 is whitelisted.
-    base::Time yesterday = base::Time::Now();
-    yesterday -= base::TimeDelta::FromDays(1);
-
-    net::TestCompletionCallback callback2;
-    result = tracker->DeleteDataModifiedSince(yesterday, callback2.callback());
-    EXPECT_EQ(net::ERR_IO_PENDING, result);
-    ASSERT_FALSE(callback2.have_result());
-    EXPECT_TRUE(observer.DidReceiveNewNotification());
-    tracker->DatabaseClosed(kOrigin1, kDB1);
-    tracker->DatabaseClosed(kOrigin2, kDB2);
-    result = callback2.GetResult(result);
-    EXPECT_EQ(net::OK, result);
-    EXPECT_FALSE(base::PathExists(tracker->GetOriginDirectory(kOrigin1)));
-    EXPECT_TRUE(base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
-    EXPECT_TRUE(base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
-
-    tracker->DatabaseClosed(kOrigin2, kDB3);
-    tracker->RemoveObserver(&observer);
+    base::RunLoop run_loop;
+    tracker->task_runner()->PostTask(
+        FROM_HERE, base::BindLambdaForTesting([&]() {
+          base::ScopedClosureRunner quit_runner(
+              base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
+
+          // Create and open three databases.
+          int64_t database_size = 0;
+          const std::string kOrigin1 =
+              GetIdentifierFromOrigin(GURL(kOrigin1Url));
+          const std::string kOrigin2 =
+              GetIdentifierFromOrigin(GURL(kOrigin2Url));
+          const base::string16 kDB1 = ASCIIToUTF16("db1");
+          const base::string16 kDB2 = ASCIIToUTF16("db2");
+          const base::string16 kDB3 = ASCIIToUTF16("db3");
+          const base::string16 kDescription =
+              ASCIIToUTF16("database_description");
+
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
+                                  &database_size);
+          tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
+                                  &database_size);
+          tracker->DatabaseOpened(kOrigin2, kDB3, kDescription, 0,
+                                  &database_size);
+
+          EXPECT_TRUE(
+              base::CreateDirectory(tracker->GetOriginDirectory(kOrigin1)));
+          EXPECT_TRUE(
+              base::CreateDirectory(tracker->GetOriginDirectory(kOrigin2)));
+          EXPECT_TRUE(
+              base::WriteFile(tracker->GetFullDBFilePath(kOrigin1, kDB1), "a"));
+          EXPECT_TRUE(base::WriteFile(
+              tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa"));
+          EXPECT_TRUE(base::WriteFile(
+              tracker->GetFullDBFilePath(kOrigin2, kDB3), "aaa"));
+          tracker->DatabaseModified(kOrigin1, kDB1);
+          tracker->DatabaseModified(kOrigin2, kDB2);
+          tracker->DatabaseModified(kOrigin2, kDB3);
+
+          // Delete db1. Should also delete origin1.
+          TestObserver observer;
+          tracker->AddObserver(&observer);
+          net::TestCompletionCallback callback1;
+          int result =
+              tracker->DeleteDatabase(kOrigin1, kDB1, callback1.callback());
+          EXPECT_EQ(net::ERR_IO_PENDING, result);
+          ASSERT_FALSE(callback1.have_result());
+          EXPECT_TRUE(observer.DidReceiveNewNotification());
+          EXPECT_EQ(kOrigin1, observer.GetNotificationOriginIdentifier());
+          EXPECT_EQ(kDB1, observer.GetNotificationDatabaseName());
+          tracker->DatabaseClosed(kOrigin1, kDB1);
+          result = callback1.GetResult(result);
+          EXPECT_EQ(net::OK, result);
+          EXPECT_FALSE(base::PathExists(tracker->GetOriginDirectory(kOrigin1)));
+
+          // Recreate db1.
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
+                                  &database_size);
+          EXPECT_TRUE(
+              base::CreateDirectory(tracker->GetOriginDirectory(kOrigin1)));
+          EXPECT_TRUE(
+              base::WriteFile(tracker->GetFullDBFilePath(kOrigin1, kDB1), "a"));
+          tracker->DatabaseModified(kOrigin1, kDB1);
+
+          // Setup file modification times.  db1 and db2 are modified now, db3
+          // three days ago.
+          base::Time now = base::Time::Now();
+          EXPECT_TRUE(base::TouchFile(
+              tracker->GetFullDBFilePath(kOrigin1, kDB1), now, now));
+          EXPECT_TRUE(base::TouchFile(
+              tracker->GetFullDBFilePath(kOrigin2, kDB2), now, now));
+          base::Time three_days_ago = now - base::TimeDelta::FromDays(3);
+          EXPECT_TRUE(
+              base::TouchFile(tracker->GetFullDBFilePath(kOrigin2, kDB3),
+                              three_days_ago, three_days_ago));
+
+          // Delete databases modified since yesterday. db2 is whitelisted.
+          base::Time yesterday = base::Time::Now();
+          yesterday -= base::TimeDelta::FromDays(1);
+
+          net::TestCompletionCallback callback2;
+          result =
+              tracker->DeleteDataModifiedSince(yesterday, callback2.callback());
+          EXPECT_EQ(net::ERR_IO_PENDING, result);
+          ASSERT_FALSE(callback2.have_result());
+          EXPECT_TRUE(observer.DidReceiveNewNotification());
+          tracker->DatabaseClosed(kOrigin1, kDB1);
+          tracker->DatabaseClosed(kOrigin2, kDB2);
+          result = callback2.GetResult(result);
+          EXPECT_EQ(net::OK, result);
+          EXPECT_FALSE(base::PathExists(tracker->GetOriginDirectory(kOrigin1)));
+          EXPECT_TRUE(
+              base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
+          EXPECT_TRUE(
+              base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
+
+          tracker->DatabaseClosed(kOrigin2, kDB3);
+          tracker->RemoveObserver(&observer);
+        }));
+    run_loop.Run();
   }
 
   static void TestDatabaseTracker(bool incognito_mode) {
@@ -284,127 +308,147 @@ class DatabaseTracker_TestHelper_Test {
         base::MakeRefCounted<DatabaseTracker>(
             temp_dir.GetPath(), incognito_mode, special_storage_policy.get(),
             nullptr));
-    tracker->set_task_runner_for_testing(
-        base::SequencedTaskRunnerHandle::Get());
-
-    // Add two observers.
-    TestObserver observer1;
-    TestObserver observer2;
-    tracker->AddObserver(&observer1);
-    tracker->AddObserver(&observer2);
-
-    // Open three new databases.
-    int64_t database_size = 0;
-    const std::string kOrigin1 = GetIdentifierFromOrigin(GURL(kOrigin1Url));
-    const std::string kOrigin2 = GetIdentifierFromOrigin(GURL(kOrigin2Url));
-    const base::string16 kDB1 = ASCIIToUTF16("db1");
-    const base::string16 kDB2 = ASCIIToUTF16("db2");
-    const base::string16 kDB3 = ASCIIToUTF16("db3");
-    const base::string16 kDescription = ASCIIToUTF16("database_description");
 
-    // Get the info for kOrigin1 and kOrigin2
-    DatabaseTracker::CachedOriginInfo* origin1_info =
-        tracker->GetCachedOriginInfo(kOrigin1);
-    DatabaseTracker::CachedOriginInfo* origin2_info =
-        tracker->GetCachedOriginInfo(kOrigin1);
-    EXPECT_TRUE(origin1_info);
-    EXPECT_TRUE(origin2_info);
-
-    tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, &database_size);
-    EXPECT_EQ(0, database_size);
-    tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0, &database_size);
-    EXPECT_EQ(0, database_size);
-    tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0, &database_size);
-    EXPECT_EQ(0, database_size);
-
-    // Write some data to each file and check that the listeners are
-    // called with the appropriate values.
-    EXPECT_TRUE(base::CreateDirectory(tracker->GetOriginDirectory(kOrigin1)));
-    EXPECT_TRUE(base::CreateDirectory(tracker->GetOriginDirectory(kOrigin2)));
-    EXPECT_EQ(
-        1, base::WriteFile(tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
-    EXPECT_EQ(2, base::WriteFile(tracker->GetFullDBFilePath(kOrigin2, kDB2),
-                                 "aa", 2));
-    EXPECT_EQ(4, base::WriteFile(tracker->GetFullDBFilePath(kOrigin1, kDB3),
-                                 "aaaa", 4));
-    tracker->DatabaseModified(kOrigin1, kDB1);
-    CheckNotificationReceived(&observer1, kOrigin1, kDB1, 1);
-    CheckNotificationReceived(&observer2, kOrigin1, kDB1, 1);
-    tracker->DatabaseModified(kOrigin2, kDB2);
-    CheckNotificationReceived(&observer1, kOrigin2, kDB2, 2);
-    CheckNotificationReceived(&observer2, kOrigin2, kDB2, 2);
-    tracker->DatabaseModified(kOrigin1, kDB3);
-    CheckNotificationReceived(&observer1, kOrigin1, kDB3, 4);
-    CheckNotificationReceived(&observer2, kOrigin1, kDB3, 4);
-
-    // Close all databases
-    tracker->DatabaseClosed(kOrigin1, kDB1);
-    tracker->DatabaseClosed(kOrigin2, kDB2);
-    tracker->DatabaseClosed(kOrigin1, kDB3);
-
-    // Open an existing database and check the reported size
-    tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, &database_size);
-    EXPECT_EQ(1, database_size);
-    tracker->DatabaseClosed(kOrigin1, kDB1);
-
-    // Remove an observer; this should clear all caches.
-    tracker->RemoveObserver(&observer2);
-
-    // Close the tracker database and clear all caches.
-    // Then make sure that DatabaseOpened() still returns the correct result.
-    tracker->CloseTrackerDatabaseAndClearCaches();
-    tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, &database_size);
-    EXPECT_EQ(1, database_size);
-    tracker->DatabaseClosed(kOrigin1, kDB1);
-
-    // Remove all observers.
-    tracker->RemoveObserver(&observer1);
-
-    // Trying to delete a database in use should fail
-    tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0, &database_size);
-    EXPECT_FALSE(tracker->DeleteClosedDatabase(kOrigin1, kDB3));
-    origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
-    EXPECT_TRUE(origin1_info);
-    EXPECT_EQ(4, origin1_info->GetDatabaseSize(kDB3));
-    tracker->DatabaseClosed(kOrigin1, kDB3);
-
-    // Delete a database and make sure the space used by that origin is updated
-    EXPECT_TRUE(tracker->DeleteClosedDatabase(kOrigin1, kDB3));
-    origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
-    EXPECT_TRUE(origin1_info);
-    EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
-    EXPECT_EQ(0, origin1_info->GetDatabaseSize(kDB3));
-
-    // Get all data for all origins
-    std::vector<OriginInfo> origins_info;
-    EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
-    EXPECT_EQ(size_t(2), origins_info.size());
-    EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
-    EXPECT_EQ(1, origins_info[0].TotalSize());
-    EXPECT_EQ(1, origins_info[0].GetDatabaseSize(kDB1));
-    EXPECT_EQ(0, origins_info[0].GetDatabaseSize(kDB3));
-
-    EXPECT_EQ(kOrigin2, origins_info[1].GetOriginIdentifier());
-    EXPECT_EQ(2, origins_info[1].TotalSize());
-
-    // Trying to delete an origin with databases in use should fail
-    tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, &database_size);
-    EXPECT_FALSE(tracker->DeleteOrigin(kOrigin1, false));
-    origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
-    EXPECT_TRUE(origin1_info);
-    EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
-    tracker->DatabaseClosed(kOrigin1, kDB1);
-
-    // Delete an origin that doesn't have any database in use
-    EXPECT_TRUE(tracker->DeleteOrigin(kOrigin1, false));
-    origins_info.clear();
-    EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
-    EXPECT_EQ(size_t(1), origins_info.size());
-    EXPECT_EQ(kOrigin2, origins_info[0].GetOriginIdentifier());
-
-    origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
-    EXPECT_TRUE(origin1_info);
-    EXPECT_EQ(0, origin1_info->TotalSize());
+    base::RunLoop run_loop;
+    tracker->task_runner()->PostTask(
+        FROM_HERE, base::BindLambdaForTesting([&]() {
+          base::ScopedClosureRunner quit_runner(
+              base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
+
+          // Add two observers.
+          TestObserver observer1;
+          TestObserver observer2;
+          tracker->AddObserver(&observer1);
+          tracker->AddObserver(&observer2);
+
+          // Open three new databases.
+          int64_t database_size = 0;
+          const std::string kOrigin1 =
+              GetIdentifierFromOrigin(GURL(kOrigin1Url));
+          const std::string kOrigin2 =
+              GetIdentifierFromOrigin(GURL(kOrigin2Url));
+          const base::string16 kDB1 = ASCIIToUTF16("db1");
+          const base::string16 kDB2 = ASCIIToUTF16("db2");
+          const base::string16 kDB3 = ASCIIToUTF16("db3");
+          const base::string16 kDescription =
+              ASCIIToUTF16("database_description");
+
+          // Get the info for kOrigin1 and kOrigin2
+          DatabaseTracker::CachedOriginInfo* origin1_info =
+              tracker->GetCachedOriginInfo(kOrigin1);
+          DatabaseTracker::CachedOriginInfo* origin2_info =
+              tracker->GetCachedOriginInfo(kOrigin1);
+          EXPECT_TRUE(origin1_info);
+          EXPECT_TRUE(origin2_info);
+
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
+                                  &database_size);
+          EXPECT_EQ(0, database_size);
+          tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
+                                  &database_size);
+          EXPECT_EQ(0, database_size);
+          tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
+                                  &database_size);
+          EXPECT_EQ(0, database_size);
+
+          // Write some data to each file and check that the listeners are
+          // called with the appropriate values.
+          EXPECT_TRUE(
+              base::CreateDirectory(tracker->GetOriginDirectory(kOrigin1)));
+          EXPECT_TRUE(
+              base::CreateDirectory(tracker->GetOriginDirectory(kOrigin2)));
+          EXPECT_TRUE(
+              base::WriteFile(tracker->GetFullDBFilePath(kOrigin1, kDB1), "a"));
+          EXPECT_TRUE(base::WriteFile(
+              tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa"));
+          EXPECT_TRUE(base::WriteFile(
+              tracker->GetFullDBFilePath(kOrigin1, kDB3), "aaaa"));
+          tracker->DatabaseModified(kOrigin1, kDB1);
+          CheckNotificationReceived(&observer1, kOrigin1, kDB1, 1);
+          CheckNotificationReceived(&observer2, kOrigin1, kDB1, 1);
+          tracker->DatabaseModified(kOrigin2, kDB2);
+          CheckNotificationReceived(&observer1, kOrigin2, kDB2, 2);
+          CheckNotificationReceived(&observer2, kOrigin2, kDB2, 2);
+          tracker->DatabaseModified(kOrigin1, kDB3);
+          CheckNotificationReceived(&observer1, kOrigin1, kDB3, 4);
+          CheckNotificationReceived(&observer2, kOrigin1, kDB3, 4);
+
+          // Close all databases
+          tracker->DatabaseClosed(kOrigin1, kDB1);
+          tracker->DatabaseClosed(kOrigin2, kDB2);
+          tracker->DatabaseClosed(kOrigin1, kDB3);
+
+          // Open an existing database and check the reported size
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
+                                  &database_size);
+          EXPECT_EQ(1, database_size);
+          tracker->DatabaseClosed(kOrigin1, kDB1);
+
+          // Remove an observer; this should clear all caches.
+          tracker->RemoveObserver(&observer2);
+
+          // Close the tracker database and clear all caches.
+          // Then make sure that DatabaseOpened() still returns the correct
+          // result.
+          tracker->CloseTrackerDatabaseAndClearCaches();
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
+                                  &database_size);
+          EXPECT_EQ(1, database_size);
+          tracker->DatabaseClosed(kOrigin1, kDB1);
+
+          // Remove all observers.
+          tracker->RemoveObserver(&observer1);
+
+          // Trying to delete a database in use should fail
+          tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
+                                  &database_size);
+          EXPECT_FALSE(tracker->DeleteClosedDatabase(kOrigin1, kDB3));
+          origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
+          EXPECT_TRUE(origin1_info);
+          EXPECT_EQ(4, origin1_info->GetDatabaseSize(kDB3));
+          tracker->DatabaseClosed(kOrigin1, kDB3);
+
+          // Delete a database and make sure the space used by that origin is
+          // updated
+          EXPECT_TRUE(tracker->DeleteClosedDatabase(kOrigin1, kDB3));
+          origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
+          EXPECT_TRUE(origin1_info);
+          EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
+          EXPECT_EQ(0, origin1_info->GetDatabaseSize(kDB3));
+
+          // Get all data for all origins
+          std::vector<OriginInfo> origins_info;
+          EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
+          EXPECT_EQ(size_t(2), origins_info.size());
+          EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
+          EXPECT_EQ(1, origins_info[0].TotalSize());
+          EXPECT_EQ(1, origins_info[0].GetDatabaseSize(kDB1));
+          EXPECT_EQ(0, origins_info[0].GetDatabaseSize(kDB3));
+
+          EXPECT_EQ(kOrigin2, origins_info[1].GetOriginIdentifier());
+          EXPECT_EQ(2, origins_info[1].TotalSize());
+
+          // Trying to delete an origin with databases in use should fail
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
+                                  &database_size);
+          EXPECT_FALSE(tracker->DeleteOrigin(kOrigin1, false));
+          origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
+          EXPECT_TRUE(origin1_info);
+          EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
+          tracker->DatabaseClosed(kOrigin1, kDB1);
+
+          // Delete an origin that doesn't have any database in use
+          EXPECT_TRUE(tracker->DeleteOrigin(kOrigin1, false));
+          origins_info.clear();
+          EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
+          EXPECT_EQ(size_t(1), origins_info.size());
+          EXPECT_EQ(kOrigin2, origins_info[0].GetOriginIdentifier());
+
+          origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
+          EXPECT_TRUE(origin1_info);
+          EXPECT_EQ(0, origin1_info->TotalSize());
+        }));
+    run_loop.Run();
   }
 
   static void DatabaseTrackerQuotaIntegration(bool incognito_mode) {
@@ -424,93 +468,108 @@ class DatabaseTracker_TestHelper_Test {
         base::MakeRefCounted<DatabaseTracker>(temp_dir.GetPath(),
                                               incognito_mode, nullptr,
                                               test_quota_proxy.get()));
-    tracker->set_task_runner_for_testing(
-        base::SequencedTaskRunnerHandle::Get());
-
-    EXPECT_TRUE(test_quota_proxy->registered_client_);
-
-    // Create a database and modify it a couple of times, close it,
-    // then delete it. Observe the tracker notifies accordingly.
-
-    int64_t database_size = 0;
-    tracker->DatabaseOpened(kOriginId, kName, kDescription, 0, &database_size);
-    EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
-    test_quota_proxy->reset();
-
-    base::FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName));
-    EXPECT_FALSE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
-    EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
-    EXPECT_TRUE(EnsureFileOfSize(db_file, 10));
-    EXPECT_TRUE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
-    tracker->DatabaseModified(kOriginId, kName);
-    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 10));
-    test_quota_proxy->reset();
-
-    EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
-    tracker->DatabaseModified(kOriginId, kName);
-    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 90));
-    test_quota_proxy->reset();
-
-    tracker->DatabaseClosed(kOriginId, kName);
-    EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
-    EXPECT_EQ(net::OK, tracker->DeleteDatabase(kOriginId, kName,
-                                               net::CompletionOnceCallback()));
-    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
-    test_quota_proxy->reset();
-
-    EXPECT_FALSE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
-
-    // Create a database and modify it, try to delete it while open,
-    // then close it (at which time deletion will actually occur).
-    // Observe the tracker notifies accordingly.
-
-    tracker->DatabaseOpened(kOriginId, kName, kDescription, 0, &database_size);
-    EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
-    test_quota_proxy->reset();
-
-    db_file = tracker->GetFullDBFilePath(kOriginId, kName);
-    EXPECT_FALSE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
-    EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
-    EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
-    EXPECT_TRUE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
-    tracker->DatabaseModified(kOriginId, kName);
-    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
-    test_quota_proxy->reset();
-
-    EXPECT_EQ(net::ERR_IO_PENDING,
-              tracker->DeleteDatabase(kOriginId, kName,
-                                      net::CompletionOnceCallback()));
-    EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
-    EXPECT_TRUE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
-
-    tracker->DatabaseClosed(kOriginId, kName);
-    EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
-    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
-    EXPECT_FALSE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
-    test_quota_proxy->reset();
-
-    // Create a database and up the file size without telling
-    // the tracker about the modification, than simulate a
-    // a renderer crash.
-    // Observe the tracker notifies accordingly.
-
-    tracker->DatabaseOpened(kOriginId, kName, kDescription, 0, &database_size);
-    EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
-    test_quota_proxy->reset();
-    db_file = tracker->GetFullDBFilePath(kOriginId, kName);
-    EXPECT_FALSE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
-    EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
-    EXPECT_TRUE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
-    EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
-    DatabaseConnections crashed_renderer_connections;
-    crashed_renderer_connections.AddConnection(kOriginId, kName);
-    EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
-    tracker->CloseDatabases(crashed_renderer_connections);
-    EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
-
-    // Cleanup.
-    crashed_renderer_connections.RemoveAllConnections();
-    test_quota_proxy->SimulateQuotaManagerDestroyed();
+    base::RunLoop run_loop;
+    tracker->task_runner()->PostTask(
+        FROM_HERE, base::BindLambdaForTesting([&]() {
+          base::ScopedClosureRunner quit_runner(
+              base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
+
+          EXPECT_TRUE(test_quota_proxy->registered_client_);
+
+          // Create a database and modify it a couple of times, close it,
+          // then delete it. Observe the tracker notifies accordingly.
+
+          int64_t database_size = 0;
+          tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+                                  &database_size);
+          EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
+          test_quota_proxy->reset();
+
+          base::FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName));
+          EXPECT_FALSE(
+              base::PathExists(tracker->GetOriginDirectory(kOriginId)));
+          EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
+          EXPECT_TRUE(EnsureFileOfSize(db_file, 10));
+          EXPECT_TRUE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
+          tracker->DatabaseModified(kOriginId, kName);
+          EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 10));
+          test_quota_proxy->reset();
+
+          EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
+          tracker->DatabaseModified(kOriginId, kName);
+          EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 90));
+          test_quota_proxy->reset();
+
+          tracker->DatabaseClosed(kOriginId, kName);
+          EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
+          EXPECT_EQ(net::OK,
+                    tracker->DeleteDatabase(kOriginId, kName,
+                                            net::CompletionOnceCallback()));
+          EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
+          test_quota_proxy->reset();
+
+          EXPECT_FALSE(
+              base::PathExists(tracker->GetOriginDirectory(kOriginId)));
+
+          // Create a database and modify it, try to delete it while open,
+          // then close it (at which time deletion will actually occur).
+          // Observe the tracker notifies accordingly.
+
+          tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+                                  &database_size);
+          EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
+          test_quota_proxy->reset();
+
+          db_file = tracker->GetFullDBFilePath(kOriginId, kName);
+          EXPECT_FALSE(
+              base::PathExists(tracker->GetOriginDirectory(kOriginId)));
+          EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
+          EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
+          EXPECT_TRUE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
+          tracker->DatabaseModified(kOriginId, kName);
+          EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
+          test_quota_proxy->reset();
+
+          EXPECT_EQ(net::ERR_IO_PENDING,
+                    tracker->DeleteDatabase(kOriginId, kName,
+                                            net::CompletionOnceCallback()));
+          EXPECT_FALSE(
+              test_quota_proxy->WasModificationNotified(kOrigin, -100));
+          EXPECT_TRUE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
+
+          tracker->DatabaseClosed(kOriginId, kName);
+          EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
+          EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
+          EXPECT_FALSE(
+              base::PathExists(tracker->GetOriginDirectory(kOriginId)));
+          test_quota_proxy->reset();
+
+          // Create a database and up the file size without telling
+          // the tracker about the modification, than simulate a
+          // a renderer crash.
+          // Observe the tracker notifies accordingly.
+
+          tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+                                  &database_size);
+          EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
+          test_quota_proxy->reset();
+          db_file = tracker->GetFullDBFilePath(kOriginId, kName);
+          EXPECT_FALSE(
+              base::PathExists(tracker->GetOriginDirectory(kOriginId)));
+          EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
+          EXPECT_TRUE(base::PathExists(tracker->GetOriginDirectory(kOriginId)));
+          EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
+          DatabaseConnections crashed_renderer_connections;
+          crashed_renderer_connections.AddConnection(kOriginId, kName);
+          EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
+          tracker->CloseDatabases(crashed_renderer_connections);
+          EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
+
+          // Cleanup.
+          crashed_renderer_connections.RemoveAllConnections();
+          test_quota_proxy->SimulateQuotaManagerDestroyed();
+        }));
+    run_loop.Run();
   }
 
   static void DatabaseTrackerClearSessionOnlyDatabasesOnExit() {
@@ -535,60 +594,77 @@ class DatabaseTracker_TestHelper_Test {
           base::MakeRefCounted<DatabaseTracker>(temp_dir.GetPath(), false,
                                                 special_storage_policy.get(),
                                                 nullptr));
-      tracker->set_task_runner_for_testing(
-          base::SequencedTaskRunnerHandle::Get());
-
-      // Open two new databases.
-      tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, &database_size);
-      EXPECT_EQ(0, database_size);
-      tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0, &database_size);
-      EXPECT_EQ(0, database_size);
-
-      // Write some data to each file.
-      base::FilePath db_file;
-      db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
-      EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
-      EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
-
-      db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
-      EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
-      EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
-
-      // Store the origin database directories as long as they still exist.
-      origin1_db_dir = tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
-      origin2_db_dir = tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
-
-      tracker->DatabaseModified(kOrigin1, kDB1);
-      tracker->DatabaseModified(kOrigin2, kDB2);
-
-      // Close all databases.
-      tracker->DatabaseClosed(kOrigin1, kDB1);
-      tracker->DatabaseClosed(kOrigin2, kDB2);
-
-      tracker->Shutdown();
+      base::RunLoop run_loop;
+      tracker->task_runner()->PostTask(
+          FROM_HERE, base::BindLambdaForTesting([&]() {
+            base::ScopedClosureRunner quit_runner(
+                base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
+
+            // Open two new databases.
+            tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
+                                    &database_size);
+            EXPECT_EQ(0, database_size);
+            tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
+                                    &database_size);
+            EXPECT_EQ(0, database_size);
+
+            // Write some data to each file.
+            base::FilePath db_file;
+            db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
+            EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
+            EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
+
+            db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
+            EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
+            EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
+
+            // Store the origin database directories as long as they still
+            // exist.
+            origin1_db_dir =
+                tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
+            origin2_db_dir =
+                tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
+
+            tracker->DatabaseModified(kOrigin1, kDB1);
+            tracker->DatabaseModified(kOrigin2, kDB2);
+
+            // Close all databases.
+            tracker->DatabaseClosed(kOrigin1, kDB1);
+            tracker->DatabaseClosed(kOrigin2, kDB2);
+
+            tracker->Shutdown();
+          }));
+      run_loop.Run();
     }
 
     // At this point, the database tracker should be gone. Create a new one.
     scoped_refptr<DatabaseTracker> tracker(
         base::MakeRefCounted<DatabaseTracker>(temp_dir.GetPath(), false,
                                               nullptr, nullptr));
-    tracker->set_task_runner_for_testing(
-        base::SequencedTaskRunnerHandle::Get());
-
-    // Get all data for all origins.
-    std::vector<OriginInfo> origins_info;
-    EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
-    // kOrigin1 was not session-only, so it survived. kOrigin2 was session-only
-    // and it got deleted.
-    EXPECT_EQ(size_t(1), origins_info.size());
-    EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
-    EXPECT_TRUE(base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
-    EXPECT_EQ(base::FilePath(), tracker->GetFullDBFilePath(kOrigin2, kDB2));
-
-    // The origin directory of kOrigin1 remains, but the origin directory of
-    // kOrigin2 is deleted.
-    EXPECT_TRUE(base::PathExists(origin1_db_dir));
-    EXPECT_FALSE(base::PathExists(origin2_db_dir));
+    base::RunLoop run_loop;
+    tracker->task_runner()->PostTask(
+        FROM_HERE, base::BindLambdaForTesting([&]() {
+          base::ScopedClosureRunner quit_runner(
+              base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
+
+          // Get all data for all origins.
+          std::vector<OriginInfo> origins_info;
+          EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
+          // kOrigin1 was not session-only, so it survived. kOrigin2 was
+          // session-only and it got deleted.
+          EXPECT_EQ(size_t(1), origins_info.size());
+          EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
+          EXPECT_TRUE(
+              base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
+          EXPECT_EQ(base::FilePath(),
+                    tracker->GetFullDBFilePath(kOrigin2, kDB2));
+
+          // The origin directory of kOrigin1 remains, but the origin directory
+          // of kOrigin2 is deleted.
+          EXPECT_TRUE(base::PathExists(origin1_db_dir));
+          EXPECT_FALSE(base::PathExists(origin2_db_dir));
+        }));
+    run_loop.Run();
   }
 
   static void DatabaseTrackerSetForceKeepSessionState() {
@@ -613,57 +689,75 @@ class DatabaseTracker_TestHelper_Test {
           base::MakeRefCounted<DatabaseTracker>(temp_dir.GetPath(), false,
                                                 special_storage_policy.get(),
                                                 nullptr));
-      tracker->set_task_runner_for_testing(
-          base::SequencedTaskRunnerHandle::Get());
-      tracker->SetForceKeepSessionState();
-
-      // Open two new databases.
-      tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, &database_size);
-      EXPECT_EQ(0, database_size);
-      tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0, &database_size);
-      EXPECT_EQ(0, database_size);
-
-      // Write some data to each file.
-      base::FilePath db_file;
-      db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
-      EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
-      EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
-
-      db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
-      EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
-      EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
-
-      // Store the origin database directories as long as they still exist.
-      origin1_db_dir = tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
-      origin2_db_dir = tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
-
-      tracker->DatabaseModified(kOrigin1, kDB1);
-      tracker->DatabaseModified(kOrigin2, kDB2);
-
-      // Close all databases.
-      tracker->DatabaseClosed(kOrigin1, kDB1);
-      tracker->DatabaseClosed(kOrigin2, kDB2);
-
-      tracker->Shutdown();
+      base::RunLoop run_loop;
+      tracker->task_runner()->PostTask(
+          FROM_HERE, base::BindLambdaForTesting([&]() {
+            base::ScopedClosureRunner quit_runner(
+                base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
+
+            tracker->SetForceKeepSessionState();
+
+            // Open two new databases.
+            tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
+                                    &database_size);
+            EXPECT_EQ(0, database_size);
+            tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
+                                    &database_size);
+            EXPECT_EQ(0, database_size);
+
+            // Write some data to each file.
+            base::FilePath db_file;
+            db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
+            EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
+            EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
+
+            db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
+            EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
+            EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
+
+            // Store the origin database directories as long as they still
+            // exist.
+            origin1_db_dir =
+                tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
+            origin2_db_dir =
+                tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
+
+            tracker->DatabaseModified(kOrigin1, kDB1);
+            tracker->DatabaseModified(kOrigin2, kDB2);
+
+            // Close all databases.
+            tracker->DatabaseClosed(kOrigin1, kDB1);
+            tracker->DatabaseClosed(kOrigin2, kDB2);
+
+            tracker->Shutdown();
+          }));
+      run_loop.Run();
     }
 
     // At this point, the database tracker should be gone. Create a new one.
     scoped_refptr<DatabaseTracker> tracker(
         base::MakeRefCounted<DatabaseTracker>(temp_dir.GetPath(), false,
                                               nullptr, nullptr));
-    tracker->set_task_runner_for_testing(
-        base::SequencedTaskRunnerHandle::Get());
-
-    // Get all data for all origins.
-    std::vector<OriginInfo> origins_info;
-    EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
-    // No origins were deleted.
-    EXPECT_EQ(size_t(2), origins_info.size());
-    EXPECT_TRUE(base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
-    EXPECT_TRUE(base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
-
-    EXPECT_TRUE(base::PathExists(origin1_db_dir));
-    EXPECT_TRUE(base::PathExists(origin2_db_dir));
+    base::RunLoop run_loop;
+    tracker->task_runner()->PostTask(
+        FROM_HERE, base::BindLambdaForTesting([&]() {
+          base::ScopedClosureRunner quit_runner(
+              base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
+
+          // Get all data for all origins.
+          std::vector<OriginInfo> origins_info;
+          EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
+          // No origins were deleted.
+          EXPECT_EQ(size_t(2), origins_info.size());
+          EXPECT_TRUE(
+              base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
+          EXPECT_TRUE(
+              base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
+
+          EXPECT_TRUE(base::PathExists(origin1_db_dir));
+          EXPECT_TRUE(base::PathExists(origin2_db_dir));
+        }));
+    run_loop.Run();
   }
 
   static void EmptyDatabaseNameIsValid() {
@@ -682,39 +776,47 @@ class DatabaseTracker_TestHelper_Test {
     scoped_refptr<DatabaseTracker> tracker(
         base::MakeRefCounted<DatabaseTracker>(
             temp_dir.GetPath(), kUseInMemoryTrackerDatabase, nullptr, nullptr));
-    tracker->set_task_runner_for_testing(
-        base::SequencedTaskRunnerHandle::Get());
-
-    // Starts off with no databases.
-    std::vector<OriginInfo> infos;
-    EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
-    EXPECT_TRUE(infos.empty());
-
-    // Create a db with an empty name.
-    int64_t database_size = -1;
-    tracker->DatabaseOpened(kOriginId, kEmptyName, kDescription, 0,
-                            &database_size);
-    EXPECT_EQ(0, database_size);
-    tracker->DatabaseModified(kOriginId, kEmptyName);
-    EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
-    EXPECT_EQ(1u, infos.size());
-    EXPECT_EQ(kDescription, infos[0].GetDatabaseDescription(kEmptyName));
-    EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kEmptyName).empty());
-    tracker->DatabaseOpened(kOriginId, kEmptyName, kChangedDescription, 0,
-                            &database_size);
-    infos.clear();
-    EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
-    EXPECT_EQ(1u, infos.size());
-    EXPECT_EQ(kChangedDescription, infos[0].GetDatabaseDescription(kEmptyName));
-    tracker->DatabaseClosed(kOriginId, kEmptyName);
-    tracker->DatabaseClosed(kOriginId, kEmptyName);
-
-    // Deleting it should return to the initial state.
-    EXPECT_EQ(net::OK, tracker->DeleteDatabase(kOriginId, kEmptyName,
-                                               net::CompletionOnceCallback()));
-    infos.clear();
-    EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
-    EXPECT_TRUE(infos.empty());
+    base::RunLoop run_loop;
+    tracker->task_runner()->PostTask(
+        FROM_HERE, base::BindLambdaForTesting([&]() {
+          base::ScopedClosureRunner quit_runner(
+              base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
+
+          // Starts off with no databases.
+          std::vector<OriginInfo> infos;
+          EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
+          EXPECT_TRUE(infos.empty());
+
+          // Create a db with an empty name.
+          int64_t database_size = -1;
+          tracker->DatabaseOpened(kOriginId, kEmptyName, kDescription, 0,
+                                  &database_size);
+          EXPECT_EQ(0, database_size);
+          tracker->DatabaseModified(kOriginId, kEmptyName);
+          EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
+          EXPECT_EQ(1u, infos.size());
+          EXPECT_EQ(kDescription, infos[0].GetDatabaseDescription(kEmptyName));
+          EXPECT_FALSE(
+              tracker->GetFullDBFilePath(kOriginId, kEmptyName).empty());
+          tracker->DatabaseOpened(kOriginId, kEmptyName, kChangedDescription, 0,
+                                  &database_size);
+          infos.clear();
+          EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
+          EXPECT_EQ(1u, infos.size());
+          EXPECT_EQ(kChangedDescription,
+                    infos[0].GetDatabaseDescription(kEmptyName));
+          tracker->DatabaseClosed(kOriginId, kEmptyName);
+          tracker->DatabaseClosed(kOriginId, kEmptyName);
+
+          // Deleting it should return to the initial state.
+          EXPECT_EQ(net::OK,
+                    tracker->DeleteDatabase(kOriginId, kEmptyName,
+                                            net::CompletionOnceCallback()));
+          infos.clear();
+          EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
+          EXPECT_TRUE(infos.empty());
+        }));
+    run_loop.Run();
   }
 
   static void HandleSqliteError() {
@@ -731,66 +833,78 @@ class DatabaseTracker_TestHelper_Test {
     scoped_refptr<DatabaseTracker> tracker(
         base::MakeRefCounted<DatabaseTracker>(
             temp_dir.GetPath(), kUseInMemoryTrackerDatabase, nullptr, nullptr));
-    tracker->set_task_runner_for_testing(
-        base::SequencedTaskRunnerHandle::Get());
-
-    // Setup to observe OnScheduledForDelete notifications.
-    TestObserver observer(false, true);
-    tracker->AddObserver(&observer);
-
-    // Verify does no harm when there is no such database.
-    tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
-    EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
-    EXPECT_FALSE(observer.DidReceiveNewNotification());
-
-    // --------------------------------------------------------
-    // Create a record of a database in the tracker db and create
-    // a spoof_db_file on disk in the expected location.
-    int64_t database_size = 0;
-    tracker->DatabaseOpened(kOriginId, kName, kDescription, 0, &database_size);
-    base::FilePath spoof_db_file = tracker->GetFullDBFilePath(kOriginId, kName);
-    EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
-    EXPECT_TRUE(base::CreateDirectory(spoof_db_file.DirName()));
-    EXPECT_TRUE(EnsureFileOfSize(spoof_db_file, 1));
-
-    // Verify does no harm with a non-error is reported.
-    tracker->HandleSqliteError(kOriginId, kName, SQLITE_OK);
-    EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
-    EXPECT_FALSE(observer.DidReceiveNewNotification());
-
-    // Verify that with a connection open, the db is scheduled for deletion,
-    // but that the file still exists.
-    tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
-    EXPECT_TRUE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
-    EXPECT_TRUE(observer.DidReceiveNewNotification());
-    EXPECT_TRUE(base::PathExists(spoof_db_file));
-
-    // Verify that once closed, the file is deleted and the record in the
-    // tracker db is removed.
-    tracker->DatabaseClosed(kOriginId, kName);
-    EXPECT_FALSE(base::PathExists(spoof_db_file));
-    EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
-
-    // --------------------------------------------------------
-    // Create another record of a database in the tracker db and create
-    // a spoof_db_file on disk in the expected location.
-    tracker->DatabaseOpened(kOriginId, kName, kDescription, 0, &database_size);
-    base::FilePath spoof_db_file2 =
-        tracker->GetFullDBFilePath(kOriginId, kName);
-    EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
-    EXPECT_NE(spoof_db_file, spoof_db_file2);
-    EXPECT_TRUE(base::CreateDirectory(spoof_db_file2.DirName()));
-    EXPECT_TRUE(EnsureFileOfSize(spoof_db_file2, 1));
-
-    // Verify that with no connection open, the db is deleted immediately.
-    tracker->DatabaseClosed(kOriginId, kName);
-    tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
-    EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
-    EXPECT_FALSE(observer.DidReceiveNewNotification());
-    EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
-    EXPECT_FALSE(base::PathExists(spoof_db_file2));
-
-    tracker->RemoveObserver(&observer);
+    base::RunLoop run_loop;
+    tracker->task_runner()->PostTask(
+        FROM_HERE, base::BindLambdaForTesting([&]() {
+          base::ScopedClosureRunner quit_runner(
+              base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
+
+          // Setup to observe OnScheduledForDelete notifications.
+          TestObserver observer(false, true);
+          tracker->AddObserver(&observer);
+
+          // Verify does no harm when there is no such database.
+          tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
+          EXPECT_FALSE(
+              tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
+          EXPECT_FALSE(observer.DidReceiveNewNotification());
+
+          // --------------------------------------------------------
+          // Create a record of a database in the tracker db and create
+          // a spoof_db_file on disk in the expected location.
+          int64_t database_size = 0;
+          tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+                                  &database_size);
+          base::FilePath spoof_db_file =
+              tracker->GetFullDBFilePath(kOriginId, kName);
+          EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
+          EXPECT_TRUE(base::CreateDirectory(spoof_db_file.DirName()));
+          EXPECT_TRUE(EnsureFileOfSize(spoof_db_file, 1));
+
+          // Verify does no harm with a non-error is reported.
+          tracker->HandleSqliteError(kOriginId, kName, SQLITE_OK);
+          EXPECT_FALSE(
+              tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
+          EXPECT_FALSE(observer.DidReceiveNewNotification());
+
+          // Verify that with a connection open, the db is scheduled for
+          // deletion, but that the file still exists.
+          tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
+          EXPECT_TRUE(
+              tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
+          EXPECT_TRUE(observer.DidReceiveNewNotification());
+          EXPECT_TRUE(base::PathExists(spoof_db_file));
+
+          // Verify that once closed, the file is deleted and the record in the
+          // tracker db is removed.
+          tracker->DatabaseClosed(kOriginId, kName);
+          EXPECT_FALSE(base::PathExists(spoof_db_file));
+          EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
+
+          // --------------------------------------------------------
+          // Create another record of a database in the tracker db and create
+          // a spoof_db_file on disk in the expected location.
+          tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+                                  &database_size);
+          base::FilePath spoof_db_file2 =
+              tracker->GetFullDBFilePath(kOriginId, kName);
+          EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
+          EXPECT_NE(spoof_db_file, spoof_db_file2);
+          EXPECT_TRUE(base::CreateDirectory(spoof_db_file2.DirName()));
+          EXPECT_TRUE(EnsureFileOfSize(spoof_db_file2, 1));
+
+          // Verify that with no connection open, the db is deleted immediately.
+          tracker->DatabaseClosed(kOriginId, kName);
+          tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
+          EXPECT_FALSE(
+              tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
+          EXPECT_FALSE(observer.DidReceiveNewNotification());
+          EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
+          EXPECT_FALSE(base::PathExists(spoof_db_file2));
+
+          tracker->RemoveObserver(&observer);
+        }));
+    run_loop.Run();
   }
 };
 
diff --git a/chromium/storage/browser/database/databases_table.cc b/chromium/storage/browser/database/databases_table.cc
index f1565e550c2..c5b3fed03e9 100644
--- a/chromium/storage/browser/database/databases_table.cc
+++ b/chromium/storage/browser/database/databases_table.cc
@@ -6,7 +6,7 @@
 
 #include <stdint.h>
 
-#include "base/logging.h"
+#include "base/check.h"
 #include "base/strings/utf_string_conversions.h"
 #include "sql/statement.h"
 
diff --git a/chromium/storage/browser/database/vfs_backend.cc b/chromium/storage/browser/database/vfs_backend.cc
index 8be20f25365..6f7403cab56 100644
--- a/chromium/storage/browser/database/vfs_backend.cc
+++ b/chromium/storage/browser/database/vfs_backend.cc
@@ -6,9 +6,9 @@
 
 #include <stdint.h>
 
+#include "base/check.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
-#include "base/logging.h"
 #include "build/build_config.h"
 #include "third_party/sqlite/sqlite3.h"
 
diff --git a/chromium/storage/browser/file_system/copy_or_move_operation_delegate_unittest.cc b/chromium/storage/browser/file_system/copy_or_move_operation_delegate_unittest.cc
index 2f0e1888471..c965b63762b 100644
--- a/chromium/storage/browser/file_system/copy_or_move_operation_delegate_unittest.cc
+++ b/chromium/storage/browser/file_system/copy_or_move_operation_delegate_unittest.cc
@@ -690,8 +690,7 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, StreamCopyHelper) {
   base::FilePath source_path = temp_dir.GetPath().AppendASCII("source");
   base::FilePath dest_path = temp_dir.GetPath().AppendASCII("dest");
   const char kTestData[] = "abcdefghijklmnopqrstuvwxyz0123456789";
-  base::WriteFile(source_path, kTestData,
-                  base::size(kTestData) - 1);  // Exclude trailing '\0'.
+  base::WriteFile(source_path, kTestData);
 
   base::test::SingleThreadTaskEnvironment task_environment(
       base::test::SingleThreadTaskEnvironment::MainThreadType::IO);
@@ -747,8 +746,7 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, StreamCopyHelperWithFlush) {
   base::FilePath source_path = temp_dir.GetPath().AppendASCII("source");
   base::FilePath dest_path = temp_dir.GetPath().AppendASCII("dest");
   const char kTestData[] = "abcdefghijklmnopqrstuvwxyz0123456789";
-  base::WriteFile(source_path, kTestData,
-                  base::size(kTestData) - 1);  // Exclude trailing '\0'.
+  base::WriteFile(source_path, kTestData);
 
   base::test::SingleThreadTaskEnvironment task_environment(
       base::test::SingleThreadTaskEnvironment::MainThreadType::IO);
@@ -800,8 +798,7 @@ TEST(LocalFileSystemCopyOrMoveOperationTest, StreamCopyHelper_Cancel) {
   base::FilePath source_path = temp_dir.GetPath().AppendASCII("source");
   base::FilePath dest_path = temp_dir.GetPath().AppendASCII("dest");
   const char kTestData[] = "abcdefghijklmnopqrstuvwxyz0123456789";
-  base::WriteFile(source_path, kTestData,
-                  base::size(kTestData) - 1);  // Exclude trailing '\0'.
+  base::WriteFile(source_path, kTestData);
 
   base::test::SingleThreadTaskEnvironment task_environment(
       base::test::SingleThreadTaskEnvironment::MainThreadType::IO);
diff --git a/chromium/storage/browser/file_system/dragged_file_util_unittest.cc b/chromium/storage/browser/file_system/dragged_file_util_unittest.cc
index 3c1ac4e0c3a..9b07aaa1011 100644
--- a/chromium/storage/browser/file_system/dragged_file_util_unittest.cc
+++ b/chromium/storage/browser/file_system/dragged_file_util_unittest.cc
@@ -10,11 +10,11 @@
 #include <string>
 #include <vector>
 
+#include "base/check.h"
 #include "base/containers/queue.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/test/task_environment.h"
diff --git a/chromium/storage/browser/file_system/file_system_operation_impl_unittest.cc b/chromium/storage/browser/file_system/file_system_operation_impl_unittest.cc
index cc9348fac83..0751995c806 100644
--- a/chromium/storage/browser/file_system/file_system_operation_impl_unittest.cc
+++ b/chromium/storage/browser/file_system/file_system_operation_impl_unittest.cc
@@ -14,7 +14,6 @@
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
diff --git a/chromium/storage/browser/file_system/file_system_quota_client.cc b/chromium/storage/browser/file_system/file_system_quota_client.cc
index 0fa79a68aa2..66a3007178b 100644
--- a/chromium/storage/browser/file_system/file_system_quota_client.cc
+++ b/chromium/storage/browser/file_system/file_system_quota_client.cc
@@ -8,9 +8,9 @@
 #include <memory>
 
 #include "base/bind.h"
+#include "base/check.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
-#include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner_util.h"
@@ -96,8 +96,8 @@ FileSystemQuotaClient::FileSystemQuotaClient(
 
 FileSystemQuotaClient::~FileSystemQuotaClient() = default;
 
-QuotaClient::ID FileSystemQuotaClient::id() const {
-  return QuotaClient::kFileSystem;
+QuotaClientType FileSystemQuotaClient::type() const {
+  return QuotaClientType::kFileSystem;
 }
 
 void FileSystemQuotaClient::GetOriginUsage(const url::Origin& origin,
diff --git a/chromium/storage/browser/file_system/file_system_quota_client.h b/chromium/storage/browser/file_system/file_system_quota_client.h
index e4e46432063..01afe9eb2b2 100644
--- a/chromium/storage/browser/file_system/file_system_quota_client.h
+++ b/chromium/storage/browser/file_system/file_system_quota_client.h
@@ -16,6 +16,7 @@
 #include "base/memory/ref_counted.h"
 #include "storage/browser/file_system/file_system_quota_util.h"
 #include "storage/browser/quota/quota_client.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "storage/common/file_system/file_system_types.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
 #include "url/origin.h"
@@ -33,10 +34,10 @@ class FileSystemContext;
 class COMPONENT_EXPORT(STORAGE_BROWSER) FileSystemQuotaClient
     : public QuotaClient {
  public:
-  FileSystemQuotaClient(FileSystemContext* file_system_context);
+  explicit FileSystemQuotaClient(FileSystemContext* file_system_context);
 
   // QuotaClient methods.
-  QuotaClient::ID id() const override;
+  QuotaClientType type() const override;
   void OnQuotaManagerDestroyed() override {}
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
diff --git a/chromium/storage/browser/file_system/file_system_url.cc b/chromium/storage/browser/file_system/file_system_url.cc
index a6b6bc2990b..3aac33f3ad0 100644
--- a/chromium/storage/browser/file_system/file_system_url.cc
+++ b/chromium/storage/browser/file_system/file_system_url.cc
@@ -6,7 +6,7 @@
 
 #include <sstream>
 
-#include "base/logging.h"
+#include "base/check.h"
 #include "base/strings/string_util.h"
 #include "net/base/escape.h"
 #include "storage/common/file_system/file_system_util.h"
diff --git a/chromium/storage/browser/file_system/isolated_context.cc b/chromium/storage/browser/file_system/isolated_context.cc
index b0655f9fe01..b24d7f20d13 100644
--- a/chromium/storage/browser/file_system/isolated_context.cc
+++ b/chromium/storage/browser/file_system/isolated_context.cc
@@ -9,8 +9,9 @@
 
 #include <memory>
 
-#include "base/logging.h"
+#include "base/check_op.h"
 #include "base/macros.h"
+#include "base/notreached.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
diff --git a/chromium/storage/browser/file_system/isolated_context_unittest.cc b/chromium/storage/browser/file_system/isolated_context_unittest.cc
index c24d59ef5e9..2c28720f820 100644
--- a/chromium/storage/browser/file_system/isolated_context_unittest.cc
+++ b/chromium/storage/browser/file_system/isolated_context_unittest.cc
@@ -6,7 +6,6 @@
 
 #include <string>
 
-#include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "storage/browser/file_system/file_system_url.h"
diff --git a/chromium/storage/browser/file_system/isolated_file_system_backend.cc b/chromium/storage/browser/file_system/isolated_file_system_backend.cc
index f35a7f85ad8..ef345ee9b3e 100644
--- a/chromium/storage/browser/file_system/isolated_file_system_backend.cc
+++ b/chromium/storage/browser/file_system/isolated_file_system_backend.cc
@@ -11,8 +11,9 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/check.h"
 #include "base/files/file_path.h"
-#include "base/logging.h"
+#include "base/notreached.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "storage/browser/file_system/async_file_util_adapter.h"
diff --git a/chromium/storage/browser/file_system/local_file_stream_reader.cc b/chromium/storage/browser/file_system/local_file_stream_reader.cc
index 78d3ad1928b..716b5806cff 100644
--- a/chromium/storage/browser/file_system/local_file_stream_reader.cc
+++ b/chromium/storage/browser/file_system/local_file_stream_reader.cc
@@ -9,9 +9,9 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/check_op.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
-#include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
diff --git a/chromium/storage/browser/file_system/local_file_stream_reader_unittest.cc b/chromium/storage/browser/file_system/local_file_stream_reader_unittest.cc
index a31cf659396..7b7887d5214 100644
--- a/chromium/storage/browser/file_system/local_file_stream_reader_unittest.cc
+++ b/chromium/storage/browser/file_system/local_file_stream_reader_unittest.cc
@@ -54,7 +54,7 @@ class LocalFileStreamReaderTest : public testing::Test {
     ASSERT_TRUE(file_thread_.Start());
     ASSERT_TRUE(dir_.CreateUniqueTempDir());
 
-    base::WriteFile(test_path(), kTestData, kTestDataSize);
+    base::WriteFile(test_path(), kTestData);
     base::File::Info info;
     ASSERT_TRUE(base::GetFileInfo(test_path(), &info));
     test_file_modification_time_ = info.last_modified;
diff --git a/chromium/storage/browser/file_system/local_file_stream_writer_unittest.cc b/chromium/storage/browser/file_system/local_file_stream_writer_unittest.cc
index 62cce18002f..e2b2c1cbeb2 100644
--- a/chromium/storage/browser/file_system/local_file_stream_writer_unittest.cc
+++ b/chromium/storage/browser/file_system/local_file_stream_writer_unittest.cc
@@ -13,7 +13,6 @@
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/task_environment.h"
@@ -55,7 +54,7 @@ class LocalFileStreamWriterTest : public testing::Test {
   base::FilePath CreateFileWithContent(const std::string& name,
                                        const std::string& data) {
     base::FilePath path = Path(name);
-    base::WriteFile(path, data.c_str(), data.size());
+    base::WriteFile(path, data);
     return path;
   }
 
diff --git a/chromium/storage/browser/file_system/obfuscated_file_util_memory_delegate_unittest.cc b/chromium/storage/browser/file_system/obfuscated_file_util_memory_delegate_unittest.cc
index 9652b795cb7..6428d9f28b2 100644
--- a/chromium/storage/browser/file_system/obfuscated_file_util_memory_delegate_unittest.cc
+++ b/chromium/storage/browser/file_system/obfuscated_file_util_memory_delegate_unittest.cc
@@ -319,8 +319,7 @@ TEST_F(ObfuscatedFileUtilMemoryDelegateTest, CopyForeignFile) {
                                      FileSystemOperation::OPTION_NONE, sync));
 
   // Create source file.
-  EXPECT_EQ(test_data_len,
-            base::WriteFile(from_file, test_data, test_data_len));
+  EXPECT_TRUE(base::WriteFile(from_file, test_data));
 
   // Test copying to a nonexistent directory.
   EXPECT_EQ(
diff --git a/chromium/storage/browser/file_system/quota/quota_backend_impl.cc b/chromium/storage/browser/file_system/quota/quota_backend_impl.cc
index 09ebe7a5fdd..f5a5ddacfbf 100644
--- a/chromium/storage/browser/file_system/quota/quota_backend_impl.cc
+++ b/chromium/storage/browser/file_system/quota/quota_backend_impl.cc
@@ -12,7 +12,7 @@
 
 #include "base/bind.h"
 #include "base/callback.h"
-#include "base/logging.h"
+#include "base/check_op.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/sequenced_task_runner.h"
 #include "storage/browser/file_system/file_system_usage_cache.h"
@@ -140,7 +140,7 @@ void QuotaBackendImpl::ReserveQuotaInternal(const QuotaReservationInfo& info) {
   DCHECK(!info.origin.opaque());
   DCHECK(quota_manager_proxy_.get());
   quota_manager_proxy_->NotifyStorageModified(
-      QuotaClient::kFileSystem, info.origin,
+      QuotaClientType::kFileSystem, info.origin,
       FileSystemTypeToQuotaStorageType(info.type), info.delta);
 }
 
diff --git a/chromium/storage/browser/file_system/quota/quota_backend_impl_unittest.cc b/chromium/storage/browser/file_system/quota/quota_backend_impl_unittest.cc
index 5fb0ab50082..e7e8c49e7f1 100644
--- a/chromium/storage/browser/file_system/quota/quota_backend_impl_unittest.cc
+++ b/chromium/storage/browser/file_system/quota/quota_backend_impl_unittest.cc
@@ -49,12 +49,12 @@ class MockQuotaManagerProxy : public QuotaManagerProxy {
   // We don't mock them.
   void NotifyOriginInUse(const url::Origin& origin) override {}
   void NotifyOriginNoLongerInUse(const url::Origin& origin) override {}
-  void SetUsageCacheEnabled(QuotaClient::ID client_id,
+  void SetUsageCacheEnabled(QuotaClientType client_id,
                             const url::Origin& origin,
                             blink::mojom::StorageType type,
                             bool enabled) override {}
 
-  void NotifyStorageModified(QuotaClient::ID client_id,
+  void NotifyStorageModified(QuotaClientType client_id,
                              const url::Origin& origin,
                              blink::mojom::StorageType type,
                              int64_t delta) override {
diff --git a/chromium/storage/browser/file_system/sandbox_file_stream_writer.cc b/chromium/storage/browser/file_system/sandbox_file_stream_writer.cc
index 21495aee426..4e140b60827 100644
--- a/chromium/storage/browser/file_system/sandbox_file_stream_writer.cc
+++ b/chromium/storage/browser/file_system/sandbox_file_stream_writer.cc
@@ -70,10 +70,14 @@ int SandboxFileStreamWriter::Write(net::IOBuffer* buf,
                                    net::CompletionOnceCallback callback) {
   DCHECK(!write_callback_);
   has_pending_operation_ = true;
-  write_callback_ = std::move(callback);
-  if (file_writer_)
-    return WriteInternal(buf, buf_len);
+  if (file_writer_) {
+    const int result = WriteInternal(buf, buf_len);
+    if (result == net::ERR_IO_PENDING)
+      write_callback_ = std::move(callback);
+    return result;
+  }
 
+  write_callback_ = std::move(callback);
   net::CompletionOnceCallback write_task = base::BindOnce(
       &SandboxFileStreamWriter::DidInitializeForWrite,
       weak_factory_.GetWeakPtr(), base::RetainedRef(buf), buf_len);
@@ -111,7 +115,7 @@ int SandboxFileStreamWriter::WriteInternal(net::IOBuffer* buf, int buf_len) {
                           base::BindOnce(&SandboxFileStreamWriter::DidWrite,
                                          weak_factory_.GetWeakPtr()));
   if (result != net::ERR_IO_PENDING)
-    has_pending_operation_ = false;
+    DidWrite(result);
   return result;
 }
 
@@ -210,8 +214,8 @@ void SandboxFileStreamWriter::DidInitializeForWrite(net::IOBuffer* buf,
   allowed_bytes_to_write_ = AdjustQuotaForOverlap(allowed_bytes_to_write_,
                                                   initial_offset_, file_size_);
   const int result = WriteInternal(buf, buf_len);
-  if (result != net::ERR_IO_PENDING)
-    std::move(write_callback_).Run(result);
+  if (result == net::ERR_IO_PENDING)
+    DCHECK(!write_callback_.is_null());
 }
 
 void SandboxFileStreamWriter::DidWrite(int write_response) {
@@ -236,7 +240,8 @@ void SandboxFileStreamWriter::DidWrite(int write_response) {
 
   if (CancelIfRequested())
     return;
-  std::move(write_callback_).Run(write_response);
+  if (write_callback_)
+    std::move(write_callback_).Run(write_response);
 }
 
 bool SandboxFileStreamWriter::CancelIfRequested() {
diff --git a/chromium/storage/browser/file_system/sandbox_file_system_backend.cc b/chromium/storage/browser/file_system/sandbox_file_system_backend.cc
index 580047cecd7..89597058355 100644
--- a/chromium/storage/browser/file_system/sandbox_file_system_backend.cc
+++ b/chromium/storage/browser/file_system/sandbox_file_system_backend.cc
@@ -10,8 +10,8 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/check.h"
 #include "base/files/file_util.h"
-#include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/task_runner_util.h"
 #include "storage/browser/file_system/async_file_util_adapter.h"
diff --git a/chromium/storage/browser/file_system/sandbox_file_system_backend_delegate.cc b/chromium/storage/browser/file_system/sandbox_file_system_backend_delegate.cc
index c1bb1911236..f3f9cc079db 100644
--- a/chromium/storage/browser/file_system/sandbox_file_system_backend_delegate.cc
+++ b/chromium/storage/browser/file_system/sandbox_file_system_backend_delegate.cc
@@ -351,7 +351,7 @@ SandboxFileSystemBackendDelegate::DeleteOriginDataOnFileTaskRunner(
   bool result = obfuscated_file_util()->DeleteDirectoryForOriginAndType(
       origin, GetTypeString(type));
   if (result && proxy && usage) {
-    proxy->NotifyStorageModified(storage::QuotaClient::kFileSystem, origin,
+    proxy->NotifyStorageModified(QuotaClientType::kFileSystem, origin,
                                  FileSystemTypeToQuotaStorageType(type),
                                  -usage);
   }
diff --git a/chromium/storage/browser/file_system/sandbox_isolated_origin_database.cc b/chromium/storage/browser/file_system/sandbox_isolated_origin_database.cc
index 7be752693ac..a465dcd6be6 100644
--- a/chromium/storage/browser/file_system/sandbox_isolated_origin_database.cc
+++ b/chromium/storage/browser/file_system/sandbox_isolated_origin_database.cc
@@ -5,7 +5,6 @@
 #include "storage/browser/file_system/sandbox_isolated_origin_database.h"
 
 #include "base/files/file_util.h"
-#include "base/logging.h"
 #include "storage/browser/file_system/sandbox_origin_database.h"
 
 namespace storage {
diff --git a/chromium/storage/browser/file_system/sandbox_prioritized_origin_database.cc b/chromium/storage/browser/file_system/sandbox_prioritized_origin_database.cc
index 88d76f0fb8d..04166096734 100644
--- a/chromium/storage/browser/file_system/sandbox_prioritized_origin_database.cc
+++ b/chromium/storage/browser/file_system/sandbox_prioritized_origin_database.cc
@@ -4,9 +4,9 @@
 
 #include "storage/browser/file_system/sandbox_prioritized_origin_database.h"
 
+#include "base/check.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
-#include "base/logging.h"
 #include "base/pickle.h"
 #include "storage/browser/file_system/sandbox_isolated_origin_database.h"
 #include "storage/browser/file_system/sandbox_origin_database.h"
diff --git a/chromium/storage/browser/file_system/sandbox_prioritized_origin_database_unittest.cc b/chromium/storage/browser/file_system/sandbox_prioritized_origin_database_unittest.cc
index 018176c72da..1c805dabbeb 100644
--- a/chromium/storage/browser/file_system/sandbox_prioritized_origin_database_unittest.cc
+++ b/chromium/storage/browser/file_system/sandbox_prioritized_origin_database_unittest.cc
@@ -119,7 +119,7 @@ TEST(SandboxPrioritizedOriginDatabaseTest, LostPrimaryOriginFileTest) {
   EXPECT_TRUE(database.GetPathForOrigin(kOrigin1, &path));
 
   // Corrupt the primary origin file.
-  base::WriteFile(database.primary_origin_file(), kData.data(), kData.size());
+  base::WriteFile(database.primary_origin_file(), kData);
 
   // Reset the database.
   database.DropDatabase();
@@ -158,16 +158,12 @@ TEST(SandboxPrioritizedOriginDatabaseTest, MigrationTest) {
     // Populate the origin directory with some fake data.
     old_dir_db_path1 = dir.GetPath().Append(path1);
     ASSERT_TRUE(base::CreateDirectory(old_dir_db_path1));
-    EXPECT_EQ(static_cast<int>(kFakeDirectoryData1.size()),
-              base::WriteFile(old_dir_db_path1.AppendASCII("dummy"),
-                              kFakeDirectoryData1.data(),
-                              kFakeDirectoryData1.size()));
+    EXPECT_TRUE(base::WriteFile(old_dir_db_path1.AppendASCII("dummy"),
+                                kFakeDirectoryData1));
     old_dir_db_path2 = dir.GetPath().Append(path2);
     ASSERT_TRUE(base::CreateDirectory(old_dir_db_path2));
-    EXPECT_EQ(static_cast<int>(kFakeDirectoryData2.size()),
-              base::WriteFile(old_dir_db_path2.AppendASCII("dummy"),
-                              kFakeDirectoryData2.data(),
-                              kFakeDirectoryData2.size()));
+    EXPECT_TRUE(base::WriteFile(old_dir_db_path2.AppendASCII("dummy"),
+                                kFakeDirectoryData2));
   }
 
   // Re-open the directory using sandboxPrioritizedOriginDatabase.
diff --git a/chromium/storage/browser/file_system/sandbox_quota_observer.cc b/chromium/storage/browser/file_system/sandbox_quota_observer.cc
index 3cf90c3d458..894f56cbd3a 100644
--- a/chromium/storage/browser/file_system/sandbox_quota_observer.cc
+++ b/chromium/storage/browser/file_system/sandbox_quota_observer.cc
@@ -41,7 +41,7 @@ void SandboxQuotaObserver::OnUpdate(const FileSystemURL& url, int64_t delta) {
 
   if (quota_manager_proxy_.get()) {
     quota_manager_proxy_->NotifyStorageModified(
-        QuotaClient::kFileSystem, url.origin(),
+        QuotaClientType::kFileSystem, url.origin(),
         FileSystemTypeToQuotaStorageType(url.type()), delta);
   }
 
@@ -87,7 +87,7 @@ void SandboxQuotaObserver::SetUsageCacheEnabled(const url::Origin& origin,
                                                 bool enabled) {
   if (quota_manager_proxy_.get()) {
     quota_manager_proxy_->SetUsageCacheEnabled(
-        QuotaClient::kFileSystem, origin,
+        QuotaClientType::kFileSystem, origin,
         FileSystemTypeToQuotaStorageType(type), enabled);
   }
 }
diff --git a/chromium/storage/browser/quota/quota_client.h b/chromium/storage/browser/quota/quota_client.h
index 417cfab0d27..642f52ea189 100644
--- a/chromium/storage/browser/quota/quota_client.h
+++ b/chromium/storage/browser/quota/quota_client.h
@@ -12,6 +12,7 @@
 
 #include "base/callback.h"
 #include "base/component_export.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom-forward.h"
 #include "url/origin.h"
 
@@ -35,18 +36,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaClient
   using DeletionCallback =
       base::OnceCallback<void(blink::mojom::QuotaStatusCode status)>;
 
-  enum ID {
-    kFileSystem = 1 << 0,
-    kDatabase = 1 << 1,
-    kAppcache = 1 << 2,
-    kIndexedDatabase = 1 << 3,
-    kServiceWorkerCache = 1 << 4,
-    kServiceWorker = 1 << 5,
-    kBackgroundFetch = 1 << 6,
-    kAllClientsMask = -1,
-  };
-
-  virtual ID id() const = 0;
+  virtual QuotaClientType type() const = 0;
 
   // Called when the QuotaManager is destroyed.
   virtual void OnQuotaManagerDestroyed() = 0;
diff --git a/chromium/storage/browser/quota/quota_client_type.cc b/chromium/storage/browser/quota/quota_client_type.cc
new file mode 100644
index 00000000000..b9e9f62a6af
--- /dev/null
+++ b/chromium/storage/browser/quota/quota_client_type.cc
@@ -0,0 +1,24 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "storage/browser/quota/quota_client_type.h"
+
+#include "base/no_destructor.h"
+
+namespace storage {
+
+const QuotaClientTypes& AllQuotaClientTypes() {
+  static base::NoDestructor<QuotaClientTypes> all({
+      QuotaClientType::kFileSystem,
+      QuotaClientType::kDatabase,
+      QuotaClientType::kAppcache,
+      QuotaClientType::kIndexedDatabase,
+      QuotaClientType::kServiceWorkerCache,
+      QuotaClientType::kServiceWorker,
+      QuotaClientType::kBackgroundFetch,
+  });
+  return *all;
+}
+
+}  // namespace storage
diff --git a/chromium/storage/browser/quota/quota_client_type.h b/chromium/storage/browser/quota/quota_client_type.h
new file mode 100644
index 00000000000..f3c62f8eb5d
--- /dev/null
+++ b/chromium/storage/browser/quota/quota_client_type.h
@@ -0,0 +1,36 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef STORAGE_BROWSER_QUOTA_QUOTA_CLIENT_TYPE_H_
+#define STORAGE_BROWSER_QUOTA_QUOTA_CLIENT_TYPE_H_
+
+#include "base/component_export.h"
+#include "base/containers/flat_set.h"
+
+namespace storage {
+
+// Identifies storage features for browser data deletion.
+//
+// Values are not expected to be persisted or logged. Enum members may be added,
+// removed, and reordered without warning.
+enum class QuotaClientType {
+  kFileSystem = 1,
+  kDatabase = 2,
+  kIndexedDatabase = 3,
+  kServiceWorkerCache = 4,
+  kServiceWorker = 5,
+  kBackgroundFetch = 6,
+  kAppcache = 7,
+};
+
+// Set of QuotaClientType values.
+//
+// TODO(pwnall): Switch to std::bitset, or another type that's cheap to copy.
+using QuotaClientTypes = base::flat_set<QuotaClientType>;
+
+COMPONENT_EXPORT(STORAGE_BROWSER) const QuotaClientTypes& AllQuotaClientTypes();
+
+}  // namespace storage
+
+#endif  // STORAGE_BROWSER_QUOTA_QUOTA_CLIENT_TYPE_H_
diff --git a/chromium/storage/browser/quota/quota_manager.cc b/chromium/storage/browser/quota/quota_manager.cc
index 4f2ba2cb9a8..a84b117d1c1 100644
--- a/chromium/storage/browser/quota/quota_manager.cc
+++ b/chromium/storage/browser/quota/quota_manager.cc
@@ -36,6 +36,7 @@
 #include "base/trace_event/trace_event.h"
 #include "net/base/url_util.h"
 #include "storage/browser/quota/client_usage_tracker.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "storage/browser/quota/quota_features.h"
 #include "storage/browser/quota/quota_macros.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
@@ -355,12 +356,12 @@ class QuotaManager::UsageAndQuotaInfoGatherer : public QuotaTask {
 
   void OnBarrierComplete() { CallCompleted(); }
 
-  url::Origin origin_;
+  const url::Origin origin_;
   QuotaManager::UsageAndQuotaWithBreakdownCallback callback_;
-  StorageType type_;
-  bool is_unlimited_;
-  bool is_session_only_;
-  bool is_incognito_;
+  const StorageType type_;
+  const bool is_unlimited_;
+  const bool is_session_only_;
+  const bool is_incognito_;
   int64_t available_space_ = 0;
   int64_t total_space_ = 0;
   int64_t desired_host_quota_ = 0;
@@ -450,11 +451,6 @@ class QuotaManager::EvictionRoundInfoHelper : public QuotaTask {
   void OnGotGlobalUsage(int64_t usage, int64_t unlimited_usage) {
     global_usage_ = std::max(INT64_C(0), usage - unlimited_usage);
     global_usage_is_complete_ = true;
-    if (total_space_ > 0) {
-      UMA_HISTOGRAM_PERCENTAGE("Quota.PercentUsedForTemporaryStorage",
-          std::min(100,
-              static_cast<int>((global_usage_ * 100) / total_space_)));
-    }
     CallCompleted();
   }
 
@@ -537,13 +533,13 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {
   OriginDataDeleter(QuotaManager* manager,
                     const url::Origin& origin,
                     StorageType type,
-                    int quota_client_mask,
+                    QuotaClientTypes quota_client_types,
                     bool is_eviction,
                     StatusCallback callback)
       : QuotaTask(manager),
         origin_(origin),
         type_(type),
-        quota_client_mask_(quota_client_mask),
+        quota_client_types_(std::move(quota_client_types)),
         error_count_(0),
         remaining_clients_(0),
         skipped_clients_(0),
@@ -555,11 +551,11 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {
     error_count_ = 0;
     remaining_clients_ = manager()->clients_.size();
     for (const auto& client : manager()->clients_) {
-      if (quota_client_mask_ & client->id()) {
+      if (quota_client_types_.contains(client->type())) {
         static int tracing_id = 0;
         TRACE_EVENT_ASYNC_BEGIN2(
             "browsing_data", "QuotaManager::OriginDataDeleter", ++tracing_id,
-            "client_id", client->id(), "origin", origin_.Serialize());
+            "client_type", client->type(), "origin", origin_.Serialize());
         client->DeleteOriginData(
             origin_, type_,
             base::BindOnce(&OriginDataDeleter::DidDeleteOriginData,
@@ -608,13 +604,13 @@ class QuotaManager::OriginDataDeleter : public QuotaTask {
     return static_cast<QuotaManager*>(observer());
   }
 
-  url::Origin origin_;
-  StorageType type_;
-  int quota_client_mask_;
+  const url::Origin origin_;
+  const StorageType type_;
+  const QuotaClientTypes quota_client_types_;
   int error_count_;
   size_t remaining_clients_;
   int skipped_clients_;
-  bool is_eviction_;
+  const bool is_eviction_;
   StatusCallback callback_;
 
   base::WeakPtrFactory<OriginDataDeleter> weak_factory_{this};
@@ -626,12 +622,12 @@ class QuotaManager::HostDataDeleter : public QuotaTask {
   HostDataDeleter(QuotaManager* manager,
                   const std::string& host,
                   StorageType type,
-                  int quota_client_mask,
+                  QuotaClientTypes quota_client_types,
                   StatusCallback callback)
       : QuotaTask(manager),
         host_(host),
         type_(type),
-        quota_client_mask_(quota_client_mask),
+        quota_client_types_(std::move(quota_client_types)),
         error_count_(0),
         remaining_clients_(0),
         remaining_deleters_(0),
@@ -683,7 +679,7 @@ class QuotaManager::HostDataDeleter : public QuotaTask {
     remaining_deleters_ = origins_.size();
     for (const auto& origin : origins_) {
       OriginDataDeleter* deleter = new OriginDataDeleter(
-          manager(), origin, type_, quota_client_mask_, false,
+          manager(), origin, type_, std::move(quota_client_types_), false,
           base::BindOnce(&HostDataDeleter::DidDeleteOriginData,
                          weak_factory_.GetWeakPtr()));
       deleter->Start();
@@ -704,9 +700,9 @@ class QuotaManager::HostDataDeleter : public QuotaTask {
     return static_cast<QuotaManager*>(observer());
   }
 
-  std::string host_;
-  StorageType type_;
-  int quota_client_mask_;
+  const std::string host_;
+  const StorageType type_;
+  const QuotaClientTypes quota_client_types_;
   std::set<url::Origin> origins_;
   int error_count_;
   size_t remaining_clients_;
@@ -721,11 +717,11 @@ class QuotaManager::StorageCleanupHelper : public QuotaTask {
  public:
   StorageCleanupHelper(QuotaManager* manager,
                        StorageType type,
-                       int quota_client_mask,
+                       QuotaClientTypes quota_client_types,
                        base::OnceClosure callback)
       : QuotaTask(manager),
         type_(type),
-        quota_client_mask_(quota_client_mask),
+        quota_client_types_(std::move(quota_client_types)),
         callback_(std::move(callback)) {}
 
  protected:
@@ -738,7 +734,7 @@ class QuotaManager::StorageCleanupHelper : public QuotaTask {
     // 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_mask_ & client->id()) {
+      if (quota_client_types_.contains(client->type())) {
         client->PerformStorageCleanup(type_, barrier);
       } else {
         barrier.Run();
@@ -763,8 +759,8 @@ class QuotaManager::StorageCleanupHelper : public QuotaTask {
     return static_cast<QuotaManager*>(observer());
   }
 
-  StorageType type_;
-  int quota_client_mask_;
+  const StorageType type_;
+  const QuotaClientTypes quota_client_types_;
   base::OnceClosure callback_;
   base::WeakPtrFactory<StorageCleanupHelper> weak_factory_{this};
   DISALLOW_COPY_AND_ASSIGN(StorageCleanupHelper);
@@ -994,7 +990,7 @@ void QuotaManager::NotifyStorageAccessed(const url::Origin& origin,
   NotifyStorageAccessedInternal(origin, type, base::Time::Now());
 }
 
-void QuotaManager::NotifyStorageModified(QuotaClient::ID client_id,
+void QuotaManager::NotifyStorageModified(QuotaClientType client_id,
                                          const url::Origin& origin,
                                          StorageType type,
                                          int64_t delta) {
@@ -1038,7 +1034,7 @@ void QuotaManager::NotifyOriginNoLongerInUse(const url::Origin& origin) {
     origins_in_use_.erase(origin);
 }
 
-void QuotaManager::SetUsageCacheEnabled(QuotaClient::ID client_id,
+void QuotaManager::SetUsageCacheEnabled(QuotaClientType client_id,
                                         const url::Origin& origin,
                                         StorageType type,
                                         bool enabled) {
@@ -1050,25 +1046,25 @@ void QuotaManager::SetUsageCacheEnabled(QuotaClient::ID client_id,
 
 void QuotaManager::DeleteOriginData(const url::Origin& origin,
                                     StorageType type,
-                                    int quota_client_mask,
+                                    QuotaClientTypes quota_client_types,
                                     StatusCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  DeleteOriginDataInternal(origin, type, quota_client_mask, false,
+  DeleteOriginDataInternal(origin, type, std::move(quota_client_types), false,
                            std::move(callback));
 }
 
 void QuotaManager::PerformStorageCleanup(StorageType type,
-                                         int quota_client_mask,
+                                         QuotaClientTypes quota_client_types,
                                          base::OnceClosure callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   StorageCleanupHelper* deleter = new StorageCleanupHelper(
-      this, type, quota_client_mask, std::move(callback));
+      this, type, std::move(quota_client_types), std::move(callback));
   deleter->Start();
 }
 
 void QuotaManager::DeleteHostData(const std::string& host,
                                   StorageType type,
-                                  int quota_client_mask,
+                                  QuotaClientTypes quota_client_types,
                                   StatusCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   LazyInitialize();
@@ -1078,7 +1074,7 @@ void QuotaManager::DeleteHostData(const std::string& host,
   }
 
   HostDataDeleter* deleter = new HostDataDeleter(
-      this, host, type, quota_client_mask, std::move(callback));
+      this, host, type, std::move(quota_client_types), std::move(callback));
   deleter->Start();
 }
 
@@ -1160,22 +1156,6 @@ void QuotaManager::GetHostUsage(const std::string& host,
   GetUsageTracker(type)->GetHostUsage(host, std::move(callback));
 }
 
-void QuotaManager::GetHostUsage(const std::string& host,
-                                StorageType type,
-                                QuotaClient::ID client_id,
-                                UsageCallback callback) {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  LazyInitialize();
-  DCHECK(GetUsageTracker(type));
-  ClientUsageTracker* tracker =
-      GetUsageTracker(type)->GetClientTracker(client_id);
-  if (!tracker) {
-    std::move(callback).Run(0);
-    return;
-  }
-  tracker->GetHostUsage(host, std::move(callback));
-}
-
 void QuotaManager::GetHostUsageWithBreakdown(
     const std::string& host,
     StorageType type,
@@ -1186,13 +1166,6 @@ void QuotaManager::GetHostUsageWithBreakdown(
   GetUsageTracker(type)->GetHostUsageWithBreakdown(host, std::move(callback));
 }
 
-bool QuotaManager::IsTrackingHostUsage(StorageType type,
-                                       QuotaClient::ID client_id) const {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  UsageTracker* tracker = GetUsageTracker(type);
-  return tracker && tracker->GetClientTracker(client_id);
-}
-
 std::map<std::string, std::string> QuotaManager::GetStatistics() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   std::map<std::string, std::string> statistics;
@@ -1386,7 +1359,7 @@ void QuotaManager::NotifyStorageAccessedInternal(const url::Origin& origin,
                      weak_factory_.GetWeakPtr()));
 }
 
-void QuotaManager::NotifyStorageModifiedInternal(QuotaClient::ID client_id,
+void QuotaManager::NotifyStorageModifiedInternal(QuotaClientType client_id,
                                                  const url::Origin& origin,
                                                  StorageType type,
                                                  int64_t delta,
@@ -1472,7 +1445,7 @@ void QuotaManager::DidOriginDataEvicted(blink::mojom::QuotaStatusCode status) {
 
 void QuotaManager::DeleteOriginDataInternal(const url::Origin& origin,
                                             StorageType type,
-                                            int quota_client_mask,
+                                            QuotaClientTypes quota_client_types,
                                             bool is_eviction,
                                             StatusCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
@@ -1483,8 +1456,9 @@ void QuotaManager::DeleteOriginDataInternal(const url::Origin& origin,
     return;
   }
 
-  OriginDataDeleter* deleter = new OriginDataDeleter(
-      this, origin, type, quota_client_mask, is_eviction, std::move(callback));
+  OriginDataDeleter* deleter =
+      new OriginDataDeleter(this, origin, type, std::move(quota_client_types),
+                            is_eviction, std::move(callback));
   deleter->Start();
 }
 
@@ -1672,7 +1646,7 @@ void QuotaManager::EvictOriginData(const url::Origin& origin,
   eviction_context_.evicted_type = type;
   eviction_context_.evict_origin_data_callback = std::move(callback);
 
-  DeleteOriginDataInternal(origin, type, QuotaClient::kAllClientsMask, true,
+  DeleteOriginDataInternal(origin, type, AllQuotaClientTypes(), true,
                            base::BindOnce(&QuotaManager::DidOriginDataEvicted,
                                           weak_factory_.GetWeakPtr()));
 }
diff --git a/chromium/storage/browser/quota/quota_manager.h b/chromium/storage/browser/quota/quota_manager.h
index 2f199207831..7554d3615d6 100644
--- a/chromium/storage/browser/quota/quota_manager.h
+++ b/chromium/storage/browser/quota/quota_manager.h
@@ -18,6 +18,7 @@
 
 #include "base/callback.h"
 #include "base/component_export.h"
+#include "base/containers/flat_set.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ -29,11 +30,13 @@
 #include "base/timer/timer.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_settings.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-forward.h"
+#include "third_party/blink/public/mojom/quota/quota_types.mojom-shared.h"
 
 namespace base {
 class SequencedTaskRunner;
@@ -166,7 +169,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
   // 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.
-  void NotifyStorageModified(QuotaClient::ID client_id,
+  void NotifyStorageModified(QuotaClientType client_id,
                              const url::Origin& origin,
                              blink::mojom::StorageType type,
                              int64_t delta);
@@ -189,7 +192,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
     return base::Contains(origins_in_use_, origin);
   }
 
-  void SetUsageCacheEnabled(QuotaClient::ID client_id,
+  void SetUsageCacheEnabled(QuotaClientType client_id,
                             const url::Origin& origin,
                             blink::mojom::StorageType type,
                             bool enabled);
@@ -197,23 +200,22 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
   // DeleteOriginData and DeleteHostData (surprisingly enough) delete data of a
   // particular blink::mojom::StorageType associated with either a specific
   // origin or set of origins. Each method additionally requires a
-  // |quota_client_mask| which specifies the types of QuotaClients to delete
-  // from the origin. This is specified by the caller as a bitmask built from
-  // QuotaClient::IDs. Setting the mask to QuotaClient::kAllClientsMask will
-  // remove all clients from the origin, regardless of type.
+  // |quota_client_types| which specifies the types of QuotaClients to delete
+  // from the origin. Pass in QuotaClientType::AllClients() to remove all
+  // clients from the origin, regardless of type.
   virtual void DeleteOriginData(const url::Origin& origin,
                                 blink::mojom::StorageType type,
-                                int quota_client_mask,
+                                QuotaClientTypes quota_client_types,
                                 StatusCallback callback);
   void DeleteHostData(const std::string& host,
                       blink::mojom::StorageType type,
-                      int quota_client_mask,
+                      QuotaClientTypes quota_client_types,
                       StatusCallback callback);
 
   // Instructs each QuotaClient to remove possible traces of deleted
   // data on the disk.
   void PerformStorageCleanup(blink::mojom::StorageType type,
-                             int quota_client_mask,
+                             QuotaClientTypes quota_client_types,
                              base::OnceClosure callback);
 
   // Called by UI and internal modules.
@@ -226,17 +228,10 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
   void GetHostUsage(const std::string& host,
                     blink::mojom::StorageType type,
                     UsageCallback callback);
-  void GetHostUsage(const std::string& host,
-                    blink::mojom::StorageType type,
-                    QuotaClient::ID client_id,
-                    UsageCallback callback);
   void GetHostUsageWithBreakdown(const std::string& host,
                                  blink::mojom::StorageType type,
                                  UsageWithBreakdownCallback callback);
 
-  bool IsTrackingHostUsage(blink::mojom::StorageType type,
-                           QuotaClient::ID client_id) const;
-
   std::map<std::string, std::string> GetStatistics();
 
   bool IsStorageUnlimited(const url::Origin& origin,
@@ -276,7 +271,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
   friend class base::RefCountedDeleteOnSequence<QuotaManager>;
   friend class quota_internals::QuotaInternalsProxy;
   friend class MockQuotaManager;
-  friend class MockStorageClient;
+  friend class MockQuotaClient;
   friend class QuotaManagerProxy;
   friend class QuotaManagerTest;
   friend class QuotaTemporaryStorageEvictor;
@@ -346,7 +341,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
   void NotifyStorageAccessedInternal(const url::Origin& origin,
                                      blink::mojom::StorageType type,
                                      base::Time accessed_time);
-  void NotifyStorageModifiedInternal(QuotaClient::ID client_id,
+  void NotifyStorageModifiedInternal(QuotaClientType client_id,
                                      const url::Origin& origin,
                                      blink::mojom::StorageType type,
                                      int64_t delta,
@@ -357,7 +352,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManager
 
   void DeleteOriginDataInternal(const url::Origin& origin,
                                 blink::mojom::StorageType type,
-                                int quota_client_mask,
+                                QuotaClientTypes quota_client_types,
                                 bool is_eviction,
                                 StatusCallback callback);
 
diff --git a/chromium/storage/browser/quota/quota_manager_proxy.cc b/chromium/storage/browser/quota/quota_manager_proxy.cc
index fa74a10eb51..892566064d7 100644
--- a/chromium/storage/browser/quota/quota_manager_proxy.cc
+++ b/chromium/storage/browser/quota/quota_manager_proxy.cc
@@ -63,7 +63,7 @@ void QuotaManagerProxy::NotifyStorageAccessed(const url::Origin& origin,
     manager_->NotifyStorageAccessed(origin, type);
 }
 
-void QuotaManagerProxy::NotifyStorageModified(QuotaClient::ID client_id,
+void QuotaManagerProxy::NotifyStorageModified(QuotaClientType client_id,
                                               const url::Origin& origin,
                                               blink::mojom::StorageType type,
                                               int64_t delta) {
@@ -112,7 +112,7 @@ void QuotaManagerProxy::NotifyWriteFailed(const url::Origin& origin) {
     manager_->NotifyWriteFailed(origin);
 }
 
-void QuotaManagerProxy::SetUsageCacheEnabled(QuotaClient::ID client_id,
+void QuotaManagerProxy::SetUsageCacheEnabled(QuotaClientType client_id,
                                              const url::Origin& origin,
                                              blink::mojom::StorageType type,
                                              bool enabled) {
diff --git a/chromium/storage/browser/quota/quota_manager_proxy.h b/chromium/storage/browser/quota/quota_manager_proxy.h
index 98cdf5b44fb..2d1cfee778a 100644
--- a/chromium/storage/browser/quota/quota_manager_proxy.h
+++ b/chromium/storage/browser/quota/quota_manager_proxy.h
@@ -41,7 +41,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerProxy
   virtual void RegisterClient(scoped_refptr<QuotaClient> client);
   virtual void NotifyStorageAccessed(const url::Origin& origin,
                                      blink::mojom::StorageType type);
-  virtual void NotifyStorageModified(QuotaClient::ID client_id,
+  virtual void NotifyStorageModified(QuotaClientType client_id,
                                      const url::Origin& origin,
                                      blink::mojom::StorageType type,
                                      int64_t delta);
@@ -49,7 +49,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaManagerProxy
   virtual void NotifyOriginNoLongerInUse(const url::Origin& origin);
   virtual void NotifyWriteFailed(const url::Origin& origin);
 
-  virtual void SetUsageCacheEnabled(QuotaClient::ID client_id,
+  virtual void SetUsageCacheEnabled(QuotaClientType client_id,
                                     const url::Origin& origin,
                                     blink::mojom::StorageType type,
                                     bool enabled);
diff --git a/chromium/storage/browser/quota/quota_manager_unittest.cc b/chromium/storage/browser/quota/quota_manager_unittest.cc
index 14f32b69ece..e64135a246c 100644
--- a/chromium/storage/browser/quota/quota_manager_unittest.cc
+++ b/chromium/storage/browser/quota/quota_manager_unittest.cc
@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "base/bind.h"
+#include "base/containers/span.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
@@ -26,12 +27,13 @@
 #include "base/test/task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "storage/browser/quota/quota_database.h"
 #include "storage/browser/quota/quota_features.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
+#include "storage/browser/test/mock_quota_client.h"
 #include "storage/browser/test/mock_special_storage_policy.h"
-#include "storage/browser/test/mock_storage_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 #include "url/origin.h"
@@ -48,8 +50,6 @@ const StorageType kTemp = StorageType::kTemporary;
 const StorageType kPerm = StorageType::kPersistent;
 const StorageType kSync = StorageType::kSyncable;
 
-const int kAllClients = QuotaClient::kAllClientsMask;
-
 // Values in bytes.
 const int64_t kAvailableSpaceForApp = 13377331U;
 const int64_t kMustRemainAvailableForSystem = kAvailableSpaceForApp / 2;
@@ -72,6 +72,7 @@ std::tuple<int64_t, int64_t> GetVolumeInfoForTests(
 url::Origin ToOrigin(const std::string& url) {
   return url::Origin::Create(GURL(url));
 }
+
 }  // namespace
 
 class QuotaManagerTest : public testing::Test {
@@ -111,16 +112,13 @@ class QuotaManagerTest : public testing::Test {
     additional_callback_count_ = 0;
   }
 
-  MockStorageClient* CreateClient(
-      const MockOriginData* mock_data,
-      size_t mock_data_size,
-      QuotaClient::ID id) {
-    return new MockStorageClient(quota_manager_->proxy(),
-                                 mock_data, id, mock_data_size);
-  }
-
-  void RegisterClient(MockStorageClient* client) {
+  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);
+    return client;
   }
 
   void GetUsageInfo() {
@@ -244,20 +242,20 @@ class QuotaManagerTest : public testing::Test {
 
   void DeleteOriginData(const url::Origin& origin,
                         StorageType type,
-                        int quota_client_mask) {
+                        QuotaClientTypes quota_client_types) {
     quota_status_ = QuotaStatusCode::kUnknown;
     quota_manager_->DeleteOriginData(
-        origin, type, quota_client_mask,
+        origin, type, std::move(quota_client_types),
         base::BindOnce(&QuotaManagerTest::StatusCallback,
                        weak_factory_.GetWeakPtr()));
   }
 
   void DeleteHostData(const std::string& host,
                       StorageType type,
-                      int quota_client_mask) {
+                      QuotaClientTypes quota_client_types) {
     quota_status_ = QuotaStatusCode::kUnknown;
     quota_manager_->DeleteHostData(
-        host, type, quota_client_mask,
+        host, type, std::move(quota_client_types),
         base::BindOnce(&QuotaManagerTest::StatusCallback,
                        weak_factory_.GetWeakPtr()));
   }
@@ -470,6 +468,11 @@ class QuotaManagerTest : public testing::Test {
   base::test::ScopedFeatureList scoped_feature_list_;
   base::test::TaskEnvironment task_environment_;
 
+  static std::vector<QuotaClientType> AllClients() {
+    // TODO(pwnall): Implement using something other than an empty vector?
+    return {};
+  }
+
  private:
   base::Time IncrementMockTime() {
     ++mock_time_counter_;
@@ -519,10 +522,8 @@ TEST_F(QuotaManagerTest, GetUsageInfo) {
     { "http://bar.com/",       kPerm,  40 },
     { "http://example.com/",   kPerm,  40 },
   };
-  RegisterClient(
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem));
-  RegisterClient(
-      CreateClient(kData2, base::size(kData2), QuotaClient::kDatabase));
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
 
   GetUsageInfo();
   task_environment_.RunUntilIdle();
@@ -549,8 +550,7 @@ TEST_F(QuotaManagerTest, GetUsageAndQuota_Simple) {
     { "http://foo.com/", kTemp, 10 },
     { "http://foo.com/", kPerm, 80 },
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kPerm);
   task_environment_.RunUntilIdle();
@@ -603,7 +603,8 @@ TEST_F(QuotaManagerTest, GetUsage_NoClient) {
 }
 
 TEST_F(QuotaManagerTest, GetUsage_EmptyClient) {
-  RegisterClient(CreateClient(nullptr, 0, QuotaClient::kFileSystem));
+  CreateAndRegisterClient(base::span<MockOriginData>(),
+                          QuotaClientType::kFileSystem);
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(QuotaStatusCode::kOk, status());
@@ -642,8 +643,7 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_MultiOrigins) {
     { "http://baz.com/",        kTemp,  30 },
     { "http://foo.com/",        kPerm,  40 },
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   // This time explicitly sets a temporary global quota.
   const int kPoolSize = 100;
@@ -680,10 +680,8 @@ TEST_F(QuotaManagerTest, GetUsage_MultipleClients) {
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
   GetStorageCapacity();
-  RegisterClient(
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem));
-  RegisterClient(
-      CreateClient(kData2, base::size(kData2), QuotaClient::kDatabase));
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
 
   const int64_t kPoolSize = GetAvailableDiskSpaceForTest();
   const int64_t kPerHostQuota = kPoolSize / 5;
@@ -738,15 +736,9 @@ TEST_F(QuotaManagerTest, GetUsageWithBreakdown_Simple) {
   static const MockOriginData kData3[] = {
       {"http://foo.com/", kTemp, 8},
   };
-  MockStorageClient* client1 =
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem);
-  MockStorageClient* client2 =
-      CreateClient(kData2, base::size(kData2), QuotaClient::kDatabase);
-  MockStorageClient* client3 =
-      CreateClient(kData3, base::size(kData3), QuotaClient::kAppcache);
-  RegisterClient(client1);
-  RegisterClient(client2);
-  RegisterClient(client3);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData3, QuotaClientType::kAppcache);
 
   GetUsageAndQuotaWithBreakdown(ToOrigin("http://foo.com/"), kPerm);
   task_environment_.RunUntilIdle();
@@ -811,8 +803,7 @@ 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},
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GetUsageAndQuotaWithBreakdown(ToOrigin("http://foo.com/"), kTemp);
   task_environment_.RunUntilIdle();
@@ -844,10 +835,8 @@ TEST_F(QuotaManagerTest, GetUsageWithBreakdown_MultipleClients) {
       {"http://unlimited/", kTemp, 512},
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
-  RegisterClient(
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem));
-  RegisterClient(
-      CreateClient(kData2, base::size(kData2), QuotaClient::kDatabase));
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
 
   GetUsageAndQuotaWithBreakdown(ToOrigin("http://foo.com/"), kTemp);
   task_environment_.RunUntilIdle();
@@ -887,9 +876,8 @@ void QuotaManagerTest::GetUsage_WithModifyTestBody(const StorageType type) {
     { "http://foo.com/",   type,  10 },
     { "http://foo.com:1/", type,  20 },
   };
-  MockStorageClient* client =
-      CreateClient(data, base::size(data), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  MockQuotaClient* client =
+      CreateAndRegisterClient(data, QuotaClientType::kFileSystem);
 
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), type);
   task_environment_.RunUntilIdle();
@@ -929,8 +917,7 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_WithAdditionalTasks) {
     { "http://bar.com/",        kTemp, 13 },
     { "http://foo.com/",        kPerm, 40 },
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   const int kPoolSize = 100;
   const int kPerHostQuota = 20;
@@ -962,8 +949,7 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_NukeManager) {
     { "http://bar.com/",        kTemp, 13 },
     { "http://foo.com/",        kPerm, 40 },
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
   const int kPoolSize = 100;
   const int kPerHostQuota = 20;
   SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailableForSystem);
@@ -973,8 +959,8 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_NukeManager) {
   RunAdditionalUsageAndQuotaTask(ToOrigin("http://foo.com/"), kTemp);
   RunAdditionalUsageAndQuotaTask(ToOrigin("http://bar.com/"), kTemp);
 
-  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp, kAllClients);
-  DeleteOriginData(ToOrigin("http://bar.com/"), kTemp, kAllClients);
+  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp, AllQuotaClientTypes());
+  DeleteOriginData(ToOrigin("http://bar.com/"), kTemp, AllQuotaClientTypes());
 
   // Nuke before waiting for callbacks.
   set_quota_manager(nullptr);
@@ -988,8 +974,7 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Overbudget) {
     { "http://usage10/",   kTemp,  10 },
     { "http://usage200/",  kTemp, 200 },
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
   const int kPoolSize = 100;
   const int kPerHostQuota = 20;
   SetQuotaSettings(kPoolSize, kPerHostQuota, kMustRemainAvailableForSystem);
@@ -1028,9 +1013,7 @@ TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Unlimited) {
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
   GetStorageCapacity();
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   // Test when not overbugdet.
   const int kPerHostQuotaFor1000 = 200;
@@ -1149,7 +1132,8 @@ TEST_F(QuotaManagerTest, OriginInUse) {
 }
 
 TEST_F(QuotaManagerTest, GetAndSetPerststentHostQuota) {
-  RegisterClient(CreateClient(nullptr, 0, QuotaClient::kFileSystem));
+  CreateAndRegisterClient(base::span<MockOriginData>(),
+                          QuotaClientType::kFileSystem);
 
   GetPersistentHostQuota("foo.com");
   task_environment_.RunUntilIdle();
@@ -1177,7 +1161,8 @@ TEST_F(QuotaManagerTest, GetAndSetPerststentHostQuota) {
 
 TEST_F(QuotaManagerTest, GetAndSetPersistentUsageAndQuota) {
   GetStorageCapacity();
-  RegisterClient(CreateClient(nullptr, 0, QuotaClient::kFileSystem));
+  CreateAndRegisterClient(base::span<MockOriginData>(),
+                          QuotaClientType::kFileSystem);
 
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kPerm);
   task_environment_.RunUntilIdle();
@@ -1212,9 +1197,7 @@ TEST_F(QuotaManagerTest, GetQuotaLowAvailableDiskSpace) {
       {"http://unlimited/", kTemp, 4000000},
   };
 
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   const int kPoolSize = 10000000;
   const int kPerHostQuota = kPoolSize / 5;
@@ -1251,9 +1234,7 @@ TEST_F(QuotaManagerTest,
       {"http://unlimited/", kTemp, 4000000},
   };
 
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   const int kPoolSize = 10000000;
   const int kPerHostQuota = kPoolSize / 5;
@@ -1270,7 +1251,8 @@ TEST_F(QuotaManagerTest,
 }
 
 TEST_F(QuotaManagerTest, GetSyncableQuota) {
-  RegisterClient(CreateClient(nullptr, 0, QuotaClient::kFileSystem));
+  CreateAndRegisterClient(base::span<MockOriginData>(),
+                          QuotaClientType::kFileSystem);
 
   // Pre-condition check: available disk space (for testing) is less than
   // the default quota for syncable storage.
@@ -1302,8 +1284,7 @@ TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_MultiOrigins) {
     { "http://baz.com/",        kPerm, 30 },
     { "http://foo.com/",        kTemp, 40 },
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   SetPersistentHostQuota("foo.com", 100);
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kPerm);
@@ -1324,8 +1305,7 @@ TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_WithAdditionalTasks) {
     { "http://bar.com/",        kPerm,  13 },
     { "http://foo.com/",        kTemp,  40 },
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
   SetPersistentHostQuota("foo.com", 100);
 
   GetUsageAndQuotaForWebApps(ToOrigin("http://foo.com/"), kPerm);
@@ -1353,8 +1333,7 @@ TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_NukeManager) {
     { "http://bar.com/",        kPerm,  13 },
     { "http://foo.com/",        kTemp,  40 },
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
   SetPersistentHostQuota("foo.com", 100);
 
   set_additional_callback_count(0);
@@ -1378,8 +1357,7 @@ TEST_F(QuotaManagerTest, GetUsage_Simple) {
     { "http://bar.com:1/", kPerm,  600000 },
     { "http://foo.com/",   kTemp, 7000000 },
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GetGlobalUsage(kPerm);
   task_environment_.RunUntilIdle();
@@ -1411,9 +1389,8 @@ TEST_F(QuotaManagerTest, GetUsage_WithModification) {
     { "http://foo.com/",   kTemp, 7000000 },
   };
 
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  MockQuotaClient* client =
+      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GetGlobalUsage(kPerm);
   task_environment_.RunUntilIdle();
@@ -1457,9 +1434,8 @@ TEST_F(QuotaManagerTest, GetUsage_WithDeleteOrigin) {
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  MockQuotaClient* client =
+      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1511,12 +1487,8 @@ TEST_F(QuotaManagerTest, EvictOriginData) {
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  MockStorageClient* client1 =
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem);
-  MockStorageClient* client2 =
-      CreateClient(kData2, base::size(kData2), QuotaClient::kDatabase);
-  RegisterClient(client1);
-  RegisterClient(client2);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1571,9 +1543,8 @@ TEST_F(QuotaManagerTest, EvictOriginDataHistogram) {
   };
 
   base::HistogramTester histograms;
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  MockQuotaClient* client =
+      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1637,9 +1608,8 @@ TEST_F(QuotaManagerTest, EvictOriginDataWithDeletionError) {
     { "http://bar.com/",   kTemp,    4000 },
   };
   static const int kNumberOfTemporaryOrigins = 3;
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  MockQuotaClient* client =
+      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1720,9 +1690,7 @@ TEST_F(QuotaManagerTest, GetEvictionRoundInfo) {
   };
 
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   const int kPoolSize = 10000000;
   const int kPerHostQuota = kPoolSize / 5;
@@ -1740,9 +1708,7 @@ TEST_F(QuotaManagerTest, DeleteHostDataSimple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,     1 },
   };
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1756,7 +1722,7 @@ TEST_F(QuotaManagerTest, DeleteHostDataSimple) {
   task_environment_.RunUntilIdle();
   int64_t predelete_host_pers = usage();
 
-  DeleteHostData(std::string(), kTemp, kAllClients);
+  DeleteHostData(std::string(), kTemp, AllQuotaClientTypes());
   task_environment_.RunUntilIdle();
   EXPECT_EQ(QuotaStatusCode::kOk, status());
 
@@ -1772,7 +1738,7 @@ TEST_F(QuotaManagerTest, DeleteHostDataSimple) {
   task_environment_.RunUntilIdle();
   EXPECT_EQ(predelete_host_pers, usage());
 
-  DeleteHostData("foo.com", kTemp, kAllClients);
+  DeleteHostData("foo.com", kTemp, AllQuotaClientTypes());
   task_environment_.RunUntilIdle();
   EXPECT_EQ(QuotaStatusCode::kOk, status());
 
@@ -1803,12 +1769,8 @@ TEST_F(QuotaManagerTest, DeleteHostDataMultiple) {
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  MockStorageClient* client1 =
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem);
-  MockStorageClient* client2 =
-      CreateClient(kData2, base::size(kData2), QuotaClient::kDatabase);
-  RegisterClient(client1);
-  RegisterClient(client2);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1831,9 +1793,9 @@ TEST_F(QuotaManagerTest, DeleteHostDataMultiple) {
   const int64_t predelete_bar_pers = usage();
 
   reset_status_callback_count();
-  DeleteHostData("foo.com", kTemp, kAllClients);
-  DeleteHostData("bar.com", kTemp, kAllClients);
-  DeleteHostData("foo.com", kTemp, kAllClients);
+  DeleteHostData("foo.com", kTemp, AllQuotaClientTypes());
+  DeleteHostData("bar.com", kTemp, AllQuotaClientTypes());
+  DeleteHostData("foo.com", kTemp, AllQuotaClientTypes());
   task_environment_.RunUntilIdle();
 
   EXPECT_EQ(3, status_callback_count());
@@ -1889,12 +1851,8 @@ TEST_F(QuotaManagerTest, DeleteOriginDataMultiple) {
     { "https://foo.com/",  kTemp,    80 },
     { "http://bar.com/",   kTemp,     9 },
   };
-  MockStorageClient* client1 =
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem);
-  MockStorageClient* client2 =
-      CreateClient(kData2, base::size(kData2), QuotaClient::kDatabase);
-  RegisterClient(client1);
-  RegisterClient(client2);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kDatabase);
 
   GetGlobalUsage(kTemp);
   task_environment_.RunUntilIdle();
@@ -1927,9 +1885,9 @@ TEST_F(QuotaManagerTest, DeleteOriginDataMultiple) {
   task_environment_.RunUntilIdle();
 
   reset_status_callback_count();
-  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp, kAllClients);
-  DeleteOriginData(ToOrigin("http://bar.com/"), kTemp, kAllClients);
-  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp, kAllClients);
+  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp, AllQuotaClientTypes());
+  DeleteOriginData(ToOrigin("http://bar.com/"), kTemp, AllQuotaClientTypes());
+  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp, AllQuotaClientTypes());
   task_environment_.RunUntilIdle();
 
   EXPECT_EQ(3, status_callback_count());
@@ -1973,9 +1931,7 @@ TEST_F(QuotaManagerTest, GetCachedOrigins) {
     { "http://b.com/",   kPerm,     300 },
     { "http://c.com/",   kTemp,    4000 },
   };
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   // TODO(kinuko): Be careful when we add cache pruner.
 
@@ -2019,9 +1975,7 @@ TEST_F(QuotaManagerTest, NotifyAndLRUOrigin) {
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GURL origin;
   GetEvictionOrigin(kTemp);
@@ -2059,9 +2013,7 @@ TEST_F(QuotaManagerTest, GetLRUOriginWithOriginInUse) {
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GURL origin;
   GetEvictionOrigin(kTemp);
@@ -2114,9 +2066,8 @@ TEST_F(QuotaManagerTest, GetOriginsModifiedSince) {
     { "http://b.com/",   kPerm,  0 },  // persistent
     { "http://c.com/",   kTemp,  0 },
   };
-  MockStorageClient* client =
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem);
-  RegisterClient(client);
+  MockQuotaClient* client =
+      CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   GetOriginsModifiedSince(kTemp, base::Time());
   task_environment_.RunUntilIdle();
@@ -2241,44 +2192,38 @@ TEST_F(QuotaManagerTest, DeleteSpecificClientTypeSingleOrigin) {
   static const MockOriginData kData4[] = {
     { "http://foo.com/",   kTemp, 8 },
   };
-  MockStorageClient* client1 =
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem);
-  MockStorageClient* client2 =
-      CreateClient(kData2, base::size(kData2), QuotaClient::kAppcache);
-  MockStorageClient* client3 =
-      CreateClient(kData3, base::size(kData3), QuotaClient::kDatabase);
-  MockStorageClient* client4 =
-      CreateClient(kData4, base::size(kData4), QuotaClient::kIndexedDatabase);
-  RegisterClient(client1);
-  RegisterClient(client2);
-  RegisterClient(client3);
-  RegisterClient(client4);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache);
+  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase);
 
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   const int64_t predelete_foo_tmp = usage();
 
   DeleteOriginData(ToOrigin("http://foo.com/"), kTemp,
-                   QuotaClient::kFileSystem);
+                   {QuotaClientType::kFileSystem});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 1, usage());
 
-  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp, QuotaClient::kAppcache);
+  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp,
+                   {QuotaClientType::kAppcache});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 2 - 1, usage());
 
-  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp, QuotaClient::kDatabase);
+  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp,
+                   {QuotaClientType::kDatabase});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 4 - 2 - 1, usage());
 
   DeleteOriginData(ToOrigin("http://foo.com/"), kTemp,
-                   QuotaClient::kIndexedDatabase);
+                   {QuotaClientType::kIndexedDatabase});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
@@ -2298,42 +2243,34 @@ TEST_F(QuotaManagerTest, DeleteSpecificClientTypeSingleHost) {
   static const MockOriginData kData4[] = {
     { "http://foo.com:4444/",   kTemp, 8 },
   };
-  MockStorageClient* client1 =
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem);
-  MockStorageClient* client2 =
-      CreateClient(kData2, base::size(kData2), QuotaClient::kAppcache);
-  MockStorageClient* client3 =
-      CreateClient(kData3, base::size(kData3), QuotaClient::kDatabase);
-  MockStorageClient* client4 =
-      CreateClient(kData4, base::size(kData4), QuotaClient::kIndexedDatabase);
-  RegisterClient(client1);
-  RegisterClient(client2);
-  RegisterClient(client3);
-  RegisterClient(client4);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache);
+  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase);
 
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   const int64_t predelete_foo_tmp = usage();
 
-  DeleteHostData("foo.com", kTemp, QuotaClient::kFileSystem);
+  DeleteHostData("foo.com", kTemp, {QuotaClientType::kFileSystem});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 1, usage());
 
-  DeleteHostData("foo.com", kTemp, QuotaClient::kAppcache);
+  DeleteHostData("foo.com", kTemp, {QuotaClientType::kAppcache});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 2 - 1, usage());
 
-  DeleteHostData("foo.com", kTemp, QuotaClient::kDatabase);
+  DeleteHostData("foo.com", kTemp, {QuotaClientType::kDatabase});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 4 - 2 - 1, usage());
 
-  DeleteHostData("foo.com", kTemp, QuotaClient::kIndexedDatabase);
+  DeleteHostData("foo.com", kTemp, {QuotaClientType::kIndexedDatabase});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
@@ -2353,32 +2290,25 @@ TEST_F(QuotaManagerTest, DeleteMultipleClientTypesSingleOrigin) {
   static const MockOriginData kData4[] = {
     { "http://foo.com/",   kTemp, 8 },
   };
-  MockStorageClient* client1 =
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem);
-  MockStorageClient* client2 =
-      CreateClient(kData2, base::size(kData2), QuotaClient::kAppcache);
-  MockStorageClient* client3 =
-      CreateClient(kData3, base::size(kData3), QuotaClient::kDatabase);
-  MockStorageClient* client4 =
-      CreateClient(kData4, base::size(kData4), QuotaClient::kIndexedDatabase);
-  RegisterClient(client1);
-  RegisterClient(client2);
-  RegisterClient(client3);
-  RegisterClient(client4);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache);
+  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase);
 
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   const int64_t predelete_foo_tmp = usage();
 
   DeleteOriginData(ToOrigin("http://foo.com/"), kTemp,
-                   QuotaClient::kFileSystem | QuotaClient::kDatabase);
+                   {QuotaClientType::kFileSystem, QuotaClientType::kDatabase});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 4 - 1, usage());
 
-  DeleteOriginData(ToOrigin("http://foo.com/"), kTemp,
-                   QuotaClient::kAppcache | QuotaClient::kIndexedDatabase);
+  DeleteOriginData(
+      ToOrigin("http://foo.com/"), kTemp,
+      {QuotaClientType::kAppcache, QuotaClientType::kIndexedDatabase});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
@@ -2398,32 +2328,25 @@ TEST_F(QuotaManagerTest, DeleteMultipleClientTypesSingleHost) {
   static const MockOriginData kData4[] = {
     { "http://foo.com:4444/",   kTemp, 8 },
   };
-  MockStorageClient* client1 =
-      CreateClient(kData1, base::size(kData1), QuotaClient::kFileSystem);
-  MockStorageClient* client2 =
-      CreateClient(kData2, base::size(kData2), QuotaClient::kAppcache);
-  MockStorageClient* client3 =
-      CreateClient(kData3, base::size(kData3), QuotaClient::kDatabase);
-  MockStorageClient* client4 =
-      CreateClient(kData4, base::size(kData4), QuotaClient::kIndexedDatabase);
-  RegisterClient(client1);
-  RegisterClient(client2);
-  RegisterClient(client3);
-  RegisterClient(client4);
+  CreateAndRegisterClient(kData1, QuotaClientType::kFileSystem);
+  CreateAndRegisterClient(kData2, QuotaClientType::kAppcache);
+  CreateAndRegisterClient(kData3, QuotaClientType::kDatabase);
+  CreateAndRegisterClient(kData4, QuotaClientType::kIndexedDatabase);
 
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   const int64_t predelete_foo_tmp = usage();
 
   DeleteHostData("foo.com", kTemp,
-      QuotaClient::kFileSystem | QuotaClient::kAppcache);
+                 {QuotaClientType::kFileSystem, QuotaClientType::kAppcache});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 2 - 1, usage());
 
-  DeleteHostData("foo.com", kTemp,
-      QuotaClient::kDatabase | QuotaClient::kIndexedDatabase);
+  DeleteHostData(
+      "foo.com", kTemp,
+      {QuotaClientType::kDatabase, QuotaClientType::kIndexedDatabase});
   task_environment_.RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   task_environment_.RunUntilIdle();
@@ -2437,8 +2360,7 @@ TEST_F(QuotaManagerTest, GetUsageAndQuota_Incognito) {
     { "http://foo.com/", kTemp, 10 },
     { "http://foo.com/", kPerm, 80 },
   };
-  RegisterClient(
-      CreateClient(kData, base::size(kData), QuotaClient::kFileSystem));
+  CreateAndRegisterClient(kData, QuotaClientType::kFileSystem);
 
   // Query global usage to warmup the usage tracker caching.
   GetGlobalUsage(kTemp);
diff --git a/chromium/storage/browser/quota/quota_temporary_storage_evictor_unittest.cc b/chromium/storage/browser/quota/quota_temporary_storage_evictor_unittest.cc
index cde57cbcf08..df0cb6a46ac 100644
--- a/chromium/storage/browser/quota/quota_temporary_storage_evictor_unittest.cc
+++ b/chromium/storage/browser/quota/quota_temporary_storage_evictor_unittest.cc
@@ -18,7 +18,6 @@
 #include "base/test/task_environment.h"
 #include "storage/browser/quota/quota_manager.h"
 #include "storage/browser/quota/quota_temporary_storage_evictor.h"
-#include "storage/browser/test/mock_storage_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using blink::mojom::StorageType;
diff --git a/chromium/storage/browser/quota/usage_tracker.cc b/chromium/storage/browser/quota/usage_tracker.cc
index 755d72488e2..319dece4680 100644
--- a/chromium/storage/browser/quota/usage_tracker.cc
+++ b/chromium/storage/browser/quota/usage_tracker.cc
@@ -50,8 +50,9 @@ UsageTracker::UsageTracker(
     : type_(type) {
   for (const auto& client : clients) {
     if (client->DoesSupport(type)) {
-      client_tracker_map_[client->id()] = std::make_unique<ClientUsageTracker>(
-          this, client, type, special_storage_policy);
+      client_tracker_map_[client->type()] =
+          std::make_unique<ClientUsageTracker>(this, client, type,
+                                               special_storage_policy);
     }
   }
 }
@@ -60,14 +61,6 @@ UsageTracker::~UsageTracker() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
-ClientUsageTracker* UsageTracker::GetClientTracker(QuotaClient::ID client_id) {
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  auto found = client_tracker_map_.find(client_id);
-  if (found != client_tracker_map_.end())
-    return found->second.get();
-  return nullptr;
-}
-
 void UsageTracker::GetGlobalLimitedUsage(UsageCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (!global_usage_callbacks_.empty()) {
@@ -93,8 +86,8 @@ void UsageTracker::GetGlobalLimitedUsage(UsageCallback callback) {
       base::BindRepeating(&UsageTracker::AccumulateClientGlobalLimitedUsage,
                           weak_factory_.GetWeakPtr(), base::Owned(info));
 
-  for (const auto& client_id_and_tracker : client_tracker_map_)
-    client_id_and_tracker.second->GetGlobalLimitedUsage(accumulator);
+  for (const auto& client_type_and_tracker : client_tracker_map_)
+    client_type_and_tracker.second->GetGlobalLimitedUsage(accumulator);
 
   // Fire the sentinel as we've now called GetGlobalUsage for all clients.
   accumulator.Run(0);
@@ -119,8 +112,8 @@ void UsageTracker::GetGlobalUsage(GlobalUsageCallback callback) {
       base::BindRepeating(&UsageTracker::AccumulateClientGlobalUsage,
                           weak_factory_.GetWeakPtr(), base::Owned(info));
 
-  for (const auto& client_id_and_tracker : client_tracker_map_)
-    client_id_and_tracker.second->GetGlobalUsage(accumulator);
+  for (const auto& client_type_and_tracker : client_tracker_map_)
+    client_type_and_tracker.second->GetGlobalUsage(accumulator);
 
   // Fire the sentinel as we've now called GetGlobalUsage for all clients.
   accumulator.Run(0, 0);
@@ -151,37 +144,37 @@ void UsageTracker::GetHostUsageWithBreakdown(
       base::BindOnce(&UsageTracker::FinallySendHostUsageWithBreakdown,
                      weak_factory_.GetWeakPtr(), base::Owned(info), host));
 
-  for (const auto& client_id_and_tracker : client_tracker_map_) {
-    client_id_and_tracker.second->GetHostUsage(
+  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_id_and_tracker.first));
+                             client_type_and_tracker.first));
   }
 }
 
-void UsageTracker::UpdateUsageCache(QuotaClient::ID client_id,
+void UsageTracker::UpdateUsageCache(QuotaClientType client_type,
                                     const url::Origin& origin,
                                     int64_t delta) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  ClientUsageTracker* client_tracker = GetClientTracker(client_id);
-  DCHECK(client_tracker);
+  DCHECK(client_tracker_map_.count(client_type));
+  ClientUsageTracker* client_tracker = client_tracker_map_[client_type].get();
   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_id_and_tracker : client_tracker_map_)
-    usage += client_id_and_tracker.second->GetCachedUsage();
+  for (const auto& client_type_and_tracker : client_tracker_map_)
+    usage += client_type_and_tracker.second->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_id_and_tracker : client_tracker_map_) {
+  for (const auto& client_type_and_tracker : client_tracker_map_) {
     std::map<std::string, int64_t> client_host_usage =
-        client_id_and_tracker.second->GetCachedHostsUsage();
+        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;
   }
@@ -191,9 +184,9 @@ 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_id_and_tracker : client_tracker_map_) {
+  for (const auto& client_type_and_tracker : client_tracker_map_) {
     std::map<url::Origin, int64_t> client_origin_usage =
-        client_id_and_tracker.second->GetCachedOriginsUsage();
+        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;
   }
@@ -203,21 +196,21 @@ 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_id_and_tracker : client_tracker_map_) {
+  for (const auto& client_type_and_tracker : client_tracker_map_) {
     std::set<url::Origin> client_origins =
-        client_id_and_tracker.second->GetCachedOrigins();
+        client_type_and_tracker.second->GetCachedOrigins();
     for (const auto& client_origin : client_origins)
       origins.insert(client_origin);
   }
   return origins;
 }
 
-void UsageTracker::SetUsageCacheEnabled(QuotaClient::ID client_id,
+void UsageTracker::SetUsageCacheEnabled(QuotaClientType client_type,
                                         const url::Origin& origin,
                                         bool enabled) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  ClientUsageTracker* client_tracker = GetClientTracker(client_id);
-  DCHECK(client_tracker);
+  DCHECK(client_tracker_map_.count(client_type));
+  ClientUsageTracker* client_tracker = client_tracker_map_[client_type].get();
 
   client_tracker->SetUsageCacheEnabled(origin, enabled);
 }
@@ -270,7 +263,7 @@ void UsageTracker::AccumulateClientGlobalUsage(AccumulateInfo* info,
 void UsageTracker::AccumulateClientHostUsage(base::OnceClosure callback,
                                              AccumulateInfo* info,
                                              const std::string& host,
-                                             QuotaClient::ID client,
+                                             QuotaClientType client,
                                              int64_t usage) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   info->usage += usage;
@@ -279,30 +272,27 @@ void UsageTracker::AccumulateClientHostUsage(base::OnceClosure callback,
     info->usage = 0;
 
   switch (client) {
-    case QuotaClient::kFileSystem:
+    case QuotaClientType::kFileSystem:
       info->usage_breakdown->fileSystem += usage;
       break;
-    case QuotaClient::kDatabase:
+    case QuotaClientType::kDatabase:
       info->usage_breakdown->webSql += usage;
       break;
-    case QuotaClient::kAppcache:
+    case QuotaClientType::kAppcache:
       info->usage_breakdown->appcache += usage;
       break;
-    case QuotaClient::kIndexedDatabase:
+    case QuotaClientType::kIndexedDatabase:
       info->usage_breakdown->indexedDatabase += usage;
       break;
-    case QuotaClient::kServiceWorkerCache:
+    case QuotaClientType::kServiceWorkerCache:
       info->usage_breakdown->serviceWorkerCache += usage;
       break;
-    case QuotaClient::kServiceWorker:
+    case QuotaClientType::kServiceWorker:
       info->usage_breakdown->serviceWorker += usage;
       break;
-    case QuotaClient::kBackgroundFetch:
+    case QuotaClientType::kBackgroundFetch:
       info->usage_breakdown->backgroundFetch += usage;
       break;
-    case QuotaClient::kAllClientsMask:
-      NOTREACHED();
-      break;
   }
 
   std::move(callback).Run();
diff --git a/chromium/storage/browser/quota/usage_tracker.h b/chromium/storage/browser/quota/usage_tracker.h
index 4b30c46b1b2..dc5446f9eab 100644
--- a/chromium/storage/browser/quota/usage_tracker.h
+++ b/chromium/storage/browser/quota/usage_tracker.h
@@ -47,14 +47,13 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) UsageTracker
     DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     return type_;
   }
-  ClientUsageTracker* GetClientTracker(QuotaClient::ID client_id);
 
   void GetGlobalLimitedUsage(UsageCallback callback);
   void GetGlobalUsage(GlobalUsageCallback callback);
   void GetHostUsage(const std::string& host, UsageCallback callback);
   void GetHostUsageWithBreakdown(const std::string& host,
                                  UsageWithBreakdownCallback callback);
-  void UpdateUsageCache(QuotaClient::ID client_id,
+  void UpdateUsageCache(QuotaClientType client_type,
                         const url::Origin& origin,
                         int64_t delta);
   int64_t GetCachedUsage() const;
@@ -66,7 +65,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) UsageTracker
     return !global_usage_callbacks_.empty() || !host_usage_callbacks_.empty();
   }
 
-  void SetUsageCacheEnabled(QuotaClient::ID client_id,
+  void SetUsageCacheEnabled(QuotaClientType client_type,
                             const url::Origin& origin,
                             bool enabled);
 
@@ -82,13 +81,13 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) UsageTracker
   void AccumulateClientHostUsage(base::OnceClosure callback,
                                  AccumulateInfo* info,
                                  const std::string& host,
-                                 QuotaClient::ID client,
+                                 QuotaClientType client,
                                  int64_t usage);
   void FinallySendHostUsageWithBreakdown(AccumulateInfo* info,
                                          const std::string& host);
 
   const blink::mojom::StorageType type_;
-  std::map<QuotaClient::ID, std::unique_ptr<ClientUsageTracker>>
+  std::map<QuotaClientType, std::unique_ptr<ClientUsageTracker>>
       client_tracker_map_;
 
   std::vector<UsageCallback> global_limited_usage_callbacks_;
diff --git a/chromium/storage/browser/quota/usage_tracker_unittest.cc b/chromium/storage/browser/quota/usage_tracker_unittest.cc
index 5cec6b2ccaa..1b07b48c97b 100644
--- a/chromium/storage/browser/quota/usage_tracker_unittest.cc
+++ b/chromium/storage/browser/quota/usage_tracker_unittest.cc
@@ -15,6 +15,7 @@
 #include "base/test/task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "net/base/url_util.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "storage/browser/quota/usage_tracker.h"
 #include "storage/browser/test/mock_special_storage_policy.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -43,13 +44,11 @@ void DidGetUsage(bool* done, int64_t* usage_out, int64_t usage) {
   *usage_out = usage;
 }
 
-}  // namespace
-
-class MockQuotaClient : public QuotaClient {
+class UsageTrackerTestQuotaClient : public QuotaClient {
  public:
-  MockQuotaClient() = default;
+  UsageTrackerTestQuotaClient() = default;
 
-  ID id() const override { return kFileSystem; }
+  QuotaClientType type() const override { return QuotaClientType::kFileSystem; }
 
   void OnQuotaManagerDestroyed() override {}
 
@@ -119,18 +118,20 @@ class MockQuotaClient : public QuotaClient {
   }
 
  private:
-  ~MockQuotaClient() override = default;
+  ~UsageTrackerTestQuotaClient() override = default;
 
   std::map<url::Origin, int64_t> origin_usage_map_;
 
-  DISALLOW_COPY_AND_ASSIGN(MockQuotaClient);
+  DISALLOW_COPY_AND_ASSIGN(UsageTrackerTestQuotaClient);
 };
 
+}  // namespace
+
 class UsageTrackerTest : public testing::Test {
  public:
   UsageTrackerTest()
       : storage_policy_(new MockSpecialStoragePolicy()),
-        quota_client_(base::MakeRefCounted<MockQuotaClient>()),
+        quota_client_(base::MakeRefCounted<UsageTrackerTestQuotaClient>()),
         usage_tracker_(GetUsageTrackerList(),
                        StorageType::kTemporary,
                        storage_policy_.get()) {}
@@ -155,7 +156,7 @@ class UsageTrackerTest : public testing::Test {
 
   void UpdateUsage(const url::Origin& origin, int64_t delta) {
     quota_client_->UpdateUsage(origin, delta);
-    usage_tracker_.UpdateUsageCache(quota_client_->id(), origin, delta);
+    usage_tracker_.UpdateUsageCache(quota_client_->type(), origin, delta);
     base::RunLoop().RunUntilIdle();
   }
 
@@ -222,7 +223,7 @@ class UsageTrackerTest : public testing::Test {
   }
 
   void SetUsageCacheEnabled(const url::Origin& origin, bool enabled) {
-    usage_tracker_.SetUsageCacheEnabled(quota_client_->id(), origin, enabled);
+    usage_tracker_.SetUsageCacheEnabled(quota_client_->type(), origin, enabled);
   }
 
  private:
@@ -235,7 +236,7 @@ class UsageTrackerTest : public testing::Test {
   base::test::TaskEnvironment task_environment_;
 
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
-  scoped_refptr<MockQuotaClient> quota_client_;
+  scoped_refptr<UsageTrackerTestQuotaClient> quota_client_;
   UsageTracker usage_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(UsageTrackerTest);
diff --git a/chromium/storage/common/BUILD.gn b/chromium/storage/common/BUILD.gn
index 9e8d3a19651..5e76c440e76 100644
--- a/chromium/storage/common/BUILD.gn
+++ b/chromium/storage/common/BUILD.gn
@@ -17,8 +17,6 @@ component("common") {
     "file_system/file_system_types.h",
     "file_system/file_system_util.cc",
     "file_system/file_system_util.h",
-    "storage_histograms.cc",
-    "storage_histograms.h",
   ]
 
   # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
diff --git a/chromium/storage/common/database/database_connections.cc b/chromium/storage/common/database/database_connections.cc
index f7caba16dfc..d4a32d78558 100644
--- a/chromium/storage/common/database/database_connections.cc
+++ b/chromium/storage/common/database/database_connections.cc
@@ -4,7 +4,9 @@
 
 #include "storage/common/database/database_connections.h"
 
-#include "base/logging.h"
+#include <ostream>
+
+#include "base/check.h"
 
 namespace storage {
 
diff --git a/chromium/storage/common/file_system/file_system_util.cc b/chromium/storage/common/file_system/file_system_util.cc
index 6258b084ad1..3bead664f78 100644
--- a/chromium/storage/common/file_system/file_system_util.cc
+++ b/chromium/storage/common/file_system/file_system_util.cc
@@ -8,8 +8,9 @@
 
 #include <algorithm>
 
-#include "base/logging.h"
+#include "base/check.h"
 #include "base/macros.h"
+#include "base/notreached.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
diff --git a/chromium/storage/common/storage_histograms.cc b/chromium/storage/common/storage_histograms.cc
deleted file mode 100644
index fdae1a63358..00000000000
--- a/chromium/storage/common/storage_histograms.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "storage/common/storage_histograms.h"
-
-#include "base/metrics/histogram_functions.h"
-
-namespace storage {
-
-void RecordBytesWritten(const char* label, int amount) {
-  const std::string name = "Storage.BytesWritten.";
-  base::UmaHistogramCounts10M(name + label, amount);
-}
-
-void RecordBytesRead(const char* label, int amount) {
-  const std::string name = "Storage.BytesRead.";
-  base::UmaHistogramCounts10M(name + label, amount);
-}
-
-}  // namespace storage
diff --git a/chromium/storage/common/storage_histograms.h b/chromium/storage/common/storage_histograms.h
deleted file mode 100644
index 155ec6ac67c..00000000000
--- a/chromium/storage/common/storage_histograms.h
+++ /dev/null
@@ -1,21 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef STORAGE_COMMON_STORAGE_HISTOGRAMS_H_
-#define STORAGE_COMMON_STORAGE_HISTOGRAMS_H_
-
-#include <string>
-
-#include "base/component_export.h"
-
-namespace storage {
-
-COMPONENT_EXPORT(STORAGE_COMMON)
-void RecordBytesWritten(const char* label, int bytes);
-COMPONENT_EXPORT(STORAGE_COMMON)
-void RecordBytesRead(const char* label, int bytes);
-
-}  // namespace storage
-
-#endif  // STORAGE_COMMON_STORAGE_HISTOGRAMS_H_