BASELINE: Update Chromium to 85.0.4183.14085-based

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

22 files changed, 155 insertions, 249 deletions

diff --git a/chromium/content/browser/cache_storage/cache_storage.proto b/chromium/content/browser/cache_storage/cache_storage.proto
index bdec6e51cdd..3fcaef2bd27 100644
--- a/chromium/content/browser/cache_storage/cache_storage.proto
+++ b/chromium/content/browser/cache_storage/cache_storage.proto
@@ -50,6 +50,11 @@ message CacheResponse {
   repeated string cors_exposed_header_names = 7;
   repeated string url_list = 8;
   optional bool loaded_with_credentials = 9;
+  // Mapped to net::HttpResponseInfo::ConnectionInfo via static casting.
+  optional int32 connection_info = 10;
+  optional string alpn_negotiated_protocol = 11;
+  optional bool was_fetched_via_spdy = 12;
+  optional string mime_type = 13;
 }
 
 message CacheMetadata {
diff --git a/chromium/content/browser/cache_storage/cache_storage_blob_to_disk_cache.cc b/chromium/content/browser/cache_storage/cache_storage_blob_to_disk_cache.cc
index 0c34c8b1e29..0926ea95133 100644
--- a/chromium/content/browser/cache_storage/cache_storage_blob_to_disk_cache.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_blob_to_disk_cache.cc
@@ -12,7 +12,6 @@
 #include "net/base/io_buffer.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
-#include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "third_party/blink/public/common/blob/blob_utils.h"
 #include "url/origin.h"
diff --git a/chromium/content/browser/cache_storage/cache_storage_blob_to_disk_cache_unittest.cc b/chromium/content/browser/cache_storage/cache_storage_blob_to_disk_cache_unittest.cc
index 52f1d7bfc6f..7a4af2b7e43 100644
--- a/chromium/content/browser/cache_storage/cache_storage_blob_to_disk_cache_unittest.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_blob_to_disk_cache_unittest.cc
@@ -21,7 +21,6 @@
 #include "content/browser/cache_storage/scoped_writable_entry.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/storage_partition.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/test_browser_context.h"
 #include "net/disk_cache/disk_cache.h"
diff --git a/chromium/content/browser/cache_storage/cache_storage_cache_entry_handler.cc b/chromium/content/browser/cache_storage/cache_storage_cache_entry_handler.cc
index 0df665356f4..972e54f3ad3 100644
--- a/chromium/content/browser/cache_storage/cache_storage_cache_entry_handler.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_cache_entry_handler.cc
@@ -7,6 +7,7 @@
 #include "base/callback_helpers.h"
 #include "base/guid.h"
 #include "base/optional.h"
+#include "components/services/storage/public/mojom/blob_storage_context.mojom.h"
 #include "content/browser/background_fetch/storage/cache_entry_handler_impl.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
 #include "content/browser/cache_storage/legacy/legacy_cache_storage.h"
@@ -17,7 +18,6 @@
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_impl.h"
 #include "storage/browser/blob/blob_storage_context.h"
-#include "storage/browser/blob/mojom/blob_storage_context.mojom.h"
 #include "third_party/blink/public/common/blob/blob_utils.h"
 
 namespace content {
diff --git a/chromium/content/browser/cache_storage/cache_storage_cache_unittest.cc b/chromium/content/browser/cache_storage/cache_storage_cache_unittest.cc
index 3a346bd50cd..9395f795ff4 100644
--- a/chromium/content/browser/cache_storage/cache_storage_cache_unittest.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_cache_unittest.cc
@@ -36,9 +36,6 @@
 #include "content/browser/cache_storage/legacy/legacy_cache_storage_cache.h"
 #include "content/common/background_fetch/background_fetch_types.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/storage_partition.h"
-#include "content/public/common/content_features.h"
-#include "content/public/common/referrer.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_utils.h"
@@ -50,10 +47,6 @@
 #include "net/base/test_completion_callback.h"
 #include "net/base/url_util.h"
 #include "net/disk_cache/disk_cache.h"
-#include "storage/browser/blob/blob_data_builder.h"
-#include "storage/browser/blob/blob_data_handle.h"
-#include "storage/browser/blob/blob_data_snapshot.h"
-#include "storage/browser/blob/blob_impl.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/test/blob_test_utils.h"
@@ -67,7 +60,6 @@
 using blink::FetchAPIRequestHeadersMap;
 using blink::mojom::CacheStorageError;
 using blink::mojom::CacheStorageVerboseErrorPtr;
-using storage::BlobDataItem;
 
 namespace content {
 namespace cache_storage_cache_unittest {
@@ -671,13 +663,16 @@ class CacheStorageCacheTest : public testing::Test {
         network::mojom::FetchResponseSource::kUnspecified,
         base::flat_map<std::string, std::string>(kHeaders.cbegin(),
                                                  kHeaders.cend()),
-        nullptr /* blob */, blink::mojom::ServiceWorkerResponseError::kUnknown,
-        response_time_, std::string() /* cache_storage_cache_name */,
+        base::nullopt /* mime_type */, nullptr /* blob */,
+        blink::mojom::ServiceWorkerResponseError::kUnknown, response_time_,
+        std::string() /* cache_storage_cache_name */,
         std::vector<std::string>() /* cors_exposed_header_names */,
         nullptr /* side_data_blob */,
         nullptr /* side_data_blob_for_cache_put */,
         network::mojom::ParsedHeaders::New(),
-        false /* loaded_with_credentials */);
+        net::HttpResponseInfo::CONNECTION_INFO_UNKNOWN,
+        "unknown" /* alpn_negotiated_protocol */,
+        false /* loaded_with_credentials */, false /* was_fetched_via_spdy */);
   }
 
   void CopySideDataToResponse(const std::string& uuid,
@@ -718,7 +713,6 @@ class CacheStorageCacheTest : public testing::Test {
   void CheckOpHistograms(base::HistogramTester& histogram_tester,
                          const char* op_name) {
     std::string base("ServiceWorkerCache.Cache.Scheduler.");
-    histogram_tester.ExpectTotalCount(base + "IsOperationSlow." + op_name, 1);
     histogram_tester.ExpectTotalCount(base + "OperationDuration2." + op_name,
                                       1);
     histogram_tester.ExpectTotalCount(base + "QueueDuration2." + op_name, 1);
diff --git a/chromium/content/browser/cache_storage/cache_storage_context_impl.cc b/chromium/content/browser/cache_storage/cache_storage_context_impl.cc
index 599832e97f3..93b990bd6f4 100644
--- a/chromium/content/browser/cache_storage/cache_storage_context_impl.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_context_impl.cc
@@ -8,7 +8,6 @@
 #include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/sequenced_task_runner.h"
-#include "base/task/post_task.h"
 #include "base/task/thread_pool.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
@@ -17,10 +16,10 @@
 #include "content/browser/cache_storage/cache_storage_quota_client.h"
 #include "content/browser/cache_storage/cross_sequence/cross_sequence_cache_storage_manager.h"
 #include "content/browser/cache_storage/legacy/legacy_cache_storage_manager.h"
-#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "storage/browser/blob/blob_storage_context.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "url/origin.h"
@@ -43,15 +42,14 @@ const base::Feature kCacheStorageSequenceFeature{
 
 scoped_refptr<base::SequencedTaskRunner> CreateSchedulerTaskRunner() {
   if (!base::FeatureList::IsEnabled(kCacheStorageSequenceFeature))
-    return base::CreateSingleThreadTaskRunner({BrowserThread::IO});
+    return GetIOThreadTaskRunner({});
   return base::ThreadPool::CreateSequencedTaskRunner(
       {base::TaskPriority::USER_VISIBLE});
 }
 
 }  // namespace
 
-CacheStorageContextImpl::CacheStorageContextImpl(
-    BrowserContext* browser_context)
+CacheStorageContextImpl::CacheStorageContextImpl()
     : task_runner_(CreateSchedulerTaskRunner()),
       observers_(base::MakeRefCounted<ObserverList>()) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ -88,8 +86,8 @@ void CacheStorageContextImpl::Init(
   // running with a different target sequence then the quota client code will
   // get a cross-sequence wrapper that is guaranteed to initialize its internal
   // SequenceBound<> object after the real manager is created.
-  base::PostTask(
-      FROM_HERE, {BrowserThread::IO},
+  GetIOThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(&CacheStorageContextImpl::CreateQuotaClientsOnIOThread,
                      base::WrapRefCounted(this),
                      std::move(quota_manager_proxy)));
@@ -171,8 +169,8 @@ void CacheStorageContextImpl::SetBlobParametersForCache(
   // We can only bind a mojo interface for BlobStorageContext on the IO thread.
   // TODO(enne): clean this up in the future to not require this bounce and
   // to have this mojo context live on the cache storage sequence.
-  base::PostTask(
-      FROM_HERE, {BrowserThread::IO},
+  GetIOThreadTaskRunner({})->PostTask(
+      FROM_HERE,
       base::BindOnce(
           &CacheStorageContextImpl::BindBlobStorageMojoContextOnIOThread, this,
           base::RetainedRef(blob_storage_context), std::move(receiver)));
@@ -321,10 +319,14 @@ void CacheStorageContextImpl::CreateQuotaClientsOnIOThread(
     return;
   quota_manager_proxy->RegisterClient(
       base::MakeRefCounted<CacheStorageQuotaClient>(
-          manager, CacheStorageOwner::kCacheAPI));
+          manager, CacheStorageOwner::kCacheAPI),
+      storage::QuotaClientType::kServiceWorkerCache,
+      {blink::mojom::StorageType::kTemporary});
   quota_manager_proxy->RegisterClient(
       base::MakeRefCounted<CacheStorageQuotaClient>(
-          manager, CacheStorageOwner::kBackgroundFetch));
+          manager, CacheStorageOwner::kBackgroundFetch),
+      storage::QuotaClientType::kBackgroundFetch,
+      {blink::mojom::StorageType::kTemporary});
 }
 
 }  // namespace content
diff --git a/chromium/content/browser/cache_storage/cache_storage_context_impl.h b/chromium/content/browser/cache_storage/cache_storage_context_impl.h
index 656ceb9f8a9..4b7fa256196 100644
--- a/chromium/content/browser/cache_storage/cache_storage_context_impl.h
+++ b/chromium/content/browser/cache_storage/cache_storage_context_impl.h
@@ -13,6 +13,7 @@
 #include "base/observer_list_threadsafe.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/sequence_bound.h"
+#include "components/services/storage/public/mojom/blob_storage_context.mojom.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/cache_storage_context.h"
@@ -20,7 +21,6 @@
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "services/network/public/mojom/cross_origin_embedder_policy.mojom.h"
-#include "storage/browser/blob/mojom/blob_storage_context.mojom.h"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "third_party/blink/public/mojom/cache_storage/cache_storage.mojom-forward.h"
 
@@ -39,7 +39,6 @@ class Origin;
 
 namespace content {
 
-class BrowserContext;
 class ChromeBlobStorageContext;
 class CacheStorageDispatcherHost;
 class CacheStorageManager;
@@ -65,7 +64,7 @@ class CONTENT_EXPORT CacheStorageContextWithManager
 class CONTENT_EXPORT CacheStorageContextImpl
     : public CacheStorageContextWithManager {
  public:
-  explicit CacheStorageContextImpl(BrowserContext* browser_context);
+  CacheStorageContextImpl();
 
   class Observer {
    public:
diff --git a/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.cc b/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.cc
index 73ee5b6d279..ae141c45e44 100644
--- a/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.cc
@@ -21,7 +21,6 @@
 #include "content/common/background_fetch/background_fetch_types.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/origin_util.h"
-#include "content/public/common/referrer_type_converters.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/bindings/pending_associated_remote.h"
 #include "net/http/http_response_headers.h"
@@ -274,11 +273,8 @@ class CacheStorageDispatcherHost::CacheImpl
 
     CacheStorageSchedulerPriority priority =
         CacheStorageSchedulerPriority::kNormal;
-    if (in_related_fetch_event &&
-        base::FeatureList::IsEnabled(
-            features::kCacheStorageHighPriorityMatch)) {
+    if (in_related_fetch_event)
       priority = CacheStorageSchedulerPriority::kHigh;
-    }
 
     cache->Match(std::move(request), std::move(match_options), priority,
                  trace_id, std::move(cb));
@@ -727,11 +723,8 @@ class CacheStorageDispatcherHost::CacheStorageImpl final
 
     CacheStorageSchedulerPriority priority =
         CacheStorageSchedulerPriority::kNormal;
-    if (in_related_fetch_event &&
-        base::FeatureList::IsEnabled(
-            features::kCacheStorageHighPriorityMatch)) {
+    if (in_related_fetch_event)
       priority = CacheStorageSchedulerPriority::kHigh;
-    }
 
     if (!match_options->cache_name) {
       cache_storage->MatchAllCaches(std::move(request),
diff --git a/chromium/content/browser/cache_storage/cache_storage_histogram_utils.cc b/chromium/content/browser/cache_storage/cache_storage_histogram_utils.cc
index 08589a6b051..c8455961bd2 100644
--- a/chromium/content/browser/cache_storage/cache_storage_histogram_utils.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_histogram_utils.cc
@@ -25,8 +25,6 @@ namespace {
 
 base::StringPiece UMAToName(CacheStorageSchedulerUMA uma_type) {
   switch (uma_type) {
-    case CacheStorageSchedulerUMA::kIsOperationSlow:
-      RETURN_LITERAL_STRING_PIECE("IsOperationSlow");
     case CacheStorageSchedulerUMA::kOperationDuration:
       RETURN_LITERAL_STRING_PIECE("OperationDuration2");
     case CacheStorageSchedulerUMA::kQueueDuration:
@@ -106,22 +104,15 @@ void RecordCacheStorageSchedulerUMA(CacheStorageSchedulerUMA uma_type,
                                     CacheStorageSchedulerClient client_type,
                                     CacheStorageSchedulerOp op_type,
                                     int value) {
-  DCHECK(uma_type == CacheStorageSchedulerUMA::kIsOperationSlow ||
-         uma_type == CacheStorageSchedulerUMA::kQueueLength);
+  DCHECK(uma_type == CacheStorageSchedulerUMA::kQueueLength);
   DCHECK(client_type != CacheStorageSchedulerClient::kBackgroundSync ||
          op_type == CacheStorageSchedulerOp::kBackgroundSync);
   std::string histogram_name = GetClientHistogramName(uma_type, client_type);
-  if (uma_type == CacheStorageSchedulerUMA::kIsOperationSlow)
-    base::UmaHistogramBoolean(histogram_name, value);
-  else
-    base::UmaHistogramCounts10000(histogram_name, value);
+  base::UmaHistogramCounts10000(histogram_name, value);
   if (!ShouldRecordOpUMA(op_type))
     return;
   histogram_name.append(OpToName(op_type).as_string());
-  if (uma_type == CacheStorageSchedulerUMA::kIsOperationSlow)
-    base::UmaHistogramBoolean(histogram_name, value);
-  else
-    base::UmaHistogramCounts10000(histogram_name, value);
+  base::UmaHistogramCounts10000(histogram_name, value);
 }
 
 void RecordCacheStorageSchedulerUMA(CacheStorageSchedulerUMA uma_type,
diff --git a/chromium/content/browser/cache_storage/cache_storage_histogram_utils.h b/chromium/content/browser/cache_storage/cache_storage_histogram_utils.h
index a7c7520c80a..031ddacc804 100644
--- a/chromium/content/browser/cache_storage/cache_storage_histogram_utils.h
+++ b/chromium/content/browser/cache_storage/cache_storage_histogram_utils.h
@@ -43,10 +43,9 @@ enum class ErrorStorageType {
 blink::mojom::CacheStorageError MakeErrorStorage(ErrorStorageType type);
 
 enum class CacheStorageSchedulerUMA {
-  kIsOperationSlow = 0,
-  kOperationDuration = 1,
-  kQueueDuration = 2,
-  kQueueLength = 3,
+  kOperationDuration = 0,
+  kQueueDuration = 1,
+  kQueueLength = 2,
 };
 
 // The following functions are used to record UMA histograms for the
diff --git a/chromium/content/browser/cache_storage/cache_storage_manager_unittest.cc b/chromium/content/browser/cache_storage/cache_storage_manager_unittest.cc
index fb58ce9c866..63c31a85474 100644
--- a/chromium/content/browser/cache_storage/cache_storage_manager_unittest.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_manager_unittest.cc
@@ -37,9 +37,7 @@
 #include "content/browser/cache_storage/legacy/legacy_cache_storage_manager.h"
 #include "content/common/background_fetch/background_fetch_types.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/storage_partition.h"
 #include "content/public/browser/storage_usage_info.h"
-#include "content/public/common/content_features.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_utils.h"
@@ -48,12 +46,9 @@
 #include "mojo/public/cpp/bindings/remote.h"
 #include "net/disk_cache/disk_cache.h"
 #include "services/network/public/mojom/fetch_api.mojom.h"
-#include "storage/browser/blob/blob_data_builder.h"
-#include "storage/browser/blob/blob_data_handle.h"
-#include "storage/browser/blob/blob_handle.h"
-#include "storage/browser/blob/blob_impl.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/padding_key.h"
+#include "storage/browser/quota/quota_client_type.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/test/fake_blob.h"
 #include "storage/browser/test/mock_quota_manager_proxy.h"
@@ -177,7 +172,10 @@ class MockCacheStorageQuotaManagerProxy
                                     base::SingleThreadTaskRunner* task_runner)
       : MockQuotaManagerProxy(quota_manager, task_runner) {}
 
-  void RegisterClient(scoped_refptr<storage::QuotaClient> client) override {
+  void RegisterClient(
+      scoped_refptr<storage::QuotaClient> client,
+      storage::QuotaClientType client_type,
+      const std::vector<blink::mojom::StorageType>& storage_types) override {
     registered_clients_.push_back(std::move(client));
   }
 
@@ -450,7 +448,6 @@ class CacheStorageManagerTest : public testing::Test {
   void CheckOpHistograms(base::HistogramTester& histogram_tester,
                          const char* op_name) {
     std::string base("ServiceWorkerCache.CacheStorage.Scheduler.");
-    histogram_tester.ExpectTotalCount(base + "IsOperationSlow." + op_name, 1);
     histogram_tester.ExpectTotalCount(base + "OperationDuration2." + op_name,
                                       1);
     histogram_tester.ExpectTotalCount(base + "QueueDuration2." + op_name, 1);
@@ -663,13 +660,16 @@ class CacheStorageManagerTest : public testing::Test {
     auto response = blink::mojom::FetchAPIResponse::New(
         std::vector<GURL>({request->url}), status_code, "OK", response_type,
         network::mojom::FetchResponseSource::kUnspecified, response_headers,
-        std::move(blob), blink::mojom::ServiceWorkerResponseError::kUnknown,
-        base::Time(), std::string() /* cache_storage_cache_name */,
+        base::nullopt /* mime_type */, std::move(blob),
+        blink::mojom::ServiceWorkerResponseError::kUnknown, base::Time(),
+        std::string() /* cache_storage_cache_name */,
         std::vector<std::string>() /* cors_exposed_header_names */,
         nullptr /* side_data_blob */,
         nullptr /* side_data_blob_for_cache_put */,
         network::mojom::ParsedHeaders::New(),
-        false /* loaded_with_credentials */);
+        net::HttpResponseInfo::CONNECTION_INFO_UNKNOWN,
+        "unknown" /* alpn_negotiated_protocol */,
+        false /* loaded_with_credentials */, false /* was_fetched_via_spdy */);
 
     blink::mojom::BatchOperationPtr operation =
         blink::mojom::BatchOperation::New();
@@ -822,7 +822,6 @@ class CacheStorageManagerTest : public testing::Test {
   int callback_bool_;
   CacheStorageError callback_error_;
   blink::mojom::FetchAPIResponsePtr callback_cache_handle_response_;
-  std::unique_ptr<storage::BlobDataHandle> callback_data_handle_;
   std::vector<std::string> cache_names_;
 
   const url::Origin origin1_;
@@ -1056,8 +1055,6 @@ TEST_F(CacheStorageManagerTest, StorageReuseCacheName) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(CachePut(callback_cache_handle_.value(), kTestURL));
   EXPECT_TRUE(CacheMatch(callback_cache_handle_.value(), kTestURL));
-  std::unique_ptr<storage::BlobDataHandle> data_handle =
-      std::move(callback_data_handle_);
 
   EXPECT_TRUE(Delete(origin1_, "foo"));
   // The cache is deleted but the handle to one of its entries is still
@@ -2498,10 +2495,6 @@ class CacheStorageQuotaClientTest : public CacheStorageManagerTest {
     return callback_status_ == blink::mojom::QuotaStatusCode::kOk;
   }
 
-  bool QuotaDoesSupport(StorageType type) {
-    return quota_client_->DoesSupport(type);
-  }
-
   scoped_refptr<CacheStorageQuotaClient> quota_client_;
 
   blink::mojom::QuotaStatusCode callback_status_;
@@ -2525,11 +2518,6 @@ class CacheStorageQuotaClientTestP : public CacheStorageQuotaClientTest,
   TestManager ManagerType() override { return GetParam().manager_; }
 };
 
-TEST_P(CacheStorageQuotaClientTestP, QuotaID) {
-  EXPECT_EQ(storage::QuotaClientType::kServiceWorkerCache,
-            quota_client_->type());
-}
-
 TEST_P(CacheStorageQuotaClientTestP, QuotaGetOriginUsage) {
   EXPECT_EQ(0, QuotaGetOriginUsage(origin1_));
   EXPECT_TRUE(Open(origin1_, "foo"));
@@ -2619,14 +2607,6 @@ TEST_F(CacheStorageQuotaClientDiskOnlyTest, QuotaDeleteUnloadedOriginData) {
   EXPECT_EQ(0, QuotaGetOriginUsage(origin1_));
 }
 
-TEST_P(CacheStorageQuotaClientTestP, QuotaDoesSupport) {
-  EXPECT_TRUE(QuotaDoesSupport(StorageType::kTemporary));
-  EXPECT_FALSE(QuotaDoesSupport(StorageType::kPersistent));
-  EXPECT_FALSE(QuotaDoesSupport(StorageType::kSyncable));
-  EXPECT_FALSE(QuotaDoesSupport(StorageType::kQuotaNotManaged));
-  EXPECT_FALSE(QuotaDoesSupport(StorageType::kUnknown));
-}
-
 INSTANTIATE_TEST_SUITE_P(
     CacheStorageManagerTests,
     CacheStorageManagerTestP,
diff --git a/chromium/content/browser/cache_storage/cache_storage_operation.cc b/chromium/content/browser/cache_storage/cache_storage_operation.cc
index 7be85256def..de2b32d9185 100644
--- a/chromium/content/browser/cache_storage/cache_storage_operation.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_operation.cc
@@ -8,10 +8,6 @@
 
 namespace content {
 
-namespace {
-const int kNumSecondsForSlowOperation = 10;
-}
-
 CacheStorageOperation::CacheStorageOperation(
     base::OnceClosure closure,
     CacheStorageSchedulerId id,
@@ -33,27 +29,11 @@ CacheStorageOperation::~CacheStorageOperation() {
   RecordCacheStorageSchedulerUMA(CacheStorageSchedulerUMA::kOperationDuration,
                                  client_type_, op_type_,
                                  base::TimeTicks::Now() - start_ticks_);
-
-  if (!was_slow_)
-    RecordCacheStorageSchedulerUMA(CacheStorageSchedulerUMA::kIsOperationSlow,
-                                   client_type_, op_type_, was_slow_);
 }
 
 void CacheStorageOperation::Run() {
   start_ticks_ = base::TimeTicks::Now();
-
-  task_runner_->PostDelayedTask(
-      FROM_HERE,
-      base::BindOnce(&CacheStorageOperation::NotifyOperationSlow,
-                     weak_ptr_factory_.GetWeakPtr()),
-      base::TimeDelta::FromSeconds(kNumSecondsForSlowOperation));
   std::move(closure_).Run();
 }
 
-void CacheStorageOperation::NotifyOperationSlow() {
-  was_slow_ = true;
-  RecordCacheStorageSchedulerUMA(CacheStorageSchedulerUMA::kIsOperationSlow,
-                                 client_type_, op_type_, was_slow_);
-}
-
 }  // namespace content
diff --git a/chromium/content/browser/cache_storage/cache_storage_operation.h b/chromium/content/browser/cache_storage/cache_storage_operation.h
index 2f776582759..d667ed96327 100644
--- a/chromium/content/browser/cache_storage/cache_storage_operation.h
+++ b/chromium/content/browser/cache_storage/cache_storage_operation.h
@@ -43,8 +43,6 @@ class CONTENT_EXPORT CacheStorageOperation {
   }
 
  private:
-  void NotifyOperationSlow();
-
   // The operation's closure to run.
   base::OnceClosure closure_;
 
@@ -54,9 +52,6 @@ class CONTENT_EXPORT CacheStorageOperation {
   // Ticks at time the operation's closure is run.
   base::TimeTicks start_ticks_;
 
-  // If the operation took a long time to run.
-  bool was_slow_ = false;
-
   const CacheStorageSchedulerId id_;
   const CacheStorageSchedulerClient client_type_;
   const CacheStorageSchedulerMode mode_;
diff --git a/chromium/content/browser/cache_storage/cache_storage_operation_unittest.cc b/chromium/content/browser/cache_storage/cache_storage_operation_unittest.cc
deleted file mode 100644
index 32c7e25b394..00000000000
--- a/chromium/content/browser/cache_storage/cache_storage_operation_unittest.cc
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "content/browser/cache_storage/cache_storage_operation.h"
-
-#include "base/bind.h"
-#include "base/callback.h"
-#include "base/memory/ref_counted.h"
-#include "base/run_loop.h"
-#include "base/test/metrics/histogram_tester.h"
-#include "base/test/test_mock_time_task_runner.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace content {
-
-namespace {
-
-const char kSlowOperation[] =
-    "ServiceWorkerCache.CacheStorage.Scheduler.IsOperationSlow";
-
-class TestTask {
- public:
-  TestTask() = default;
-  ~TestTask() = default;
-  void Run() { callback_count_++; }
-
-  int callback_count() const { return callback_count_; }
-
- protected:
-  int callback_count_ = 0;
-};
-
-}  // namespace
-
-class CacheStorageOperationTest : public testing::Test {
- protected:
-  CacheStorageOperationTest()
-      : mock_task_runner_(new base::TestMockTimeTaskRunner()) {
-    operation_ = std::make_unique<CacheStorageOperation>(
-        base::BindOnce(&TestTask::Run, base::Unretained(&task_)),
-        /* id = */ 0, CacheStorageSchedulerClient::kStorage,
-        CacheStorageSchedulerMode::kExclusive, CacheStorageSchedulerOp::kTest,
-        CacheStorageSchedulerPriority::kNormal, mock_task_runner_);
-  }
-
-  base::HistogramTester histogram_tester_;
-  TestTask task_;
-  scoped_refptr<base::TestMockTimeTaskRunner> mock_task_runner_;
-  std::unique_ptr<CacheStorageOperation> operation_;
-};
-
-TEST_F(CacheStorageOperationTest, OperationFast) {
-  operation_->Run();
-  mock_task_runner_->RunUntilIdle();
-  EXPECT_EQ(1, task_.callback_count());
-  histogram_tester_.ExpectTotalCount(kSlowOperation, 0);
-
-  // Finish the operation.
-  operation_.reset();
-
-  mock_task_runner_->RunUntilIdle();
-  EXPECT_EQ(1, task_.callback_count());
-  histogram_tester_.ExpectTotalCount(kSlowOperation, 1);
-  histogram_tester_.ExpectBucketCount(kSlowOperation, false, 1);
-}
-
-TEST_F(CacheStorageOperationTest, OperationSlow) {
-  operation_->Run();
-  mock_task_runner_->RunUntilIdle();
-  EXPECT_EQ(1, task_.callback_count());
-  histogram_tester_.ExpectTotalCount(kSlowOperation, 0);
-
-  // The operation takes 10 seconds.
-  mock_task_runner_->FastForwardBy(base::TimeDelta::FromSeconds(10));
-  mock_task_runner_->RunUntilIdle();
-  histogram_tester_.ExpectTotalCount(kSlowOperation, 1);
-  histogram_tester_.ExpectBucketCount(kSlowOperation, true, 1);
-
-  // Finish the operation.
-  operation_.reset();
-  mock_task_runner_->RunUntilIdle();
-  EXPECT_EQ(1, task_.callback_count());
-  histogram_tester_.ExpectTotalCount(kSlowOperation, 1);
-  histogram_tester_.ExpectBucketCount(kSlowOperation, true, 1);
-}
-
-}  // namespace content
diff --git a/chromium/content/browser/cache_storage/cache_storage_quota_client.cc b/chromium/content/browser/cache_storage/cache_storage_quota_client.cc
index 2f87d3c0000..18e73a717bc 100644
--- a/chromium/content/browser/cache_storage/cache_storage_quota_client.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_quota_client.cc
@@ -19,19 +19,15 @@ CacheStorageQuotaClient::CacheStorageQuotaClient(
 
 CacheStorageQuotaClient::~CacheStorageQuotaClient() = default;
 
-storage::QuotaClientType CacheStorageQuotaClient::type() const {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  return GetClientTypeFromOwner(owner_);
-}
-
 void CacheStorageQuotaClient::OnQuotaManagerDestroyed() {}
 
 void CacheStorageQuotaClient::GetOriginUsage(const url::Origin& origin,
                                              blink::mojom::StorageType type,
                                              GetUsageCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
 
-  if (!DoesSupport(type) || !CacheStorageManager::IsValidQuotaOrigin(origin)) {
+  if (!CacheStorageManager::IsValidQuotaOrigin(origin)) {
     std::move(callback).Run(0);
     return;
   }
@@ -42,11 +38,7 @@ void CacheStorageQuotaClient::GetOriginUsage(const url::Origin& origin,
 void CacheStorageQuotaClient::GetOriginsForType(blink::mojom::StorageType type,
                                                 GetOriginsCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (!DoesSupport(type)) {
-    std::move(callback).Run(std::set<url::Origin>());
-    return;
-  }
+  DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
 
   cache_manager_->GetOrigins(owner_, std::move(callback));
 }
@@ -55,11 +47,7 @@ void CacheStorageQuotaClient::GetOriginsForHost(blink::mojom::StorageType type,
                                                 const std::string& host,
                                                 GetOriginsCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (!DoesSupport(type)) {
-    std::move(callback).Run(std::set<url::Origin>());
-    return;
-  }
+  DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
 
   cache_manager_->GetOriginsForHost(host, owner_, std::move(callback));
 }
@@ -68,8 +56,9 @@ void CacheStorageQuotaClient::DeleteOriginData(const url::Origin& origin,
                                                blink::mojom::StorageType type,
                                                DeletionCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK_EQ(type, blink::mojom::StorageType::kTemporary);
 
-  if (!DoesSupport(type) || !CacheStorageManager::IsValidQuotaOrigin(origin)) {
+  if (!CacheStorageManager::IsValidQuotaOrigin(origin)) {
     std::move(callback).Run(blink::mojom::QuotaStatusCode::kOk);
     return;
   }
@@ -83,13 +72,6 @@ void CacheStorageQuotaClient::PerformStorageCleanup(
   std::move(callback).Run();
 }
 
-bool CacheStorageQuotaClient::DoesSupport(
-    blink::mojom::StorageType type) const {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  return type == blink::mojom::StorageType::kTemporary;
-}
-
 // static
 storage::QuotaClientType CacheStorageQuotaClient::GetClientTypeFromOwner(
     CacheStorageOwner owner) {
diff --git a/chromium/content/browser/cache_storage/cache_storage_quota_client.h b/chromium/content/browser/cache_storage/cache_storage_quota_client.h
index 7719a617e66..5b27bccfae5 100644
--- a/chromium/content/browser/cache_storage/cache_storage_quota_client.h
+++ b/chromium/content/browser/cache_storage/cache_storage_quota_client.h
@@ -27,7 +27,6 @@ class CONTENT_EXPORT CacheStorageQuotaClient : public storage::QuotaClient {
                           CacheStorageOwner owner);
 
   // QuotaClient.
-  storage::QuotaClientType type() const override;
   void OnQuotaManagerDestroyed() override;
   void GetOriginUsage(const url::Origin& origin,
                       blink::mojom::StorageType type,
@@ -42,7 +41,6 @@ class CONTENT_EXPORT CacheStorageQuotaClient : public storage::QuotaClient {
                         DeletionCallback callback) override;
   void PerformStorageCleanup(blink::mojom::StorageType type,
                              base::OnceClosure callback) override;
-  bool DoesSupport(blink::mojom::StorageType type) const override;
 
   static storage::QuotaClientType GetClientTypeFromOwner(
       CacheStorageOwner owner);
diff --git a/chromium/content/browser/cache_storage/cache_storage_scheduler.cc b/chromium/content/browser/cache_storage/cache_storage_scheduler.cc
index f156950ce61..1cc55a3c06d 100644
--- a/chromium/content/browser/cache_storage/cache_storage_scheduler.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_scheduler.cc
@@ -99,11 +99,6 @@ void CacheStorageScheduler::CompleteOperationAndRunNext(
     DCHECK_EQ(num_running_exclusive_, 0);
     DCHECK_GT(num_running_shared_, 0);
     num_running_shared_ -= 1;
-    if (num_running_shared_ == 0) {
-      UMA_HISTOGRAM_COUNTS_100("ServiceWorkerCache.PeakParallelSharedOps2",
-                               peak_parallel_shared_);
-      peak_parallel_shared_ = 0;
-    }
   } else {
     DCHECK_EQ(num_running_shared_, 0);
     DCHECK_EQ(num_running_exclusive_, 1);
@@ -170,8 +165,6 @@ void CacheStorageScheduler::MaybeRunOperation() {
   if (next_operation->mode() == CacheStorageSchedulerMode::kShared) {
     DCHECK_EQ(num_running_exclusive_, 0);
     num_running_shared_ += 1;
-    peak_parallel_shared_ =
-        std::max(num_running_shared_, peak_parallel_shared_);
   } else {
     DCHECK_EQ(num_running_exclusive_, 0);
     DCHECK_EQ(num_running_shared_, 0);
diff --git a/chromium/content/browser/cache_storage/cache_storage_scheduler.h b/chromium/content/browser/cache_storage/cache_storage_scheduler.h
index a9d2580b5fa..851e15fffb1 100644
--- a/chromium/content/browser/cache_storage/cache_storage_scheduler.h
+++ b/chromium/content/browser/cache_storage/cache_storage_scheduler.h
@@ -111,11 +111,6 @@ class CONTENT_EXPORT CacheStorageScheduler {
   int num_running_shared_ = 0;
   int num_running_exclusive_ = 0;
 
-  // The peak number of parallel shared operations that ran at once.  Measured
-  // between the last time the sheduler started running shared operations and
-  // when the number of running shared operations drops to zero.
-  int peak_parallel_shared_ = 0;
-
   SEQUENCE_CHECKER(sequence_checker_);
   base::WeakPtrFactory<CacheStorageScheduler> weak_ptr_factory_{this};
 
diff --git a/chromium/content/browser/cache_storage/legacy/legacy_cache_storage.cc b/chromium/content/browser/cache_storage/legacy/legacy_cache_storage.cc
index 34097e5bc34..5b63f7eeb75 100644
--- a/chromium/content/browser/cache_storage/legacy/legacy_cache_storage.cc
+++ b/chromium/content/browser/cache_storage/legacy/legacy_cache_storage.cc
@@ -81,7 +81,6 @@ struct LegacyCacheStorage::CacheMatchResponse {
 
   CacheStorageError error;
   blink::mojom::FetchAPIResponsePtr response;
-  std::unique_ptr<storage::BlobDataHandle> blob_data_handle;
 };
 
 // Handles the loading and clean up of CacheStorageCache objects.
diff --git a/chromium/content/browser/cache_storage/legacy/legacy_cache_storage.h b/chromium/content/browser/cache_storage/legacy/legacy_cache_storage.h
index 47b191efc47..abcf8382e78 100644
--- a/chromium/content/browser/cache_storage/legacy/legacy_cache_storage.h
+++ b/chromium/content/browser/cache_storage/legacy/legacy_cache_storage.h
@@ -16,13 +16,13 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
+#include "components/services/storage/public/mojom/blob_storage_context.mojom.h"
 #include "content/browser/cache_storage/cache_storage.h"
 #include "content/browser/cache_storage/cache_storage_cache_observer.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
 #include "content/browser/cache_storage/cache_storage_scheduler_types.h"
 #include "content/browser/cache_storage/legacy/legacy_cache_storage_cache.h"
 #include "mojo/public/cpp/bindings/remote.h"
-#include "storage/browser/blob/mojom/blob_storage_context.mojom.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/application_status_listener.h"
diff --git a/chromium/content/browser/cache_storage/legacy/legacy_cache_storage_cache.cc b/chromium/content/browser/cache_storage/legacy/legacy_cache_storage_cache.cc
index 55296adaa7c..ff5eb680b78 100644
--- a/chromium/content/browser/cache_storage/legacy/legacy_cache_storage_cache.cc
+++ b/chromium/content/browser/cache_storage/legacy/legacy_cache_storage_cache.cc
@@ -41,10 +41,6 @@
 #include "content/browser/cache_storage/cache_storage_trace_utils.h"
 #include "content/browser/cache_storage/legacy/legacy_cache_storage.h"
 #include "content/common/background_fetch/background_fetch_types.h"
-#include "content/common/service_worker/service_worker_utils.h"
-#include "content/public/common/content_features.h"
-#include "content/public/common/referrer.h"
-#include "content/public/common/referrer_type_converters.h"
 #include "crypto/hmac.h"
 #include "crypto/symmetric_key.h"
 #include "mojo/public/cpp/bindings/remote.h"
@@ -53,14 +49,13 @@
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "services/network/public/mojom/fetch_api.mojom.h"
-#include "storage/browser/blob/blob_data_handle.h"
-#include "storage/browser/blob/blob_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/padding_key.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "third_party/blink/public/common/cache_storage/cache_storage_utils.h"
 #include "third_party/blink/public/common/fetch/fetch_api_request_headers_map.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
+#include "third_party/blink/public/mojom/referrer.mojom.h"
 
 using blink::mojom::CacheStorageError;
 using blink::mojom::CacheStorageVerboseError;
@@ -130,6 +125,83 @@ proto::CacheResponse::ResponseType FetchResponseTypeToProtoResponseType(
   return proto::CacheResponse::OPAQUE_TYPE;
 }
 
+// Assert that ConnectionInfo does not change since we cast it to
+// an integer in order to serialize it to disk.
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_UNKNOWN == 0,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_HTTP1_1 == 1,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_DEPRECATED_SPDY2 == 2,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_DEPRECATED_SPDY3 == 3,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_HTTP2 == 4,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_UNKNOWN_VERSION == 5,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_DEPRECATED_HTTP2_14 == 6,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_DEPRECATED_HTTP2_15 == 7,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_HTTP0_9 == 8,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_HTTP1_0 == 9,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_32 == 10,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_33 == 11,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_34 == 12,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_35 == 13,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_36 == 14,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_37 == 15,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_38 == 16,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_39 == 17,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_40 == 18,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_41 == 19,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_42 == 20,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_43 == 21,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_Q099 == 22,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_44 == 23,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_45 == 24,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_46 == 25,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_47 == 26,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_999 == 27,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_Q048 == 28,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_Q049 == 29,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_Q050 == 30,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_T048 == 31,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_T049 == 32,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_T050 == 33,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_T099 == 34,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_DRAFT_25 == 35,
+              "ConnectionInfo enum is stable");
+static_assert(net::HttpResponseInfo::CONNECTION_INFO_QUIC_DRAFT_27 == 36,
+              "ConnectionInfo enum is stable");
+
 // Copy headers out of a cache entry and into a protobuf. The callback is
 // guaranteed to be run.
 void ReadMetadata(disk_cache::Entry* entry, MetadataCallback callback);
@@ -339,11 +411,20 @@ blink::mojom::FetchAPIResponsePtr CreateResponse(
     headers.insert(std::make_pair(header.name(), header.value()));
   }
 
+  std::string alpn_negotiated_protocol =
+      metadata.response().has_alpn_negotiated_protocol()
+          ? metadata.response().alpn_negotiated_protocol()
+          : "unknown";
+
+  base::Optional<std::string> mime_type;
+  if (metadata.response().has_mime_type())
+    mime_type = metadata.response().mime_type();
+
   return blink::mojom::FetchAPIResponse::New(
       url_list, metadata.response().status_code(),
       metadata.response().status_text(),
       ProtoResponseTypeToFetchResponseType(metadata.response().response_type()),
-      network::mojom::FetchResponseSource::kCacheStorage, headers,
+      network::mojom::FetchResponseSource::kCacheStorage, headers, mime_type,
       nullptr /* blob */, blink::mojom::ServiceWorkerResponseError::kUnknown,
       base::Time::FromInternalValue(metadata.response().response_time()),
       cache_name,
@@ -352,7 +433,11 @@ blink::mojom::FetchAPIResponsePtr CreateResponse(
           metadata.response().cors_exposed_header_names().end()),
       nullptr /* side_data_blob */, nullptr /* side_data_blob_for_cache_put */,
       network::mojom::ParsedHeaders::New(),
-      metadata.response().loaded_with_credentials());
+      // Default proto value of 0 maps to CONNECTION_INFO_UNKNOWN.
+      static_cast<net::HttpResponseInfo::ConnectionInfo>(
+          metadata.response().connection_info()),
+      alpn_negotiated_protocol, metadata.response().loaded_with_credentials(),
+      metadata.response().was_fetched_via_spdy());
 }
 
 // The size of opaque (non-cors) resource responses are padded in order
@@ -1674,8 +1759,6 @@ void LegacyCacheStorageCache::PutDidCreateEntry(
   // via WritingCompleted.
   put_context->cache_entry.reset(result.ReleaseEntry());
 
-  base::UmaHistogramSparse("ServiceWorkerCache.DiskCacheCreateEntryResult",
-                           std::abs(rv));
   if (rv != net::OK) {
     quota_manager_proxy_->NotifyWriteFailed(origin_);
     PutComplete(std::move(put_context), CacheStorageError::kErrorExists);
@@ -1703,6 +1786,14 @@ void LegacyCacheStorageCache::PutDidCreateEntry(
     response_metadata->add_url_list(url.spec());
   response_metadata->set_loaded_with_credentials(
       put_context->response->loaded_with_credentials);
+  response_metadata->set_connection_info(
+      put_context->response->connection_info);
+  response_metadata->set_alpn_negotiated_protocol(
+      put_context->response->alpn_negotiated_protocol);
+  response_metadata->set_was_fetched_via_spdy(
+      put_context->response->was_fetched_via_spdy);
+  if (put_context->response->mime_type.has_value())
+    response_metadata->set_mime_type(put_context->response->mime_type.value());
   response_metadata->set_response_time(
       put_context->response->response_time.ToInternalValue());
   for (ResponseHeaderMap::const_iterator it =
diff --git a/chromium/content/browser/cache_storage/legacy/legacy_cache_storage_manager.cc b/chromium/content/browser/cache_storage/legacy/legacy_cache_storage_manager.cc
index 745cfd72471..64e3e480d10 100644
--- a/chromium/content/browser/cache_storage/legacy/legacy_cache_storage_manager.cc
+++ b/chromium/content/browser/cache_storage/legacy/legacy_cache_storage_manager.cc
@@ -31,7 +31,6 @@
 #include "content/browser/cache_storage/cache_storage.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_quota_client.h"
-#include "content/browser/service_worker/service_worker_context_core.h"
 #include "net/base/url_util.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/common/database/database_identifier.h"
@@ -278,6 +277,7 @@ CacheStorageHandle LegacyCacheStorageManager::OpenCacheStorage(
   // thread.
   if (!memory_pressure_listener_) {
     memory_pressure_listener_ = std::make_unique<base::MemoryPressureListener>(
+        FROM_HERE,
         base::BindRepeating(&LegacyCacheStorageManager::OnMemoryPressure,
                             base::Unretained(this)));
   }