BASELINE: Update Chromium to 91.0.4472.160

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

33 files changed, 307 insertions, 348 deletions

diff --git a/chromium/storage/browser/BUILD.gn b/chromium/storage/browser/BUILD.gn
index bb9f5ff3184..56f3b131eb4 100644
--- a/chromium/storage/browser/BUILD.gn
+++ b/chromium/storage/browser/BUILD.gn
@@ -59,6 +59,8 @@ component("browser") {
     "blob/view_blob_internals_job.h",
     "blob/write_blob_to_file.cc",
     "blob/write_blob_to_file.h",
+    "database/database_connections.cc",
+    "database/database_connections.h",
     "database/database_quota_client.cc",
     "database/database_quota_client.h",
     "database/database_tracker.cc",
@@ -277,6 +279,7 @@ source_set("unittests") {
     "blob/blob_transport_strategy_unittest.cc",
     "blob/blob_url_registry_unittest.cc",
     "blob/blob_url_store_impl_unittest.cc",
+    "database/database_connections_unittest.cc",
     "database/database_quota_client_unittest.cc",
     "database/database_tracker_unittest.cc",
     "database/database_util_unittest.cc",
diff --git a/chromium/storage/browser/blob/blob_reader.cc b/chromium/storage/browser/blob/blob_reader.cc
index 1adc28006a0..8cf4623ed7a 100644
--- a/chromium/storage/browser/blob/blob_reader.cc
+++ b/chromium/storage/browser/blob/blob_reader.cc
@@ -79,7 +79,7 @@ BlobReader::BlobReader(const BlobDataHandle* blob_handle)
     if (blob_handle->IsBroken()) {
       net_error_ = ConvertBlobErrorToNetError(blob_handle->GetBlobStatus());
     } else {
-      blob_handle_.reset(new BlobDataHandle(*blob_handle));
+      blob_handle_ = std::make_unique<BlobDataHandle>(*blob_handle);
     }
   }
 }
diff --git a/chromium/storage/browser/blob/blob_reader_unittest.cc b/chromium/storage/browser/blob/blob_reader_unittest.cc
index 26a4973299f..6d978e74714 100644
--- a/chromium/storage/browser/blob/blob_reader_unittest.cc
+++ b/chromium/storage/browser/blob/blob_reader_unittest.cc
@@ -73,14 +73,14 @@ class FakeFileStreamReader : public FileStreamReader {
   explicit FakeFileStreamReader(const std::string& contents)
       : buffer_(base::MakeRefCounted<DrainableIOBuffer>(
             base::MakeRefCounted<net::StringIOBuffer>(
-                std::unique_ptr<std::string>(new std::string(contents))),
+                std::make_unique<std::string>(contents)),
             contents.size())),
         net_error_(net::OK),
         size_(contents.size()) {}
   FakeFileStreamReader(const std::string& contents, uint64_t size)
       : buffer_(base::MakeRefCounted<DrainableIOBuffer>(
             base::MakeRefCounted<net::StringIOBuffer>(
-                std::unique_ptr<std::string>(new std::string(contents))),
+                std::make_unique<std::string>(contents)),
             contents.size())),
         net_error_(net::OK),
         size_(size) {}
@@ -801,7 +801,7 @@ TEST_F(BlobReaderTest, FileRange) {
   ExpectLocalFileCall(kPath, kTime, 0, reader.release());
 
   // We create the reader again with the offset after the seek.
-  reader.reset(new FakeFileStreamReader(kRangeData));
+  reader = std::make_unique<FakeFileStreamReader>(kRangeData);
   reader->SetAsyncRunner(base::ThreadTaskRunnerHandle::Get().get());
   ExpectLocalFileCall(kPath, kTime, kOffset, reader.release());
 
diff --git a/chromium/storage/browser/blob/blob_url_loader_factory.cc b/chromium/storage/browser/blob/blob_url_loader_factory.cc
index 48399bfbc13..a6ac1405207 100644
--- a/chromium/storage/browser/blob/blob_url_loader_factory.cc
+++ b/chromium/storage/browser/blob/blob_url_loader_factory.cc
@@ -59,7 +59,6 @@ void BlobURLLoaderFactory::Create(
 
 void BlobURLLoaderFactory::CreateLoaderAndStart(
     mojo::PendingReceiver<network::mojom::URLLoader> loader,
-    int32_t routing_id,
     int32_t request_id,
     uint32_t options,
     const network::ResourceRequest& request,
diff --git a/chromium/storage/browser/blob/blob_url_loader_factory.h b/chromium/storage/browser/blob/blob_url_loader_factory.h
index 7fcb24471bb..76ba963d9dc 100644
--- a/chromium/storage/browser/blob/blob_url_loader_factory.h
+++ b/chromium/storage/browser/blob/blob_url_loader_factory.h
@@ -39,7 +39,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) BlobURLLoaderFactory
   // URLLoaderFactory:
   void CreateLoaderAndStart(
       mojo::PendingReceiver<network::mojom::URLLoader> loader,
-      int32_t routing_id,
       int32_t request_id,
       uint32_t options,
       const network::ResourceRequest& request,
diff --git a/chromium/storage/browser/database/OWNERS b/chromium/storage/browser/database/OWNERS
index 5b2fdf3f2f4..dd55f956da2 100644
--- a/chromium/storage/browser/database/OWNERS
+++ b/chromium/storage/browser/database/OWNERS
@@ -1 +1,5 @@
+# Primary
 pwnall@chromium.org
+
+# Seconday
+mek@chromium.org
diff --git a/chromium/storage/common/database/database_connections.cc b/chromium/storage/browser/database/database_connections.cc
index d4a32d78558..22cd1e4da87 100644
--- a/chromium/storage/common/database/database_connections.cc
+++ b/chromium/storage/browser/database/database_connections.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "storage/common/database/database_connections.h"
+#include "storage/browser/database/database_connections.h"
 
 #include <ostream>
 
@@ -22,7 +22,7 @@ bool DatabaseConnections::IsEmpty() const {
 
 bool DatabaseConnections::IsDatabaseOpened(
     const std::string& origin_identifier,
-    const base::string16& database_name) const {
+    const std::u16string& database_name) const {
   auto origin_it = connections_.find(origin_identifier);
   if (origin_it == connections_.end())
     return false;
@@ -35,16 +35,15 @@ bool DatabaseConnections::IsOriginUsed(
   return (connections_.find(origin_identifier) != connections_.end());
 }
 
-bool DatabaseConnections::AddConnection(
-    const std::string& origin_identifier,
-    const base::string16& database_name) {
+bool DatabaseConnections::AddConnection(const std::string& origin_identifier,
+                                        const std::u16string& database_name) {
   int& count = connections_[origin_identifier][database_name].first;
   return ++count == 1;
 }
 
 bool DatabaseConnections::RemoveConnection(
     const std::string& origin_identifier,
-    const base::string16& database_name) {
+    const std::u16string& database_name) {
   return RemoveConnectionsHelper(origin_identifier, database_name, 1);
 }
 
@@ -52,9 +51,9 @@ void DatabaseConnections::RemoveAllConnections() {
   connections_.clear();
 }
 
-std::vector<std::pair<std::string, base::string16>>
+std::vector<std::pair<std::string, std::u16string>>
 DatabaseConnections::RemoveConnections(const DatabaseConnections& connections) {
-  std::vector<std::pair<std::string, base::string16>> closed_dbs;
+  std::vector<std::pair<std::string, std::u16string>> closed_dbs;
   for (const auto& origin_connections_pair : connections.connections_) {
     const DBConnections& db_connections = origin_connections_pair.second;
     for (const auto& count_size_pair : db_connections) {
@@ -71,7 +70,7 @@ DatabaseConnections::RemoveConnections(const DatabaseConnections& connections) {
 
 int64_t DatabaseConnections::GetOpenDatabaseSize(
     const std::string& origin_identifier,
-    const base::string16& database_name) const {
+    const std::u16string& database_name) const {
   auto origin_it = connections_.find(origin_identifier);
   DCHECK(origin_it != connections_.end()) << "Database not opened";
   auto it = origin_it->second.find(database_name);
@@ -81,15 +80,15 @@ int64_t DatabaseConnections::GetOpenDatabaseSize(
 
 void DatabaseConnections::SetOpenDatabaseSize(
     const std::string& origin_identifier,
-    const base::string16& database_name,
+    const std::u16string& database_name,
     int64_t size) {
   DCHECK(IsDatabaseOpened(origin_identifier, database_name));
   connections_[origin_identifier][database_name].second = size;
 }
 
-std::vector<std::pair<std::string, base::string16>>
+std::vector<std::pair<std::string, std::u16string>>
 DatabaseConnections::ListConnections() const {
-  std::vector<std::pair<std::string, base::string16>> list;
+  std::vector<std::pair<std::string, std::u16string>> list;
   for (const auto& origin_connections_pair : connections_) {
     const DBConnections& db_connections = origin_connections_pair.second;
     for (const auto& count_size_pair : db_connections)
@@ -100,7 +99,7 @@ DatabaseConnections::ListConnections() const {
 
 bool DatabaseConnections::RemoveConnectionsHelper(
     const std::string& origin_identifier,
-    const base::string16& database_name,
+    const std::u16string& database_name,
     int num_connections) {
   auto origin_iterator = connections_.find(origin_identifier);
   DCHECK(origin_iterator != connections_.end());
diff --git a/chromium/storage/common/database/database_connections.h b/chromium/storage/browser/database/database_connections.h
index 6636f6dc95f..cdca7fc796e 100644
--- a/chromium/storage/common/database/database_connections.h
+++ b/chromium/storage/browser/database/database_connections.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef STORAGE_COMMON_DATABASE_DATABASE_CONNECTIONS_H_
-#define STORAGE_COMMON_DATABASE_DATABASE_CONNECTIONS_H_
+#ifndef STORAGE_BROWSER_DATABASE_DATABASE_CONNECTIONS_H_
+#define STORAGE_BROWSER_DATABASE_DATABASE_CONNECTIONS_H_
 
 #include <stdint.h>
 
@@ -12,54 +12,53 @@
 #include <vector>
 
 #include "base/component_export.h"
-#include "base/strings/string16.h"
 
 namespace storage {
 
-class COMPONENT_EXPORT(STORAGE_COMMON) DatabaseConnections {
+class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseConnections {
  public:
   DatabaseConnections();
   ~DatabaseConnections();
 
   bool IsEmpty() const;
   bool IsDatabaseOpened(const std::string& origin_identifier,
-                        const base::string16& database_name) const;
+                        const std::u16string& database_name) const;
   bool IsOriginUsed(const std::string& origin_identifier) const;
 
   // Returns true if this is the first connection.
   bool AddConnection(const std::string& origin_identifier,
-                     const base::string16& database_name);
+                     const std::u16string& database_name);
 
   // Returns true if the last connection was removed.
   bool RemoveConnection(const std::string& origin_identifier,
-                        const base::string16& database_name);
+                        const std::u16string& database_name);
 
   void RemoveAllConnections();
-  std::vector<std::pair<std::string, base::string16>> RemoveConnections(
+  std::vector<std::pair<std::string, std::u16string>> RemoveConnections(
       const DatabaseConnections& connections);
 
   // Can be called only if IsDatabaseOpened would have returned true.
   int64_t GetOpenDatabaseSize(const std::string& origin_identifier,
-                              const base::string16& database_name) const;
+                              const std::u16string& database_name) const;
   void SetOpenDatabaseSize(const std::string& origin_identifier,
-                           const base::string16& database_name,
+                           const std::u16string& database_name,
                            int64_t size);
 
   // Returns a list of the connections, <origin_id, name>.
-  std::vector<std::pair<std::string, base::string16>> ListConnections() const;
+  std::vector<std::pair<std::string, std::u16string>> ListConnections() const;
 
  private:
   // Maps database names to (open count, database size).
-  using DBConnections = std::map<base::string16, std::pair<int, int64_t>>;
+  using DBConnections = std::map<std::u16string, std::pair<int, int64_t>>;
   // Maps origin identifiers to DBConnections.
   std::map<std::string, DBConnections> connections_;
 
   // Returns true if the last connection was removed.
   bool RemoveConnectionsHelper(const std::string& origin_identifier,
-                               const base::string16& database_name,
+                               const std::u16string& database_name,
                                int num_connections);
 };
 
 }  // namespace storage
 
-#endif  // STORAGE_COMMON_DATABASE_DATABASE_CONNECTIONS_H_
+#endif  // STORAGE_BROWSER_DATABASE_DATABASE_CONNECTIONS_H_
diff --git a/chromium/storage/common/database/database_connections_unittest.cc b/chromium/storage/browser/database/database_connections_unittest.cc
index ee595f91924..9dc2f25aa69 100644
--- a/chromium/storage/common/database/database_connections_unittest.cc
+++ b/chromium/storage/browser/database/database_connections_unittest.cc
@@ -4,18 +4,15 @@
 
 #include <stdint.h>
 
-#include "base/strings/utf_string_conversions.h"
-#include "storage/common/database/database_connections.h"
+#include "storage/browser/database/database_connections.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using base::ASCIIToUTF16;
-
 namespace storage {
 
 TEST(DatabaseConnectionsTest, DatabaseConnectionsTest) {
   const std::string kOriginId("origin_id");
-  const base::string16 kName(ASCIIToUTF16("database_name"));
-  const base::string16 kName2(ASCIIToUTF16("database_name2"));
+  const std::u16string kName(u"database_name");
+  const std::u16string kName2(u"database_name2");
   const int64_t kSize = 1000;
 
   DatabaseConnections connections;
@@ -52,7 +49,7 @@ TEST(DatabaseConnectionsTest, DatabaseConnectionsTest) {
   another.AddConnection(kOriginId, kName);
   another.AddConnection(kOriginId, kName2);
 
-  std::vector<std::pair<std::string, base::string16>> closed_dbs =
+  std::vector<std::pair<std::string, std::u16string>> closed_dbs =
       connections.RemoveConnections(another);
   EXPECT_EQ(1u, closed_dbs.size());
   EXPECT_EQ(kOriginId, closed_dbs[0].first);
diff --git a/chromium/storage/browser/database/database_quota_client_unittest.cc b/chromium/storage/browser/database/database_quota_client_unittest.cc
index b0c161b9aeb..203e3541364 100644
--- a/chromium/storage/browser/database/database_quota_client_unittest.cc
+++ b/chromium/storage/browser/database/database_quota_client_unittest.cc
@@ -107,7 +107,7 @@ class MockDatabaseTracker : public DatabaseTracker {
       origin_identifier_ = origin_identifier;
     }
 
-    void AddMockDatabase(const base::string16& name, int size) {
+    void AddMockDatabase(const std::u16string& name, int size) {
       EXPECT_FALSE(base::Contains(database_sizes_, name));
       database_sizes_[name] = size;
       total_size_ += size;
diff --git a/chromium/storage/browser/database/database_tracker.cc b/chromium/storage/browser/database/database_tracker.cc
index cb40db94762..806e42d4941 100644
--- a/chromium/storage/browser/database/database_tracker.cc
+++ b/chromium/storage/browser/database/database_tracker.cc
@@ -7,6 +7,7 @@
 #include <stdint.h>
 
 #include <algorithm>
+#include <memory>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ -56,12 +57,12 @@ OriginInfo::OriginInfo(const OriginInfo& origin_info) = default;
 OriginInfo::~OriginInfo() = default;
 
 void OriginInfo::GetAllDatabaseNames(
-    std::vector<base::string16>* databases) const {
+    std::vector<std::u16string>* databases) const {
   for (const auto& name_and_size : database_sizes_)
     databases->push_back(name_and_size.first);
 }
 
-int64_t OriginInfo::GetDatabaseSize(const base::string16& database_name) const {
+int64_t OriginInfo::GetDatabaseSize(const std::u16string& database_name) const {
   auto it = database_sizes_.find(database_name);
   if (it != database_sizes_.end())
     return it->second;
@@ -100,9 +101,8 @@ DatabaseTracker::~DatabaseTracker() {
 }
 
 void DatabaseTracker::DatabaseOpened(const std::string& origin_identifier,
-                                     const base::string16& database_name,
-                                     const base::string16& database_description,
-                                     int64_t estimated_size,
+                                     const std::u16string& database_name,
+                                     const std::u16string& database_description,
                                      int64_t* database_size) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (shutting_down_ || !LazyInit()) {
@@ -116,7 +116,7 @@ void DatabaseTracker::DatabaseOpened(const std::string& origin_identifier,
         blink::mojom::StorageType::kTemporary, base::Time::Now());
 
   InsertOrUpdateDatabaseDetails(origin_identifier, database_name,
-                                database_description, estimated_size);
+                                database_description);
   if (database_connections_.AddConnection(origin_identifier, database_name)) {
     *database_size = SeedOpenDatabaseInfo(origin_identifier,
                                           database_name,
@@ -129,7 +129,7 @@ void DatabaseTracker::DatabaseOpened(const std::string& origin_identifier,
 }
 
 void DatabaseTracker::DatabaseModified(const std::string& origin_identifier,
-                                       const base::string16& database_name) {
+                                       const std::u16string& database_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (!LazyInit())
     return;
@@ -137,7 +137,7 @@ void DatabaseTracker::DatabaseModified(const std::string& origin_identifier,
 }
 
 void DatabaseTracker::DatabaseClosed(const std::string& origin_identifier,
-                                     const base::string16& database_name) {
+                                     const std::u16string& database_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (database_connections_.IsEmpty()) {
     DCHECK(!is_initialized_);
@@ -156,10 +156,9 @@ void DatabaseTracker::DatabaseClosed(const std::string& origin_identifier,
     DeleteDatabaseIfNeeded(origin_identifier, database_name);
 }
 
-void DatabaseTracker::HandleSqliteError(
-    const std::string& origin_identifier,
-    const base::string16& database_name,
-    int error) {
+void DatabaseTracker::HandleSqliteError(const std::string& origin_identifier,
+                                        const std::u16string& database_name,
+                                        int error) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   // We only handle errors that indicate corruption and we
   // do so with a heavy hand, we delete it. Any renderers/workers
@@ -196,7 +195,7 @@ void DatabaseTracker::CloseDatabases(const DatabaseConnections& connections) {
 
 void DatabaseTracker::DeleteDatabaseIfNeeded(
     const std::string& origin_identifier,
-    const base::string16& database_name) {
+    const std::u16string& database_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!database_connections_.IsDatabaseOpened(origin_identifier,
                                                  database_name));
@@ -210,7 +209,7 @@ void DatabaseTracker::DeleteDatabaseIfNeeded(
     while (callback != deletion_callbacks_.end()) {
       auto found_origin = callback->second.find(origin_identifier);
       if (found_origin != callback->second.end()) {
-        std::set<base::string16>& databases = found_origin->second;
+        std::set<std::u16string>& databases = found_origin->second;
         databases.erase(database_name);
         if (databases.empty()) {
           callback->second.erase(found_origin);
@@ -257,7 +256,7 @@ base::FilePath DatabaseTracker::GetOriginDirectory(
     const std::string& origin_identifier) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
 
-  base::string16 origin_directory;
+  std::u16string origin_directory;
 
   if (!is_incognito_) {
     origin_directory = base::UTF8ToUTF16(origin_identifier);
@@ -277,7 +276,7 @@ base::FilePath DatabaseTracker::GetOriginDirectory(
 
 base::FilePath DatabaseTracker::GetFullDBFilePath(
     const std::string& origin_identifier,
-    const base::string16& database_name) {
+    const std::u16string& database_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!origin_identifier.empty());
   if (!LazyInit())
@@ -338,7 +337,7 @@ bool DatabaseTracker::GetAllOriginsInfo(
 
 bool DatabaseTracker::DeleteClosedDatabase(
     const std::string& origin_identifier,
-    const base::string16& database_name) {
+    const std::u16string& database_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   if (!LazyInit())
     return false;
@@ -446,13 +445,13 @@ bool DatabaseTracker::DeleteOrigin(const std::string& origin_identifier,
 
 bool DatabaseTracker::IsDatabaseScheduledForDeletion(
     const std::string& origin_identifier,
-    const base::string16& database_name) {
+    const std::u16string& database_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   auto it = dbs_to_be_deleted_.find(origin_identifier);
   if (it == dbs_to_be_deleted_.end())
     return false;
 
-  const std::set<base::string16>& databases = it->second;
+  const std::set<std::u16string>& databases = it->second;
   return (databases.find(database_name) != databases.end());
 }
 
@@ -492,8 +491,8 @@ bool DatabaseTracker::LazyInit() {
         return false;
     }
 
-    databases_table_.reset(new DatabasesTable(db_.get()));
-    meta_table_.reset(new sql::MetaTable());
+    databases_table_ = std::make_unique<DatabasesTable>(db_.get());
+    meta_table_ = std::make_unique<sql::MetaTable>();
 
     is_initialized_ = base::CreateDirectory(db_dir_) &&
                       (db_->is_open() ||
@@ -528,9 +527,8 @@ bool DatabaseTracker::UpgradeToCurrentVersion() {
 
 void DatabaseTracker::InsertOrUpdateDatabaseDetails(
     const std::string& origin_identifier,
-    const base::string16& database_name,
-    const base::string16& database_description,
-    int64_t estimated_size) {
+    const std::u16string& database_name,
+    const std::u16string& database_description) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DatabaseDetails details;
   if (!databases_table_->GetDatabaseDetails(
@@ -538,12 +536,9 @@ void DatabaseTracker::InsertOrUpdateDatabaseDetails(
     details.origin_identifier = origin_identifier;
     details.database_name = database_name;
     details.description = database_description;
-    details.estimated_size = estimated_size;
     databases_table_->InsertDatabaseDetails(details);
-  } else if ((details.description != database_description) ||
-             (details.estimated_size != estimated_size)) {
+  } else if (details.description != database_description) {
     details.description = database_description;
-    details.estimated_size = estimated_size;
     databases_table_->UpdateDatabaseDetails(details);
   }
 }
@@ -598,7 +593,7 @@ DatabaseTracker::CachedOriginInfo* DatabaseTracker::MaybeGetCachedOriginInfo(
 }
 
 int64_t DatabaseTracker::GetDBFileSize(const std::string& origin_identifier,
-                                       const base::string16& database_name) {
+                                       const std::u16string& database_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   base::FilePath db_file_name = GetFullDBFilePath(origin_identifier,
                                                   database_name);
@@ -610,8 +605,8 @@ int64_t DatabaseTracker::GetDBFileSize(const std::string& origin_identifier,
 
 int64_t DatabaseTracker::SeedOpenDatabaseInfo(
     const std::string& origin_id,
-    const base::string16& name,
-    const base::string16& description) {
+    const std::u16string& name,
+    const std::u16string& description) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(database_connections_.IsDatabaseOpened(origin_id, name));
   int64_t size = GetDBFileSize(origin_id, name);
@@ -625,8 +620,8 @@ int64_t DatabaseTracker::SeedOpenDatabaseInfo(
 
 int64_t DatabaseTracker::UpdateOpenDatabaseInfoAndNotify(
     const std::string& origin_id,
-    const base::string16& name,
-    const base::string16* opt_description) {
+    const std::u16string& name,
+    const std::u16string* opt_description) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(database_connections_.IsDatabaseOpened(origin_id, name));
   int64_t new_size = GetDBFileSize(origin_id, name);
@@ -649,7 +644,7 @@ int64_t DatabaseTracker::UpdateOpenDatabaseInfoAndNotify(
 
 void DatabaseTracker::ScheduleDatabaseForDeletion(
     const std::string& origin_identifier,
-    const base::string16& database_name) {
+    const std::u16string& database_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(database_connections_.IsDatabaseOpened(origin_identifier,
                                                 database_name));
@@ -667,13 +662,13 @@ void DatabaseTracker::ScheduleDatabasesForDeletion(
     deletion_callbacks_.push_back(
         std::make_pair(std::move(callback), databases));
   for (const auto& origin_dbs : databases) {
-    for (const base::string16& db : origin_dbs.second)
+    for (const std::u16string& db : origin_dbs.second)
       ScheduleDatabaseForDeletion(origin_dbs.first, db);
   }
 }
 
 void DatabaseTracker::DeleteDatabase(const std::string& origin_identifier,
-                                     const base::string16& database_name,
+                                     const std::u16string& database_name,
                                      net::CompletionOnceCallback callback) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(!callback.is_null());
@@ -793,7 +788,7 @@ void DatabaseTracker::DeleteDataForOrigin(
 }
 
 const base::File* DatabaseTracker::GetIncognitoFile(
-    const base::string16& vfs_file_name) const {
+    const std::u16string& vfs_file_name) const {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(is_incognito_);
   auto it = incognito_file_handles_.find(vfs_file_name);
@@ -804,7 +799,7 @@ const base::File* DatabaseTracker::GetIncognitoFile(
 }
 
 const base::File* DatabaseTracker::SaveIncognitoFile(
-    const base::string16& vfs_file_name,
+    const std::u16string& vfs_file_name,
     base::File file) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(is_incognito_);
@@ -819,7 +814,7 @@ const base::File* DatabaseTracker::SaveIncognitoFile(
 }
 
 void DatabaseTracker::CloseIncognitoFileHandle(
-    const base::string16& vfs_file_name) {
+    const std::u16string& vfs_file_name) {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   DCHECK(is_incognito_);
   DCHECK(incognito_file_handles_.find(vfs_file_name) !=
@@ -833,7 +828,7 @@ void DatabaseTracker::CloseIncognitoFileHandle(
 }
 
 bool DatabaseTracker::HasSavedIncognitoFileHandle(
-    const base::string16& vfs_file_name) const {
+    const std::u16string& vfs_file_name) const {
   DCHECK(task_runner_->RunsTasksInCurrentSequence());
   return (incognito_file_handles_.find(vfs_file_name) !=
           incognito_file_handles_.end());
@@ -875,7 +870,7 @@ void DatabaseTracker::ClearSessionOnlyOrigins() {
     if (special_storage_policy_->IsStorageProtected(origin_url))
       continue;
     OriginInfo origin_info;
-    std::vector<base::string16> databases;
+    std::vector<std::u16string> databases;
     GetOriginInfo(origin, &origin_info);
     origin_info.GetAllDatabaseNames(&databases);
 
diff --git a/chromium/storage/browser/database/database_tracker.h b/chromium/storage/browser/database/database_tracker.h
index e1e34ba48a3..b8cf34923fa 100644
--- a/chromium/storage/browser/database/database_tracker.h
+++ b/chromium/storage/browser/database/database_tracker.h
@@ -21,11 +21,10 @@
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "base/sequenced_task_runner.h"
-#include "base/strings/string16.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "net/base/completion_once_callback.h"
-#include "storage/common/database/database_connections.h"
+#include "storage/browser/database/database_connections.h"
 #include "url/origin.h"
 
 namespace sql {
@@ -55,8 +54,8 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) OriginInfo {
   const std::string& GetOriginIdentifier() const { return origin_identifier_; }
   int64_t TotalSize() const { return total_size_; }
   base::Time LastModified() const { return last_modified_; }
-  void GetAllDatabaseNames(std::vector<base::string16>* databases) const;
-  int64_t GetDatabaseSize(const base::string16& database_name) const;
+  void GetAllDatabaseNames(std::vector<std::u16string>* databases) const;
+  int64_t GetDatabaseSize(const std::u16string& database_name) const;
 
  protected:
   OriginInfo(const std::string& origin_identifier, int64_t total_size);
@@ -64,7 +63,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) OriginInfo {
   std::string origin_identifier_;
   int64_t total_size_;
   base::Time last_modified_;
-  std::map<base::string16, int64_t> database_sizes_;
+  std::map<std::u16string, int64_t> database_sizes_;
 };
 
 // This class manages the main database and keeps track of open databases.
@@ -79,11 +78,11 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   class Observer {
    public:
     virtual void OnDatabaseSizeChanged(const std::string& origin_identifier,
-                                       const base::string16& database_name,
+                                       const std::u16string& database_name,
                                        int64_t database_size) = 0;
     virtual void OnDatabaseScheduledForDeletion(
         const std::string& origin_identifier,
-        const base::string16& database_name) = 0;
+        const std::u16string& database_name) = 0;
 
    protected:
     virtual ~Observer() = default;
@@ -95,16 +94,15 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
                   QuotaManagerProxy* quota_manager_proxy);
 
   void DatabaseOpened(const std::string& origin_identifier,
-                      const base::string16& database_name,
-                      const base::string16& database_details,
-                      int64_t estimated_size,
+                      const std::u16string& database_name,
+                      const std::u16string& database_details,
                       int64_t* database_size);
   void DatabaseModified(const std::string& origin_identifier,
-                        const base::string16& database_name);
+                        const std::u16string& database_name);
   void DatabaseClosed(const std::string& origin_identifier,
-                      const base::string16& database_name);
+                      const std::u16string& database_name);
   void HandleSqliteError(const std::string& origin_identifier,
-                         const base::string16& database_name,
+                         const std::u16string& database_name,
                          int error);
 
   void CloseDatabases(const DatabaseConnections& connections);
@@ -118,7 +116,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   const base::FilePath& database_directory() const { return db_dir_; }
 
   base::FilePath GetFullDBFilePath(const std::string& origin_identifier,
-                                   const base::string16& database_name);
+                                   const std::u16string& database_name);
 
   // virtual for unit-testing only
   virtual bool GetOriginInfo(const std::string& origin_id, OriginInfo* info);
@@ -131,7 +129,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   }
 
   bool IsDatabaseScheduledForDeletion(const std::string& origin_identifier,
-                                      const base::string16& database_name);
+                                      const std::u16string& database_name);
 
   // Deletes a single database.
   //
@@ -139,7 +137,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   // net::Error, which will most likely be net::OK or net::FAILED. `callback`
   // may be called before this method returns.
   void DeleteDatabase(const std::string& origin_identifier,
-                      const base::string16& database_name,
+                      const std::u16string& database_name,
                       net::CompletionOnceCallback callback);
 
   // Deletes databases touched since `cutoff`.
@@ -165,11 +163,11 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
 
   bool IsIncognitoProfile() const { return is_incognito_; }
 
-  const base::File* GetIncognitoFile(const base::string16& vfs_file_path) const;
-  const base::File* SaveIncognitoFile(const base::string16& vfs_file_path,
+  const base::File* GetIncognitoFile(const std::u16string& vfs_file_path) const;
+  const base::File* SaveIncognitoFile(const std::u16string& vfs_file_path,
                                       base::File file);
-  void CloseIncognitoFileHandle(const base::string16& vfs_file_path);
-  bool HasSavedIncognitoFileHandle(const base::string16& vfs_file_path) const;
+  void CloseIncognitoFileHandle(const std::u16string& vfs_file_path);
+  bool HasSavedIncognitoFileHandle(const std::u16string& vfs_file_path) const;
 
   // Shutdown the database tracker, deleting database files if the tracker is
   // used for an Incognito profile.
@@ -184,7 +182,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   friend class DatabaseTracker_TestHelper_Test;
   friend class MockDatabaseTracker;  // for testing
 
-  using DatabaseSet = std::map<std::string, std::set<base::string16>>;
+  using DatabaseSet = std::map<std::string, std::set<std::u16string>>;
 
   class CachedOriginInfo : public OriginInfo {
    public:
@@ -192,7 +190,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
     void SetOriginIdentifier(const std::string& origin_identifier) {
       origin_identifier_ = origin_identifier;
     }
-    void SetDatabaseSize(const base::string16& database_name,
+    void SetDatabaseSize(const std::u16string& database_name,
                          int64_t new_size) {
       // If the name does not exist in the map, operator[] creates a new entry
       // with a default-constructed value. The default-constructed value for
@@ -222,21 +220,20 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   void ClearSessionOnlyOrigins();
 
   bool DeleteClosedDatabase(const std::string& origin_identifier,
-                            const base::string16& database_name);
+                            const std::u16string& database_name);
 
   // Delete all files belonging to the given origin given that no database
   // connections within this origin are open, or if |force| is true, delete
   // the meta data and rename the associated directory.
   bool DeleteOrigin(const std::string& origin_identifier, bool force);
   void DeleteDatabaseIfNeeded(const std::string& origin_identifier,
-                              const base::string16& database_name);
+                              const std::u16string& database_name);
 
   bool LazyInit();
   bool UpgradeToCurrentVersion();
   void InsertOrUpdateDatabaseDetails(const std::string& origin_identifier,
-                                     const base::string16& database_name,
-                                     const base::string16& database_details,
-                                     int64_t estimated_size);
+                                     const std::u16string& database_name,
+                                     const std::u16string& database_details);
 
   void ClearAllCachedOriginInfo();
   CachedOriginInfo* MaybeGetCachedOriginInfo(
@@ -248,23 +245,22 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   }
 
   int64_t GetDBFileSize(const std::string& origin_identifier,
-                        const base::string16& database_name);
+                        const std::u16string& database_name);
   int64_t SeedOpenDatabaseInfo(const std::string& origin_identifier,
-                               const base::string16& database_name,
-                               const base::string16& description);
+                               const std::u16string& database_name,
+                               const std::u16string& description);
   int64_t UpdateOpenDatabaseInfoAndNotify(
       const std::string& origin_identifier,
-      const base::string16& database_name,
-      const base::string16* opt_description);
+      const std::u16string& database_name,
+      const std::u16string* opt_description);
   int64_t UpdateOpenDatabaseSizeAndNotify(const std::string& origin_identifier,
-                                          const base::string16& database_name) {
+                                          const std::u16string& database_name) {
     return UpdateOpenDatabaseInfoAndNotify(origin_identifier, database_name,
                                            nullptr);
   }
 
-
   void ScheduleDatabaseForDeletion(const std::string& origin_identifier,
-                                   const base::string16& database_name);
+                                   const std::u16string& database_name);
   // Schedule a set of open databases for deletion. If non-null, callback is
   // invoked upon completion.
   void ScheduleDatabasesForDeletion(const DatabaseSet& databases,
@@ -311,7 +307,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   // main DB and journal file that was accessed. When the Incognito 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_;
+  std::map<std::u16string, 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
@@ -319,7 +315,7 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseTracker
   // (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_;
+  std::map<std::string, std::u16string> incognito_origin_directories_;
   int incognito_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 03a534a78c2..b4a517f4e47 100644
--- a/chromium/storage/browser/database/database_tracker_unittest.cc
+++ b/chromium/storage/browser/database/database_tracker_unittest.cc
@@ -16,7 +16,6 @@
 #include "base/memory/scoped_refptr.h"
 #include "base/notreached.h"
 #include "base/run_loop.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/test/bind.h"
 #include "base/test/task_environment.h"
 #include "base/threading/sequenced_task_runner_handle.h"
@@ -31,8 +30,6 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/sqlite3.h"
 
-using base::ASCIIToUTF16;
-
 namespace storage {
 
 const char kOrigin1Url[] = "http://origin1";
@@ -51,7 +48,7 @@ class TestObserver : public DatabaseTracker::Observer {
 
   ~TestObserver() override = default;
   void OnDatabaseSizeChanged(const std::string& origin_identifier,
-                             const base::string16& database_name,
+                             const std::u16string& database_name,
                              int64_t database_size) override {
     if (!observe_size_changes_)
       return;
@@ -62,7 +59,7 @@ class TestObserver : public DatabaseTracker::Observer {
   }
   void OnDatabaseScheduledForDeletion(
       const std::string& origin_identifier,
-      const base::string16& database_name) override {
+      const std::u16string& database_name) override {
     if (!observe_scheduled_deletions_)
       return;
     new_notification_received_ = true;
@@ -75,7 +72,7 @@ class TestObserver : public DatabaseTracker::Observer {
     return temp_new_notification_received;
   }
   std::string GetNotificationOriginIdentifier() { return origin_identifier_; }
-  base::string16 GetNotificationDatabaseName() { return database_name_; }
+  std::u16string GetNotificationDatabaseName() { return database_name_; }
   int64_t GetNotificationDatabaseSize() { return database_size_; }
 
  private:
@@ -83,13 +80,13 @@ class TestObserver : public DatabaseTracker::Observer {
   bool observe_size_changes_;
   bool observe_scheduled_deletions_;
   std::string origin_identifier_;
-  base::string16 database_name_;
+  std::u16string database_name_;
   int64_t database_size_;
 };
 
 void CheckNotificationReceived(TestObserver* observer,
                                const std::string& expected_origin_identifier,
-                               const base::string16& expected_database_name,
+                               const std::u16string& expected_database_name,
                                int64_t expected_database_size) {
   EXPECT_TRUE(observer->DidReceiveNewNotification());
   EXPECT_EQ(expected_origin_identifier,
@@ -228,18 +225,14 @@ class DatabaseTracker_TestHelper_Test {
               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");
+          const std::u16string kDB1 = u"db1";
+          const std::u16string kDB2 = u"db2";
+          const std::u16string kDB3 = u"db3";
+          const std::u16string kDescription = u"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);
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, &database_size);
+          tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, &database_size);
+          tracker->DatabaseOpened(kOrigin2, kDB3, kDescription, &database_size);
 
           EXPECT_TRUE(
               base::CreateDirectory(tracker->GetOriginDirectory(kOrigin1)));
@@ -270,8 +263,7 @@ class DatabaseTracker_TestHelper_Test {
           EXPECT_FALSE(base::PathExists(tracker->GetOriginDirectory(kOrigin1)));
 
           // Recreate db1.
-          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
-                                  &database_size);
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, &database_size);
           EXPECT_TRUE(
               base::CreateDirectory(tracker->GetOriginDirectory(kOrigin1)));
           EXPECT_TRUE(
@@ -346,11 +338,10 @@ class DatabaseTracker_TestHelper_Test {
               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");
+          const std::u16string kDB1 = u"db1";
+          const std::u16string kDB2 = u"db2";
+          const std::u16string kDB3 = u"db3";
+          const std::u16string kDescription = u"database_description";
 
           // Get the info for kOrigin1 and kOrigin2
           DatabaseTracker::CachedOriginInfo* origin1_info =
@@ -360,14 +351,11 @@ class DatabaseTracker_TestHelper_Test {
           EXPECT_TRUE(origin1_info);
           EXPECT_TRUE(origin2_info);
 
-          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
-                                  &database_size);
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, &database_size);
           EXPECT_EQ(0, database_size);
-          tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
-                                  &database_size);
+          tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, &database_size);
           EXPECT_EQ(0, database_size);
-          tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
-                                  &database_size);
+          tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, &database_size);
           EXPECT_EQ(0, database_size);
 
           // Write some data to each file and check that the listeners are
@@ -398,8 +386,7 @@ class DatabaseTracker_TestHelper_Test {
           tracker->DatabaseClosed(kOrigin1, kDB3);
 
           // Open an existing database and check the reported size
-          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
-                                  &database_size);
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, &database_size);
           EXPECT_EQ(1, database_size);
           tracker->DatabaseClosed(kOrigin1, kDB1);
 
@@ -410,8 +397,7 @@ class DatabaseTracker_TestHelper_Test {
           // Then make sure that DatabaseOpened() still returns the correct
           // result.
           tracker->CloseTrackerDatabaseAndClearCaches();
-          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
-                                  &database_size);
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, &database_size);
           EXPECT_EQ(1, database_size);
           tracker->DatabaseClosed(kOrigin1, kDB1);
 
@@ -419,8 +405,7 @@ class DatabaseTracker_TestHelper_Test {
           tracker->RemoveObserver(&observer1);
 
           // Trying to delete a database in use should fail
-          tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
-                                  &database_size);
+          tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, &database_size);
           EXPECT_FALSE(tracker->DeleteClosedDatabase(kOrigin1, kDB3));
           origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
           EXPECT_TRUE(origin1_info);
@@ -448,8 +433,7 @@ class DatabaseTracker_TestHelper_Test {
           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);
+          tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, &database_size);
           EXPECT_FALSE(tracker->DeleteOrigin(kOrigin1, false));
           origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
           EXPECT_TRUE(origin1_info);
@@ -473,8 +457,8 @@ class DatabaseTracker_TestHelper_Test {
   static void DatabaseTrackerQuotaIntegration(bool incognito_mode) {
     const url::Origin kOrigin(url::Origin::Create(GURL(kOrigin1Url)));
     const std::string kOriginId = GetIdentifierFromOrigin(kOrigin);
-    const base::string16 kName = ASCIIToUTF16("name");
-    const base::string16 kDescription = ASCIIToUTF16("description");
+    const std::u16string kName = u"name";
+    const std::u16string kDescription = u"description";
 
     base::test::TaskEnvironment task_environment;
     base::ScopedTempDir temp_dir;
@@ -499,7 +483,7 @@ class DatabaseTracker_TestHelper_Test {
           // then delete it. Observe the tracker notifies accordingly.
 
           int64_t database_size = 0;
-          tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+          tracker->DatabaseOpened(kOriginId, kName, kDescription,
                                   &database_size);
           EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
           test_quota_proxy->reset();
@@ -536,7 +520,7 @@ class DatabaseTracker_TestHelper_Test {
           // then close it (at which time deletion will actually occur).
           // Observe the tracker notifies accordingly.
 
-          tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+          tracker->DatabaseOpened(kOriginId, kName, kDescription,
                                   &database_size);
           EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
           test_quota_proxy->reset();
@@ -573,7 +557,7 @@ class DatabaseTracker_TestHelper_Test {
           // a renderer crash.
           // Observe the tracker notifies accordingly.
 
-          tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
+          tracker->DatabaseOpened(kOriginId, kName, kDescription,
                                   &database_size);
           EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
           test_quota_proxy->reset();
@@ -600,9 +584,9 @@ class DatabaseTracker_TestHelper_Test {
     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 kDescription = ASCIIToUTF16("database_description");
+    const std::u16string kDB1 = u"db1";
+    const std::u16string kDB2 = u"db2";
+    const std::u16string kDescription = u"database_description";
 
     // Initialize the tracker database.
     base::test::TaskEnvironment task_environment;
@@ -625,10 +609,10 @@ class DatabaseTracker_TestHelper_Test {
                 base::BindLambdaForTesting([&]() { run_loop.Quit(); }));
 
             // Open two new databases.
-            tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
+            tracker->DatabaseOpened(kOrigin1, kDB1, kDescription,
                                     &database_size);
             EXPECT_EQ(0, database_size);
-            tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
+            tracker->DatabaseOpened(kOrigin2, kDB2, kDescription,
                                     &database_size);
             EXPECT_EQ(0, database_size);
 
@@ -695,9 +679,9 @@ class DatabaseTracker_TestHelper_Test {
     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 kDescription = ASCIIToUTF16("database_description");
+    const std::u16string kDB1 = u"db1";
+    const std::u16string kDB2 = u"db2";
+    const std::u16string kDescription = u"database_description";
 
     // Initialize the tracker database.
     base::test::TaskEnvironment task_environment;
@@ -722,10 +706,10 @@ class DatabaseTracker_TestHelper_Test {
             tracker->SetForceKeepSessionState();
 
             // Open two new databases.
-            tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
+            tracker->DatabaseOpened(kOrigin1, kDB1, kDescription,
                                     &database_size);
             EXPECT_EQ(0, database_size);
-            tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
+            tracker->DatabaseOpened(kOrigin2, kDB2, kDescription,
                                     &database_size);
             EXPECT_EQ(0, database_size);
 
@@ -787,10 +771,9 @@ class DatabaseTracker_TestHelper_Test {
   static void EmptyDatabaseNameIsValid() {
     const GURL kOrigin(kOrigin1Url);
     const std::string kOriginId = GetIdentifierFromOrigin(kOrigin);
-    const base::string16 kEmptyName;
-    const base::string16 kDescription(ASCIIToUTF16("description"));
-    const base::string16 kChangedDescription(
-        ASCIIToUTF16("changed_description"));
+    const std::u16string kEmptyName;
+    const std::u16string kDescription(u"description");
+    const std::u16string kChangedDescription(u"changed_description");
 
     // Initialize a tracker database, no need to put it on disk.
     const bool kUseInMemoryTrackerDatabase = true;
@@ -813,7 +796,7 @@ class DatabaseTracker_TestHelper_Test {
 
           // Create a db with an empty name.
           int64_t database_size = -1;
-          tracker->DatabaseOpened(kOriginId, kEmptyName, kDescription, 0,
+          tracker->DatabaseOpened(kOriginId, kEmptyName, kDescription,
                                   &database_size);
           EXPECT_EQ(0, database_size);
           tracker->DatabaseModified(kOriginId, kEmptyName);
@@ -821,7 +804,7 @@ class DatabaseTracker_TestHelper_Test {
           EXPECT_EQ(1u, infos.size());
           EXPECT_FALSE(
               tracker->GetFullDBFilePath(kOriginId, kEmptyName).empty());
-          tracker->DatabaseOpened(kOriginId, kEmptyName, kChangedDescription, 0,
+          tracker->DatabaseOpened(kOriginId, kEmptyName, kChangedDescription,
                                   &database_size);
           infos.clear();
           EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
@@ -845,8 +828,8 @@ class DatabaseTracker_TestHelper_Test {
   static void HandleSqliteError() {
     const GURL kOrigin(kOrigin1Url);
     const std::string kOriginId = GetIdentifierFromOrigin(kOrigin);
-    const base::string16 kName(ASCIIToUTF16("name"));
-    const base::string16 kDescription(ASCIIToUTF16("description"));
+    const std::u16string kName(u"name");
+    const std::u16string kDescription(u"description");
 
     // Initialize a tracker database, no need to put it on disk.
     const bool kUseInMemoryTrackerDatabase = true;
@@ -876,7 +859,7 @@ class DatabaseTracker_TestHelper_Test {
           // 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,
+          tracker->DatabaseOpened(kOriginId, kName, kDescription,
                                   &database_size);
           base::FilePath spoof_db_file =
               tracker->GetFullDBFilePath(kOriginId, kName);
@@ -907,7 +890,7 @@ class DatabaseTracker_TestHelper_Test {
           // --------------------------------------------------------
           // 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,
+          tracker->DatabaseOpened(kOriginId, kName, kDescription,
                                   &database_size);
           base::FilePath spoof_db_file2 =
               tracker->GetFullDBFilePath(kOriginId, kName);
diff --git a/chromium/storage/browser/database/database_util.cc b/chromium/storage/browser/database/database_util.cc
index f555600ece4..5742c252f93 100644
--- a/chromium/storage/browser/database/database_util.cc
+++ b/chromium/storage/browser/database/database_util.cc
@@ -15,9 +15,9 @@ namespace storage {
 
 namespace {
 
-bool IsSafeSuffix(const base::string16& suffix) {
-  base::char16 prev_c = 0;
-  for (const base::char16 c : suffix) {
+bool IsSafeSuffix(const std::u16string& suffix) {
+  char16_t prev_c = 0;
+  for (const char16_t c : suffix) {
     if (!(base::IsAsciiAlpha(c) || base::IsAsciiDigit(c) || c == '-' ||
           c == '.' || c == '_')) {
       return false;
@@ -28,15 +28,14 @@ bool IsSafeSuffix(const base::string16& suffix) {
   }
   return true;
 }
-
 }
 
 const char DatabaseUtil::kJournalFileSuffix[] = "-journal";
 
-bool DatabaseUtil::CrackVfsFileName(const base::string16& vfs_file_name,
+bool DatabaseUtil::CrackVfsFileName(const std::u16string& vfs_file_name,
                                     std::string* origin_identifier,
-                                    base::string16* database_name,
-                                    base::string16* sqlite_suffix) {
+                                    std::u16string* database_name,
+                                    std::u16string* sqlite_suffix) {
   // 'vfs_file_name' is of the form <origin_identifier>/<db_name>#<suffix>.
   // <suffix> is optional.
   DCHECK(!vfs_file_name.empty());
@@ -44,9 +43,8 @@ bool DatabaseUtil::CrackVfsFileName(const base::string16& vfs_file_name,
   size_t last_pound_index = vfs_file_name.rfind('#');
   // '/' and '#' must be present in the string. Also, the string cannot start
   // with a '/' (origin_identifier cannot be empty) and '/' must come before '#'
-  if ((first_slash_index == base::string16::npos) ||
-      (last_pound_index == base::string16::npos) ||
-      (first_slash_index == 0) ||
+  if ((first_slash_index == std::u16string::npos) ||
+      (last_pound_index == std::u16string::npos) || (first_slash_index == 0) ||
       (first_slash_index > last_pound_index)) {
     return false;
   }
@@ -56,7 +54,7 @@ bool DatabaseUtil::CrackVfsFileName(const base::string16& vfs_file_name,
   if (!IsValidOriginIdentifier(origin_id))
     return false;
 
-  base::string16 suffix = vfs_file_name.substr(
+  std::u16string suffix = vfs_file_name.substr(
       last_pound_index + 1, vfs_file_name.length() - last_pound_index - 1);
   if (!IsSafeSuffix(suffix))
     return false;
@@ -76,10 +74,11 @@ bool DatabaseUtil::CrackVfsFileName(const base::string16& vfs_file_name,
 }
 
 base::FilePath DatabaseUtil::GetFullFilePathForVfsFile(
-    DatabaseTracker* db_tracker, const base::string16& vfs_file_name) {
+    DatabaseTracker* db_tracker,
+    const std::u16string& vfs_file_name) {
   std::string origin_identifier;
-  base::string16 database_name;
-  base::string16 sqlite_suffix;
+  std::u16string database_name;
+  std::u16string sqlite_suffix;
   if (!CrackVfsFileName(vfs_file_name, &origin_identifier,
                         &database_name, &sqlite_suffix)) {
     return base::FilePath(); // invalid vfs_file_name
diff --git a/chromium/storage/browser/database/database_util.h b/chromium/storage/browser/database/database_util.h
index a78e3804edb..ac72ec1190c 100644
--- a/chromium/storage/browser/database/database_util.h
+++ b/chromium/storage/browser/database/database_util.h
@@ -8,7 +8,6 @@
 #include <string>
 
 #include "base/component_export.h"
-#include "base/strings/string16.h"
 #include "url/gurl.h"
 
 namespace base {
@@ -25,13 +24,13 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseUtil {
 
   // Extract various information from a database vfs_file_name.  All return
   // parameters are optional.
-  static bool CrackVfsFileName(const base::string16& vfs_file_name,
+  static bool CrackVfsFileName(const std::u16string& vfs_file_name,
                                std::string* origin_identifier,
-                               base::string16* database_name,
-                               base::string16* sqlite_suffix);
+                               std::u16string* database_name,
+                               std::u16string* sqlite_suffix);
   static base::FilePath GetFullFilePathForVfsFile(
       DatabaseTracker* db_tracker,
-      const base::string16& vfs_file_name);
+      const std::u16string& vfs_file_name);
 };
 
 }  // namespace storage
diff --git a/chromium/storage/browser/database/database_util_unittest.cc b/chromium/storage/browser/database/database_util_unittest.cc
index 2da94bd9069..6de6151cdf3 100644
--- a/chromium/storage/browser/database/database_util_unittest.cc
+++ b/chromium/storage/browser/database/database_util_unittest.cc
@@ -20,8 +20,8 @@ void TestVfsFilePath(bool expected_result,
                      const char* expected_database_name = "",
                      const char* expected_sqlite_suffix = "") {
   std::string origin_identifier;
-  base::string16 database_name;
-  base::string16 sqlite_suffix;
+  std::u16string database_name;
+  std::u16string sqlite_suffix;
   EXPECT_EQ(expected_result,
             DatabaseUtil::CrackVfsFileName(ASCIIToUTF16(vfs_file_name),
                                            &origin_identifier, &database_name,
diff --git a/chromium/storage/browser/database/databases_table.cc b/chromium/storage/browser/database/databases_table.cc
index c5b3fed03e9..a43bcd09de3 100644
--- a/chromium/storage/browser/database/databases_table.cc
+++ b/chromium/storage/browser/database/databases_table.cc
@@ -7,12 +7,11 @@
 #include <stdint.h>
 
 #include "base/check.h"
-#include "base/strings/utf_string_conversions.h"
 #include "sql/statement.h"
 
 namespace storage {
 
-DatabaseDetails::DatabaseDetails() : estimated_size(0) { }
+DatabaseDetails::DatabaseDetails() = default;
 
 DatabaseDetails::DatabaseDetails(const DatabaseDetails& other) = default;
 
@@ -42,7 +41,7 @@ bool DatabasesTable::Init() {
 }
 
 int64_t DatabasesTable::GetDatabaseID(const std::string& origin_identifier,
-                                      const base::string16& database_name) {
+                                      const std::u16string& database_name) {
   sql::Statement select_statement(db_->GetCachedStatement(
       SQL_FROM_HERE, "SELECT id FROM Databases WHERE origin = ? AND name = ?"));
   select_statement.BindString(0, origin_identifier);
@@ -56,11 +55,11 @@ int64_t DatabasesTable::GetDatabaseID(const std::string& origin_identifier,
 }
 
 bool DatabasesTable::GetDatabaseDetails(const std::string& origin_identifier,
-                                        const base::string16& database_name,
+                                        const std::u16string& database_name,
                                         DatabaseDetails* details) {
   DCHECK(details);
   sql::Statement select_statement(db_->GetCachedStatement(
-      SQL_FROM_HERE, "SELECT description, estimated_size FROM Databases "
+      SQL_FROM_HERE, "SELECT description FROM Databases "
                      "WHERE origin = ? AND name = ?"));
   select_statement.BindString(0, origin_identifier);
   select_statement.BindString16(1, database_name);
@@ -69,7 +68,6 @@ bool DatabasesTable::GetDatabaseDetails(const std::string& origin_identifier,
     details->origin_identifier = origin_identifier;
     details->database_name = database_name;
     details->description = select_statement.ColumnString16(0);
-    details->estimated_size = select_statement.ColumnInt64(1);
     return true;
   }
 
@@ -79,30 +77,28 @@ bool DatabasesTable::GetDatabaseDetails(const std::string& origin_identifier,
 bool DatabasesTable::InsertDatabaseDetails(const DatabaseDetails& details) {
   sql::Statement insert_statement(db_->GetCachedStatement(
       SQL_FROM_HERE, "INSERT INTO Databases (origin, name, description, "
-                     "estimated_size) VALUES (?, ?, ?, ?)"));
+                     "estimated_size) VALUES (?, ?, ?, 0)"));
   insert_statement.BindString(0, details.origin_identifier);
   insert_statement.BindString16(1, details.database_name);
   insert_statement.BindString16(2, details.description);
-  insert_statement.BindInt64(3, details.estimated_size);
 
   return insert_statement.Run();
 }
 
 bool DatabasesTable::UpdateDatabaseDetails(const DatabaseDetails& details) {
   sql::Statement update_statement(db_->GetCachedStatement(
-      SQL_FROM_HERE, "UPDATE Databases SET description = ?, "
-                     "estimated_size = ? WHERE origin = ? AND name = ?"));
+      SQL_FROM_HERE, "UPDATE Databases SET description = ? "
+                     "WHERE origin = ? AND name = ?"));
   update_statement.BindString16(0, details.description);
-  update_statement.BindInt64(1, details.estimated_size);
-  update_statement.BindString(2, details.origin_identifier);
-  update_statement.BindString16(3, details.database_name);
+  update_statement.BindString(1, details.origin_identifier);
+  update_statement.BindString16(2, details.database_name);
 
   return (update_statement.Run() && db_->GetLastChangeCount());
 }
 
 bool DatabasesTable::DeleteDatabaseDetails(
     const std::string& origin_identifier,
-    const base::string16& database_name) {
+    const std::u16string& database_name) {
   sql::Statement delete_statement(db_->GetCachedStatement(
       SQL_FROM_HERE, "DELETE FROM Databases WHERE origin = ? AND name = ?"));
   delete_statement.BindString(0, origin_identifier);
@@ -126,7 +122,7 @@ bool DatabasesTable::GetAllDatabaseDetailsForOriginIdentifier(
     const std::string& origin_identifier,
     std::vector<DatabaseDetails>* details_vector) {
   sql::Statement statement(db_->GetCachedStatement(
-      SQL_FROM_HERE, "SELECT name, description, estimated_size "
+      SQL_FROM_HERE, "SELECT name, description "
                      "FROM Databases WHERE origin = ? ORDER BY name"));
   statement.BindString(0, origin_identifier);
 
@@ -135,7 +131,6 @@ bool DatabasesTable::GetAllDatabaseDetailsForOriginIdentifier(
     details.origin_identifier = origin_identifier;
     details.database_name = statement.ColumnString16(0);
     details.description = statement.ColumnString16(1);
-    details.estimated_size = statement.ColumnInt64(2);
     details_vector->push_back(details);
   }
 
diff --git a/chromium/storage/browser/database/databases_table.h b/chromium/storage/browser/database/databases_table.h
index 6057346e42a..fc7bc701a41 100644
--- a/chromium/storage/browser/database/databases_table.h
+++ b/chromium/storage/browser/database/databases_table.h
@@ -7,10 +7,10 @@
 
 #include <stdint.h>
 
+#include <string>
 #include <vector>
 
 #include "base/component_export.h"
-#include "base/strings/string16.h"
 
 namespace sql {
 class Database;
@@ -24,9 +24,8 @@ struct COMPONENT_EXPORT(STORAGE_BROWSER) DatabaseDetails {
   ~DatabaseDetails();
 
   std::string origin_identifier;
-  base::string16 database_name;
-  base::string16 description;
-  int64_t estimated_size;
+  std::u16string database_name;
+  std::u16string description;
 };
 
 class COMPONENT_EXPORT(STORAGE_BROWSER) DatabasesTable {
@@ -35,14 +34,14 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) DatabasesTable {
 
   bool Init();
   int64_t GetDatabaseID(const std::string& origin_identifier,
-                        const base::string16& database_name);
+                        const std::u16string& database_name);
   bool GetDatabaseDetails(const std::string& origin_identifier,
-                          const base::string16& database_name,
+                          const std::u16string& database_name,
                           DatabaseDetails* details);
   bool InsertDatabaseDetails(const DatabaseDetails& details);
   bool UpdateDatabaseDetails(const DatabaseDetails& details);
   bool DeleteDatabaseDetails(const std::string& origin_identifier,
-                             const base::string16& database_name);
+                             const std::u16string& database_name);
   bool GetAllOriginIdentifiers(std::vector<std::string>* origin_identifiers);
   bool GetAllDatabaseDetailsForOriginIdentifier(
       const std::string& origin_identifier,
diff --git a/chromium/storage/browser/database/databases_table_unittest.cc b/chromium/storage/browser/database/databases_table_unittest.cc
index 8a42041d789..e2d24fc5d2f 100644
--- a/chromium/storage/browser/database/databases_table_unittest.cc
+++ b/chromium/storage/browser/database/databases_table_unittest.cc
@@ -8,7 +8,6 @@
 
 #include "base/bind.h"
 #include "base/strings/string_util.h"
-#include "base/strings/utf_string_conversions.h"
 #include "sql/database.h"
 #include "sql/statement.h"
 #include "sql/test/scoped_error_expecter.h"
@@ -16,8 +15,6 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/sqlite3.h"
 
-using base::ASCIIToUTF16;
-
 namespace storage {
 
 static void CheckDetailsAreEqual(const DatabaseDetails& d1,
@@ -25,7 +22,6 @@ static void CheckDetailsAreEqual(const DatabaseDetails& d1,
   EXPECT_EQ(d1.origin_identifier, d2.origin_identifier);
   EXPECT_EQ(d1.database_name, d2.database_name);
   EXPECT_EQ(d1.description, d2.description);
-  EXPECT_EQ(d1.estimated_size, d2.estimated_size);
 }
 
 static bool DatabasesTableIsEmpty(sql::Database* db) {
@@ -58,9 +54,8 @@ TEST(DatabasesTableTest, TestIt) {
   DatabaseDetails details_in1;
   DatabaseDetails details_out1;
   details_in1.origin_identifier = "origin1";
-  details_in1.database_name = ASCIIToUTF16("db1");
-  details_in1.description = ASCIIToUTF16("description_db1");
-  details_in1.estimated_size = 100;
+  details_in1.database_name = u"db1";
+  details_in1.description = u"description_db1";
 
   // Updating details for this database should fail.
   EXPECT_FALSE(databases_table.UpdateDatabaseDetails(details_in1));
@@ -83,9 +78,8 @@ TEST(DatabasesTableTest, TestIt) {
   // Insert details for another database with the same origin.
   DatabaseDetails details_in2;
   details_in2.origin_identifier = "origin1";
-  details_in2.database_name = ASCIIToUTF16("db2");
-  details_in2.description = ASCIIToUTF16("description_db2");
-  details_in2.estimated_size = 200;
+  details_in2.database_name = u"db2";
+  details_in2.description = u"description_db2";
   EXPECT_TRUE(databases_table.InsertDatabaseDetails(details_in2));
   EXPECT_EQ(2, databases_table.GetDatabaseID(details_in2.origin_identifier,
                                              details_in2.database_name));
@@ -93,9 +87,8 @@ TEST(DatabasesTableTest, TestIt) {
   // Insert details for a third database with a different origin.
   DatabaseDetails details_in3;
   details_in3.origin_identifier = "origin2";
-  details_in3.database_name = ASCIIToUTF16("db3");
-  details_in3.description = ASCIIToUTF16("description_db3");
-  details_in3.estimated_size = 300;
+  details_in3.database_name = u"db3";
+  details_in3.description = u"description_db3";
   EXPECT_TRUE(databases_table.InsertDatabaseDetails(details_in3));
   EXPECT_EQ(3, databases_table.GetDatabaseID(details_in3.origin_identifier,
                                              details_in3.database_name));
@@ -139,8 +132,8 @@ TEST(DatabasesTableTest, TestIt) {
       details_in1.origin_identifier, details_in1.database_name, &details_out1));
 
   // Check that trying to delete a record that doesn't exist fails.
-  EXPECT_FALSE(databases_table.DeleteDatabaseDetails(
-      "unknown_origin", ASCIIToUTF16("unknown_database")));
+  EXPECT_FALSE(databases_table.DeleteDatabaseDetails("unknown_origin",
+                                                     u"unknown_database"));
 
   ASSERT_TRUE(expecter.SawExpectedErrors());
 }
diff --git a/chromium/storage/browser/database/vfs_backend.h b/chromium/storage/browser/database/vfs_backend.h
index e53b471c67e..11609c72b34 100644
--- a/chromium/storage/browser/database/vfs_backend.h
+++ b/chromium/storage/browser/database/vfs_backend.h
@@ -7,10 +7,11 @@
 
 #include <stdint.h>
 
+#include <string>
+
 #include "base/component_export.h"
 #include "base/files/file.h"
 #include "base/process/process.h"
-#include "base/strings/string16.h"
 
 namespace base {
 class FilePath;
diff --git a/chromium/storage/browser/file_system/file_system_operation_impl.cc b/chromium/storage/browser/file_system/file_system_operation_impl.cc
index a897d6f4c73..4871ad66f8a 100644
--- a/chromium/storage/browser/file_system/file_system_operation_impl.cc
+++ b/chromium/storage/browser/file_system/file_system_operation_impl.cc
@@ -14,7 +14,6 @@
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/base/escape.h"
diff --git a/chromium/storage/browser/file_system/local_file_util_unittest.cc b/chromium/storage/browser/file_system/local_file_util_unittest.cc
index c9e1b6d484b..2bdd61caedc 100644
--- a/chromium/storage/browser/file_system/local_file_util_unittest.cc
+++ b/chromium/storage/browser/file_system/local_file_util_unittest.cc
@@ -13,8 +13,6 @@
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
-#include "base/strings/sys_string_conversions.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/test/task_environment.h"
 #include "build/build_config.h"
 #include "storage/browser/file_system/async_file_util_adapter.h"
diff --git a/chromium/storage/browser/file_system/obfuscated_file_util.cc b/chromium/storage/browser/file_system/obfuscated_file_util.cc
index f2ad76f4342..014f99a4fc9 100644
--- a/chromium/storage/browser/file_system/obfuscated_file_util.cc
+++ b/chromium/storage/browser/file_system/obfuscated_file_util.cc
@@ -21,8 +21,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "base/strings/sys_string_conversions.h"
-#include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "storage/browser/file_system/file_observers.h"
 #include "storage/browser/file_system/file_system_context.h"
diff --git a/chromium/storage/browser/file_system/obfuscated_file_util_memory_delegate.cc b/chromium/storage/browser/file_system/obfuscated_file_util_memory_delegate.cc
index 20b000b6cae..b6f3dd71c66 100644
--- a/chromium/storage/browser/file_system/obfuscated_file_util_memory_delegate.cc
+++ b/chromium/storage/browser/file_system/obfuscated_file_util_memory_delegate.cc
@@ -4,8 +4,10 @@
 
 #include "storage/browser/file_system/obfuscated_file_util_memory_delegate.h"
 
+#include <algorithm>
 #include <utility>
 
+#include "base/allocator/partition_allocator/partition_alloc_constants.h"
 #include "base/files/file_util.h"
 #include "base/numerics/checked_math.h"
 #include "base/system/sys_info.h"
@@ -29,7 +31,11 @@ bool IsMemoryAvailable(int64_t required_memory) {
   // This function is not implemented on FUCHSIA, yet. (crbug.com/986608)
   return true;
 #else
-  return base::SysInfo::AmountOfAvailablePhysicalMemory() >= required_memory;
+  int64_t max_allocatable =
+      std::min(base::SysInfo::AmountOfAvailablePhysicalMemory(),
+               static_cast<int64_t>(base::MaxDirectMapped()));
+
+  return max_allocatable >= required_memory;
 #endif
 }
 
@@ -526,18 +532,37 @@ int ObfuscatedFileUtilMemoryDelegate::WriteFile(
       static_cast<size_t>(buf_len))
     return net::ERR_REQUEST_RANGE_NOT_SATISFIABLE;
 
-  // Fail if enough memory is not available.
-  if (offset_u + buf_len > dp->entry->file_content.capacity() &&
-      !IsMemoryAvailable(offset_u + buf_len)) {
-    return net::ERR_FILE_NO_SPACE;
+  const size_t last_position = offset_u + buf_len;
+  if (last_position > dp->entry->file_content.capacity()) {
+    // Fail if enough memory is not available.
+    if (!IsMemoryAvailable(last_position))
+      return net::ERR_FILE_NO_SPACE;
+
+// If required memory is bigger than half of the max allocatable memory block,
+// reserve first to avoid STL getting more than required memory.
+// See crbug.com/1043914 for more context.
+// |MaxDirectMapped| function is not implemented on FUCHSIA, yet.
+// (crbug.com/986608)
+#if !defined(OS_FUCHSIA)
+    if (last_position >= base::MaxDirectMapped() / 2) {
+      // TODO(https://crbug.com/1043914): Allocated memory is rounded up to
+      // 100MB blocks to reduce memory allocation delays. Switch to a more
+      // proper container to remove this dependency.
+      const size_t round_up_size = 100 * 1024 * 1024;
+      size_t rounded_up = ((last_position / round_up_size) + 1) * round_up_size;
+      if (!IsMemoryAvailable(rounded_up))
+        return net::ERR_FILE_NO_SPACE;
+      dp->entry->file_content.reserve(rounded_up);
+    }
+#endif
   }
 
   if (offset_u == dp->entry->file_content.size()) {
     dp->entry->file_content.insert(dp->entry->file_content.end(), buf->data(),
                                    buf->data() + buf_len);
   } else {
-    if (offset_u + buf_len > dp->entry->file_content.size())
-      dp->entry->file_content.resize(offset_u + buf_len);
+    if (last_position > dp->entry->file_content.size())
+      dp->entry->file_content.resize(last_position);
 
     // if |offset_u| is larger than the original file size, there will be null
     // bytes between the end of the file and |offset_u|.
diff --git a/chromium/storage/browser/quota/OWNERS b/chromium/storage/browser/quota/OWNERS
index 5d7b9c5d488..94ee5f99dc4 100644
--- a/chromium/storage/browser/quota/OWNERS
+++ b/chromium/storage/browser/quota/OWNERS
@@ -4,5 +4,6 @@ jarrydg@chromium.org
 # Secondary
 jsbell@chromium.org
 kinuko@chromium.org
+mek@chromium.org
 nhiroki@chromium.org
 pwnall@chromium.org
diff --git a/chromium/storage/browser/quota/quota_database.cc b/chromium/storage/browser/quota/quota_database.cc
index 6033663757b..ceba20334e4 100644
--- a/chromium/storage/browser/quota/quota_database.cc
+++ b/chromium/storage/browser/quota/quota_database.cc
@@ -7,6 +7,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <tuple>
 #include <vector>
 
@@ -191,10 +192,10 @@ bool QuotaDatabase::SetOriginLastAccessTime(const url::Origin& origin,
         " (used_count, last_access_time, origin, type, last_modified_time)"
         " VALUES (?, ?, ?, ?, ?)";
     statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
-    statement.BindInt64(4, TimeToSqlValue(last_access_time));
+    statement.BindTime(4, last_access_time);
   }
   statement.BindInt(0, entry.used_count);
-  statement.BindInt64(1, TimeToSqlValue(last_access_time));
+  statement.BindTime(1, last_access_time);
   statement.BindString(2, origin.GetURL().spec());
   statement.BindInt(3, static_cast<int>(type));
 
@@ -226,9 +227,9 @@ bool QuotaDatabase::SetOriginLastModifiedTime(const url::Origin& origin,
         "INSERT INTO OriginInfoTable"
         " (last_modified_time, origin, type, last_access_time)  VALUES (?, ?, ?, ?)";
     statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
-    statement.BindInt64(3, TimeToSqlValue(last_modified_time));
+    statement.BindTime(3, last_modified_time);
   }
-  statement.BindInt64(0, TimeToSqlValue(last_modified_time));
+  statement.BindTime(0, last_modified_time);
 
   statement.BindString(1, origin.GetURL().spec());
   statement.BindInt(2, static_cast<int>(type));
@@ -260,7 +261,7 @@ bool QuotaDatabase::GetOriginLastEvictionTime(const url::Origin& origin,
   if (!statement.Step())
     return false;
 
-  *last_modified_time = TimeFromSqlValue(statement.ColumnInt64(0));
+  *last_modified_time = statement.ColumnTime(0);
   return true;
 }
 
@@ -276,7 +277,7 @@ bool QuotaDatabase::SetOriginLastEvictionTime(const url::Origin& origin,
       " (last_eviction_time, origin, type)"
       " VALUES (?, ?, ?)";
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
-  statement.BindInt64(0, TimeToSqlValue(last_modified_time));
+  statement.BindTime(0, last_modified_time);
   statement.BindString(1, origin.GetURL().spec());
   statement.BindInt(2, static_cast<int>(type));
 
@@ -352,8 +353,7 @@ bool QuotaDatabase::GetOriginInfo(const url::Origin& origin,
   *entry = OriginInfoTableEntry(
       url::Origin::Create(GURL(statement.ColumnString(0))),
       static_cast<StorageType>(statement.ColumnInt(1)), statement.ColumnInt(2),
-      TimeFromSqlValue(statement.ColumnInt64(3)),
-      TimeFromSqlValue(statement.ColumnInt64(4)));
+      statement.ColumnTime(3), statement.ColumnTime(4));
 
   return true;
 }
@@ -462,9 +462,9 @@ bool QuotaDatabase::GetOriginsModifiedBetween(StorageType type,
     statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, kSqlQueryBetween));
   }
   statement.BindInt(0, static_cast<int>(type));
-  statement.BindInt64(1, TimeToSqlValue(begin));
+  statement.BindTime(1, begin);
   if (!end.is_max())
-    statement.BindInt64(2, TimeToSqlValue(end));
+    statement.BindTime(2, end);
 
   origins->clear();
   while (statement.Step())
@@ -529,8 +529,8 @@ bool QuotaDatabase::LazyOpen(bool create_if_needed) {
     return false;
   }
 
-  db_.reset(new sql::Database);
-  meta_table_.reset(new sql::MetaTable);
+  db_ = std::make_unique<sql::Database>();
+  meta_table_ = std::make_unique<sql::MetaTable>();
 
   db_->set_histogram_tag("Quota");
 
@@ -757,8 +757,8 @@ bool QuotaDatabase::DumpOriginInfoTable(
     OriginInfoTableEntry entry(
         url::Origin::Create(GURL(statement.ColumnString(0))),
         static_cast<StorageType>(statement.ColumnInt(1)),
-        statement.ColumnInt(2), TimeFromSqlValue(statement.ColumnInt64(3)),
-        TimeFromSqlValue(statement.ColumnInt64(4)));
+        statement.ColumnInt(2), statement.ColumnTime(3),
+        statement.ColumnTime(4));
 
     if (!callback.Run(entry))
       return true;
@@ -767,17 +767,6 @@ bool QuotaDatabase::DumpOriginInfoTable(
   return statement.Succeeded();
 }
 
-// static
-base::Time QuotaDatabase::TimeFromSqlValue(int64_t time) {
-  return base::Time::FromDeltaSinceWindowsEpoch(
-      base::TimeDelta::FromMicroseconds(time));
-}
-
-// static
-int64_t QuotaDatabase::TimeToSqlValue(const base::Time& time) {
-  return time.ToDeltaSinceWindowsEpoch().InMicroseconds();
-}
-
 bool operator<(const QuotaDatabase::QuotaTableEntry& lhs,
                const QuotaDatabase::QuotaTableEntry& rhs) {
   return std::tie(lhs.host, lhs.type, lhs.quota) <
diff --git a/chromium/storage/browser/quota/quota_database.h b/chromium/storage/browser/quota/quota_database.h
index 816b4002417..764216d9afc 100644
--- a/chromium/storage/browser/quota/quota_database.h
+++ b/chromium/storage/browser/quota/quota_database.h
@@ -191,11 +191,6 @@ class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaDatabase {
   bool DumpQuotaTable(const QuotaTableCallback& callback);
   bool DumpOriginInfoTable(const OriginInfoTableCallback& callback);
 
-  // Serialize/deserialize base::Time objects to a stable representation for
-  // persistence in the database.
-  // TODO(pwnall): Add support for base::Time values to //sql directly.
-  static base::Time TimeFromSqlValue(int64_t time);
-  static int64_t TimeToSqlValue(const base::Time& time);
 
   const base::FilePath db_file_path_;
 
diff --git a/chromium/storage/browser/quota/quota_database_unittest.cc b/chromium/storage/browser/quota/quota_database_unittest.cc
index f4c8bd611bc..8ba2e040a5c 100644
--- a/chromium/storage/browser/quota/quota_database_unittest.cc
+++ b/chromium/storage/browser/quota/quota_database_unittest.cc
@@ -132,16 +132,16 @@ class QuotaDatabaseTest : public testing::Test {
     const url::Origin kOrigin4 = url::Origin::Create(GURL("http://p/"));
 
     // Adding three temporary storages, and
-    EXPECT_TRUE(db.SetOriginLastAccessTime(
-        kOrigin1, kTemporary, QuotaDatabase::TimeFromSqlValue(10)));
-    EXPECT_TRUE(db.SetOriginLastAccessTime(
-        kOrigin2, kTemporary, QuotaDatabase::TimeFromSqlValue(20)));
-    EXPECT_TRUE(db.SetOriginLastAccessTime(
-        kOrigin3, kTemporary, QuotaDatabase::TimeFromSqlValue(30)));
+    EXPECT_TRUE(db.SetOriginLastAccessTime(kOrigin1, kTemporary,
+                                           base::Time::FromJavaTime(10)));
+    EXPECT_TRUE(db.SetOriginLastAccessTime(kOrigin2, kTemporary,
+                                           base::Time::FromJavaTime(20)));
+    EXPECT_TRUE(db.SetOriginLastAccessTime(kOrigin3, kTemporary,
+                                           base::Time::FromJavaTime(30)));
 
     // one persistent.
-    EXPECT_TRUE(db.SetOriginLastAccessTime(
-        kOrigin4, kPersistent, QuotaDatabase::TimeFromSqlValue(40)));
+    EXPECT_TRUE(db.SetOriginLastAccessTime(kOrigin4, kPersistent,
+                                           base::Time::FromJavaTime(40)));
 
     EXPECT_TRUE(db.GetLRUOrigin(kTemporary, exceptions, nullptr, &origin));
     EXPECT_EQ(kOrigin1, origin);
@@ -203,12 +203,12 @@ class QuotaDatabaseTest : public testing::Test {
     const url::Origin kOrigin3 = url::Origin::Create(GURL("http://c/"));
 
     // Report last mod time for the test origins.
-    EXPECT_TRUE(db.SetOriginLastModifiedTime(
-        kOrigin1, kTemporary, QuotaDatabase::TimeFromSqlValue(0)));
-    EXPECT_TRUE(db.SetOriginLastModifiedTime(
-        kOrigin2, kTemporary, QuotaDatabase::TimeFromSqlValue(10)));
-    EXPECT_TRUE(db.SetOriginLastModifiedTime(
-        kOrigin3, kTemporary, QuotaDatabase::TimeFromSqlValue(20)));
+    EXPECT_TRUE(db.SetOriginLastModifiedTime(kOrigin1, kTemporary,
+                                             base::Time::FromJavaTime(0)));
+    EXPECT_TRUE(db.SetOriginLastModifiedTime(kOrigin2, kTemporary,
+                                             base::Time::FromJavaTime(10)));
+    EXPECT_TRUE(db.SetOriginLastModifiedTime(kOrigin3, kTemporary,
+                                             base::Time::FromJavaTime(20)));
 
     EXPECT_TRUE(db.GetOriginsModifiedBetween(kTemporary, &origins, base::Time(),
                                              base::Time::Max()));
@@ -217,71 +217,67 @@ class QuotaDatabaseTest : public testing::Test {
     EXPECT_EQ(1U, origins.count(kOrigin2));
     EXPECT_EQ(1U, origins.count(kOrigin3));
 
-    EXPECT_TRUE(db.GetOriginsModifiedBetween(kTemporary, &origins,
-                                             QuotaDatabase::TimeFromSqlValue(5),
-                                             base::Time::Max()));
+    EXPECT_TRUE(db.GetOriginsModifiedBetween(
+        kTemporary, &origins, base::Time::FromJavaTime(5), base::Time::Max()));
     EXPECT_EQ(2U, origins.size());
     EXPECT_EQ(0U, origins.count(kOrigin1));
     EXPECT_EQ(1U, origins.count(kOrigin2));
     EXPECT_EQ(1U, origins.count(kOrigin3));
 
     EXPECT_TRUE(db.GetOriginsModifiedBetween(
-        kTemporary, &origins, QuotaDatabase::TimeFromSqlValue(15),
-        base::Time::Max()));
+        kTemporary, &origins, base::Time::FromJavaTime(15), base::Time::Max()));
     EXPECT_EQ(1U, origins.size());
     EXPECT_EQ(0U, origins.count(kOrigin1));
     EXPECT_EQ(0U, origins.count(kOrigin2));
     EXPECT_EQ(1U, origins.count(kOrigin3));
 
     EXPECT_TRUE(db.GetOriginsModifiedBetween(
-        kTemporary, &origins, QuotaDatabase::TimeFromSqlValue(25),
-        base::Time::Max()));
+        kTemporary, &origins, base::Time::FromJavaTime(25), base::Time::Max()));
     EXPECT_TRUE(origins.empty());
 
-    EXPECT_TRUE(db.GetOriginsModifiedBetween(
-        kTemporary, &origins, QuotaDatabase::TimeFromSqlValue(5),
-        QuotaDatabase::TimeFromSqlValue(15)));
+    EXPECT_TRUE(db.GetOriginsModifiedBetween(kTemporary, &origins,
+                                             base::Time::FromJavaTime(5),
+                                             base::Time::FromJavaTime(15)));
     EXPECT_EQ(1U, origins.size());
     EXPECT_EQ(0U, origins.count(kOrigin1));
     EXPECT_EQ(1U, origins.count(kOrigin2));
     EXPECT_EQ(0U, origins.count(kOrigin3));
 
-    EXPECT_TRUE(db.GetOriginsModifiedBetween(
-        kTemporary, &origins, QuotaDatabase::TimeFromSqlValue(0),
-        QuotaDatabase::TimeFromSqlValue(20)));
+    EXPECT_TRUE(db.GetOriginsModifiedBetween(kTemporary, &origins,
+                                             base::Time::FromJavaTime(0),
+                                             base::Time::FromJavaTime(20)));
     EXPECT_EQ(2U, origins.size());
     EXPECT_EQ(1U, origins.count(kOrigin1));
     EXPECT_EQ(1U, origins.count(kOrigin2));
     EXPECT_EQ(0U, origins.count(kOrigin3));
 
     // Update origin1's mod time but for persistent storage.
-    EXPECT_TRUE(db.SetOriginLastModifiedTime(
-        kOrigin1, kPersistent, QuotaDatabase::TimeFromSqlValue(30)));
+    EXPECT_TRUE(db.SetOriginLastModifiedTime(kOrigin1, kPersistent,
+                                             base::Time::FromJavaTime(30)));
 
     // Must have no effects on temporary origins info.
-    EXPECT_TRUE(db.GetOriginsModifiedBetween(kTemporary, &origins,
-                                             QuotaDatabase::TimeFromSqlValue(5),
-                                             base::Time::Max()));
+    EXPECT_TRUE(db.GetOriginsModifiedBetween(
+        kTemporary, &origins, base::Time::FromJavaTime(5), base::Time::Max()));
     EXPECT_EQ(2U, origins.size());
     EXPECT_EQ(0U, origins.count(kOrigin1));
     EXPECT_EQ(1U, origins.count(kOrigin2));
     EXPECT_EQ(1U, origins.count(kOrigin3));
 
     // One more update for persistent origin2.
-    EXPECT_TRUE(db.SetOriginLastModifiedTime(
-        kOrigin2, kPersistent, QuotaDatabase::TimeFromSqlValue(40)));
+    EXPECT_TRUE(db.SetOriginLastModifiedTime(kOrigin2, kPersistent,
+                                             base::Time::FromJavaTime(40)));
 
-    EXPECT_TRUE(db.GetOriginsModifiedBetween(
-        kPersistent, &origins, QuotaDatabase::TimeFromSqlValue(25),
-        base::Time::Max()));
+    EXPECT_TRUE(db.GetOriginsModifiedBetween(kPersistent, &origins,
+                                             base::Time::FromJavaTime(25),
+                                             base::Time::Max()));
     EXPECT_EQ(2U, origins.size());
     EXPECT_EQ(1U, origins.count(kOrigin1));
     EXPECT_EQ(1U, origins.count(kOrigin2));
     EXPECT_EQ(0U, origins.count(kOrigin3));
 
-    EXPECT_TRUE(db.GetOriginsModifiedBetween(
-        kPersistent, &origins, QuotaDatabase::TimeFromSqlValue(35),
-        base::Time::Max()));
+    EXPECT_TRUE(db.GetOriginsModifiedBetween(kPersistent, &origins,
+                                             base::Time::FromJavaTime(35),
+                                             base::Time::Max()));
     EXPECT_EQ(1U, origins.size());
     EXPECT_EQ(0U, origins.count(kOrigin1));
     EXPECT_EQ(1U, origins.count(kOrigin2));
@@ -302,22 +298,22 @@ class QuotaDatabaseTest : public testing::Test {
     EXPECT_EQ(base::Time(), last_eviction_time);
 
     // Report last eviction time for the test origins.
-    EXPECT_TRUE(db.SetOriginLastEvictionTime(
-        kOrigin1, kTemporary, QuotaDatabase::TimeFromSqlValue(10)));
-    EXPECT_TRUE(db.SetOriginLastEvictionTime(
-        kOrigin2, kTemporary, QuotaDatabase::TimeFromSqlValue(20)));
-    EXPECT_TRUE(db.SetOriginLastEvictionTime(
-        kOrigin3, kTemporary, QuotaDatabase::TimeFromSqlValue(30)));
+    EXPECT_TRUE(db.SetOriginLastEvictionTime(kOrigin1, kTemporary,
+                                             base::Time::FromJavaTime(10)));
+    EXPECT_TRUE(db.SetOriginLastEvictionTime(kOrigin2, kTemporary,
+                                             base::Time::FromJavaTime(20)));
+    EXPECT_TRUE(db.SetOriginLastEvictionTime(kOrigin3, kTemporary,
+                                             base::Time::FromJavaTime(30)));
 
     EXPECT_TRUE(db.GetOriginLastEvictionTime(kOrigin1, kTemporary,
                                              &last_eviction_time));
-    EXPECT_EQ(QuotaDatabase::TimeFromSqlValue(10), last_eviction_time);
+    EXPECT_EQ(base::Time::FromJavaTime(10), last_eviction_time);
     EXPECT_TRUE(db.GetOriginLastEvictionTime(kOrigin2, kTemporary,
                                              &last_eviction_time));
-    EXPECT_EQ(QuotaDatabase::TimeFromSqlValue(20), last_eviction_time);
+    EXPECT_EQ(base::Time::FromJavaTime(20), last_eviction_time);
     EXPECT_TRUE(db.GetOriginLastEvictionTime(kOrigin3, kTemporary,
                                              &last_eviction_time));
-    EXPECT_EQ(QuotaDatabase::TimeFromSqlValue(30), last_eviction_time);
+    EXPECT_EQ(base::Time::FromJavaTime(30), last_eviction_time);
 
     // Delete last eviction times for the test origins.
     EXPECT_TRUE(db.DeleteOriginLastEvictionTime(kOrigin1, kTemporary));
@@ -497,10 +493,8 @@ class QuotaDatabaseTest : public testing::Test {
       statement.BindString(0, itr->origin.GetURL().spec());
       statement.BindInt(1, static_cast<int>(itr->type));
       statement.BindInt(2, itr->used_count);
-      statement.BindInt64(3,
-                          QuotaDatabase::TimeToSqlValue(itr->last_access_time));
-      statement.BindInt64(
-          4, QuotaDatabase::TimeToSqlValue(itr->last_modified_time));
+      statement.BindTime(3, itr->last_access_time);
+      statement.BindTime(4, itr->last_modified_time);
       EXPECT_TRUE(statement.Run());
     }
   }
diff --git a/chromium/storage/browser/quota/quota_device_info_helper.cc b/chromium/storage/browser/quota/quota_device_info_helper.cc
index 23f5c2889e6..8f415442983 100644
--- a/chromium/storage/browser/quota/quota_device_info_helper.cc
+++ b/chromium/storage/browser/quota/quota_device_info_helper.cc
@@ -4,13 +4,17 @@
 
 #include "storage/browser/quota/quota_device_info_helper.h"
 
+#include "base/metrics/histogram_macros.h"
+
 namespace storage {
 
 QuotaDeviceInfoHelper::~QuotaDeviceInfoHelper() = default;
 
 int64_t QuotaDeviceInfoHelper::AmountOfTotalDiskSpace(
     const base::FilePath& path) const {
-  return base::SysInfo::AmountOfTotalDiskSpace(path);
+  int64_t disk_space = base::SysInfo::AmountOfTotalDiskSpace(path);
+  UMA_HISTOGRAM_BOOLEAN("Quota.TotalDiskSpaceIsZero", disk_space <= 0);
+  return disk_space;
 }
 
 int64_t QuotaDeviceInfoHelper::AmountOfPhysicalMemory() const {
diff --git a/chromium/storage/browser/quota/quota_manager_unittest.cc b/chromium/storage/browser/quota/quota_manager_unittest.cc
index 08458755356..691e6195b4f 100644
--- a/chromium/storage/browser/quota/quota_manager_unittest.cc
+++ b/chromium/storage/browser/quota/quota_manager_unittest.cc
@@ -64,7 +64,7 @@ const int64_t kAvailableSpaceForApp = 13377331U;
 const int64_t kMustRemainAvailableForSystem = kAvailableSpaceForApp / 2;
 const int64_t kDefaultPoolSize = 1000;
 const int64_t kDefaultPerHostQuota = 200;
-const int64_t kGigabytes = QuotaManagerImpl::kMBytes * 1024;
+const int64_t kGigabytes = QuotaManagerImpl::kGBytes;
 
 // Returns a deterministic value for the amount of available disk space.
 int64_t GetAvailableDiskSpaceForTest() {
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 46154a0e245..a247b821386 100644
--- a/chromium/storage/browser/quota/quota_temporary_storage_evictor_unittest.cc
+++ b/chromium/storage/browser/quota/quota_temporary_storage_evictor_unittest.cc
@@ -153,11 +153,11 @@ class QuotaTemporaryStorageEvictorTest : public testing::Test {
       : num_get_usage_and_quota_for_eviction_(0) {}
 
   void SetUp() override {
-    quota_eviction_handler_.reset(new MockQuotaEvictionHandler(this));
+    quota_eviction_handler_ = std::make_unique<MockQuotaEvictionHandler>(this);
 
     // Run multiple evictions in a single RunUntilIdle() when interval_ms == 0
-    temporary_storage_evictor_.reset(new QuotaTemporaryStorageEvictor(
-        quota_eviction_handler_.get(), 0));
+    temporary_storage_evictor_ = std::make_unique<QuotaTemporaryStorageEvictor>(
+        quota_eviction_handler_.get(), 0);
   }
 
   void TearDown() override {
diff --git a/chromium/storage/common/BUILD.gn b/chromium/storage/common/BUILD.gn
index 8fdf0dc0951..26e2ec35062 100644
--- a/chromium/storage/common/BUILD.gn
+++ b/chromium/storage/common/BUILD.gn
@@ -7,8 +7,6 @@ import("//mojo/public/tools/bindings/mojom.gni")
 component("common") {
   output_name = "storage_common"
   sources = [
-    "database/database_connections.cc",
-    "database/database_connections.h",
     "database/database_identifier.cc",
     "database/database_identifier.h",
     "file_system/file_system_info.cc",
@@ -47,7 +45,6 @@ source_set("unittests") {
   testonly = true
 
   sources = [
-    "database/database_connections_unittest.cc",
     "database/database_identifier_unittest.cc",
     "file_system/file_system_util_unittest.cc",
     "run_all_unittests.cc",
diff --git a/chromium/storage/common/file_system/file_system_util.cc b/chromium/storage/common/file_system/file_system_util.cc
index 77ac0532ea4..4b457f803cd 100644
--- a/chromium/storage/common/file_system/file_system_util.cc
+++ b/chromium/storage/common/file_system/file_system_util.cc
@@ -14,7 +14,6 @@
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
-#include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"