BASELINE: Update Chromium to 69.0.3497.70

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

52 files changed, 375 insertions, 412 deletions

diff --git a/chromium/storage/DEPS b/chromium/storage/DEPS
index 93adf45bf5f..5da38bf069b 100644
--- a/chromium/storage/DEPS
+++ b/chromium/storage/DEPS
@@ -4,6 +4,7 @@ include_rules = [
   "+net",
   "+services/network/public/cpp",
   "+services/network/public/mojom",
+  "+services/network/session_cleanup_cookie_store.h",
   "+sql",
   "+third_party/blink/public/mojom",
   "+third_party/blink/public/platform",
diff --git a/chromium/storage/browser/BUILD.gn b/chromium/storage/browser/BUILD.gn
index 80bd20eaea4..4b2d919699b 100644
--- a/chromium/storage/browser/BUILD.gn
+++ b/chromium/storage/browser/BUILD.gn
@@ -215,6 +215,7 @@ component("browser") {
     "//base/third_party/dynamic_annotations",
     "//mojo/public/cpp/bindings",
     "//net",
+    "//services/network:network_service",
     "//services/network/public/cpp",
     "//services/network/public/mojom",
     "//sql",
@@ -232,7 +233,6 @@ executable("dump_file_system") {
   deps = [
     ":browser",
     "//base",
-    "//build/config:exe_and_shlib_deps",
     "//build/win:default_exe_manifest",
     "//storage/common",
   ]
@@ -304,9 +304,10 @@ source_set("unittests") {
     ":test_support",
     "//base/test:test_support",
     "//components/services/filesystem/public/interfaces",
-    "//mojo/edk",
+    "//mojo/core/embedder",
     "//net:test_support",
     "//services/network/public/cpp",
+    "//services/network/public/mojom",
     "//sql:test_support",
     "//testing/gtest",
     "//third_party/leveldatabase",
@@ -319,6 +320,8 @@ static_library("test_support") {
   sources = [
     "test/async_file_test_helper.cc",
     "test/async_file_test_helper.h",
+    "test/fake_blob.cc",
+    "test/fake_blob.h",
     "test/fake_progress_client.cc",
     "test/fake_progress_client.h",
     "test/fileapi_test_file_set.cc",
@@ -357,6 +360,7 @@ static_library("test_support") {
     ":browser",
     "//base/test:test_support",
     "//net:test_support",
+    "//services/network:network_service",
     "//testing/gtest",
     "//third_party/leveldatabase",
   ]
diff --git a/chromium/storage/browser/blob/OWNERS b/chromium/storage/browser/blob/OWNERS
index 567c157be76..3568456627a 100644
--- a/chromium/storage/browser/blob/OWNERS
+++ b/chromium/storage/browser/blob/OWNERS
@@ -3,4 +3,4 @@ mek@chromium.org
 jianli@chromium.org
 
 # TEAM: storage-dev@chromium.org
-# COMPONENT: Blink>FileAPI
+# COMPONENT: Blink>Storage>FileAPI
diff --git a/chromium/storage/browser/blob/blob_data_item.cc b/chromium/storage/browser/blob/blob_data_item.cc
index 00b36875d26..804cd81d7f1 100644
--- a/chromium/storage/browser/blob/blob_data_item.cc
+++ b/chromium/storage/browser/blob/blob_data_item.cc
@@ -19,6 +19,9 @@ const base::FilePath::CharType kFutureFileName[] =
 
 constexpr uint64_t BlobDataItem::kUnknownSize;
 
+bool BlobDataItem::DataHandle::IsValid() {
+  return true;
+}
 BlobDataItem::DataHandle::~DataHandle() = default;
 
 // static
diff --git a/chromium/storage/browser/blob/blob_data_item.h b/chromium/storage/browser/blob/blob_data_item.h
index 796e1b29c21..9c39d18b10f 100644
--- a/chromium/storage/browser/blob/blob_data_item.h
+++ b/chromium/storage/browser/blob/blob_data_item.h
@@ -49,8 +49,11 @@ class STORAGE_EXPORT BlobDataItem : public base::RefCounted<BlobDataItem> {
   // a different backend version (mem-to-disk or the reverse), then the item
   // will be destructed after all pending reads are complete.
   class STORAGE_EXPORT DataHandle : public base::RefCounted<DataHandle> {
+   public:
+    virtual bool IsValid();
+
    protected:
-    virtual ~DataHandle() = 0;
+    virtual ~DataHandle();
 
    private:
     friend class base::RefCounted<DataHandle>;
@@ -112,9 +115,13 @@ class STORAGE_EXPORT BlobDataItem : public base::RefCounted<BlobDataItem> {
     return expected_modification_time_;
   }
 
+  // This can return null if the underlying disk cache entry was invalidated
+  // (because the user cleared site data), so users should make sure to always
+  // check for that.
   disk_cache::Entry* disk_cache_entry() const {
     DCHECK_EQ(type_, Type::kDiskCacheEntry);
-    return disk_cache_entry_;
+    DCHECK(data_handle_);
+    return data_handle_->IsValid() ? disk_cache_entry_ : nullptr;
   }
 
   int disk_cache_stream_index() const {
@@ -182,6 +189,9 @@ class STORAGE_EXPORT BlobDataItem : public base::RefCounted<BlobDataItem> {
 
   // This naked pointer is safe because the scope is protected by the DataHandle
   // instance for disk cache entries during the lifetime of this BlobDataItem.
+  // Only valid if the DataHandle's IsValid method returns true.
+  // TODO(mek): Make this part of the DataHandle and abstract away cache
+  // specific logic to be part of an API exposed by DataHandle.
   disk_cache::Entry* disk_cache_entry_;  // For Type::kDiskCacheEntry.
   int disk_cache_stream_index_;          // For Type::kDiskCacheEntry.
   int disk_cache_side_stream_index_;     // For Type::kDiskCacheEntry.
diff --git a/chromium/storage/browser/blob/blob_impl.cc b/chromium/storage/browser/blob/blob_impl.cc
index f833fe240a8..903a5607475 100644
--- a/chromium/storage/browser/blob/blob_impl.cc
+++ b/chromium/storage/browser/blob/blob_impl.cc
@@ -140,6 +140,10 @@ void BlobImpl::ReadSideData(ReadSideDataCallback callback) {
 
         const auto& item = items[0];
         disk_cache::Entry* entry = item->disk_cache_entry();
+        if (!entry) {
+          std::move(callback).Run(base::nullopt);
+          return;
+        }
         int32_t body_size =
             entry->GetDataSize(item->disk_cache_side_stream_index());
         auto io_buffer = base::MakeRefCounted<net::IOBufferWithSize>(body_size);
diff --git a/chromium/storage/browser/blob/blob_reader.cc b/chromium/storage/browser/blob/blob_reader.cc
index eb02752c95d..9cf4fe38075 100644
--- a/chromium/storage/browser/blob/blob_reader.cc
+++ b/chromium/storage/browser/blob/blob_reader.cc
@@ -121,6 +121,8 @@ bool BlobReader::has_side_data() const {
   const int disk_cache_side_stream_index = item.disk_cache_side_stream_index();
   if (disk_cache_side_stream_index < 0)
     return false;
+  if (!item.disk_cache_entry())
+    return false;
   return item.disk_cache_entry()->GetDataSize(disk_cache_side_stream_index) > 0;
 }
 
@@ -560,6 +562,8 @@ BlobReader::Status BlobReader::ReadDiskCacheEntryItem(const BlobDataItem& item,
                            "uuid", blob_data_->uuid());
   DCHECK_GE(read_buf_->BytesRemaining(), bytes_to_read);
 
+  if (!item.disk_cache_entry())
+    return ReportError(net::ERR_CACHE_READ_FAILURE);
   const int result = item.disk_cache_entry()->ReadData(
       item.disk_cache_stream_index(), item.offset() + current_item_offset_,
       read_buf_.get(), bytes_to_read,
diff --git a/chromium/storage/browser/blob/blob_reader_unittest.cc b/chromium/storage/browser/blob/blob_reader_unittest.cc
index 1a1a0045bc8..c7bc7b25947 100644
--- a/chromium/storage/browser/blob/blob_reader_unittest.cc
+++ b/chromium/storage/browser/blob/blob_reader_unittest.cc
@@ -81,10 +81,10 @@ class DelayedReadEntry : public disk_cache::Entry {
   bool HasPendingReadCallbacks() { return !pending_read_callbacks_.empty(); }
 
   void RunPendingReadCallbacks() {
-    std::vector<base::Callback<void(void)>> callbacks;
+    std::vector<base::OnceCallback<void(void)>> callbacks;
     pending_read_callbacks_.swap(callbacks);
-    for (const auto& callback : callbacks)
-      callback.Run();
+    for (auto& callback : callbacks)
+      std::move(callback).Run();
   }
 
   // From disk_cache::Entry:
@@ -108,12 +108,13 @@ class DelayedReadEntry : public disk_cache::Entry {
                int offset,
                IOBuffer* buf,
                int buf_len,
-               const CompletionCallback& original_callback) override {
+               CompletionOnceCallback original_callback) override {
     net::TestCompletionCallback callback;
     int rv = entry_->ReadData(index, offset, buf, buf_len, callback.callback());
     DCHECK_NE(rv, net::ERR_IO_PENDING)
         << "Test expects to use a MEMORY_CACHE instance, which is synchronous.";
-    pending_read_callbacks_.push_back(base::Bind(original_callback, rv));
+    pending_read_callbacks_.push_back(
+        base::BindOnce(std::move(original_callback), rv));
     return net::ERR_IO_PENDING;
   }
 
@@ -121,44 +122,45 @@ class DelayedReadEntry : public disk_cache::Entry {
                 int offset,
                 IOBuffer* buf,
                 int buf_len,
-                const CompletionCallback& callback,
+                CompletionOnceCallback callback,
                 bool truncate) override {
-    return entry_->WriteData(index, offset, buf, buf_len, callback, truncate);
+    return entry_->WriteData(index, offset, buf, buf_len, std::move(callback),
+                             truncate);
   }
 
   int ReadSparseData(int64_t offset,
                      IOBuffer* buf,
                      int buf_len,
-                     const CompletionCallback& callback) override {
-    return entry_->ReadSparseData(offset, buf, buf_len, callback);
+                     CompletionOnceCallback callback) override {
+    return entry_->ReadSparseData(offset, buf, buf_len, std::move(callback));
   }
 
   int WriteSparseData(int64_t offset,
                       IOBuffer* buf,
                       int buf_len,
-                      const CompletionCallback& callback) override {
-    return entry_->WriteSparseData(offset, buf, buf_len, callback);
+                      CompletionOnceCallback callback) override {
+    return entry_->WriteSparseData(offset, buf, buf_len, std::move(callback));
   }
 
   int GetAvailableRange(int64_t offset,
                         int len,
                         int64_t* start,
-                        const CompletionCallback& callback) override {
-    return entry_->GetAvailableRange(offset, len, start, callback);
+                        CompletionOnceCallback callback) override {
+    return entry_->GetAvailableRange(offset, len, start, std::move(callback));
   }
 
   bool CouldBeSparse() const override { return entry_->CouldBeSparse(); }
 
   void CancelSparseIO() override { entry_->CancelSparseIO(); }
 
-  int ReadyForSparseIO(const CompletionCallback& callback) override {
-    return entry_->ReadyForSparseIO(callback);
+  int ReadyForSparseIO(CompletionOnceCallback callback) override {
+    return entry_->ReadyForSparseIO(std::move(callback));
   }
   void SetLastUsedTimeForTest(base::Time time) override { NOTREACHED(); }
 
  private:
   disk_cache::ScopedEntryPtr entry_;
-  std::vector<base::Callback<void(void)>> pending_read_callbacks_;
+  std::vector<base::OnceCallback<void(void)>> pending_read_callbacks_;
 };
 
 std::unique_ptr<disk_cache::Backend> CreateInMemoryDiskCache() {
@@ -177,7 +179,8 @@ disk_cache::ScopedEntryPtr CreateDiskCacheEntry(disk_cache::Backend* cache,
                                                 const std::string& data) {
   disk_cache::Entry* temp_entry = nullptr;
   net::TestCompletionCallback callback;
-  int rv = cache->CreateEntry(key, &temp_entry, callback.callback());
+  int rv =
+      cache->CreateEntry(key, net::HIGHEST, &temp_entry, callback.callback());
   if (callback.GetResult(rv) != net::OK)
     return nullptr;
   disk_cache::ScopedEntryPtr entry(temp_entry);
diff --git a/chromium/storage/browser/blob/blob_registry_impl_unittest.cc b/chromium/storage/browser/blob/blob_registry_impl_unittest.cc
index 9dea03b2e6b..0a39bfb488d 100644
--- a/chromium/storage/browser/blob/blob_registry_impl_unittest.cc
+++ b/chromium/storage/browser/blob/blob_registry_impl_unittest.cc
@@ -15,12 +15,13 @@
 #include "base/test/bind_test_util.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_restrictions.h"
-#include "mojo/edk/embedder/embedder.h"
+#include "mojo/core/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/cpp/system/data_pipe_utils.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
+#include "storage/browser/test/fake_blob.h"
 #include "storage/browser/test/fake_progress_client.h"
 #include "storage/browser/test/mock_blob_registry_delegate.h"
 #include "storage/browser/test/mock_bytes_provider.h"
@@ -40,42 +41,6 @@ const uint64_t kTestBlobStorageMaxDiskSpace = 4000;
 const uint64_t kTestBlobStorageMinFileSizeBytes = 10;
 const uint64_t kTestBlobStorageMaxFileSizeBytes = 100;
 
-class MockBlob : public blink::mojom::Blob {
- public:
-  explicit MockBlob(const std::string& uuid) : uuid_(uuid) {}
-
-  void Clone(blink::mojom::BlobRequest request) override {
-    mojo::MakeStrongBinding(std::make_unique<MockBlob>(uuid_),
-                            std::move(request));
-  }
-
-  void AsDataPipeGetter(
-      network::mojom::DataPipeGetterRequest request) override {
-    NOTREACHED();
-  }
-
-  void ReadRange(uint64_t offset,
-                 uint64_t size,
-                 mojo::ScopedDataPipeProducerHandle,
-                 blink::mojom::BlobReaderClientPtr) override {
-    NOTREACHED();
-  }
-
-  void ReadAll(mojo::ScopedDataPipeProducerHandle,
-               blink::mojom::BlobReaderClientPtr) override {
-    NOTREACHED();
-  }
-
-  void ReadSideData(ReadSideDataCallback) override { NOTREACHED(); }
-
-  void GetInternalUUID(GetInternalUUIDCallback callback) override {
-    std::move(callback).Run(uuid_);
-  }
-
- private:
-  std::string uuid_;
-};
-
 void BindBytesProvider(std::unique_ptr<MockBytesProvider> impl,
                        blink::mojom::BytesProviderRequest request) {
   mojo::MakeStrongBinding(std::move(impl), std::move(request));
@@ -108,7 +73,7 @@ class BlobRegistryImplTest : public testing::Test {
     delegate_ptr_ = delegate.get();
     registry_impl_->Bind(MakeRequest(&registry_), std::move(delegate));
 
-    mojo::edk::SetDefaultProcessErrorCallback(base::Bind(
+    mojo::core::SetDefaultProcessErrorCallback(base::Bind(
         &BlobRegistryImplTest::OnBadMessage, base::Unretained(this)));
 
     storage::BlobStorageLimits limits;
@@ -129,8 +94,8 @@ class BlobRegistryImplTest : public testing::Test {
   void TearDown() override {
     base::ThreadRestrictions::SetIOAllowed(true);
 
-    mojo::edk::SetDefaultProcessErrorCallback(
-        mojo::edk::ProcessErrorCallback());
+    mojo::core::SetDefaultProcessErrorCallback(
+        mojo::core::ProcessErrorCallback());
   }
 
   std::unique_ptr<BlobDataHandle> CreateBlobFromString(
@@ -430,7 +395,7 @@ TEST_F(BlobRegistryImplTest, Register_NonExistentBlob) {
 
   std::vector<blink::mojom::DataElementPtr> elements;
   blink::mojom::BlobPtrInfo referenced_blob_info;
-  mojo::MakeStrongBinding(std::make_unique<MockBlob>("mock blob"),
+  mojo::MakeStrongBinding(std::make_unique<FakeBlob>("mock blob"),
                           MakeRequest(&referenced_blob_info));
   elements.push_back(
       blink::mojom::DataElement::NewBlob(blink::mojom::DataElementBlob::New(
@@ -460,7 +425,7 @@ TEST_F(BlobRegistryImplTest, Register_ValidBlobReferences) {
   std::unique_ptr<BlobDataHandle> handle =
       CreateBlobFromString(kId1, "hello world");
   blink::mojom::BlobPtrInfo blob1_info;
-  mojo::MakeStrongBinding(std::make_unique<MockBlob>(kId1),
+  mojo::MakeStrongBinding(std::make_unique<FakeBlob>(kId1),
                           MakeRequest(&blob1_info));
 
   const std::string kId2 = "id2";
@@ -930,7 +895,7 @@ TEST_F(BlobRegistryImplTest,
   auto blob_handle = context_->AddFutureBlob(
       kDepId, "", "", BlobStorageContext::BuildAbortedCallback());
   blink::mojom::BlobPtrInfo referenced_blob_info;
-  mojo::MakeStrongBinding(std::make_unique<MockBlob>(kDepId),
+  mojo::MakeStrongBinding(std::make_unique<FakeBlob>(kDepId),
                           MakeRequest(&referenced_blob_info));
 
   // Create mojo blob depending on future blob.
diff --git a/chromium/storage/browser/blob/blob_storage_context_unittest.cc b/chromium/storage/browser/blob/blob_storage_context_unittest.cc
index 71ef114f7ab..1e61d9ed8a1 100644
--- a/chromium/storage/browser/blob/blob_storage_context_unittest.cc
+++ b/chromium/storage/browser/blob/blob_storage_context_unittest.cc
@@ -71,7 +71,8 @@ disk_cache::ScopedEntryPtr CreateDiskCacheEntry(disk_cache::Backend* cache,
                                                 const std::string& data) {
   disk_cache::Entry* temp_entry = nullptr;
   net::TestCompletionCallback callback;
-  int rv = cache->CreateEntry(key, &temp_entry, callback.callback());
+  int rv =
+      cache->CreateEntry(key, net::HIGHEST, &temp_entry, callback.callback());
   if (callback.GetResult(rv) != net::OK)
     return nullptr;
   disk_cache::ScopedEntryPtr entry(temp_entry);
diff --git a/chromium/storage/browser/blob/blob_transport_strategy_unittest.cc b/chromium/storage/browser/blob/blob_transport_strategy_unittest.cc
index 9349e98968d..3000df34920 100644
--- a/chromium/storage/browser/blob/blob_transport_strategy_unittest.cc
+++ b/chromium/storage/browser/blob/blob_transport_strategy_unittest.cc
@@ -14,7 +14,7 @@
 #include "base/task_scheduler/post_task.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_restrictions.h"
-#include "mojo/edk/embedder/embedder.h"
+#include "mojo/core/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/test/mock_bytes_provider.h"
@@ -61,7 +61,7 @@ class BlobTransportStrategyTest : public testing::Test {
     limits_.min_page_file_size = kTestBlobStorageMinFileSizeBytes;
     limits_.max_file_size = kTestBlobStorageMaxFileSizeBytes;
 
-    mojo::edk::SetDefaultProcessErrorCallback(base::Bind(
+    mojo::core::SetDefaultProcessErrorCallback(base::Bind(
         &BlobTransportStrategyTest::OnBadMessage, base::Unretained(this)));
 
     // Disallow IO on the main loop.
@@ -71,8 +71,8 @@ class BlobTransportStrategyTest : public testing::Test {
   void TearDown() override {
     base::ThreadRestrictions::SetIOAllowed(true);
 
-    mojo::edk::SetDefaultProcessErrorCallback(
-        mojo::edk::ProcessErrorCallback());
+    mojo::core::SetDefaultProcessErrorCallback(
+        mojo::core::ProcessErrorCallback());
   }
 
   void OnBadMessage(const std::string& error) {
diff --git a/chromium/storage/browser/blob/blob_url_loader.cc b/chromium/storage/browser/blob/blob_url_loader.cc
index 2af4fb7881f..ca16d565ebd 100644
--- a/chromium/storage/browser/blob/blob_url_loader.cc
+++ b/chromium/storage/browser/blob/blob_url_loader.cc
@@ -93,12 +93,11 @@ void BlobURLLoader::Start(const network::ResourceRequest& request) {
 }
 
 void BlobURLLoader::FollowRedirect(
+    const base::Optional<std::vector<std::string>>&
+        to_be_removed_request_headers,
     const base::Optional<net::HttpRequestHeaders>& modified_request_headers) {
   NOTREACHED();
 }
-void BlobURLLoader::ProceedWithResponse() {
-  NOTREACHED();
-}
 
 mojo::ScopedDataPipeProducerHandle BlobURLLoader::PassDataPipe() {
   mojo::DataPipe data_pipe(kDefaultAllocationSize);
@@ -165,7 +164,7 @@ void BlobURLLoader::HeadersCompleted(net::HttpStatusCode status_code,
 
   // TODO(jam): some of this code can be shared with
   // services/network/url_loader.h
-  client_->OnReceiveResponse(response, nullptr);
+  client_->OnReceiveResponse(response);
   sent_headers_ = true;
 
   if (metadata) {
diff --git a/chromium/storage/browser/blob/blob_url_loader.h b/chromium/storage/browser/blob/blob_url_loader.h
index a4da5128c60..12d005ece44 100644
--- a/chromium/storage/browser/blob/blob_url_loader.h
+++ b/chromium/storage/browser/blob/blob_url_loader.h
@@ -39,9 +39,11 @@ class STORAGE_EXPORT BlobURLLoader : public storage::MojoBlobReader::Delegate,
   void Start(const network::ResourceRequest& request);
 
   // network::mojom::URLLoader implementation:
-  void FollowRedirect(const base::Optional<net::HttpRequestHeaders>&
+  void FollowRedirect(const base::Optional<std::vector<std::string>>&
+                          to_be_removed_request_headers,
+                      const base::Optional<net::HttpRequestHeaders>&
                           modified_request_headers) override;
-  void ProceedWithResponse() override;
+  void ProceedWithResponse() override {}
   void SetPriority(net::RequestPriority priority,
                    int32_t intra_priority_value) override {}
   void PauseReadingBodyFromNet() override {}
diff --git a/chromium/storage/browser/blob/blob_url_loader_factory.cc b/chromium/storage/browser/blob/blob_url_loader_factory.cc
index 76373fec3f1..e69bd56f8ab 100644
--- a/chromium/storage/browser/blob/blob_url_loader_factory.cc
+++ b/chromium/storage/browser/blob/blob_url_loader_factory.cc
@@ -69,7 +69,6 @@ void BlobURLLoaderFactory::CreateLoaderAndStart(
         network::URLLoaderCompletionStatus(net::ERR_INVALID_URL));
     return;
   }
-  DCHECK(!request.download_to_file);
   BlobURLLoader::CreateAndStart(
       std::move(loader), request, std::move(client),
       handle_ ? std::make_unique<BlobDataHandle>(*handle_) : nullptr);
diff --git a/chromium/storage/browser/blob/blob_url_store_impl_unittest.cc b/chromium/storage/browser/blob/blob_url_store_impl_unittest.cc
index c463e4e6d2f..5e0d0397788 100644
--- a/chromium/storage/browser/blob/blob_url_store_impl_unittest.cc
+++ b/chromium/storage/browser/blob/blob_url_store_impl_unittest.cc
@@ -4,9 +4,12 @@
 
 #include "storage/browser/blob/blob_url_store_impl.h"
 
+#include "base/test/bind_test_util.h"
 #include "base/test/scoped_task_environment.h"
-#include "mojo/edk/embedder/embedder.h"
+#include "mojo/core/embedder/embedder.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
+#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
+#include "services/network/public/cpp/simple_url_loader.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_impl.h"
 #include "storage/browser/blob/blob_storage_context.h"
@@ -24,13 +27,13 @@ class BlobURLStoreImplTest : public testing::Test {
   void SetUp() override {
     context_ = std::make_unique<BlobStorageContext>();
 
-    mojo::edk::SetDefaultProcessErrorCallback(base::BindRepeating(
+    mojo::core::SetDefaultProcessErrorCallback(base::BindRepeating(
         &BlobURLStoreImplTest::OnBadMessage, base::Unretained(this)));
   }
 
   void TearDown() override {
-    mojo::edk::SetDefaultProcessErrorCallback(
-        mojo::edk::ProcessErrorCallback());
+    mojo::core::SetDefaultProcessErrorCallback(
+        mojo::core::ProcessErrorCallback());
   }
 
   void OnBadMessage(const std::string& error) {
@@ -238,4 +241,54 @@ TEST_F(BlobURLStoreImplTest, ResolveInvalidURL) {
   EXPECT_FALSE(blob);
 }
 
+TEST_F(BlobURLStoreImplTest, ResolveAsURLLoaderFactory) {
+  BlobPtr blob = CreateBlobFromString(kId, "hello world");
+
+  BlobURLStoreImpl url_store(context_->AsWeakPtr(), &delegate_);
+  RegisterURL(&url_store, std::move(blob), kValidUrl);
+
+  network::mojom::URLLoaderFactoryPtr factory;
+  url_store.ResolveAsURLLoaderFactory(kValidUrl, MakeRequest(&factory));
+
+  auto request = std::make_unique<network::ResourceRequest>();
+  request->url = kValidUrl;
+  auto loader = network::SimpleURLLoader::Create(std::move(request),
+                                                 TRAFFIC_ANNOTATION_FOR_TESTS);
+  base::RunLoop loop;
+  loader->DownloadToStringOfUnboundedSizeUntilCrashAndDie(
+      factory.get(), base::BindLambdaForTesting(
+                         [&](std::unique_ptr<std::string> response_body) {
+                           loop.Quit();
+                           ASSERT_TRUE(response_body);
+                           EXPECT_EQ("hello world", *response_body);
+                         }));
+  loop.Run();
+}
+
+TEST_F(BlobURLStoreImplTest, ResolveForNavigation) {
+  BlobPtr blob = CreateBlobFromString(kId, "hello world");
+
+  BlobURLStoreImpl url_store(context_->AsWeakPtr(), &delegate_);
+  RegisterURL(&url_store, std::move(blob), kValidUrl);
+
+  blink::mojom::BlobURLTokenPtr token_ptr;
+  url_store.ResolveForNavigation(kValidUrl, MakeRequest(&token_ptr));
+
+  base::UnguessableToken token;
+  base::RunLoop loop;
+  token_ptr->GetToken(base::BindLambdaForTesting(
+      [&](const base::UnguessableToken& received_token) {
+        token = received_token;
+        loop.Quit();
+      }));
+  loop.Run();
+
+  GURL blob_url;
+  std::string blob_uuid;
+  EXPECT_TRUE(
+      context_->registry().GetTokenMapping(token, &blob_url, &blob_uuid));
+  EXPECT_EQ(kValidUrl, blob_url);
+  EXPECT_EQ(kId, blob_uuid);
+}
+
 }  // namespace storage
diff --git a/chromium/storage/browser/blob/mojo_blob_reader.cc b/chromium/storage/browser/blob/mojo_blob_reader.cc
index 2208ce39c10..2e0cd6ba6ca 100644
--- a/chromium/storage/browser/blob/mojo_blob_reader.cc
+++ b/chromium/storage/browser/blob/mojo_blob_reader.cc
@@ -180,35 +180,39 @@ void MojoBlobReader::ReadMore() {
       base::BindOnce(&MojoBlobReader::DidRead, base::Unretained(this), false));
   switch (read_status) {
     case BlobReader::Status::NET_ERROR:
-      TRACE_EVENT_ASYNC_END1("Blob", "BlobReader::ReadMore", this, "result",
-                             "error");
-      NotifyCompletedAndDeleteIfNeeded(blob_reader_->net_error());
+      DidRead(true, blob_reader_->net_error());
       return;
     case BlobReader::Status::IO_PENDING:
       // Wait for DidRead.
       return;
     case BlobReader::Status::DONE:
-      if (bytes_read > 0) {
-        DidRead(true, bytes_read);
-      } else {
-        TRACE_EVENT_ASYNC_END1("Blob", "BlobReader::ReadMore", this, "result",
-                               "success");
-        writable_handle_watcher_.Cancel();
-        pending_write_->Complete(0);
-        pending_write_ = nullptr;  // This closes the data pipe.
-        NotifyCompletedAndDeleteIfNeeded(net::OK);
-        return;
-      }
+      DidRead(true, bytes_read);
+      return;
   }
 }
 
 void MojoBlobReader::DidRead(bool completed_synchronously, int num_bytes) {
-  delegate_->DidRead(num_bytes);
+  if (num_bytes < 0) {
+    TRACE_EVENT_ASYNC_END2("Blob", "BlobReader::ReadMore", this, "result",
+                           "error", "net_error", num_bytes);
+    writable_handle_watcher_.Cancel();
+    pending_write_->Complete(0);
+    pending_write_ = nullptr;  // This closes the data pipe.
+    NotifyCompletedAndDeleteIfNeeded(num_bytes);
+    return;
+  }
+  if (num_bytes > 0)
+    delegate_->DidRead(num_bytes);
   TRACE_EVENT_ASYNC_END2("Blob", "BlobReader::ReadMore", this, "result",
                          "success", "num_bytes", num_bytes);
   response_body_stream_ = pending_write_->Complete(num_bytes);
   total_written_bytes_ += num_bytes;
   pending_write_ = nullptr;
+  if (num_bytes == 0) {
+    response_body_stream_.reset();  // This closes the data pipe.
+    NotifyCompletedAndDeleteIfNeeded(net::OK);
+    return;
+  }
   if (completed_synchronously) {
     base::SequencedTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
diff --git a/chromium/storage/browser/blob/view_blob_internals_job.cc b/chromium/storage/browser/blob/view_blob_internals_job.cc
index 3ce74444e7f..e18a815e001 100644
--- a/chromium/storage/browser/blob/view_blob_internals_job.cc
+++ b/chromium/storage/browser/blob/view_blob_internals_job.cc
@@ -159,12 +159,15 @@ void ViewBlobInternalsJob::Start() {
                                 weak_factory_.GetWeakPtr()));
 }
 
-bool ViewBlobInternalsJob::IsRedirectResponse(GURL* location,
-                                              int* http_status_code) {
+bool ViewBlobInternalsJob::IsRedirectResponse(
+    GURL* location,
+    int* http_status_code,
+    bool* insecure_scheme_was_upgraded) {
   if (request_->url().has_query()) {
     // Strip the query parameters.
     GURL::Replacements replacements;
     replacements.ClearQuery();
+    *insecure_scheme_was_upgraded = false;
     *location = request_->url().ReplaceComponents(replacements);
     *http_status_code = 307;
     return true;
@@ -273,7 +276,10 @@ void ViewBlobInternalsJob::GenerateHTMLForBlobData(
         break;
       case BlobDataItem::Type::kDiskCacheEntry:
         AddHTMLListItem(kType, "disk cache entry", out);
-        AddHTMLListItem(kURL, item.disk_cache_entry()->GetKey(), out);
+        if (item.disk_cache_entry())
+          AddHTMLListItem(kURL, item.disk_cache_entry()->GetKey(), out);
+        else
+          AddHTMLListItem(kURL, "Broken", out);
         break;
       case BlobDataItem::Type::kBytesDescription:
         AddHTMLListItem(kType, "pending data", out);
diff --git a/chromium/storage/browser/blob/view_blob_internals_job.h b/chromium/storage/browser/blob/view_blob_internals_job.h
index ddb57725742..746361cb930 100644
--- a/chromium/storage/browser/blob/view_blob_internals_job.h
+++ b/chromium/storage/browser/blob/view_blob_internals_job.h
@@ -35,7 +35,9 @@ class STORAGE_EXPORT ViewBlobInternalsJob
               std::string* charset,
               std::string* data,
               const net::CompletionCallback& callback) const override;
-  bool IsRedirectResponse(GURL* location, int* http_status_code) override;
+  bool IsRedirectResponse(GURL* location,
+                          int* http_status_code,
+                          bool* insecure_scheme_was_upgraded) override;
   void Kill() override;
 
   static std::string GenerateHTML(BlobStorageContext* blob_storage_context);
diff --git a/chromium/storage/browser/database/database_tracker.h b/chromium/storage/browser/database/database_tracker.h
index 2daecebb87b..e8863de292b 100644
--- a/chromium/storage/browser/database/database_tracker.h
+++ b/chromium/storage/browser/database/database_tracker.h
@@ -93,7 +93,7 @@ class STORAGE_EXPORT DatabaseTracker
         const base::string16& database_name) = 0;
 
    protected:
-    virtual ~Observer() {}
+    virtual ~Observer() = default;
   };
 
   DatabaseTracker(const base::FilePath& profile_path,
@@ -121,7 +121,9 @@ class STORAGE_EXPORT DatabaseTracker
 
   void CloseTrackerDatabaseAndClearCaches();
 
-  const base::FilePath& DatabaseDirectory() const { return db_dir_; }
+  // Thread-safe getter.
+  const base::FilePath& database_directory() const { return db_dir_; }
+
   base::FilePath GetFullDBFilePath(const std::string& origin_identifier,
                                    const base::string16& database_name);
 
@@ -130,7 +132,7 @@ class STORAGE_EXPORT DatabaseTracker
   virtual bool GetAllOriginIdentifiers(std::vector<std::string>* origin_ids);
   virtual bool GetAllOriginsInfo(std::vector<OriginInfo>* origins_info);
 
-  // Safe to call on any thread.
+  // Thread-safe getter.
   storage::QuotaManagerProxy* quota_manager_proxy() const {
     return quota_manager_proxy_.get();
   }
@@ -281,7 +283,12 @@ class STORAGE_EXPORT DatabaseTracker
   bool force_keep_session_state_ = false;
   bool shutting_down_ = false;
   const base::FilePath profile_path_;
+
+  // Can be accessed from any thread via database_directory().
+  //
+  // Thread-safety argument: The member is immutable.
   const base::FilePath db_dir_;
+
   std::unique_ptr<sql::Connection> db_;
   std::unique_ptr<DatabasesTable> databases_table_;
   std::unique_ptr<sql::MetaTable> meta_table_;
@@ -294,9 +301,12 @@ class STORAGE_EXPORT DatabaseTracker
   PendingDeletionCallbacks deletion_callbacks_;
 
   // Apps and Extensions can have special rights.
-  scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_;
+  const scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_;
 
-  scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
+  // Can be accessed from any thread via quota_manager_proxy().
+  //
+  // Thread-safety argument: The reference is immutable.
+  const scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
 
   // The database tracker thread we're supposed to run file IO on.
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
diff --git a/chromium/storage/browser/database/database_tracker_unittest.cc b/chromium/storage/browser/database/database_tracker_unittest.cc
index daed560cfd9..f213778c2de 100644
--- a/chromium/storage/browser/database/database_tracker_unittest.cc
+++ b/chromium/storage/browser/database/database_tracker_unittest.cc
@@ -218,10 +218,10 @@ class DatabaseTracker_TestHelper_Test {
     tracker->DatabaseOpened(kOrigin2, kDB3, kDescription, 0, &database_size);
 
     EXPECT_TRUE(base::CreateDirectory(
-        tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
+        tracker->database_directory().Append(base::FilePath::FromUTF16Unsafe(
             tracker->GetOriginDirectory(kOrigin1)))));
     EXPECT_TRUE(base::CreateDirectory(
-        tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
+        tracker->database_directory().Append(base::FilePath::FromUTF16Unsafe(
             tracker->GetOriginDirectory(kOrigin2)))));
     EXPECT_EQ(
         1, base::WriteFile(tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
@@ -247,12 +247,12 @@ class DatabaseTracker_TestHelper_Test {
     result = callback.GetResult(result);
     EXPECT_EQ(net::OK, result);
     EXPECT_FALSE(
-        base::PathExists(tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
+        base::PathExists(tracker->database_directory().AppendASCII(kOrigin1)));
 
     // Recreate db1.
     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0, &database_size);
     EXPECT_TRUE(base::CreateDirectory(
-        tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
+        tracker->database_directory().Append(base::FilePath::FromUTF16Unsafe(
             tracker->GetOriginDirectory(kOrigin1)))));
     EXPECT_EQ(
         1, base::WriteFile(tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
@@ -281,7 +281,7 @@ class DatabaseTracker_TestHelper_Test {
     result = callback.GetResult(result);
     EXPECT_EQ(net::OK, result);
     EXPECT_FALSE(
-        base::PathExists(tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
+        base::PathExists(tracker->database_directory().AppendASCII(kOrigin1)));
     EXPECT_TRUE(base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
     EXPECT_TRUE(base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
 
@@ -339,10 +339,10 @@ class DatabaseTracker_TestHelper_Test {
     // Write some data to each file and check that the listeners are
     // called with the appropriate values.
     EXPECT_TRUE(base::CreateDirectory(
-        tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
+        tracker->database_directory().Append(base::FilePath::FromUTF16Unsafe(
             tracker->GetOriginDirectory(kOrigin1)))));
     EXPECT_TRUE(base::CreateDirectory(
-        tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
+        tracker->database_directory().Append(base::FilePath::FromUTF16Unsafe(
             tracker->GetOriginDirectory(kOrigin2)))));
     EXPECT_EQ(
         1, base::WriteFile(tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
diff --git a/chromium/storage/browser/fileapi/dragged_file_util_unittest.cc b/chromium/storage/browser/fileapi/dragged_file_util_unittest.cc
index 2fb301aca04..7f0f5fe05b0 100644
--- a/chromium/storage/browser/fileapi/dragged_file_util_unittest.cc
+++ b/chromium/storage/browser/fileapi/dragged_file_util_unittest.cc
@@ -380,7 +380,7 @@ TEST_F(DraggedFileUtilTest, ReadDirectoryTest) {
       entry.name = current.BaseName();
       expected_entry_map[entry.name.value()] = entry;
 
-#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
+#if defined(OS_POSIX)
       // Creates a symlink for each file/directory.
       // They should be ignored by ReadDirectory, so we don't add them
       // to expected_entry_map.
diff --git a/chromium/storage/browser/fileapi/file_system_dir_url_request_job_unittest.cc b/chromium/storage/browser/fileapi/file_system_dir_url_request_job_unittest.cc
index eca61fff8e5..fd57b21b7d1 100644
--- a/chromium/storage/browser/fileapi/file_system_dir_url_request_job_unittest.cc
+++ b/chromium/storage/browser/fileapi/file_system_dir_url_request_job_unittest.cc
@@ -174,7 +174,6 @@ class FileSystemDirURLRequestJobTest : public testing::Test {
   void TestRequestHelper(const GURL& url, bool run_to_completion,
                          FileSystemContext* file_system_context) {
     delegate_.reset(new net::TestDelegate());
-    delegate_->set_quit_on_redirect(true);
     job_factory_.reset(new FileSystemDirURLRequestJobFactory(
         url.GetOrigin().host(), file_system_context));
     empty_context_.set_job_factory(job_factory_.get());
@@ -185,7 +184,7 @@ class FileSystemDirURLRequestJobTest : public testing::Test {
     request_->Start();
     ASSERT_TRUE(request_->is_pending());  // verify that we're starting async
     if (run_to_completion)
-      base::RunLoop().Run();
+      delegate_->RunUntilComplete();
   }
 
   void TestRequest(const GURL& url) {
diff --git a/chromium/storage/browser/fileapi/file_system_operation_runner.cc b/chromium/storage/browser/fileapi/file_system_operation_runner.cc
index 24980faa129..fbda72b3cdf 100644
--- a/chromium/storage/browser/fileapi/file_system_operation_runner.cc
+++ b/chromium/storage/browser/fileapi/file_system_operation_runner.cc
@@ -45,6 +45,8 @@ FileSystemOperationRunner::OperationHandle::~OperationHandle() = default;
 FileSystemOperationRunner::~FileSystemOperationRunner() = default;
 
 void FileSystemOperationRunner::Shutdown() {
+  // Clearing |operations_| may release our owning FileSystemContext, causing
+  // |this| to be deleted, so do not touch |this| after clear()ing it.
   operations_.clear();
 }
 
@@ -705,6 +707,11 @@ FileSystemOperationRunner::BeginOperation(
 }
 
 void FileSystemOperationRunner::FinishOperation(OperationID id) {
+  // Deleting the |operations_| entry may release the FileSystemContext which
+  // owns this runner, so take a reference to keep both alive until the end of
+  // this call.
+  scoped_refptr<FileSystemContext> context(file_system_context_);
+
   OperationToURLSet::iterator found = write_target_urls_.find(id);
   if (found != write_target_urls_.end()) {
     const FileSystemURLSet& urls = found->second;
diff --git a/chromium/storage/browser/fileapi/file_system_operation_runner.h b/chromium/storage/browser/fileapi/file_system_operation_runner.h
index 4a77320797b..a330f4802d5 100644
--- a/chromium/storage/browser/fileapi/file_system_operation_runner.h
+++ b/chromium/storage/browser/fileapi/file_system_operation_runner.h
@@ -302,6 +302,8 @@ class STORAGE_EXPORT FileSystemOperationRunner
   // These must be called at the beginning and end of any async operations.
   OperationHandle BeginOperation(std::unique_ptr<FileSystemOperation> operation,
                                  base::WeakPtr<BeginOperationScoper> scope);
+  // Cleans up the FileSystemOperation for |id|, which may result in the
+  // FileSystemContext, and |this| being deleted, by the time the call returns.
   void FinishOperation(OperationID id);
 
   // Not owned; file_system_context owns this.
diff --git a/chromium/storage/browser/fileapi/file_system_quota_util.h b/chromium/storage/browser/fileapi/file_system_quota_util.h
index b12cf6c83b8..1e54dedc7c5 100644
--- a/chromium/storage/browser/fileapi/file_system_quota_util.h
+++ b/chromium/storage/browser/fileapi/file_system_quota_util.h
@@ -11,6 +11,7 @@
 #include <string>
 
 #include "base/files/file.h"
+#include "base/memory/scoped_refptr.h"
 #include "storage/browser/storage_browser_export.h"
 #include "storage/common/fileapi/file_system_types.h"
 #include "url/gurl.h"
diff --git a/chromium/storage/browser/fileapi/file_system_url_request_job.cc b/chromium/storage/browser/fileapi/file_system_url_request_job.cc
index e5deee374d9..a2713177cd7 100644
--- a/chromium/storage/browser/fileapi/file_system_url_request_job.cc
+++ b/chromium/storage/browser/fileapi/file_system_url_request_job.cc
@@ -233,8 +233,10 @@ void FileSystemURLRequestJob::DidRead(int result) {
   ReadRawDataComplete(result);
 }
 
-bool FileSystemURLRequestJob::IsRedirectResponse(GURL* location,
-                                                 int* http_status_code) {
+bool FileSystemURLRequestJob::IsRedirectResponse(
+    GURL* location,
+    int* http_status_code,
+    bool* insecure_scheme_was_upgraded) {
   if (is_directory_) {
     // This happens when we discovered the file is a directory, so needs a
     // slash at the end of the path.
@@ -242,6 +244,7 @@ bool FileSystemURLRequestJob::IsRedirectResponse(GURL* location,
     new_path.push_back('/');
     GURL::Replacements replacements;
     replacements.SetPathStr(new_path);
+    *insecure_scheme_was_upgraded = false;
     *location = request_->url().ReplaceComponents(replacements);
     *http_status_code = 301;  // simulate a permanent redirect
     return true;
diff --git a/chromium/storage/browser/fileapi/file_system_url_request_job.h b/chromium/storage/browser/fileapi/file_system_url_request_job.h
index 7ed1042676e..162cc0e12a5 100644
--- a/chromium/storage/browser/fileapi/file_system_url_request_job.h
+++ b/chromium/storage/browser/fileapi/file_system_url_request_job.h
@@ -42,7 +42,9 @@ class STORAGE_EXPORT FileSystemURLRequestJob : public net::URLRequestJob {
   void Start() override;
   void Kill() override;
   int ReadRawData(net::IOBuffer* buf, int buf_size) override;
-  bool IsRedirectResponse(GURL* location, int* http_status_code) override;
+  bool IsRedirectResponse(GURL* location,
+                          int* http_status_code,
+                          bool* insecure_scheme_was_upgraded) override;
   void SetExtraRequestHeaders(const net::HttpRequestHeaders& headers) override;
   void GetResponseInfo(net::HttpResponseInfo* info) override;
 
diff --git a/chromium/storage/browser/fileapi/file_system_url_request_job_unittest.cc b/chromium/storage/browser/fileapi/file_system_url_request_job_unittest.cc
index a536527232a..2caef9dfd5d 100644
--- a/chromium/storage/browser/fileapi/file_system_url_request_job_unittest.cc
+++ b/chromium/storage/browser/fileapi/file_system_url_request_job_unittest.cc
@@ -186,9 +186,6 @@ class FileSystemURLRequestJobTest : public testing::Test {
                          bool run_to_completion,
                          FileSystemContext* file_system_context) {
     delegate_.reset(new net::TestDelegate());
-    // Make delegate_ exit the MessageLoop when the request is done.
-    delegate_->set_quit_on_complete(true);
-    delegate_->set_quit_on_redirect(true);
 
     job_factory_.reset(new FileSystemURLRequestJobFactory(
         url.GetOrigin().host(), file_system_context));
@@ -203,7 +200,7 @@ class FileSystemURLRequestJobTest : public testing::Test {
     request_->Start();
     ASSERT_TRUE(request_->is_pending());  // verify that we're starting async
     if (run_to_completion)
-      base::RunLoop().Run();
+      delegate_->RunUntilComplete();
   }
 
   void TestRequest(const GURL& url) {
@@ -356,14 +353,15 @@ TEST_F(FileSystemURLRequestJobTest, RangeOutOfBounds) {
 
 TEST_F(FileSystemURLRequestJobTest, FileDirRedirect) {
   CreateDirectory("dir");
-  TestRequest(CreateFileSystemURL("dir"));
+  TestRequestNoRun(CreateFileSystemURL("dir"));
+  delegate_->RunUntilRedirect();
 
   EXPECT_EQ(1, delegate_->received_redirect_count());
   EXPECT_FALSE(delegate_->request_failed());
 
   // We've deferred the redirect; now cancel the request to avoid following it.
   request_->Cancel();
-  base::RunLoop().Run();
+  delegate_->RunUntilComplete();
 }
 
 TEST_F(FileSystemURLRequestJobTest, InvalidURL) {
diff --git a/chromium/storage/browser/fileapi/local_file_util_unittest.cc b/chromium/storage/browser/fileapi/local_file_util_unittest.cc
index 936d8b1dcbc..8a3bc2883d2 100644
--- a/chromium/storage/browser/fileapi/local_file_util_unittest.cc
+++ b/chromium/storage/browser/fileapi/local_file_util_unittest.cc
@@ -142,7 +142,7 @@ TEST_F(LocalFileUtilTest, CreateAndClose) {
 }
 
 // base::CreateSymbolicLink is supported on most POSIX, but not on Fuchsia.
-#if defined(OS_POSIX) && !defined(OS_FUCHSIA)
+#if defined(OS_POSIX)
 TEST_F(LocalFileUtilTest, CreateFailForSymlink) {
   // Create symlink target file.
   const char *target_name = "symlink_target";
diff --git a/chromium/storage/browser/fileapi/quota/quota_backend_impl.cc b/chromium/storage/browser/fileapi/quota/quota_backend_impl.cc
index f0689b611c7..0b71123f078 100644
--- a/chromium/storage/browser/fileapi/quota/quota_backend_impl.cc
+++ b/chromium/storage/browser/fileapi/quota/quota_backend_impl.cc
@@ -35,41 +35,40 @@ QuotaBackendImpl::QuotaBackendImpl(
 
 QuotaBackendImpl::~QuotaBackendImpl() = default;
 
-void QuotaBackendImpl::ReserveQuota(const GURL& origin,
+void QuotaBackendImpl::ReserveQuota(const url::Origin& origin,
                                     FileSystemType type,
                                     int64_t delta,
                                     const ReserveQuotaCallback& callback) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   if (!delta) {
     callback.Run(base::File::FILE_OK, 0);
     return;
   }
   DCHECK(quota_manager_proxy_.get());
   quota_manager_proxy_->GetUsageAndQuota(
-      file_task_runner_.get(), url::Origin::Create(origin),
-      FileSystemTypeToQuotaStorageType(type),
+      file_task_runner_.get(), origin, FileSystemTypeToQuotaStorageType(type),
       base::BindOnce(&QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota,
                      weak_ptr_factory_.GetWeakPtr(),
                      QuotaReservationInfo(origin, type, delta), callback));
 }
 
-void QuotaBackendImpl::ReleaseReservedQuota(const GURL& origin,
+void QuotaBackendImpl::ReleaseReservedQuota(const url::Origin& origin,
                                             FileSystemType type,
                                             int64_t size) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   DCHECK_LE(0, size);
   if (!size)
     return;
   ReserveQuotaInternal(QuotaReservationInfo(origin, type, -size));
 }
 
-void QuotaBackendImpl::CommitQuotaUsage(const GURL& origin,
+void QuotaBackendImpl::CommitQuotaUsage(const url::Origin& origin,
                                         FileSystemType type,
                                         int64_t delta) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   if (!delta)
     return;
   ReserveQuotaInternal(QuotaReservationInfo(origin, type, delta));
@@ -80,10 +79,10 @@ void QuotaBackendImpl::CommitQuotaUsage(const GURL& origin,
   DCHECK(result);
 }
 
-void QuotaBackendImpl::IncrementDirtyCount(const GURL& origin,
+void QuotaBackendImpl::IncrementDirtyCount(const url::Origin& origin,
                                            FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   base::FilePath path;
   if (GetUsageCachePath(origin, type, &path) != base::File::FILE_OK)
     return;
@@ -91,10 +90,10 @@ void QuotaBackendImpl::IncrementDirtyCount(const GURL& origin,
   file_system_usage_cache_->IncrementDirty(path);
 }
 
-void QuotaBackendImpl::DecrementDirtyCount(const GURL& origin,
+void QuotaBackendImpl::DecrementDirtyCount(const url::Origin& origin,
                                            FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   base::FilePath path;
   if (GetUsageCachePath(origin, type, &path) != base::File::FILE_OK)
     return;
@@ -109,7 +108,7 @@ void QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota(
     int64_t usage,
     int64_t quota) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(info.origin.is_valid());
+  DCHECK(!info.origin.unique());
   DCHECK_LE(0, usage);
   DCHECK_LE(0, quota);
   if (status != blink::mojom::QuotaStatusCode::kOk) {
@@ -139,29 +138,29 @@ void QuotaBackendImpl::DidGetUsageAndQuotaForReserveQuota(
 
 void QuotaBackendImpl::ReserveQuotaInternal(const QuotaReservationInfo& info) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(info.origin.is_valid());
+  DCHECK(!info.origin.unique());
   DCHECK(quota_manager_proxy_.get());
   quota_manager_proxy_->NotifyStorageModified(
-      storage::QuotaClient::kFileSystem, url::Origin::Create(info.origin),
+      storage::QuotaClient::kFileSystem, info.origin,
       FileSystemTypeToQuotaStorageType(info.type), info.delta);
 }
 
 base::File::Error QuotaBackendImpl::GetUsageCachePath(
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type,
     base::FilePath* usage_file_path) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   DCHECK(usage_file_path);
   base::File::Error error = base::File::FILE_OK;
   *usage_file_path =
       SandboxFileSystemBackendDelegate::GetUsageCachePathForOriginAndType(
-          obfuscated_file_util_, origin, type, &error);
+          obfuscated_file_util_, origin.GetURL(), type, &error);
   return error;
 }
 
 QuotaBackendImpl::QuotaReservationInfo::QuotaReservationInfo(
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type,
     int64_t delta)
     : origin(origin), type(type), delta(delta) {}
diff --git a/chromium/storage/browser/fileapi/quota/quota_backend_impl.h b/chromium/storage/browser/fileapi/quota/quota_backend_impl.h
index 48dff001dac..347522b1768 100644
--- a/chromium/storage/browser/fileapi/quota/quota_backend_impl.h
+++ b/chromium/storage/browser/fileapi/quota/quota_backend_impl.h
@@ -14,6 +14,7 @@
 #include "storage/browser/fileapi/sandbox_file_system_backend_delegate.h"
 #include "storage/browser/storage_browser_export.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
+#include "url/origin.h"
 
 namespace base {
 class SequencedTaskRunner;
@@ -24,13 +25,10 @@ class QuotaBackendImplTest;
 }
 
 namespace storage {
-class QuotaManagerProxy;
-}
-
-namespace storage {
 
 class FileSystemUsageCache;
 class ObfuscatedFileUtil;
+class QuotaManagerProxy;
 
 // An instance of this class is owned by QuotaReservationManager.
 class STORAGE_EXPORT QuotaBackendImpl
@@ -45,29 +43,31 @@ class STORAGE_EXPORT QuotaBackendImpl
   ~QuotaBackendImpl() override;
 
   // QuotaReservationManager::QuotaBackend overrides.
-  void ReserveQuota(const GURL& origin,
+  void ReserveQuota(const url::Origin& origin,
                     FileSystemType type,
                     int64_t delta,
                     const ReserveQuotaCallback& callback) override;
-  void ReleaseReservedQuota(const GURL& origin,
+  void ReleaseReservedQuota(const url::Origin& origin,
                             FileSystemType type,
                             int64_t size) override;
-  void CommitQuotaUsage(const GURL& origin,
+  void CommitQuotaUsage(const url::Origin& origin,
                         FileSystemType type,
                         int64_t delta) override;
-  void IncrementDirtyCount(const GURL& origin, FileSystemType type) override;
-  void DecrementDirtyCount(const GURL& origin, FileSystemType type) override;
+  void IncrementDirtyCount(const url::Origin& origin,
+                           FileSystemType type) override;
+  void DecrementDirtyCount(const url::Origin& origin,
+                           FileSystemType type) override;
 
  private:
   friend class content::QuotaBackendImplTest;
 
   struct QuotaReservationInfo {
-    QuotaReservationInfo(const GURL& origin,
+    QuotaReservationInfo(const url::Origin& origin,
                          FileSystemType type,
                          int64_t delta);
     ~QuotaReservationInfo();
 
-    GURL origin;
+    url::Origin origin;
     FileSystemType type;
     int64_t delta;
   };
@@ -80,10 +80,9 @@ class STORAGE_EXPORT QuotaBackendImpl
 
   void ReserveQuotaInternal(
       const QuotaReservationInfo& info);
-  base::File::Error GetUsageCachePath(
-      const GURL& origin,
-      FileSystemType type,
-      base::FilePath* usage_file_path);
+  base::File::Error GetUsageCachePath(const url::Origin& origin,
+                                      FileSystemType type,
+                                      base::FilePath* usage_file_path);
 
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
 
diff --git a/chromium/storage/browser/fileapi/quota/quota_backend_impl_unittest.cc b/chromium/storage/browser/fileapi/quota/quota_backend_impl_unittest.cc
index f57d1f8ad54..e4023ecc5ff 100644
--- a/chromium/storage/browser/fileapi/quota/quota_backend_impl_unittest.cc
+++ b/chromium/storage/browser/fileapi/quota/quota_backend_impl_unittest.cc
@@ -29,7 +29,7 @@ namespace content {
 
 namespace {
 
-const char kOrigin[] = "http://example.com";
+const url::Origin kOrigin(url::Origin::Create(GURL("http://example.com")));
 
 bool DidReserveQuota(bool accepted,
                      base::File::Error* error_out,
@@ -115,16 +115,17 @@ class QuotaBackendImplTest : public testing::Test {
   }
 
  protected:
-  void InitializeForOriginAndType(const GURL& origin,
+  void InitializeForOriginAndType(const url::Origin& origin,
                                   storage::FileSystemType type) {
-    ASSERT_TRUE(file_util_->InitOriginDatabase(origin, true /* create */));
+    ASSERT_TRUE(
+        file_util_->InitOriginDatabase(origin.GetURL(), true /* create */));
     ASSERT_TRUE(file_util_->origin_database_ != NULL);
 
     std::string type_string =
         SandboxFileSystemBackendDelegate::GetTypeString(type);
     base::File::Error error = base::File::FILE_ERROR_FAILED;
     base::FilePath path = file_util_->GetDirectoryForOriginAndType(
-        origin, type_string, true /* create */, &error);
+        origin.GetURL(), type_string, true /* create */, &error);
     ASSERT_EQ(base::File::FILE_OK, error);
 
     ASSERT_TRUE(file_system_usage_cache_.UpdateUsage(
@@ -135,7 +136,7 @@ class QuotaBackendImplTest : public testing::Test {
     return base::ThreadTaskRunnerHandle::Get().get();
   }
 
-  base::FilePath GetUsageCachePath(const GURL& origin,
+  base::FilePath GetUsageCachePath(const url::Origin& origin,
                                    storage::FileSystemType type) {
     base::FilePath path;
     base::File::Error error = backend_->GetUsageCachePath(origin, type, &path);
@@ -158,14 +159,14 @@ class QuotaBackendImplTest : public testing::Test {
 
 TEST_F(QuotaBackendImplTest, ReserveQuota_Basic) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(10000);
 
   int64_t delta = 0;
 
   const int64_t kDelta1 = 1000;
   base::File::Error error = base::File::FILE_ERROR_FAILED;
-  backend_->ReserveQuota(GURL(kOrigin), type, kDelta1,
+  backend_->ReserveQuota(kOrigin, type, kDelta1,
                          base::Bind(&DidReserveQuota, true, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta1, delta);
@@ -173,7 +174,7 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_Basic) {
 
   const int64_t kDelta2 = -300;
   error = base::File::FILE_ERROR_FAILED;
-  backend_->ReserveQuota(GURL(kOrigin), type, kDelta2,
+  backend_->ReserveQuota(kOrigin, type, kDelta2,
                          base::Bind(&DidReserveQuota, true, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta2, delta);
@@ -184,14 +185,14 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_Basic) {
 
 TEST_F(QuotaBackendImplTest, ReserveQuota_NoSpace) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(100);
 
   int64_t delta = 0;
 
   const int64_t kDelta = 1000;
   base::File::Error error = base::File::FILE_ERROR_FAILED;
-  backend_->ReserveQuota(GURL(kOrigin), type, kDelta,
+  backend_->ReserveQuota(kOrigin, type, kDelta,
                          base::Bind(&DidReserveQuota, true, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(100, delta);
@@ -202,14 +203,14 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_NoSpace) {
 
 TEST_F(QuotaBackendImplTest, ReserveQuota_Revert) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(10000);
 
   int64_t delta = 0;
 
   const int64_t kDelta = 1000;
   base::File::Error error = base::File::FILE_ERROR_FAILED;
-  backend_->ReserveQuota(GURL(kOrigin), type, kDelta,
+  backend_->ReserveQuota(kOrigin, type, kDelta,
                          base::Bind(&DidReserveQuota, false, &error, &delta));
   EXPECT_EQ(base::File::FILE_OK, error);
   EXPECT_EQ(kDelta, delta);
@@ -220,13 +221,13 @@ TEST_F(QuotaBackendImplTest, ReserveQuota_Revert) {
 
 TEST_F(QuotaBackendImplTest, ReleaseReservedQuota) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
   const int64_t kInitialUsage = 2000;
   quota_manager_proxy_->set_usage(kInitialUsage);
   quota_manager_proxy_->set_quota(10000);
 
   const int64_t kSize = 1000;
-  backend_->ReleaseReservedQuota(GURL(kOrigin), type, kSize);
+  backend_->ReleaseReservedQuota(kOrigin, type, kSize);
   EXPECT_EQ(kInitialUsage - kSize, quota_manager_proxy_->usage());
 
   EXPECT_EQ(1, quota_manager_proxy_->storage_modified_count());
@@ -234,19 +235,19 @@ TEST_F(QuotaBackendImplTest, ReleaseReservedQuota) {
 
 TEST_F(QuotaBackendImplTest, CommitQuotaUsage) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
   quota_manager_proxy_->set_quota(10000);
-  base::FilePath path = GetUsageCachePath(GURL(kOrigin), type);
+  base::FilePath path = GetUsageCachePath(kOrigin, type);
 
   const int64_t kDelta1 = 1000;
-  backend_->CommitQuotaUsage(GURL(kOrigin), type, kDelta1);
+  backend_->CommitQuotaUsage(kOrigin, type, kDelta1);
   EXPECT_EQ(kDelta1, quota_manager_proxy_->usage());
   int64_t usage = 0;
   EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage));
   EXPECT_EQ(kDelta1, usage);
 
   const int64_t kDelta2 = -300;
-  backend_->CommitQuotaUsage(GURL(kOrigin), type, kDelta2);
+  backend_->CommitQuotaUsage(kOrigin, type, kDelta2);
   EXPECT_EQ(kDelta1 + kDelta2, quota_manager_proxy_->usage());
   usage = 0;
   EXPECT_TRUE(file_system_usage_cache_.GetUsage(path, &usage));
@@ -257,15 +258,15 @@ TEST_F(QuotaBackendImplTest, CommitQuotaUsage) {
 
 TEST_F(QuotaBackendImplTest, DirtyCount) {
   storage::FileSystemType type = storage::kFileSystemTypeTemporary;
-  InitializeForOriginAndType(GURL(kOrigin), type);
-  base::FilePath path = GetUsageCachePath(GURL(kOrigin), type);
+  InitializeForOriginAndType(kOrigin, type);
+  base::FilePath path = GetUsageCachePath(kOrigin, type);
 
-  backend_->IncrementDirtyCount(GURL(kOrigin), type);
+  backend_->IncrementDirtyCount(kOrigin, type);
   uint32_t dirty = 0;
   ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty));
   EXPECT_EQ(1u, dirty);
 
-  backend_->DecrementDirtyCount(GURL(kOrigin), type);
+  backend_->DecrementDirtyCount(kOrigin, type);
   ASSERT_TRUE(file_system_usage_cache_.GetDirty(path, &dirty));
   EXPECT_EQ(0u, dirty);
 }
diff --git a/chromium/storage/browser/fileapi/quota/quota_reservation.cc b/chromium/storage/browser/fileapi/quota/quota_reservation.cc
index e059033583d..ac3ca9f777f 100644
--- a/chromium/storage/browser/fileapi/quota/quota_reservation.cc
+++ b/chromium/storage/browser/fileapi/quota/quota_reservation.cc
@@ -67,7 +67,7 @@ QuotaReservationManager* QuotaReservation::reservation_manager() {
   return reservation_buffer_->reservation_manager();
 }
 
-const GURL& QuotaReservation::origin() const {
+const url::Origin& QuotaReservation::origin() const {
   return reservation_buffer_->origin();
 }
 
diff --git a/chromium/storage/browser/fileapi/quota/quota_reservation.h b/chromium/storage/browser/fileapi/quota/quota_reservation.h
index 44d36788a37..527caaee7c9 100644
--- a/chromium/storage/browser/fileapi/quota/quota_reservation.h
+++ b/chromium/storage/browser/fileapi/quota/quota_reservation.h
@@ -18,7 +18,9 @@
 #include "storage/browser/storage_browser_export.h"
 #include "storage/common/fileapi/file_system_types.h"
 
-class GURL;
+namespace url {
+class Origin;
+}
 
 namespace storage {
 
@@ -59,7 +61,7 @@ class STORAGE_EXPORT QuotaReservation
   int64_t remaining_quota() const { return remaining_quota_; }
 
   QuotaReservationManager* reservation_manager();
-  const GURL& origin() const;
+  const url::Origin& origin() const;
   FileSystemType type() const;
 
  private:
diff --git a/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.cc b/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.cc
index f5e96503a71..9aa294e0d29 100644
--- a/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.cc
+++ b/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.cc
@@ -19,13 +19,13 @@ namespace storage {
 
 QuotaReservationBuffer::QuotaReservationBuffer(
     base::WeakPtr<QuotaReservationManager> reservation_manager,
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type)
     : reservation_manager_(reservation_manager),
       origin_(origin),
       type_(type),
       reserved_quota_(0) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   DCHECK(sequence_checker_.CalledOnValidSequence());
   reservation_manager_->IncrementDirtyCount(origin, type);
 }
@@ -97,11 +97,11 @@ QuotaReservationBuffer::~QuotaReservationBuffer() {
 // static
 bool QuotaReservationBuffer::DecrementDirtyCount(
     base::WeakPtr<QuotaReservationManager> reservation_manager,
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type,
     base::File::Error error,
     int64_t delta_unused) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   if (error == base::File::FILE_OK && reservation_manager) {
     reservation_manager->DecrementDirtyCount(origin, type);
     return true;
diff --git a/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.h b/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.h
index 165fb9c7037..0f5d6ac2056 100644
--- a/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.h
+++ b/chromium/storage/browser/fileapi/quota/quota_reservation_buffer.h
@@ -17,7 +17,7 @@
 #include "base/memory/weak_ptr.h"
 #include "storage/browser/storage_browser_export.h"
 #include "storage/common/fileapi/file_system_types.h"
-#include "url/gurl.h"
+#include "url/origin.h"
 
 namespace storage {
 
@@ -37,7 +37,7 @@ class QuotaReservationBuffer : public base::RefCounted<QuotaReservationBuffer> {
  public:
   QuotaReservationBuffer(
       base::WeakPtr<QuotaReservationManager> reservation_manager,
-      const GURL& origin,
+      const url::Origin& origin,
       FileSystemType type);
 
   scoped_refptr<QuotaReservation> CreateReservation();
@@ -52,7 +52,7 @@ class QuotaReservationBuffer : public base::RefCounted<QuotaReservationBuffer> {
     return reservation_manager_.get();
   }
 
-  const GURL& origin() const { return origin_; }
+  const url::Origin& origin() const { return origin_; }
   FileSystemType type() const { return type_; }
 
  private:
@@ -61,7 +61,7 @@ class QuotaReservationBuffer : public base::RefCounted<QuotaReservationBuffer> {
 
   static bool DecrementDirtyCount(
       base::WeakPtr<QuotaReservationManager> reservation_manager,
-      const GURL& origin,
+      const url::Origin& origin,
       FileSystemType type,
       base::File::Error error,
       int64_t delta);
@@ -75,7 +75,7 @@ class QuotaReservationBuffer : public base::RefCounted<QuotaReservationBuffer> {
 
   base::WeakPtr<QuotaReservationManager> reservation_manager_;
 
-  GURL origin_;
+  url::Origin origin_;
   storage::FileSystemType type_;
 
   int64_t reserved_quota_;
diff --git a/chromium/storage/browser/fileapi/quota/quota_reservation_manager.cc b/chromium/storage/browser/fileapi/quota/quota_reservation_manager.cc
index 55d8ee4766a..c00bdc9ef6b 100644
--- a/chromium/storage/browser/fileapi/quota/quota_reservation_manager.cc
+++ b/chromium/storage/browser/fileapi/quota/quota_reservation_manager.cc
@@ -25,46 +25,45 @@ QuotaReservationManager::~QuotaReservationManager() {
 }
 
 void QuotaReservationManager::ReserveQuota(
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type,
     int64_t size,
     const ReserveQuotaCallback& callback) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   backend_->ReserveQuota(origin, type, size, callback);
 }
 
-void QuotaReservationManager::ReleaseReservedQuota(const GURL& origin,
+void QuotaReservationManager::ReleaseReservedQuota(const url::Origin& origin,
                                                    FileSystemType type,
                                                    int64_t size) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   backend_->ReleaseReservedQuota(origin, type, size);
 }
 
-void QuotaReservationManager::CommitQuotaUsage(const GURL& origin,
+void QuotaReservationManager::CommitQuotaUsage(const url::Origin& origin,
                                                FileSystemType type,
                                                int64_t delta) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   backend_->CommitQuotaUsage(origin, type, delta);
 }
 
-void QuotaReservationManager::IncrementDirtyCount(const GURL& origin,
-                                                 FileSystemType type) {
-  DCHECK(origin.is_valid());
+void QuotaReservationManager::IncrementDirtyCount(const url::Origin& origin,
+                                                  FileSystemType type) {
+  DCHECK(!origin.unique());
   backend_->IncrementDirtyCount(origin, type);
 }
 
-void QuotaReservationManager::DecrementDirtyCount(const GURL& origin,
-                                                 FileSystemType type) {
-  DCHECK(origin.is_valid());
+void QuotaReservationManager::DecrementDirtyCount(const url::Origin& origin,
+                                                  FileSystemType type) {
+  DCHECK(!origin.unique());
   backend_->DecrementDirtyCount(origin, type);
 }
 
 scoped_refptr<QuotaReservationBuffer>
-QuotaReservationManager::GetReservationBuffer(
-    const GURL& origin,
-    FileSystemType type) {
+QuotaReservationManager::GetReservationBuffer(const url::Origin& origin,
+                                              FileSystemType type) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   QuotaReservationBuffer** buffer =
       &reservation_buffers_[std::make_pair(origin, type)];
   if (!*buffer) {
@@ -77,16 +76,16 @@ QuotaReservationManager::GetReservationBuffer(
 void QuotaReservationManager::ReleaseReservationBuffer(
     QuotaReservationBuffer* reservation_buffer) {
   DCHECK(sequence_checker_.CalledOnValidSequence());
-  std::pair<GURL, FileSystemType> key(reservation_buffer->origin(),
-                                      reservation_buffer->type());
+  std::pair<url::Origin, FileSystemType> key(reservation_buffer->origin(),
+                                             reservation_buffer->type());
   DCHECK_EQ(reservation_buffers_[key], reservation_buffer);
   reservation_buffers_.erase(key);
 }
 
 scoped_refptr<QuotaReservation> QuotaReservationManager::CreateReservation(
-    const GURL& origin,
+    const url::Origin& origin,
     FileSystemType type) {
-  DCHECK(origin.is_valid());
+  DCHECK(!origin.unique());
   return GetReservationBuffer(origin, type)->CreateReservation();
 }
 
diff --git a/chromium/storage/browser/fileapi/quota/quota_reservation_manager.h b/chromium/storage/browser/fileapi/quota/quota_reservation_manager.h
index 47a017b2ea6..a567e4a9b76 100644
--- a/chromium/storage/browser/fileapi/quota/quota_reservation_manager.h
+++ b/chromium/storage/browser/fileapi/quota/quota_reservation_manager.h
@@ -18,12 +18,15 @@
 #include "base/memory/weak_ptr.h"
 #include "storage/browser/storage_browser_export.h"
 #include "storage/common/fileapi/file_system_types.h"
-#include "url/gurl.h"
 
 namespace content {
 class QuotaReservationManagerTest;
 }
 
+namespace url {
+class Origin;
+}
+
 namespace storage {
 
 class QuotaReservation;
@@ -48,26 +51,26 @@ class STORAGE_EXPORT QuotaReservationManager {
     // Invokes |callback| upon completion with an error code.
     // |callback| should return false if it can't accept the reservation, in
     // that case, the backend should roll back the reservation.
-    virtual void ReserveQuota(const GURL& origin,
+    virtual void ReserveQuota(const url::Origin& origin,
                               FileSystemType type,
                               int64_t delta,
                               const ReserveQuotaCallback& callback) = 0;
 
     // Reclaims |size| of quota for |origin| and |type|.
-    virtual void ReleaseReservedQuota(const GURL& origin,
+    virtual void ReleaseReservedQuota(const url::Origin& origin,
                                       FileSystemType type,
                                       int64_t size) = 0;
 
     // Updates disk usage of |origin| and |type|.
     // Invokes |callback| upon completion with an error code.
-    virtual void CommitQuotaUsage(const GURL& origin,
+    virtual void CommitQuotaUsage(const url::Origin& origin,
                                   FileSystemType type,
                                   int64_t delta) = 0;
 
-    virtual void IncrementDirtyCount(const GURL& origin,
-                                    FileSystemType type) = 0;
-    virtual void DecrementDirtyCount(const GURL& origin,
-                                    FileSystemType type) = 0;
+    virtual void IncrementDirtyCount(const url::Origin& origin,
+                                     FileSystemType type) = 0;
+    virtual void DecrementDirtyCount(const url::Origin& origin,
+                                     FileSystemType type) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(QuotaBackend);
@@ -78,34 +81,35 @@ class STORAGE_EXPORT QuotaReservationManager {
 
   // The entry point of the quota reservation.  Creates new reservation object
   // for |origin| and |type|.
-  scoped_refptr<QuotaReservation> CreateReservation(
-      const GURL& origin,
-      FileSystemType type);
+  scoped_refptr<QuotaReservation> CreateReservation(const url::Origin& origin,
+                                                    FileSystemType type);
 
  private:
   using ReservationBufferByOriginAndType =
-      std::map<std::pair<GURL, FileSystemType>, QuotaReservationBuffer*>;
+      std::map<std::pair<url::Origin, FileSystemType>, QuotaReservationBuffer*>;
 
   friend class QuotaReservation;
   friend class QuotaReservationBuffer;
   friend class content::QuotaReservationManagerTest;
 
-  void ReserveQuota(const GURL& origin,
+  void ReserveQuota(const url::Origin& origin,
                     FileSystemType type,
                     int64_t delta,
                     const ReserveQuotaCallback& callback);
 
-  void ReleaseReservedQuota(const GURL& origin,
+  void ReleaseReservedQuota(const url::Origin& origin,
                             FileSystemType type,
                             int64_t size);
 
-  void CommitQuotaUsage(const GURL& origin, FileSystemType type, int64_t delta);
+  void CommitQuotaUsage(const url::Origin& origin,
+                        FileSystemType type,
+                        int64_t delta);
 
-  void IncrementDirtyCount(const GURL& origin, FileSystemType type);
-  void DecrementDirtyCount(const GURL& origin, FileSystemType type);
+  void IncrementDirtyCount(const url::Origin& origin, FileSystemType type);
+  void DecrementDirtyCount(const url::Origin& origin, FileSystemType type);
 
   scoped_refptr<QuotaReservationBuffer> GetReservationBuffer(
-      const GURL& origin,
+      const url::Origin& origin,
       FileSystemType type);
   void ReleaseReservationBuffer(QuotaReservationBuffer* reservation_pool);
 
diff --git a/chromium/storage/browser/fileapi/quota/quota_reservation_manager_unittest.cc b/chromium/storage/browser/fileapi/quota/quota_reservation_manager_unittest.cc
index 611032df3fb..06c97e044e9 100644
--- a/chromium/storage/browser/fileapi/quota/quota_reservation_manager_unittest.cc
+++ b/chromium/storage/browser/fileapi/quota/quota_reservation_manager_unittest.cc
@@ -22,6 +22,8 @@
 #include "storage/browser/fileapi/quota/quota_reservation.h"
 #include "storage/browser/fileapi/quota/quota_reservation_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+#include "url/origin.h"
 
 using storage::kFileSystemTypeTemporary;
 using storage::OpenFileHandle;
@@ -32,7 +34,7 @@ namespace content {
 
 namespace {
 
-const char kOrigin[] = "http://example.com";
+const url::Origin kOrigin(url::Origin::Create(GURL("http://example.com")));
 const storage::FileSystemType kType = kFileSystemTypeTemporary;
 const int64_t kInitialFileSize = 1;
 
@@ -56,11 +58,11 @@ class FakeBackend : public QuotaReservationManager::QuotaBackend {
       : on_memory_usage_(kInitialFileSize), on_disk_usage_(kInitialFileSize) {}
   ~FakeBackend() override = default;
 
-  void ReserveQuota(const GURL& origin,
+  void ReserveQuota(const url::Origin& origin,
                     storage::FileSystemType type,
                     int64_t delta,
                     const ReserveQuotaCallback& callback) override {
-    EXPECT_EQ(GURL(kOrigin), origin);
+    EXPECT_EQ(kOrigin, origin);
     EXPECT_EQ(kType, type);
     on_memory_usage_ += delta;
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ -68,27 +70,27 @@ class FakeBackend : public QuotaReservationManager::QuotaBackend {
                                   base::File::FILE_OK, delta));
   }
 
-  void ReleaseReservedQuota(const GURL& origin,
+  void ReleaseReservedQuota(const url::Origin& origin,
                             storage::FileSystemType type,
                             int64_t size) override {
     EXPECT_LE(0, size);
-    EXPECT_EQ(GURL(kOrigin), origin);
+    EXPECT_EQ(kOrigin, origin);
     EXPECT_EQ(kType, type);
     on_memory_usage_ -= size;
   }
 
-  void CommitQuotaUsage(const GURL& origin,
+  void CommitQuotaUsage(const url::Origin& origin,
                         storage::FileSystemType type,
                         int64_t delta) override {
-    EXPECT_EQ(GURL(kOrigin), origin);
+    EXPECT_EQ(kOrigin, origin);
     EXPECT_EQ(kType, type);
     on_disk_usage_ += delta;
     on_memory_usage_ += delta;
   }
 
-  void IncrementDirtyCount(const GURL& origin,
+  void IncrementDirtyCount(const url::Origin& origin,
                            storage::FileSystemType type) override {}
-  void DecrementDirtyCount(const GURL& origin,
+  void DecrementDirtyCount(const url::Origin& origin,
                            storage::FileSystemType type) override {}
 
   int64_t on_memory_usage() { return on_memory_usage_; }
@@ -219,7 +221,7 @@ class QuotaReservationManagerTest : public testing::Test {
 
 TEST_F(QuotaReservationManagerTest, BasicTest) {
   scoped_refptr<QuotaReservation> reservation =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
 
   {
     RefreshReservation(reservation.get(), 10 + 20 + 3);
@@ -260,7 +262,7 @@ TEST_F(QuotaReservationManagerTest, BasicTest) {
 
 TEST_F(QuotaReservationManagerTest, MultipleWriter) {
   scoped_refptr<QuotaReservation> reservation =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
 
   {
     RefreshReservation(reservation.get(), 10 + 20 + 30 + 40 + 5);
@@ -294,12 +296,12 @@ TEST_F(QuotaReservationManagerTest, MultipleWriter) {
 
 TEST_F(QuotaReservationManagerTest, MultipleClient) {
   scoped_refptr<QuotaReservation> reservation1 =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
   RefreshReservation(reservation1.get(), 10);
   int64_t cached_reserved_quota1 = reservation1->remaining_quota();
 
   scoped_refptr<QuotaReservation> reservation2 =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
   RefreshReservation(reservation2.get(), 20);
   int64_t cached_reserved_quota2 = reservation2->remaining_quota();
 
@@ -340,11 +342,11 @@ TEST_F(QuotaReservationManagerTest, MultipleClient) {
 
 TEST_F(QuotaReservationManagerTest, ClientCrash) {
   scoped_refptr<QuotaReservation> reservation1 =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
   RefreshReservation(reservation1.get(), 15);
 
   scoped_refptr<QuotaReservation> reservation2 =
-      reservation_manager()->CreateReservation(GURL(kOrigin), kType);
+      reservation_manager()->CreateReservation(kOrigin, kType);
   RefreshReservation(reservation2.get(), 20);
 
   {
diff --git a/chromium/storage/browser/fileapi/sandbox_directory_database.cc b/chromium/storage/browser/fileapi/sandbox_directory_database.cc
index d94b818890d..b2660c9992c 100644
--- a/chromium/storage/browser/fileapi/sandbox_directory_database.cc
+++ b/chromium/storage/browser/fileapi/sandbox_directory_database.cc
@@ -24,6 +24,7 @@
 #include "storage/browser/fileapi/file_system_usage_cache.h"
 #include "storage/common/fileapi/file_system_util.h"
 #include "third_party/leveldatabase/env_chromium.h"
+#include "third_party/leveldatabase/leveldb_chrome.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
@@ -760,7 +761,7 @@ bool SandboxDirectoryDatabase::Init(RecoveryOption recovery_option) {
       FALLTHROUGH;
     case DELETE_ON_CORRUPTION:
       LOG(WARNING) << "Clearing SandboxDirectoryDatabase.";
-      if (!base::DeleteFile(filesystem_data_directory_, true))
+      if (!leveldb_chrome::DeleteDB(filesystem_data_directory_, options).ok())
         return false;
       if (!base::CreateDirectory(filesystem_data_directory_))
         return false;
diff --git a/chromium/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc b/chromium/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc
index 30a6ff07e70..06fc50fdb10 100644
--- a/chromium/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc
+++ b/chromium/storage/browser/fileapi/sandbox_file_system_backend_delegate.cc
@@ -443,7 +443,8 @@ SandboxFileSystemBackendDelegate::CreateQuotaReservationOnFileTaskRunner(
     FileSystemType type) {
   DCHECK(file_task_runner_->RunsTasksInCurrentSequence());
   DCHECK(quota_reservation_manager_);
-  return quota_reservation_manager_->CreateReservation(origin, type);
+  return quota_reservation_manager_->CreateReservation(
+      url::Origin::Create(origin), type);
 }
 
 void SandboxFileSystemBackendDelegate::AddFileUpdateObserver(
diff --git a/chromium/storage/browser/quota/quota_database.cc b/chromium/storage/browser/quota/quota_database.cc
index e7898300d41..dc8a3c3f4ee 100644
--- a/chromium/storage/browser/quota/quota_database.cc
+++ b/chromium/storage/browser/quota/quota_database.cc
@@ -198,6 +198,8 @@ bool QuotaDatabase::SetHostQuota(const std::string& host,
   DCHECK_GE(quota, 0);
   if (!LazyOpen(true))
     return false;
+  if (quota == 0)
+    return DeleteHostQuota(host, type);
   if (!InsertOrReplaceHostQuota(host, type, quota))
     return false;
   ScheduleCommit();
@@ -224,9 +226,10 @@ bool QuotaDatabase::SetOriginLastAccessTime(
     entry.used_count = 1;
     const char* kSql =
         "INSERT INTO OriginInfoTable"
-        " (used_count, last_access_time, origin, type)"
-        " VALUES (?, ?, ?, ?)";
+        " (used_count, last_access_time, origin, type, last_modified_time)"
+        " VALUES (?, ?, ?, ?, ?)";
     statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+    statement.BindInt64(4, last_access_time.ToInternalValue());
   }
   statement.BindInt(0, entry.used_count);
   statement.BindInt64(1, last_access_time.ToInternalValue());
@@ -258,8 +261,9 @@ bool QuotaDatabase::SetOriginLastModifiedTime(
   } else {
     const char* kSql =
         "INSERT INTO OriginInfoTable"
-        " (last_modified_time, origin, type)  VALUES (?, ?, ?)";
+        " (last_modified_time, origin, type, last_access_time)  VALUES (?, ?, ?, ?)";
     statement.Assign(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
+    statement.BindInt64(3, last_modified_time.ToInternalValue());
   }
   statement.BindInt64(0, last_modified_time.ToInternalValue());
   statement.BindString(1, origin.spec());
@@ -279,7 +283,7 @@ bool QuotaDatabase::GetOriginLastEvictionTime(const GURL& origin,
   if (!LazyOpen(false))
     return false;
 
-  const char kSql[] =
+  static const char kSql[] =
       "SELECT last_eviction_time"
       " FROM EvictionInfoTable"
       " WHERE origin = ? AND type = ?";
@@ -301,7 +305,7 @@ bool QuotaDatabase::SetOriginLastEvictionTime(const GURL& origin,
   if (!LazyOpen(true))
     return false;
 
-  const char kSql[] =
+  static const char kSql[] =
       "INSERT OR REPLACE INTO EvictionInfoTable"
       " (last_eviction_time, origin, type)"
       " VALUES (?, ?, ?)";
@@ -322,7 +326,7 @@ bool QuotaDatabase::DeleteOriginLastEvictionTime(const GURL& origin,
   if (!LazyOpen(false))
     return false;
 
-  const char kSql[] =
+  static const char kSql[] =
       "DELETE FROM EvictionInfoTable"
       " WHERE origin = ? AND type = ?";
 
diff --git a/chromium/storage/browser/quota/quota_database_unittest.cc b/chromium/storage/browser/quota/quota_database_unittest.cc
index 62fbcd91d07..99c3a829934 100644
--- a/chromium/storage/browser/quota/quota_database_unittest.cc
+++ b/chromium/storage/browser/quota/quota_database_unittest.cc
@@ -112,6 +112,10 @@ class QuotaDatabaseTest : public testing::Test {
     // Delete temporary storage quota.
     EXPECT_TRUE(db.DeleteHostQuota(kHost, kTemporary));
     EXPECT_FALSE(db.GetHostQuota(kHost, kTemporary, &quota));
+
+    // Delete persistent quota by setting it to zero.
+    EXPECT_TRUE(db.SetHostQuota(kHost, kPersistent, 0));
+    EXPECT_FALSE(db.GetHostQuota(kHost, kPersistent, &quota));
   }
 
   void GlobalQuota(const base::FilePath& kDbFile) {
diff --git a/chromium/storage/browser/quota/quota_manager_unittest.cc b/chromium/storage/browser/quota/quota_manager_unittest.cc
index 05853a1da08..54124896e20 100644
--- a/chromium/storage/browser/quota/quota_manager_unittest.cc
+++ b/chromium/storage/browser/quota/quota_manager_unittest.cc
@@ -21,7 +21,7 @@
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
-#include "base/test/histogram_tester.h"
+#include "base/test/metrics/histogram_tester.h"
 #include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
diff --git a/chromium/storage/browser/quota/special_storage_policy.h b/chromium/storage/browser/quota/special_storage_policy.h
index dc0f37cecc0..526cd24a02f 100644
--- a/chromium/storage/browser/quota/special_storage_policy.h
+++ b/chromium/storage/browser/quota/special_storage_policy.h
@@ -10,6 +10,7 @@
 #include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
+#include "services/network/session_cleanup_cookie_store.h"
 #include "storage/browser/storage_browser_export.h"
 
 class GURL;
@@ -41,11 +42,6 @@ class STORAGE_EXPORT SpecialStoragePolicy
     virtual ~Observer();
   };
 
-  // Returns true if the cookie associated with the domain and is_https status
-  // should be deleted.
-  using DeleteCookiePredicate =
-      base::RepeatingCallback<bool(const std::string&, bool)>;
-
   SpecialStoragePolicy();
 
   // Protected storage is not subject to removal by the browsing data remover.
@@ -74,7 +70,8 @@ class STORAGE_EXPORT SpecialStoragePolicy
   // It uses domain matching as described in section 5.1.3 of RFC 6265 to
   // identify content setting rules that could have influenced the cookie
   // when it was created.
-  virtual DeleteCookiePredicate CreateDeleteCookieOnExitPredicate() = 0;
+  virtual network::SessionCleanupCookieStore::DeleteCookiePredicate
+  CreateDeleteCookieOnExitPredicate() = 0;
 
   // Adds/removes an observer, the policy does not take
   // ownership of the observer. Should only be called on the IO thread.
diff --git a/chromium/storage/common/BUILD.gn b/chromium/storage/common/BUILD.gn
index 44d68d9226b..56863a24b67 100644
--- a/chromium/storage/common/BUILD.gn
+++ b/chromium/storage/common/BUILD.gn
@@ -62,7 +62,7 @@ source_set("unittests") {
   deps = [
     ":common",
     "//base/test:test_support",
-    "//mojo/edk",
+    "//mojo/core/embedder",
     "//testing/gtest",
     "//url",
   ]
diff --git a/chromium/storage/common/blob_storage/OWNERS b/chromium/storage/common/blob_storage/OWNERS
index e77e62a6a6f..49592325cf3 100644
--- a/chromium/storage/common/blob_storage/OWNERS
+++ b/chromium/storage/common/blob_storage/OWNERS
@@ -2,4 +2,4 @@ dmurph@chromium.org
 mek@chromium.org
 
 # TEAM: storage-dev@chromium.org
-# COMPONENT: Blink>FileAPI
+# COMPONENT: Blink>Storage>FileAPI
diff --git a/chromium/storage/common/database/database_connections.cc b/chromium/storage/common/database/database_connections.cc
index 996c8c333dc..479b45b0c7c 100644
--- a/chromium/storage/common/database/database_connections.cc
+++ b/chromium/storage/common/database/database_connections.cc
@@ -4,13 +4,7 @@
 
 #include "storage/common/database/database_connections.h"
 
-#include <stdint.h>
-
-#include "base/auto_reset.h"
-#include "base/bind.h"
 #include "base/logging.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/threading/thread_task_runner_handle.h"
 
 namespace storage {
 
@@ -77,8 +71,12 @@ DatabaseConnections::RemoveConnections(const DatabaseConnections& connections) {
 int64_t DatabaseConnections::GetOpenDatabaseSize(
     const std::string& origin_identifier,
     const base::string16& database_name) const {
-  DCHECK(IsDatabaseOpened(origin_identifier, database_name));
-  return connections_[origin_identifier][database_name].second;
+  OriginConnections::const_iterator origin_it =
+      connections_.find(origin_identifier);
+  DCHECK(origin_it != connections_.end()) << "Database not opened";
+  DBConnections::const_iterator it = origin_it->second.find(database_name);
+  DCHECK(it != origin_it->second.end()) << "Database not opened";
+  return it->second.second;
 }
 
 void DatabaseConnections::SetOpenDatabaseSize(
@@ -119,48 +117,4 @@ bool DatabaseConnections::RemoveConnectionsHelper(
   return true;
 }
 
-DatabaseConnectionsWrapper::DatabaseConnectionsWrapper() = default;
-
-DatabaseConnectionsWrapper::~DatabaseConnectionsWrapper() = default;
-
-bool DatabaseConnectionsWrapper::HasOpenConnections() {
-  base::AutoLock auto_lock(open_connections_lock_);
-  return !open_connections_.IsEmpty();
-}
-
-void DatabaseConnectionsWrapper::AddOpenConnection(
-    const std::string& origin_identifier,
-    const base::string16& database_name) {
-  base::AutoLock auto_lock(open_connections_lock_);
-  open_connections_.AddConnection(origin_identifier, database_name);
-}
-
-void DatabaseConnectionsWrapper::RemoveOpenConnection(
-    const std::string& origin_identifier,
-    const base::string16& database_name) {
-  base::AutoLock auto_lock(open_connections_lock_);
-  open_connections_.RemoveConnection(origin_identifier, database_name);
-  if (waiting_to_close_event_ && open_connections_.IsEmpty())
-    waiting_to_close_event_->Signal();
-}
-
-bool DatabaseConnectionsWrapper::WaitForAllDatabasesToClose(
-    base::TimeDelta timeout) {
-  base::WaitableEvent waitable_event(
-      base::WaitableEvent::ResetPolicy::MANUAL,
-      base::WaitableEvent::InitialState::NOT_SIGNALED);
-  {
-    base::AutoLock auto_lock(open_connections_lock_);
-    if (open_connections_.IsEmpty())
-      return true;
-    waiting_to_close_event_ = &waitable_event;
-  }
-  waitable_event.TimedWait(timeout);
-  {
-    base::AutoLock auto_lock(open_connections_lock_);
-    waiting_to_close_event_ = nullptr;
-    return open_connections_.IsEmpty();
-  }
-}
-
 }  // namespace storage
diff --git a/chromium/storage/common/database/database_connections.h b/chromium/storage/common/database/database_connections.h
index e0ad75b8159..79d6b941ad6 100644
--- a/chromium/storage/common/database/database_connections.h
+++ b/chromium/storage/common/database/database_connections.h
@@ -11,16 +11,9 @@
 #include <string>
 #include <vector>
 
-#include "base/memory/ref_counted.h"
 #include "base/strings/string16.h"
-#include "base/synchronization/lock.h"
-#include "base/time/time.h"
 #include "storage/common/storage_common_export.h"
 
-namespace base {
-class WaitableEvent;
-}
-
 namespace storage {
 
 class STORAGE_COMMON_EXPORT DatabaseConnections {
@@ -45,7 +38,7 @@ class STORAGE_COMMON_EXPORT DatabaseConnections {
   std::vector<std::pair<std::string, base::string16>> RemoveConnections(
       const DatabaseConnections& connections);
 
-  // Database sizes can be kept only if IsDatabaseOpened returns true.
+  // Can be called only if IsDatabaseOpened would have returned true.
   int64_t GetOpenDatabaseSize(const std::string& origin_identifier,
                               const base::string16& database_name) const;
   void SetOpenDatabaseSize(const std::string& origin_identifier,
@@ -56,10 +49,12 @@ class STORAGE_COMMON_EXPORT DatabaseConnections {
   std::vector<std::pair<std::string, base::string16>> ListConnections() const;
 
  private:
-  // Mapping from name to <openCount, size>
-  typedef std::map<base::string16, std::pair<int, int64_t>> DBConnections;
-  typedef std::map<std::string, DBConnections> OriginConnections;
-  mutable OriginConnections connections_;  // mutable for GetOpenDatabaseSize
+  // Maps database names to (open count, database size).
+  using DBConnections = std::map<base::string16, std::pair<int, int64_t>>;
+  // Maps origin identifiers to DBConnections.
+  using OriginConnections = std::map<std::string, DBConnections>;
+
+  OriginConnections connections_;
 
   // Returns true if the last connection was removed.
   bool RemoveConnectionsHelper(const std::string& origin_identifier,
@@ -67,32 +62,6 @@ class STORAGE_COMMON_EXPORT DatabaseConnections {
                                int num_connections);
 };
 
-// A wrapper class that provides thread-safety and the
-// ability to wait until all connections have closed.
-// Intended for use in renderer processes.
-class STORAGE_COMMON_EXPORT DatabaseConnectionsWrapper
-    : public base::RefCountedThreadSafe<DatabaseConnectionsWrapper> {
- public:
-  DatabaseConnectionsWrapper();
-
-  bool HasOpenConnections();
-  void AddOpenConnection(const std::string& origin_identifier,
-                         const base::string16& database_name);
-  void RemoveOpenConnection(const std::string& origin_identifier,
-                            const base::string16& database_name);
-
-  // Returns true if all databases are closed.
-  bool WaitForAllDatabasesToClose(base::TimeDelta timeout);
-
- private:
-  ~DatabaseConnectionsWrapper();
-  friend class base::RefCountedThreadSafe<DatabaseConnectionsWrapper>;
-
-  base::Lock open_connections_lock_;
-  DatabaseConnections open_connections_;
-  base::WaitableEvent* waiting_to_close_event_ = nullptr;
-};
-
 }  // namespace storage
 
 #endif  // STORAGE_COMMON_DATABASE_DATABASE_CONNECTIONS_H_
diff --git a/chromium/storage/common/database/database_connections_unittest.cc b/chromium/storage/common/database/database_connections_unittest.cc
index 42b03989504..ee595f91924 100644
--- a/chromium/storage/common/database/database_connections_unittest.cc
+++ b/chromium/storage/common/database/database_connections_unittest.cc
@@ -4,31 +4,13 @@
 
 #include <stdint.h>
 
-#include "base/bind.h"
-#include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/threading/thread.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "storage/common/database/database_connections.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
-using storage::DatabaseConnections;
-using storage::DatabaseConnectionsWrapper;
 
-namespace content {
-
-namespace {
-
-void RemoveConnectionTask(
-    const std::string& origin_id, const base::string16& database_name,
-    scoped_refptr<DatabaseConnectionsWrapper> obj,
-    bool* did_task_execute) {
-  *did_task_execute = true;
-  obj->RemoveOpenConnection(origin_id, database_name);
-}
-
-}  // anonymous namespace
+namespace storage {
 
 TEST(DatabaseConnectionsTest, DatabaseConnectionsTest) {
   const std::string kOriginId("origin_id");
@@ -92,38 +74,4 @@ TEST(DatabaseConnectionsTest, DatabaseConnectionsTest) {
   EXPECT_TRUE(connections.RemoveConnection(kOriginId, kName));
 }
 
-TEST(DatabaseConnectionsTest, DatabaseConnectionsWrapperTest) {
-  const std::string kOriginId("origin_id");
-  const base::string16 kName(ASCIIToUTF16("database_name"));
-
-  base::MessageLoop message_loop;
-  scoped_refptr<DatabaseConnectionsWrapper> obj(new DatabaseConnectionsWrapper);
-  EXPECT_FALSE(obj->HasOpenConnections());
-  obj->AddOpenConnection(kOriginId, kName);
-  EXPECT_TRUE(obj->HasOpenConnections());
-  obj->AddOpenConnection(kOriginId, kName);
-  EXPECT_TRUE(obj->HasOpenConnections());
-  obj->RemoveOpenConnection(kOriginId, kName);
-  EXPECT_TRUE(obj->HasOpenConnections());
-  obj->RemoveOpenConnection(kOriginId, kName);
-  EXPECT_FALSE(obj->HasOpenConnections());
-  EXPECT_TRUE(obj->WaitForAllDatabasesToClose(base::TimeDelta()));
-
-  // Test WaitForAllDatabasesToClose with the last connection
-  // being removed on another thread.
-  obj->AddOpenConnection(kOriginId, kName);
-  EXPECT_FALSE(obj->WaitForAllDatabasesToClose(base::TimeDelta()));
-  base::Thread thread("WrapperTestThread");
-  thread.Start();
-  bool did_task_execute = false;
-  thread.task_runner()->PostTask(
-      FROM_HERE, base::BindOnce(&RemoveConnectionTask, kOriginId, kName, obj,
-                                &did_task_execute));
-  // Use a long timeout value to avoid timeouts on test bots.
-  EXPECT_TRUE(obj->WaitForAllDatabasesToClose(
-      base::TimeDelta::FromSeconds(15)));
-  EXPECT_TRUE(did_task_execute);
-  EXPECT_FALSE(obj->HasOpenConnections());
-}
-
-}  // namespace content
+}  // namespace storage
diff --git a/chromium/storage/common/fileapi/file_system_util.h b/chromium/storage/common/fileapi/file_system_util.h
index a50cdb21b8c..36603fd9823 100644
--- a/chromium/storage/common/fileapi/file_system_util.h
+++ b/chromium/storage/common/fileapi/file_system_util.h
@@ -126,9 +126,6 @@ STORAGE_COMMON_EXPORT bool GetFileSystemPublicType(
 //  - StringToFilePath(FilePathToString(path)) == path
 //  - StringToFilePath(FilePathToString(path) + "/" + "SubDirectory") ==
 //    path.AppendASCII("SubDirectory");
-//
-// TODO(tzik): Replace CreateFilePath and FilePathToString in
-// third_party/leveldatabase/env_chromium.cc with them.
 STORAGE_COMMON_EXPORT std::string FilePathToString(
     const base::FilePath& file_path);
 
diff --git a/chromium/storage/common/run_all_unittests.cc b/chromium/storage/common/run_all_unittests.cc
index 75ad05f6162..a131fb2ab4d 100644
--- a/chromium/storage/common/run_all_unittests.cc
+++ b/chromium/storage/common/run_all_unittests.cc
@@ -6,13 +6,13 @@
 #include "base/test/launcher/unit_test_launcher.h"
 #include "base/test/test_suite.h"
 #include "build/build_config.h"
-#include "mojo/edk/embedder/embedder.h"
+#include "mojo/core/embedder/embedder.h"
 
 int main(int argc, char** argv) {
   int result = 0;
   {
     base::TestSuite test_suite(argc, argv);
-    mojo::edk::Init();
+    mojo::core::Init();
     result = base::LaunchUnitTests(
         argc, argv,
         base::BindOnce(&base::TestSuite::Run, base::Unretained(&test_suite)));