BASELINE: Update Chromium to 72.0.3626.110 and Ninja to 1.9.0

Change-Id: Ic57220b00ecc929a893c91f5cc552f5d3e99e922
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

26 files changed, 1053 insertions, 585 deletions

diff --git a/chromium/content/browser/cache_storage/cache_storage.cc b/chromium/content/browser/cache_storage/cache_storage.cc
index 5371daf3c55..334699f5f38 100644
--- a/chromium/content/browser/cache_storage/cache_storage.cc
+++ b/chromium/content/browser/cache_storage/cache_storage.cc
@@ -39,7 +39,6 @@
 #include "crypto/symmetric_key.h"
 #include "net/base/directory_lister.h"
 #include "net/base/net_errors.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
@@ -120,14 +119,12 @@ class CacheStorage::CacheLoader {
 
   CacheLoader(
       base::SequencedTaskRunner* cache_task_runner,
-      scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       storage::QuotaManagerProxy* quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       CacheStorage* cache_storage,
       const url::Origin& origin,
       CacheStorageOwner owner)
       : cache_task_runner_(cache_task_runner),
-        request_context_getter_(request_context_getter),
         quota_manager_proxy_(quota_manager_proxy),
         blob_context_(blob_context),
         cache_storage_(cache_storage),
@@ -172,7 +169,6 @@ class CacheStorage::CacheLoader {
 
  protected:
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner_;
-  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
   // Owned by CacheStorage which owns this.
   storage::QuotaManagerProxy* quota_manager_proxy_;
@@ -193,14 +189,12 @@ class CacheStorage::CacheLoader {
 class CacheStorage::MemoryLoader : public CacheStorage::CacheLoader {
  public:
   MemoryLoader(base::SequencedTaskRunner* cache_task_runner,
-               scoped_refptr<net::URLRequestContextGetter> request_context,
                storage::QuotaManagerProxy* quota_manager_proxy,
                base::WeakPtr<storage::BlobStorageContext> blob_context,
                CacheStorage* cache_storage,
                const url::Origin& origin,
                CacheStorageOwner owner)
       : CacheLoader(cache_task_runner,
-                    request_context,
                     quota_manager_proxy,
                     blob_context,
                     cache_storage,
@@ -213,9 +207,8 @@ class CacheStorage::MemoryLoader : public CacheStorage::CacheLoader {
       int64_t cache_padding,
       std::unique_ptr<SymmetricKey> cache_padding_key) override {
     return CacheStorageCache::CreateMemoryCache(
-        origin_, owner_, cache_name, cache_storage_, request_context_getter_,
-        quota_manager_proxy_, blob_context_,
-        s_padding_key.Get().CreateDuplicate());
+        origin_, owner_, cache_name, cache_storage_, quota_manager_proxy_,
+        blob_context_, s_padding_key.Get().CreateDuplicate());
   }
 
   void PrepareNewCacheDestination(const std::string& cache_name,
@@ -263,14 +256,12 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
  public:
   SimpleCacheLoader(const base::FilePath& origin_path,
                     base::SequencedTaskRunner* cache_task_runner,
-                    scoped_refptr<net::URLRequestContextGetter> request_context,
                     storage::QuotaManagerProxy* quota_manager_proxy,
                     base::WeakPtr<storage::BlobStorageContext> blob_context,
                     CacheStorage* cache_storage,
                     const url::Origin& origin,
                     CacheStorageOwner owner)
       : CacheLoader(cache_task_runner,
-                    request_context,
                     quota_manager_proxy,
                     blob_context,
                     cache_storage,
@@ -291,8 +282,8 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
     base::FilePath cache_path = origin_path_.AppendASCII(cache_dir);
     return CacheStorageCache::CreatePersistentCache(
         origin_, owner_, cache_name, cache_storage_, cache_path,
-        request_context_getter_, quota_manager_proxy_, blob_context_,
-        cache_size, cache_padding, std::move(cache_padding_key));
+        quota_manager_proxy_, blob_context_, cache_size, cache_padding,
+        std::move(cache_padding_key));
   }
 
   void PrepareNewCacheDestination(const std::string& cache_name,
@@ -582,7 +573,6 @@ CacheStorage::CacheStorage(
     const base::FilePath& path,
     bool memory_only,
     base::SequencedTaskRunner* cache_task_runner,
-    scoped_refptr<net::URLRequestContextGetter> request_context,
     scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context,
     CacheStorageManager* cache_storage_manager,
@@ -591,8 +581,8 @@ CacheStorage::CacheStorage(
     : initialized_(false),
       initializing_(false),
       memory_only_(memory_only),
-      scheduler_(new CacheStorageScheduler(
-          CacheStorageSchedulerClient::CLIENT_STORAGE)),
+      scheduler_(
+          new CacheStorageScheduler(CacheStorageSchedulerClient::kStorage)),
       origin_path_(path),
       cache_task_runner_(cache_task_runner),
       quota_manager_proxy_(quota_manager_proxy),
@@ -601,13 +591,13 @@ CacheStorage::CacheStorage(
       cache_storage_manager_(cache_storage_manager),
       weak_factory_(this) {
   if (memory_only)
-    cache_loader_.reset(new MemoryLoader(
-        cache_task_runner_.get(), std::move(request_context),
-        quota_manager_proxy.get(), blob_context, this, origin, owner));
+    cache_loader_.reset(new MemoryLoader(cache_task_runner_.get(),
+                                         quota_manager_proxy.get(),
+                                         blob_context, this, origin, owner));
   else
     cache_loader_.reset(new SimpleCacheLoader(
-        origin_path_, cache_task_runner_.get(), std::move(request_context),
-        quota_manager_proxy.get(), blob_context, this, origin, owner));
+        origin_path_, cache_task_runner_.get(), quota_manager_proxy.get(),
+        blob_context, this, origin, owner));
 }
 
 CacheStorage::~CacheStorage() {
@@ -624,9 +614,11 @@ void CacheStorage::OpenCache(const std::string& cache_name,
       CacheStorageQuotaClient::GetIDFromOwner(owner_), origin_,
       StorageType::kTemporary);
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorage::OpenCacheImpl, weak_factory_.GetWeakPtr(), cache_name,
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kOpen,
+      base::BindOnce(&CacheStorage::OpenCacheImpl, weak_factory_.GetWeakPtr(),
+                     cache_name,
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorage::HasCache(const std::string& cache_name,
@@ -640,9 +632,11 @@ void CacheStorage::HasCache(const std::string& cache_name,
       CacheStorageQuotaClient::GetIDFromOwner(owner_), origin_,
       StorageType::kTemporary);
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorage::HasCacheImpl, weak_factory_.GetWeakPtr(), cache_name,
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kHas,
+      base::BindOnce(&CacheStorage::HasCacheImpl, weak_factory_.GetWeakPtr(),
+                     cache_name,
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorage::DoomCache(const std::string& cache_name,
@@ -656,9 +650,11 @@ void CacheStorage::DoomCache(const std::string& cache_name,
       CacheStorageQuotaClient::GetIDFromOwner(owner_), origin_,
       StorageType::kTemporary);
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorage::DoomCacheImpl, weak_factory_.GetWeakPtr(), cache_name,
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kDelete,
+      base::BindOnce(&CacheStorage::DoomCacheImpl, weak_factory_.GetWeakPtr(),
+                     cache_name,
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorage::EnumerateCaches(IndexCallback callback) {
@@ -671,9 +667,11 @@ void CacheStorage::EnumerateCaches(IndexCallback callback) {
       CacheStorageQuotaClient::GetIDFromOwner(owner_), origin_,
       StorageType::kTemporary);
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorage::EnumerateCachesImpl, weak_factory_.GetWeakPtr(),
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kKeys,
+      base::BindOnce(&CacheStorage::EnumerateCachesImpl,
+                     weak_factory_.GetWeakPtr(),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorage::MatchCache(
@@ -691,6 +689,7 @@ void CacheStorage::MatchCache(
       StorageType::kTemporary);
 
   scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kMatch,
       base::BindOnce(&CacheStorage::MatchCacheImpl, weak_factory_.GetWeakPtr(),
                      cache_name, std::move(request), std::move(match_params),
                      scheduler_->WrapCallbackToRunNext(std::move(callback))));
@@ -709,10 +708,12 @@ void CacheStorage::MatchAllCaches(
       CacheStorageQuotaClient::GetIDFromOwner(owner_), origin_,
       StorageType::kTemporary);
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorage::MatchAllCachesImpl, weak_factory_.GetWeakPtr(),
-      std::move(request), std::move(match_params),
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kMatchAll,
+      base::BindOnce(&CacheStorage::MatchAllCachesImpl,
+                     weak_factory_.GetWeakPtr(), std::move(request),
+                     std::move(match_params),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorage::WriteToCache(
@@ -729,10 +730,12 @@ void CacheStorage::WriteToCache(
       CacheStorageQuotaClient::GetIDFromOwner(owner_), origin_,
       StorageType::kTemporary);
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorage::WriteToCacheImpl, weak_factory_.GetWeakPtr(), cache_name,
-      std::move(request), std::move(response),
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kPut,
+      base::BindOnce(&CacheStorage::WriteToCacheImpl,
+                     weak_factory_.GetWeakPtr(), cache_name, std::move(request),
+                     std::move(response),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorage::GetSizeThenCloseAllCaches(SizeCallback callback) {
@@ -741,9 +744,11 @@ void CacheStorage::GetSizeThenCloseAllCaches(SizeCallback callback) {
   if (!initialized_)
     LazyInit();
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorage::GetSizeThenCloseAllCachesImpl, weak_factory_.GetWeakPtr(),
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kSizeThenClose,
+      base::BindOnce(&CacheStorage::GetSizeThenCloseAllCachesImpl,
+                     weak_factory_.GetWeakPtr(),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorage::Size(CacheStorage::SizeCallback callback) {
@@ -753,6 +758,7 @@ void CacheStorage::Size(CacheStorage::SizeCallback callback) {
     LazyInit();
 
   scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kSize,
       base::BindOnce(&CacheStorage::SizeImpl, weak_factory_.GetWeakPtr(),
                      scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
@@ -780,6 +786,7 @@ void CacheStorage::ScheduleWriteIndex() {
 void CacheStorage::WriteIndex(base::OnceCallback<void(bool)> callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kWriteIndex,
       base::BindOnce(&CacheStorage::WriteIndexImpl, weak_factory_.GetWeakPtr(),
                      scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
@@ -812,7 +819,8 @@ void CacheStorage::CacheSizeUpdated(const CacheStorageCache* cache) {
 }
 
 void CacheStorage::StartAsyncOperationForTesting() {
-  scheduler_->ScheduleOperation(base::DoNothing());
+  scheduler_->ScheduleOperation(CacheStorageSchedulerOp::kTest,
+                                base::DoNothing());
 }
 
 void CacheStorage::CompleteAsyncOperationForTesting() {
@@ -836,6 +844,7 @@ void CacheStorage::LazyInit() {
 
   initializing_ = true;
   scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kInit,
       base::BindOnce(&CacheStorage::LazyInitImpl, weak_factory_.GetWeakPtr()));
 }
 
@@ -909,12 +918,12 @@ void CacheStorage::CreateCacheDidCreateCache(
       cache_name, cache_ptr->cache_size(), cache_ptr->cache_padding(),
       cache_ptr->cache_padding_key()->key()));
 
-  CacheStorageCacheHandle handle = CreateCacheHandle(cache_ptr);
+  CacheStorageCacheHandle handle = cache_ptr->CreateHandle();
   cache_loader_->WriteIndex(
       *cache_index_,
       base::BindOnce(&CacheStorage::CreateCacheDidWriteIndex,
                      weak_factory_.GetWeakPtr(), std::move(callback),
-                     CreateCacheHandle(cache_ptr)));
+                     cache_ptr->CreateHandle()));
 
   cache_loader_->NotifyCacheCreated(cache_name, std::move(handle));
   if (cache_storage_manager_)
@@ -1115,47 +1124,6 @@ void CacheStorage::WriteToCacheImpl(
   cache_ptr->Put(std::move(request), std::move(response), std::move(callback));
 }
 
-void CacheStorage::AddCacheHandleRef(CacheStorageCache* cache) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  auto iter = cache_handle_counts_.find(cache);
-  if (iter == cache_handle_counts_.end()) {
-    cache_handle_counts_[cache] = 1;
-    return;
-  }
-
-  iter->second += 1;
-}
-
-void CacheStorage::DropCacheHandleRef(CacheStorageCache* cache) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  auto iter = cache_handle_counts_.find(cache);
-  DCHECK(iter != cache_handle_counts_.end());
-  DCHECK_GE(iter->second, 1U);
-
-  iter->second -= 1;
-  if (iter->second == 0) {
-    cache_handle_counts_.erase(iter);
-    auto doomed_caches_iter = doomed_caches_.find(cache);
-    if (doomed_caches_iter != doomed_caches_.end()) {
-      // The last reference to a doomed cache is gone, perform clean up.
-      DeleteCacheFinalize(cache);
-      return;
-    }
-
-    auto cache_map_iter = cache_map_.find(cache->cache_name());
-    DCHECK(cache_map_iter != cache_map_.end());
-
-    cache_map_iter->second.reset();
-  }
-}
-
-CacheStorageCacheHandle CacheStorage::CreateCacheHandle(
-    CacheStorageCache* cache) {
-  DCHECK(cache);
-  return CacheStorageCacheHandle(cache->AsWeakPtr(),
-                                 weak_factory_.GetWeakPtr());
-}
-
 CacheStorageCacheHandle CacheStorage::GetLoadedCache(
     const std::string& cache_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ -1177,10 +1145,10 @@ CacheStorageCacheHandle CacheStorage::GetLoadedCache(
     CacheStorageCache* cache_ptr = new_cache.get();
     map_iter->second = std::move(new_cache);
 
-    return CreateCacheHandle(cache_ptr);
+    return cache_ptr->CreateHandle();
   }
 
-  return CreateCacheHandle(cache);
+  return cache->CreateHandle();
 }
 
 void CacheStorage::SizeRetrievedFromCache(CacheStorageCacheHandle cache_handle,
@@ -1217,8 +1185,7 @@ void CacheStorage::GetSizeThenCloseAllCachesImpl(SizeCallback callback) {
     CacheStorageCache* cache = cache_it.first;
     cache->GetSizeThenClose(base::BindOnce(
         &CacheStorage::SizeRetrievedFromCache, weak_factory_.GetWeakPtr(),
-        CacheStorageCacheHandle(cache->AsWeakPtr(), weak_factory_.GetWeakPtr()),
-        barrier_closure, accumulator_ptr));
+        cache->CreateHandle(), barrier_closure, accumulator_ptr));
   }
 }
 
@@ -1255,4 +1222,20 @@ void CacheStorage::SizeImpl(SizeCallback callback) {
   }
 }
 
+void CacheStorage::CacheUnreferenced(CacheStorageCache* cache) {
+  DCHECK(cache);
+  cache->AssertUnreferenced();
+  auto doomed_caches_it = doomed_caches_.find(cache);
+  if (doomed_caches_it != doomed_caches_.end()) {
+    // The last reference to a doomed cache is gone, perform clean up.
+    DeleteCacheFinalize(cache);
+    return;
+  }
+
+  auto cache_map_it = cache_map_.find(cache->cache_name());
+  DCHECK(cache_map_it != cache_map_.end());
+
+  cache_map_it->second.reset();
+}
+
 }  // namespace content
diff --git a/chromium/content/browser/cache_storage/cache_storage.h b/chromium/content/browser/cache_storage/cache_storage.h
index a594d0923ea..863e5cf5970 100644
--- a/chromium/content/browser/cache_storage/cache_storage.h
+++ b/chromium/content/browser/cache_storage/cache_storage.h
@@ -27,16 +27,11 @@ namespace base {
 class SequencedTaskRunner;
 }
 
-namespace net {
-class URLRequestContextGetter;
-}
-
 namespace storage {
 class BlobStorageContext;
 }
 
 namespace content {
-class CacheStorageCacheHandle;
 class CacheStorageIndex;
 class CacheStorageManager;
 class CacheStorageScheduler;
@@ -73,7 +68,6 @@ class CONTENT_EXPORT CacheStorage : public CacheStorageCacheObserver {
       const base::FilePath& origin_path,
       bool memory_only,
       base::SequencedTaskRunner* cache_task_runner,
-      scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       CacheStorageManager* cache_storage_manager,
@@ -146,7 +140,6 @@ class CONTENT_EXPORT CacheStorage : public CacheStorageCacheObserver {
   void CacheSizeUpdated(const CacheStorageCache* cache) override;
 
  private:
-  friend class CacheStorageCacheHandle;
   friend class CacheStorageCache;
   friend class cache_storage_manager_unittest::CacheStorageManagerTest;
   FRIEND_TEST_ALL_PREFIXES(
@@ -165,11 +158,6 @@ class CONTENT_EXPORT CacheStorage : public CacheStorageCacheObserver {
   // Generate a new padding key. For testing only and *not thread safe*.
   static void GenerateNewKeyForTesting();
 
-  // Functions for exposing handles to CacheStorageCache to clients.
-  CacheStorageCacheHandle CreateCacheHandle(CacheStorageCache* cache);
-  void AddCacheHandleRef(CacheStorageCache* cache);
-  void DropCacheHandleRef(CacheStorageCache* cache);
-
   // Returns a CacheStorageCacheHandle for the given name if the name is known.
   // If the CacheStorageCache has been deleted, creates a new one.
   CacheStorageCacheHandle GetLoadedCache(const std::string& cache_name);
@@ -254,6 +242,8 @@ class CONTENT_EXPORT CacheStorage : public CacheStorageCacheObserver {
   bool InitiateScheduledIndexWriteForTest(
       base::OnceCallback<void(bool)> callback);
 
+  void CacheUnreferenced(CacheStorageCache* cache);
+
   // Whether or not we've loaded the list of cache names into memory.
   bool initialized_;
   bool initializing_;
@@ -272,9 +262,6 @@ class CONTENT_EXPORT CacheStorage : public CacheStorageCacheObserver {
   std::map<CacheStorageCache*, std::unique_ptr<CacheStorageCache>>
       doomed_caches_;
 
-  // CacheStorageCacheHandle reference counts
-  std::map<CacheStorageCache*, size_t> cache_handle_counts_;
-
   // The cache index data.
   std::unique_ptr<CacheStorageIndex> cache_index_;
 
diff --git a/chromium/content/browser/cache_storage/cache_storage_cache.cc b/chromium/content/browser/cache_storage/cache_storage_cache.cc
index 72f27bb164f..e0f24f491d1 100644
--- a/chromium/content/browser/cache_storage/cache_storage_cache.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_cache.cc
@@ -27,32 +27,32 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_blob_to_disk_cache.h"
+#include "content/browser/cache_storage/cache_storage_cache_entry_handler.h"
 #include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/browser/cache_storage/cache_storage_cache_observer.h"
 #include "content/browser/cache_storage/cache_storage_histogram_utils.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
 #include "content/browser/cache_storage/cache_storage_quota_client.h"
 #include "content/browser/cache_storage/cache_storage_scheduler.h"
+#include "content/common/service_worker/service_worker_type_converter.h"
+#include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_thread.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 "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
-#include "net/url_request/url_request_context_getter.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_impl.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/common/blob_storage/blob_handle.h"
 #include "storage/common/storage_histograms.h"
-#include "third_party/blink/public/common/blob/blob_utils.h"
 #include "third_party/blink/public/common/cache_storage/cache_storage_utils.h"
 #include "third_party/blink/public/mojom/quota/quota_types.mojom.h"
 
@@ -92,7 +92,7 @@ network::mojom::FetchResponseType ProtoResponseTypeToFetchResponseType(
     case proto::CacheResponse::BASIC_TYPE:
       return network::mojom::FetchResponseType::kBasic;
     case proto::CacheResponse::CORS_TYPE:
-      return network::mojom::FetchResponseType::kCORS;
+      return network::mojom::FetchResponseType::kCors;
     case proto::CacheResponse::DEFAULT_TYPE:
       return network::mojom::FetchResponseType::kDefault;
     case proto::CacheResponse::ERROR_TYPE:
@@ -111,7 +111,7 @@ proto::CacheResponse::ResponseType FetchResponseTypeToProtoResponseType(
   switch (response_type) {
     case network::mojom::FetchResponseType::kBasic:
       return proto::CacheResponse::BASIC_TYPE;
-    case network::mojom::FetchResponseType::kCORS:
+    case network::mojom::FetchResponseType::kCors:
       return proto::CacheResponse::CORS_TYPE;
     case network::mojom::FetchResponseType::kDefault:
       return proto::CacheResponse::DEFAULT_TYPE;
@@ -146,8 +146,8 @@ bool VaryMatches(const ServiceWorkerHeaderMap& request,
     return true;
 
   for (const std::string& trimmed :
-       base::SplitString(vary_iter->second, ",",
-                         base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
+       base::SplitString(vary_iter->second, ",", base::TRIM_WHITESPACE,
+                         base::SPLIT_WANT_NONEMPTY)) {
     if (trimmed == "*")
       return false;
 
@@ -197,7 +197,7 @@ bool FindDuplicateOperations(
   }
   std::sort(sorted->begin(), sorted->end(),
             [](BatchOperation* left, BatchOperation* right) {
-              return left->request.url < right->request.url;
+              return left->request->url < right->request->url;
             });
 
   // Check each entry in the sorted vector for any duplicates.  Since the
@@ -219,7 +219,7 @@ bool FindDuplicateOperations(
     // If this entry already matches a duplicate we found, then just skip
     // ahead to find any remaining duplicates.
     if (!duplicate_url_list_out->empty() &&
-        outer_op->request.url.spec() == duplicate_url_list_out->back()) {
+        outer_op->request->url.spec() == duplicate_url_list_out->back()) {
       continue;
     }
 
@@ -227,18 +227,27 @@ bool FindDuplicateOperations(
       const BatchOperation* inner_op = *inner;
       // Since the list is sorted we can stop looking at neighbors after
       // the first different URL.
-      if (outer_op->request.url != inner_op->request.url) {
+      if (outer_op->request->url != inner_op->request->url) {
         break;
       }
+
+      // This conversion is temporary and it will be removed once
+      // ServiceWorkerHeaderMap is removed.
+      ServiceWorkerHeaderMap request_header_map =
+          ServiceWorkerUtils::ToServiceWorkerHeaderMap(
+              outer_op->request->headers);
+      ServiceWorkerHeaderMap request_header_map_cached =
+          ServiceWorkerUtils::ToServiceWorkerHeaderMap(
+              inner_op->request->headers);
       // VaryMatches() is asymmetric since the operation depends on the VARY
       // header in the target response.  Since we only visit each pair of
       // entries once we need to perform the VaryMatches() call in both
       // directions.
-      if (VaryMatches(outer_op->request.headers, inner_op->request.headers,
+      if (VaryMatches(request_header_map, request_header_map_cached,
                       inner_op->response->headers) ||
-          VaryMatches(outer_op->request.headers, inner_op->request.headers,
+          VaryMatches(request_header_map, request_header_map_cached,
                       outer_op->response->headers)) {
-        duplicate_url_list_out->push_back(inner_op->request.url.spec());
+        duplicate_url_list_out->push_back(inner_op->request->url.spec());
         break;
       }
     }
@@ -353,7 +362,7 @@ bool ShouldPadResponseType(network::mojom::FetchResponseType response_type,
                            bool has_urls) {
   switch (response_type) {
     case network::mojom::FetchResponseType::kBasic:
-    case network::mojom::FetchResponseType::kCORS:
+    case network::mojom::FetchResponseType::kCors:
     case network::mojom::FetchResponseType::kDefault:
     case network::mojom::FetchResponseType::kError:
       return false;
@@ -411,67 +420,6 @@ int64_t CalculateResponsePaddingInternal(
 
 }  // namespace
 
-// This class ensures that the cache and the entry have a lifetime as long as
-// the blob that is created to contain them.
-class CacheStorageCache::BlobDataHandle
-    : public storage::BlobDataBuilder::DataHandle {
- public:
-  BlobDataHandle(CacheStorageCacheHandle cache_handle,
-                 disk_cache::ScopedEntryPtr entry)
-      : cache_handle_(std::move(cache_handle)), entry_(std::move(entry)) {}
-
-  bool IsValid() override { return bool{entry_}; }
-
-  void Invalidate() {
-    cache_handle_ = base::nullopt;
-    entry_ = nullptr;
-  }
-
- private:
-  ~BlobDataHandle() override {
-    if (cache_handle_ && cache_handle_->value()) {
-      cache_handle_->value()->blob_data_handles_.erase(this);
-    }
-  }
-
-  base::Optional<CacheStorageCacheHandle> cache_handle_;
-  disk_cache::ScopedEntryPtr entry_;
-
-  DISALLOW_COPY_AND_ASSIGN(BlobDataHandle);
-};
-
-// The state needed to pass between CacheStorageCache::Put callbacks.
-struct CacheStorageCache::PutContext {
-  PutContext(std::unique_ptr<ServiceWorkerFetchRequest> request,
-             blink::mojom::FetchAPIResponsePtr response,
-             blink::mojom::BlobPtr blob,
-             uint64_t blob_size,
-             blink::mojom::BlobPtr side_data_blob,
-             uint64_t side_data_blob_size,
-             CacheStorageCache::ErrorCallback callback)
-      : request(std::move(request)),
-        response(std::move(response)),
-        blob(std::move(blob)),
-        blob_size(blob_size),
-        side_data_blob(std::move(side_data_blob)),
-        side_data_blob_size(side_data_blob_size),
-        callback(std::move(callback)) {}
-
-  // Input parameters to the Put function.
-  std::unique_ptr<ServiceWorkerFetchRequest> request;
-  blink::mojom::FetchAPIResponsePtr response;
-  blink::mojom::BlobPtr blob;
-  uint64_t blob_size;
-  blink::mojom::BlobPtr side_data_blob;
-  uint64_t side_data_blob_size;
-
-  CacheStorageCache::ErrorCallback callback;
-  disk_cache::ScopedEntryPtr cache_entry;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(PutContext);
-};
-
 struct CacheStorageCache::QueryCacheResult {
   explicit QueryCacheResult(base::Time entry_time) : entry_time(entry_time) {}
 
@@ -526,15 +474,13 @@ std::unique_ptr<CacheStorageCache> CacheStorageCache::CreateMemoryCache(
     CacheStorageOwner owner,
     const std::string& cache_name,
     CacheStorage* cache_storage,
-    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context,
     std::unique_ptr<crypto::SymmetricKey> cache_padding_key) {
   CacheStorageCache* cache = new CacheStorageCache(
       origin, owner, cache_name, base::FilePath(), cache_storage,
-      std::move(request_context_getter), std::move(quota_manager_proxy),
-      blob_context, 0 /* cache_size */, 0 /* cache_padding */,
-      std::move(cache_padding_key));
+      std::move(quota_manager_proxy), blob_context, 0 /* cache_size */,
+      0 /* cache_padding */, std::move(cache_padding_key));
   cache->SetObserver(cache_storage);
   cache->InitBackend();
   return base::WrapUnique(cache);
@@ -547,7 +493,6 @@ std::unique_ptr<CacheStorageCache> CacheStorageCache::CreatePersistentCache(
     const std::string& cache_name,
     CacheStorage* cache_storage,
     const base::FilePath& path,
-    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context,
     int64_t cache_size,
@@ -555,8 +500,8 @@ std::unique_ptr<CacheStorageCache> CacheStorageCache::CreatePersistentCache(
     std::unique_ptr<crypto::SymmetricKey> cache_padding_key) {
   CacheStorageCache* cache = new CacheStorageCache(
       origin, owner, cache_name, path, cache_storage,
-      std::move(request_context_getter), std::move(quota_manager_proxy),
-      blob_context, cache_size, cache_padding, std::move(cache_padding_key));
+      std::move(quota_manager_proxy), blob_context, cache_size, cache_padding,
+      std::move(cache_padding_key));
   cache->SetObserver(cache_storage);
   cache->InitBackend();
   return base::WrapUnique(cache);
@@ -566,6 +511,29 @@ base::WeakPtr<CacheStorageCache> CacheStorageCache::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
+CacheStorageCacheHandle CacheStorageCache::CreateHandle() {
+  return CacheStorageCacheHandle(weak_ptr_factory_.GetWeakPtr());
+}
+
+void CacheStorageCache::AddHandleRef() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  handle_ref_count_ += 1;
+}
+
+void CacheStorageCache::DropHandleRef() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  DCHECK(handle_ref_count_ > 0);
+  handle_ref_count_ -= 1;
+  if (handle_ref_count_ == 0 && cache_storage_) {
+    cache_storage_->CacheUnreferenced(this);
+  }
+}
+
+void CacheStorageCache::AssertUnreferenced() const {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(!handle_ref_count_);
+}
+
 void CacheStorageCache::Match(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     blink::mojom::QueryParamsPtr match_params,
@@ -576,10 +544,12 @@ void CacheStorageCache::Match(
     return;
   }
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorageCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
-      std::move(request), std::move(match_params),
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kMatch,
+      base::BindOnce(&CacheStorageCache::MatchImpl,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(request),
+                     std::move(match_params),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorageCache::MatchAll(
@@ -593,10 +563,12 @@ void CacheStorageCache::MatchAll(
     return;
   }
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorageCache::MatchAllImpl, weak_ptr_factory_.GetWeakPtr(),
-      std::move(request), std::move(match_params),
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kMatchAll,
+      base::BindOnce(&CacheStorageCache::MatchAllImpl,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(request),
+                     std::move(match_params),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorageCache::WriteSideData(ErrorCallback callback,
@@ -789,7 +761,7 @@ void CacheStorageCache::BatchDidGetUsageAndQuota(
   // last reference to this instance. Hold a handle for the duration of this
   // loop. (Asynchronous tasks scheduled by the operations use weak ptrs which
   // will no-op automatically.)
-  CacheStorageCacheHandle handle = CreateCacheHandle();
+  CacheStorageCacheHandle handle = CreateHandle();
 
   for (auto& operation : operations) {
     switch (operation->operation_type) {
@@ -849,19 +821,23 @@ void CacheStorageCache::Keys(std::unique_ptr<ServiceWorkerFetchRequest> request,
     return;
   }
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorageCache::KeysImpl, weak_ptr_factory_.GetWeakPtr(),
-      std::move(request), std::move(options),
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kKeys,
+      base::BindOnce(&CacheStorageCache::KeysImpl,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(request),
+                     std::move(options),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorageCache::Close(base::OnceClosure callback) {
   DCHECK_NE(BACKEND_CLOSED, backend_state_)
       << "Was CacheStorageCache::Close() called twice?";
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorageCache::CloseImpl, weak_ptr_factory_.GetWeakPtr(),
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kClose,
+      base::BindOnce(&CacheStorageCache::CloseImpl,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorageCache::Size(SizeCallback callback) {
@@ -872,9 +848,11 @@ void CacheStorageCache::Size(SizeCallback callback) {
     return;
   }
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorageCache::SizeImpl, weak_ptr_factory_.GetWeakPtr(),
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kSize,
+      base::BindOnce(&CacheStorageCache::SizeImpl,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorageCache::GetSizeThenClose(SizeCallback callback) {
@@ -884,11 +862,14 @@ void CacheStorageCache::GetSizeThenClose(SizeCallback callback) {
     return;
   }
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorageCache::SizeImpl, weak_ptr_factory_.GetWeakPtr(),
-      base::BindOnce(&CacheStorageCache::GetSizeThenCloseDidGetSize,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     scheduler_->WrapCallbackToRunNext(std::move(callback)))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kSizeThenClose,
+      base::BindOnce(
+          &CacheStorageCache::SizeImpl, weak_ptr_factory_.GetWeakPtr(),
+          base::BindOnce(
+              &CacheStorageCache::GetSizeThenCloseDidGetSize,
+              weak_ptr_factory_.GetWeakPtr(),
+              scheduler_->WrapCallbackToRunNext(std::move(callback)))));
 }
 
 void CacheStorageCache::SetObserver(CacheStorageCacheObserver* observer) {
@@ -906,7 +887,6 @@ CacheStorageCache::CacheStorageCache(
     const std::string& cache_name,
     const base::FilePath& path,
     CacheStorage* cache_storage,
-    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context,
     int64_t cache_size,
@@ -917,16 +897,18 @@ CacheStorageCache::CacheStorageCache(
       cache_name_(cache_name),
       path_(path),
       cache_storage_(cache_storage),
-      request_context_getter_(std::move(request_context_getter)),
       quota_manager_proxy_(std::move(quota_manager_proxy)),
       blob_storage_context_(blob_context),
       scheduler_(
-          new CacheStorageScheduler(CacheStorageSchedulerClient::CLIENT_CACHE)),
+          new CacheStorageScheduler(CacheStorageSchedulerClient::kCache)),
       cache_size_(cache_size),
       cache_padding_(cache_padding),
       cache_padding_key_(std::move(cache_padding_key)),
       max_query_size_bytes_(kMaxQueryCacheResultBytes),
       cache_observer_(nullptr),
+      cache_entry_handler_(
+          CacheStorageCacheEntryHandler::CreateCacheEntryHandler(owner,
+                                                                 blob_context)),
       memory_only_(path.empty()),
       weak_ptr_factory_(this) {
   DCHECK(!origin_.opaque());
@@ -1153,7 +1135,8 @@ void CacheStorageCache::QueryCacheDidReadMetadata(
       return;
     }
 
-    PopulateResponseBody(std::move(entry), match->response.get());
+    cache_entry_handler_->PopulateResponseBody(CreateHandle(), std::move(entry),
+                                               match->response.get());
   } else if (!(query_cache_context->query_types &
                QUERY_CACHE_RESPONSES_NO_BODIES)) {
     match->response.reset();
@@ -1287,10 +1270,12 @@ void CacheStorageCache::WriteSideDataDidGetQuota(
     return;
   }
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorageCache::WriteSideDataImpl, weak_ptr_factory_.GetWeakPtr(),
-      scheduler_->WrapCallbackToRunNext(std::move(callback)), url,
-      expected_response_time, buffer, buf_len));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kWriteSideData,
+      base::BindOnce(&CacheStorageCache::WriteSideDataImpl,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback)),
+                     url, expected_response_time, buffer, buf_len));
 }
 
 void CacheStorageCache::WriteSideDataImpl(ErrorCallback callback,
@@ -1314,7 +1299,6 @@ void CacheStorageCache::WriteSideDataImpl(ErrorCallback callback,
                      expected_response_time, buffer, buf_len,
                      std::move(scoped_entry_ptr)));
 
-
   // Use LOWEST priority here as writing side data is less important than
   // loading resources on the page.
   int rv = backend_->OpenEntry(url.spec(), net::LOWEST, entry_ptr,
@@ -1350,9 +1334,8 @@ void CacheStorageCache::WriteSideDataDidReadMetaData(
     int buf_len,
     disk_cache::ScopedEntryPtr entry,
     std::unique_ptr<proto::CacheMetadata> headers) {
-  if (!headers ||
-      headers->response().response_time() !=
-          expected_response_time.ToInternalValue()) {
+  if (!headers || headers->response().response_time() !=
+                      expected_response_time.ToInternalValue()) {
     std::move(callback).Run(CacheStorageError::kErrorNotFound);
     return;
   }
@@ -1416,9 +1399,7 @@ void CacheStorageCache::Put(blink::mojom::BatchOperationPtr operation,
 
   std::unique_ptr<ServiceWorkerFetchRequest> request(
       new ServiceWorkerFetchRequest(
-          operation->request.url, operation->request.method,
-          operation->request.headers, operation->request.referrer,
-          operation->request.is_reload));
+          mojo::ConvertTo<ServiceWorkerFetchRequest>(*(operation->request))));
 
   Put(std::move(request), std::move(operation->response), std::move(callback));
 }
@@ -1428,31 +1409,18 @@ void CacheStorageCache::Put(std::unique_ptr<ServiceWorkerFetchRequest> request,
                             ErrorCallback callback) {
   DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
 
-  blink::mojom::BlobPtr blob;
-  uint64_t blob_size = blink::BlobUtils::kUnknownSize;
-  blink::mojom::BlobPtr side_data_blob;
-  uint64_t side_data_blob_size = blink::BlobUtils::kUnknownSize;
-
-  if (response->blob) {
-    blob.Bind(std::move(response->blob->blob));
-    blob_size = response->blob->size;
-  }
-  if (response->side_data_blob) {
-    side_data_blob.Bind(std::move(response->side_data_blob->blob));
-    side_data_blob_size = response->side_data_blob->size;
-  }
-
   UMA_HISTOGRAM_ENUMERATION("ServiceWorkerCache.Cache.AllWritesResponseType",
                             response->response_type);
 
-  auto put_context = std::make_unique<PutContext>(
-      std::move(request), std::move(response), std::move(blob), blob_size,
-      std::move(side_data_blob), side_data_blob_size,
-      scheduler_->WrapCallbackToRunNext(std::move(callback)));
+  auto put_context = cache_entry_handler_->CreatePutContext(
+      std::move(request), std::move(response));
+  put_context->callback =
+      scheduler_->WrapCallbackToRunNext(std::move(callback));
 
-  scheduler_->ScheduleOperation(base::BindOnce(&CacheStorageCache::PutImpl,
-                                               weak_ptr_factory_.GetWeakPtr(),
-                                               std::move(put_context)));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kPut,
+      base::BindOnce(&CacheStorageCache::PutImpl,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(put_context)));
 }
 
 void CacheStorageCache::PutImpl(std::unique_ptr<PutContext> put_context) {
@@ -1736,10 +1704,9 @@ void CacheStorageCache::UpdateCacheSize(base::OnceClosure callback) {
   // Note that the callback holds a cache handle to keep the cache alive during
   // the operation since this UpdateCacheSize is often run after an operation
   // completes and runs its callback.
-  CalculateCacheSize(base::AdaptCallbackForRepeating(
-      base::BindOnce(&CacheStorageCache::UpdateCacheSizeGotSize,
-                     weak_ptr_factory_.GetWeakPtr(), CreateCacheHandle(),
-                     std::move(callback))));
+  CalculateCacheSize(base::AdaptCallbackForRepeating(base::BindOnce(
+      &CacheStorageCache::UpdateCacheSizeGotSize,
+      weak_ptr_factory_.GetWeakPtr(), CreateHandle(), std::move(callback))));
 }
 
 void CacheStorageCache::UpdateCacheSizeGotSize(
@@ -1764,6 +1731,63 @@ void CacheStorageCache::UpdateCacheSizeGotSize(
   std::move(callback).Run();
 }
 
+void CacheStorageCache::GetAllMatchedEntries(
+    std::unique_ptr<ServiceWorkerFetchRequest> request,
+    blink::mojom::QueryParamsPtr options,
+    CacheEntriesCallback callback) {
+  if (backend_state_ == BACKEND_CLOSED) {
+    std::move(callback).Run(
+        MakeErrorStorage(ErrorStorageType::kKeysBackendClosed), {});
+    return;
+  }
+
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kGetAllMatched,
+      base::BindOnce(&CacheStorageCache::GetAllMatchedEntriesImpl,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(request),
+                     std::move(options),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
+}
+
+void CacheStorageCache::GetAllMatchedEntriesImpl(
+    std::unique_ptr<ServiceWorkerFetchRequest> request,
+    blink::mojom::QueryParamsPtr options,
+    CacheEntriesCallback callback) {
+  DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
+  if (backend_state_ != BACKEND_OPEN) {
+    std::move(callback).Run(
+        MakeErrorStorage(
+            ErrorStorageType::kStorageGetAllMatchedEntriesBackendClosed),
+        {});
+    return;
+  }
+
+  QueryCache(
+      std::move(request), std::move(options),
+      QUERY_CACHE_REQUESTS | QUERY_CACHE_RESPONSES_WITH_BODIES,
+      base::BindOnce(&CacheStorageCache::GetAllMatchedEntriesDidQueryCache,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
+}
+
+void CacheStorageCache::GetAllMatchedEntriesDidQueryCache(
+    CacheEntriesCallback callback,
+    blink::mojom::CacheStorageError error,
+    std::unique_ptr<QueryCacheResults> query_cache_results) {
+  if (error != CacheStorageError::kSuccess) {
+    std::move(callback).Run(error, {});
+    return;
+  }
+
+  std::vector<CacheEntry> entries;
+  entries.reserve(query_cache_results->size());
+
+  for (auto& result : *query_cache_results) {
+    entries.emplace_back(std::move(result.request), std::move(result.response));
+  }
+
+  std::move(callback).Run(CacheStorageError::kSuccess, std::move(entries));
+}
+
 void CacheStorageCache::Delete(blink::mojom::BatchOperationPtr operation,
                                ErrorCallback callback) {
   DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
@@ -1771,14 +1795,18 @@ void CacheStorageCache::Delete(blink::mojom::BatchOperationPtr operation,
 
   std::unique_ptr<ServiceWorkerFetchRequest> request(
       new ServiceWorkerFetchRequest(
-          operation->request.url, operation->request.method,
-          operation->request.headers, operation->request.referrer,
-          operation->request.is_reload));
+          operation->request->url, operation->request->method,
+          ServiceWorkerUtils::ToServiceWorkerHeaderMap(
+              operation->request->headers),
+          operation->request->referrer.To<Referrer>(),
+          operation->request->is_reload));
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorageCache::DeleteImpl, weak_ptr_factory_.GetWeakPtr(),
-      std::move(request), std::move(operation->match_params),
-      scheduler_->WrapCallbackToRunNext(std::move(callback))));
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kDelete,
+      base::BindOnce(&CacheStorageCache::DeleteImpl,
+                     weak_ptr_factory_.GetWeakPtr(), std::move(request),
+                     std::move(operation->match_params),
+                     scheduler_->WrapCallbackToRunNext(std::move(callback))));
 }
 
 void CacheStorageCache::DeleteImpl(
@@ -1893,8 +1921,7 @@ void CacheStorageCache::SizeImpl(SizeCallback callback) {
 
 void CacheStorageCache::GetSizeThenCloseDidGetSize(SizeCallback callback,
                                                    int64_t cache_size) {
-  for (auto* handle : blob_data_handles_)
-    handle->Invalidate();
+  cache_entry_handler_->InvalidateBlobDataHandles();
   CloseImpl(base::BindOnce(std::move(callback), cache_size));
 }
 
@@ -1951,12 +1978,14 @@ void CacheStorageCache::InitBackend() {
   DCHECK(!scheduler_->ScheduledOperations());
   initializing_ = true;
 
-  scheduler_->ScheduleOperation(base::BindOnce(
-      &CacheStorageCache::CreateBackend, weak_ptr_factory_.GetWeakPtr(),
+  scheduler_->ScheduleOperation(
+      CacheStorageSchedulerOp::kInit,
       base::BindOnce(
-          &CacheStorageCache::InitDidCreateBackend,
-          weak_ptr_factory_.GetWeakPtr(),
-          scheduler_->WrapCallbackToRunNext(base::DoNothing::Once()))));
+          &CacheStorageCache::CreateBackend, weak_ptr_factory_.GetWeakPtr(),
+          base::BindOnce(
+              &CacheStorageCache::InitDidCreateBackend,
+              weak_ptr_factory_.GetWeakPtr(),
+              scheduler_->WrapCallbackToRunNext(base::DoNothing::Once()))));
 }
 
 void CacheStorageCache::InitDidCreateBackend(
@@ -2046,35 +2075,6 @@ void CacheStorageCache::InitGotCacheSizeAndPadding(
   std::move(callback).Run();
 }
 
-void CacheStorageCache::PopulateResponseBody(
-    disk_cache::ScopedEntryPtr entry,
-    blink::mojom::FetchAPIResponse* response) {
-  DCHECK(blob_storage_context_);
-
-  // Create a blob with the response body data.
-  response->blob = blink::mojom::SerializedBlob::New();
-  response->blob->size = entry->GetDataSize(INDEX_RESPONSE_BODY);
-  response->blob->uuid = base::GenerateGUID();
-  auto blob_data =
-      std::make_unique<storage::BlobDataBuilder>(response->blob->uuid);
-
-  disk_cache::Entry* temp_entry = entry.get();
-  auto data_handle = base::MakeRefCounted<BlobDataHandle>(CreateCacheHandle(),
-                                                          std::move(entry));
-  blob_data_handles_.insert(data_handle.get());
-  blob_data->AppendDiskCacheEntryWithSideData(
-      std::move(data_handle), temp_entry, INDEX_RESPONSE_BODY, INDEX_SIDE_DATA);
-  auto blob_handle =
-      blob_storage_context_->AddFinishedBlob(std::move(blob_data));
-
-  storage::BlobImpl::Create(std::move(blob_handle),
-                            MakeRequest(&response->blob->blob));
-}
-
-CacheStorageCacheHandle CacheStorageCache::CreateCacheHandle() {
-  return cache_storage_->CreateCacheHandle(this);
-}
-
 int64_t CacheStorageCache::PaddedCacheSize() const {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (cache_size_ == CacheStorage::kSizeUnknown ||
diff --git a/chromium/content/browser/cache_storage/cache_storage_cache.h b/chromium/content/browser/cache_storage/cache_storage_cache.h
index efcdca43ac1..a7b4e7cf437 100644
--- a/chromium/content/browser/cache_storage/cache_storage_cache.h
+++ b/chromium/content/browser/cache_storage/cache_storage_cache.h
@@ -17,6 +17,7 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/optional.h"
+#include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "net/base/io_buffer.h"
 #include "net/disk_cache/disk_cache.h"
@@ -28,10 +29,6 @@ namespace crypto {
 class SymmetricKey;
 }
 
-namespace net {
-class URLRequestContextGetter;
-}
-
 namespace storage {
 class BlobStorageContext;
 class QuotaManagerProxy;
@@ -40,11 +37,11 @@ class QuotaManagerProxy;
 namespace content {
 class CacheStorage;
 class CacheStorageBlobToDiskCache;
-class CacheStorageCacheHandle;
+class CacheStorageCacheEntryHandler;
 class CacheStorageCacheObserver;
 class CacheStorageScheduler;
-class TestCacheStorageCache;
 enum class CacheStorageOwner;
+struct PutContext;
 
 namespace proto {
 class CacheMetadata;
@@ -62,6 +59,11 @@ class CacheStorageCacheTest;
 // will be called so long as the cache object lives.
 class CONTENT_EXPORT CacheStorageCache {
  public:
+  using CacheEntry = std::pair<std::unique_ptr<ServiceWorkerFetchRequest>,
+                               blink::mojom::FetchAPIResponsePtr>;
+  using CacheEntriesCallback =
+      base::OnceCallback<void(blink::mojom::CacheStorageError,
+                              std::vector<CacheEntry>)>;
   using ErrorCallback =
       base::OnceCallback<void(blink::mojom::CacheStorageError)>;
   using VerboseErrorCallback =
@@ -80,6 +82,9 @@ class CONTENT_EXPORT CacheStorageCache {
   using SizeCallback = base::OnceCallback<void(int64_t)>;
   using SizePaddingCallback = base::OnceCallback<void(int64_t, int64_t)>;
 
+  // The stream index for a cache Entry. This cannot be extended without changes
+  // in the Entry implementation. INDEX_SIDE_DATA is used for storing any
+  // additional data, such as response side blobs or request bodies.
   enum EntryIndex { INDEX_HEADERS = 0, INDEX_RESPONSE_BODY, INDEX_SIDE_DATA };
 
   static std::unique_ptr<CacheStorageCache> CreateMemoryCache(
@@ -87,7 +92,6 @@ class CONTENT_EXPORT CacheStorageCache {
       CacheStorageOwner owner,
       const std::string& cache_name,
       CacheStorage* cache_storage,
-      scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       std::unique_ptr<crypto::SymmetricKey> cache_padding_key);
@@ -97,7 +101,6 @@ class CONTENT_EXPORT CacheStorageCache {
       const std::string& cache_name,
       CacheStorage* cache_storage,
       const base::FilePath& path,
-      scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       int64_t cache_size,
@@ -197,6 +200,11 @@ class CONTENT_EXPORT CacheStorageCache {
            blink::mojom::FetchAPIResponsePtr response,
            ErrorCallback callback);
 
+  // Similar to MatchAll, but returns the associated requests as well.
+  void GetAllMatchedEntries(std::unique_ptr<ServiceWorkerFetchRequest> request,
+                            blink::mojom::QueryParamsPtr match_params,
+                            CacheEntriesCallback callback);
+
   // Async operations in progress will cancel and not run their callbacks.
   virtual ~CacheStorageCache();
 
@@ -223,6 +231,12 @@ class CONTENT_EXPORT CacheStorageCache {
 
   base::WeakPtr<CacheStorageCache> AsWeakPtr();
 
+  // virtual for testing
+  virtual CacheStorageCacheHandle CreateHandle();
+  void AddHandleRef();
+  void DropHandleRef();
+  void AssertUnreferenced() const;
+
  private:
   // QueryCache types:
   enum QueryCacheFlags {
@@ -244,7 +258,6 @@ class CONTENT_EXPORT CacheStorageCache {
   friend class cache_storage_cache_unittest::TestCacheStorageCache;
   friend class cache_storage_cache_unittest::CacheStorageCacheTest;
 
-  struct PutContext;
   struct QueryCacheContext;
   struct QueryCacheResult;
 
@@ -264,7 +277,6 @@ class CONTENT_EXPORT CacheStorageCache {
       const std::string& cache_name,
       const base::FilePath& path,
       CacheStorage* cache_storage,
-      scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       int64_t cache_size,
@@ -393,6 +405,16 @@ class CONTENT_EXPORT CacheStorageCache {
                               base::OnceClosure callback,
                               int64_t current_cache_size);
 
+  // GetAllMatchedEntries callbacks.
+  void GetAllMatchedEntriesImpl(
+      std::unique_ptr<ServiceWorkerFetchRequest> request,
+      blink::mojom::QueryParamsPtr options,
+      CacheEntriesCallback callback);
+  void GetAllMatchedEntriesDidQueryCache(
+      CacheEntriesCallback callback,
+      blink::mojom::CacheStorageError error,
+      std::unique_ptr<QueryCacheResults> query_cache_results);
+
   // Returns ERROR_NOT_FOUND if not found. Otherwise deletes and returns OK.
   void Delete(blink::mojom::BatchOperationPtr operation,
               ErrorCallback callback);
@@ -452,12 +474,6 @@ class CONTENT_EXPORT CacheStorageCache {
       int64_t cache_padding);
   void DeleteBackendCompletedIO();
 
-  void PopulateResponseBody(disk_cache::ScopedEntryPtr entry,
-                            blink::mojom::FetchAPIResponse* response);
-
-  // Virtual for testing.
-  virtual CacheStorageCacheHandle CreateCacheHandle();
-
   // Be sure to check |backend_state_| before use.
   std::unique_ptr<disk_cache::Backend> backend_;
 
@@ -469,7 +485,6 @@ class CONTENT_EXPORT CacheStorageCache {
   // Raw pointer is safe because CacheStorage owns this object.
   CacheStorage* cache_storage_;
 
-  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
   base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
   BackendState backend_state_ = BACKEND_UNINITIALIZED;
@@ -481,18 +496,13 @@ class CONTENT_EXPORT CacheStorageCache {
   std::unique_ptr<crypto::SymmetricKey> cache_padding_key_;
   int64_t last_reported_size_ = 0;
   size_t max_query_size_bytes_;
+  size_t handle_ref_count_ = 0;
   CacheStorageCacheObserver* cache_observer_;
+  std::unique_ptr<CacheStorageCacheEntryHandler> cache_entry_handler_;
 
   // Owns the elements of the list
   BlobToDiskCacheIDMap active_blob_to_disk_cache_writers_;
 
-  // This class ensures that the cache and the entry have a lifetime as long as
-  // the blob that is created to contain them. We keep track of these instances
-  // to allow us to invalidate them if the cache has to be deleted while there
-  // are still references to data in it.
-  class BlobDataHandle;
-  std::set<BlobDataHandle*> blob_data_handles_;
-
   // Whether or not to store data in disk or memory.
   bool memory_only_;
 
@@ -500,6 +510,7 @@ class CONTENT_EXPORT CacheStorageCache {
   // the callback passed to CloseImpl.
   base::OnceClosure post_backend_closed_callback_;
 
+  SEQUENCE_CHECKER(sequence_checker_);
   base::WeakPtrFactory<CacheStorageCache> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorageCache);
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
new file mode 100644
index 00000000000..1e5217876ea
--- /dev/null
+++ b/chromium/content/browser/cache_storage/cache_storage_cache_entry_handler.cc
@@ -0,0 +1,147 @@
+// Copyright 2018 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_cache_entry_handler.h"
+
+#include "base/guid.h"
+#include "base/optional.h"
+#include "content/browser/cache_storage/cache_storage_cache.h"
+#include "content/browser/cache_storage/cache_storage_manager.h"
+#include "storage/browser/blob/blob_data_builder.h"
+#include "storage/browser/blob/blob_impl.h"
+#include "storage/browser/blob/blob_storage_context.h"
+#include "third_party/blink/public/common/blob/blob_utils.h"
+
+namespace content {
+
+CacheStorageCacheEntryHandler::BlobDataHandle::BlobDataHandle(
+    base::WeakPtr<CacheStorageCacheEntryHandler> entry_handler,
+    CacheStorageCacheHandle cache_handle,
+    disk_cache::ScopedEntryPtr entry)
+    : entry_handler_(std::move(entry_handler)),
+      cache_handle_(std::move(cache_handle)),
+      entry_(std::move(entry)) {}
+
+bool CacheStorageCacheEntryHandler::BlobDataHandle::IsValid() {
+  return entry_ != nullptr;
+}
+
+void CacheStorageCacheEntryHandler::BlobDataHandle::Invalidate() {
+  cache_handle_ = base::nullopt;
+  entry_handler_ = nullptr;
+  entry_ = nullptr;
+}
+
+CacheStorageCacheEntryHandler::BlobDataHandle::~BlobDataHandle() {
+  if (entry_handler_)
+    entry_handler_->EraseBlobDataHandle(this);
+}
+
+PutContext::PutContext(std::unique_ptr<ServiceWorkerFetchRequest> request,
+                       blink::mojom::FetchAPIResponsePtr response,
+                       blink::mojom::BlobPtr blob,
+                       uint64_t blob_size,
+                       blink::mojom::BlobPtr side_data_blob,
+                       uint64_t side_data_blob_size)
+    : request(std::move(request)),
+      response(std::move(response)),
+      blob(std::move(blob)),
+      blob_size(blob_size),
+      side_data_blob(std::move(side_data_blob)),
+      side_data_blob_size(side_data_blob_size) {}
+
+PutContext::~PutContext() = default;
+
+// Default implemetation of CacheStorageCacheEntryHandler.
+class CacheStorageCacheEntryHandlerImpl : public CacheStorageCacheEntryHandler {
+ public:
+  CacheStorageCacheEntryHandlerImpl(
+      base::WeakPtr<storage::BlobStorageContext> blob_context)
+      : CacheStorageCacheEntryHandler(std::move(blob_context)) {}
+  ~CacheStorageCacheEntryHandlerImpl() override = default;
+
+  std::unique_ptr<PutContext> CreatePutContext(
+      std::unique_ptr<ServiceWorkerFetchRequest> request,
+      blink::mojom::FetchAPIResponsePtr response) override {
+    blink::mojom::BlobPtr blob;
+    uint64_t blob_size = blink::BlobUtils::kUnknownSize;
+    blink::mojom::BlobPtr side_data_blob;
+    uint64_t side_data_blob_size = blink::BlobUtils::kUnknownSize;
+
+    if (response->blob) {
+      blob.Bind(std::move(response->blob->blob));
+      blob_size = response->blob->size;
+    }
+    if (response->side_data_blob) {
+      side_data_blob.Bind(std::move(response->side_data_blob->blob));
+      side_data_blob_size = response->side_data_blob->size;
+    }
+
+    return std::make_unique<PutContext>(
+        std::move(request), std::move(response), std::move(blob), blob_size,
+        std::move(side_data_blob), side_data_blob_size);
+  }
+
+  void PopulateResponseBody(CacheStorageCacheHandle handle,
+                            disk_cache::ScopedEntryPtr entry,
+                            blink::mojom::FetchAPIResponse* response) override {
+    // Create a blob with the response body data.
+    response->blob = blink::mojom::SerializedBlob::New();
+    response->blob->size =
+        entry->GetDataSize(CacheStorageCache::INDEX_RESPONSE_BODY);
+    response->blob->uuid = base::GenerateGUID();
+    auto blob_data =
+        std::make_unique<storage::BlobDataBuilder>(response->blob->uuid);
+
+    disk_cache::Entry* temp_entry = entry.get();
+    auto data_handle =
+        base::MakeRefCounted<CacheStorageCacheEntryHandler::BlobDataHandle>(
+            weak_ptr_factory_.GetWeakPtr(), std::move(handle),
+            std::move(entry));
+    blob_data_handles_.insert(data_handle.get());
+    blob_data->AppendDiskCacheEntryWithSideData(
+        std::move(data_handle), temp_entry,
+        CacheStorageCache::INDEX_RESPONSE_BODY,
+        CacheStorageCache::INDEX_SIDE_DATA);
+    auto blob_handle = blob_context_->AddFinishedBlob(std::move(blob_data));
+
+    storage::BlobImpl::Create(std::move(blob_handle),
+                              MakeRequest(&response->blob->blob));
+  }
+
+  void PopulateRequestBody(CacheStorageCacheHandle handle,
+                           disk_cache::ScopedEntryPtr entry,
+                           blink::mojom::FetchAPIRequest* request) override {}
+};
+
+CacheStorageCacheEntryHandler::CacheStorageCacheEntryHandler(
+    base::WeakPtr<storage::BlobStorageContext> blob_context)
+    : blob_context_(blob_context), weak_ptr_factory_(this) {}
+
+CacheStorageCacheEntryHandler::~CacheStorageCacheEntryHandler() = default;
+
+void CacheStorageCacheEntryHandler::InvalidateBlobDataHandles() {
+  // Calling Invalidate() can cause the CacheStorageCacheEntryHandler to be
+  // destroyed. Be careful not to touch |this| after calling Invalidate().
+  std::set<BlobDataHandle*> handles = std::move(blob_data_handles_);
+  for (auto* handle : handles)
+    handle->Invalidate();
+}
+
+void CacheStorageCacheEntryHandler::EraseBlobDataHandle(
+    BlobDataHandle* handle) {
+  DCHECK_NE(blob_data_handles_.count(handle), 0u);
+  blob_data_handles_.erase(handle);
+}
+
+// static
+std::unique_ptr<CacheStorageCacheEntryHandler>
+CacheStorageCacheEntryHandler::CreateCacheEntryHandler(
+    CacheStorageOwner owner,
+    base::WeakPtr<storage::BlobStorageContext> blob_context) {
+  return std::make_unique<CacheStorageCacheEntryHandlerImpl>(
+      std::move(blob_context));
+}
+
+}  // namespace content
diff --git a/chromium/content/browser/cache_storage/cache_storage_cache_entry_handler.h b/chromium/content/browser/cache_storage/cache_storage_cache_entry_handler.h
new file mode 100644
index 00000000000..89220284f8f
--- /dev/null
+++ b/chromium/content/browser/cache_storage/cache_storage_cache_entry_handler.h
@@ -0,0 +1,121 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_ENTRY_HANDLER_H_
+#define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_ENTRY_HANDLER_H_
+
+#include <memory>
+#include <set>
+
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "content/browser/cache_storage/cache_storage_cache_handle.h"
+#include "content/common/content_export.h"
+#include "net/disk_cache/disk_cache.h"
+#include "storage/browser/blob/blob_data_builder.h"
+#include "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom.h"
+
+namespace storage {
+class BlobStorageContext;
+}  // namespace storage
+
+namespace content {
+
+enum class CacheStorageOwner;
+struct ServiceWorkerFetchRequest;
+
+// The state needed to pass when writing to a cache.
+struct PutContext {
+  using ErrorCallback =
+      base::OnceCallback<void(blink::mojom::CacheStorageError)>;
+
+  PutContext(std::unique_ptr<ServiceWorkerFetchRequest> request,
+             blink::mojom::FetchAPIResponsePtr response,
+             blink::mojom::BlobPtr blob,
+             uint64_t blob_size,
+             blink::mojom::BlobPtr side_data_blob,
+             uint64_t side_data_blob_size);
+
+  ~PutContext();
+
+  // Provided by the constructor.
+  std::unique_ptr<ServiceWorkerFetchRequest> request;
+  blink::mojom::FetchAPIResponsePtr response;
+  blink::mojom::BlobPtr blob;
+  uint64_t blob_size;
+  blink::mojom::BlobPtr side_data_blob;
+  uint64_t side_data_blob_size;
+
+  // Provided while writing to the cache.
+  ErrorCallback callback;
+  disk_cache::ScopedEntryPtr cache_entry;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PutContext);
+};
+
+class CONTENT_EXPORT CacheStorageCacheEntryHandler {
+ public:
+  // This class ensures that the cache and the entry have a lifetime as long as
+  // the blob that is created to contain them.
+  class BlobDataHandle : public storage::BlobDataBuilder::DataHandle {
+   public:
+    BlobDataHandle(base::WeakPtr<CacheStorageCacheEntryHandler> entry_handler,
+                   CacheStorageCacheHandle cache_handle,
+                   disk_cache::ScopedEntryPtr entry);
+
+    bool IsValid() override;
+
+    void Invalidate();
+
+   private:
+    ~BlobDataHandle() override;
+
+    base::WeakPtr<CacheStorageCacheEntryHandler> entry_handler_;
+    base::Optional<CacheStorageCacheHandle> cache_handle_;
+    disk_cache::ScopedEntryPtr entry_;
+
+    DISALLOW_COPY_AND_ASSIGN(BlobDataHandle);
+  };
+
+  virtual ~CacheStorageCacheEntryHandler();
+
+  virtual std::unique_ptr<PutContext> CreatePutContext(
+      std::unique_ptr<ServiceWorkerFetchRequest>,
+      blink::mojom::FetchAPIResponsePtr response) = 0;
+  virtual void PopulateResponseBody(
+      CacheStorageCacheHandle handle,
+      disk_cache::ScopedEntryPtr entry,
+      blink::mojom::FetchAPIResponse* response) = 0;
+  virtual void PopulateRequestBody(CacheStorageCacheHandle handle,
+                                   disk_cache::ScopedEntryPtr entry,
+                                   blink::mojom::FetchAPIRequest* request) = 0;
+
+  static std::unique_ptr<CacheStorageCacheEntryHandler> CreateCacheEntryHandler(
+      CacheStorageOwner owner,
+      base::WeakPtr<storage::BlobStorageContext> blob_context);
+
+  void InvalidateBlobDataHandles();
+
+  void EraseBlobDataHandle(BlobDataHandle* handle);
+
+ protected:
+  CacheStorageCacheEntryHandler(
+      base::WeakPtr<storage::BlobStorageContext> blob_context);
+
+  base::WeakPtr<storage::BlobStorageContext> blob_context_;
+
+  // We keep track of the BlobDataHandle instances to allow us to invalidate
+  // them if the cache has to be deleted while there are still references to
+  // data in it.
+  std::set<BlobDataHandle*> blob_data_handles_;
+
+  base::WeakPtrFactory<CacheStorageCacheEntryHandler> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CacheStorageCacheEntryHandler);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_ENTRY_HANDLER_H_
diff --git a/chromium/content/browser/cache_storage/cache_storage_cache_handle.cc b/chromium/content/browser/cache_storage/cache_storage_cache_handle.cc
deleted file mode 100644
index ae3f68fed34..00000000000
--- a/chromium/content/browser/cache_storage/cache_storage_cache_handle.cc
+++ /dev/null
@@ -1,45 +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 <utility>
-
-#include "content/browser/cache_storage/cache_storage_cache_handle.h"
-
-namespace content {
-
-CacheStorageCacheHandle::CacheStorageCacheHandle() = default;
-
-CacheStorageCacheHandle::CacheStorageCacheHandle(
-    CacheStorageCacheHandle&& other)
-    : cache_storage_cache_(std::move(other.cache_storage_cache_)),
-      cache_storage_(std::move(other.cache_storage_)) {}
-
-CacheStorageCacheHandle::~CacheStorageCacheHandle() {
-  if (cache_storage_ && cache_storage_cache_)
-    cache_storage_->DropCacheHandleRef(cache_storage_cache_.get());
-}
-
-CacheStorageCacheHandle CacheStorageCacheHandle::Clone() const {
-  return CacheStorageCacheHandle(cache_storage_cache_, cache_storage_);
-}
-
-CacheStorageCacheHandle::CacheStorageCacheHandle(
-    base::WeakPtr<CacheStorageCache> cache_storage_cache,
-    base::WeakPtr<CacheStorage> cache_storage)
-    : cache_storage_cache_(cache_storage_cache), cache_storage_(cache_storage) {
-  DCHECK(cache_storage);
-  DCHECK(cache_storage_cache_);
-  cache_storage_->AddCacheHandleRef(cache_storage_cache_.get());
-}
-
-CacheStorageCacheHandle& CacheStorageCacheHandle::operator=(
-    CacheStorageCacheHandle&& rhs) {
-  if (cache_storage_ && cache_storage_cache_)
-    cache_storage_->DropCacheHandleRef(cache_storage_cache_.get());
-  cache_storage_cache_ = std::move(rhs.cache_storage_cache_);
-  cache_storage_ = std::move(rhs.cache_storage_);
-  return *this;
-}
-
-}  // namespace content
diff --git a/chromium/content/browser/cache_storage/cache_storage_cache_handle.h b/chromium/content/browser/cache_storage/cache_storage_cache_handle.h
index 28f1e828718..393ce5dcc9a 100644
--- a/chromium/content/browser/cache_storage/cache_storage_cache_handle.h
+++ b/chromium/content/browser/cache_storage/cache_storage_cache_handle.h
@@ -5,40 +5,12 @@
 #ifndef CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_HANDLE_H_
 #define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_CACHE_HANDLE_H_
 
-#include "base/memory/weak_ptr.h"
-#include "content/browser/cache_storage/cache_storage.h"
-#include "content/browser/cache_storage/cache_storage_cache.h"
+#include "content/browser/cache_storage/cache_storage_ref.h"
 
 namespace content {
 
-// Holds a reference to a CacheStorageCache. The CacheStorage will keep the
-// CacheStorageCache alive until the last handle is destroyed or the
-// CacheStorage is deleted.
-class CONTENT_EXPORT CacheStorageCacheHandle {
- public:
-  CacheStorageCacheHandle();
-  CacheStorageCacheHandle(CacheStorageCacheHandle&& other);
-  ~CacheStorageCacheHandle();
-
-  // Returns the underlying CacheStorageCache*. Will return nullptr if the
-  // CacheStorage has been deleted.
-  CacheStorageCache* value() { return cache_storage_cache_.get(); }
-
-  CacheStorageCacheHandle Clone() const;
-
-  CacheStorageCacheHandle& operator=(CacheStorageCacheHandle&& rhs);
-
- private:
-  friend class CacheStorage;
-
-  CacheStorageCacheHandle(base::WeakPtr<CacheStorageCache> cache_storage_cache,
-                          base::WeakPtr<CacheStorage> cache_storage);
-
-  base::WeakPtr<CacheStorageCache> cache_storage_cache_;
-  base::WeakPtr<CacheStorage> cache_storage_;
-
-  DISALLOW_COPY_AND_ASSIGN(CacheStorageCacheHandle);
-};
+class CacheStorageCache;
+using CacheStorageCacheHandle = CacheStorageRef<CacheStorageCache>;
 
 }  // 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 55b20bc194e..b378f2d04e4 100644
--- a/chromium/content/browser/cache_storage/cache_storage_cache_unittest.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_cache_unittest.cc
@@ -26,6 +26,7 @@
 #include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/browser/cache_storage/cache_storage_histogram_utils.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
+#include "content/common/service_worker/service_worker_type_converter.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
@@ -39,7 +40,6 @@
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
@@ -52,6 +52,7 @@
 #include "storage/browser/test/mock_special_storage_policy.h"
 #include "storage/common/blob_storage/blob_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/public/platform/modules/fetch/fetch_api_request.mojom.h"
 #include "url/origin.h"
 
 using blink::mojom::CacheStorageError;
@@ -159,6 +160,8 @@ class DelayableBackend : public disk_cache::Backend {
     return 0u;
   }
 
+  int64_t MaxFileSize() const override { return backend_->MaxFileSize(); }
+
   // Call to continue a delayed call to OpenEntry.
   bool OpenEntryContinue() {
     if (open_entry_callback_.is_null())
@@ -307,7 +310,6 @@ class TestCacheStorageCache : public CacheStorageCache {
       const std::string& cache_name,
       const base::FilePath& path,
       CacheStorage* cache_storage,
-      const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context)
       : CacheStorageCache(origin,
@@ -315,7 +317,6 @@ class TestCacheStorageCache : public CacheStorageCache {
                           cache_name,
                           path,
                           cache_storage,
-                          request_context_getter,
                           quota_manager_proxy,
                           blob_context,
                           0 /* cache_size */,
@@ -353,7 +354,7 @@ class TestCacheStorageCache : public CacheStorageCache {
   void Init() { InitBackend(); }
 
  private:
-  CacheStorageCacheHandle CreateCacheHandle() override {
+  CacheStorageCacheHandle CreateHandle() override {
     // Returns an empty handle. There is no need for CacheStorage and its
     // handles in these tests.
     return CacheStorageCacheHandle();
@@ -416,8 +417,6 @@ class CacheStorageCacheTest : public testing::Test {
 
     cache_ = std::make_unique<TestCacheStorageCache>(
         kOrigin, kCacheName, temp_dir_path, nullptr /* CacheStorage */,
-        BrowserContext::GetDefaultStoragePartition(&browser_context_)
-            ->GetURLRequestContext(),
         quota_manager_proxy_, blob_storage_context->context()->AsWeakPtr());
     cache_->Init();
   }
@@ -514,22 +513,37 @@ class CacheStorageCacheTest : public testing::Test {
     return callback_error_;
   }
 
+  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);
+    histogram_tester.ExpectTotalCount(base + "QueueLength." + op_name, 1);
+  }
+
   bool Put(const ServiceWorkerFetchRequest& request,
            blink::mojom::FetchAPIResponsePtr response) {
+    base::HistogramTester histogram_tester;
     blink::mojom::BatchOperationPtr operation =
         blink::mojom::BatchOperation::New();
     operation->operation_type = blink::mojom::OperationType::kPut;
-    operation->request = request;
+    operation->request =
+        mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(request);
     operation->response = std::move(response);
 
     std::vector<blink::mojom::BatchOperationPtr> operations;
     operations.emplace_back(std::move(operation));
     CacheStorageError error = BatchOperation(std::move(operations));
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "Put");
     return error == CacheStorageError::kSuccess;
   }
 
   bool Match(const ServiceWorkerFetchRequest& request,
              blink::mojom::QueryParamsPtr match_params = nullptr) {
+    base::HistogramTester histogram_tester;
     std::unique_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->Match(
@@ -537,19 +551,35 @@ class CacheStorageCacheTest : public testing::Test {
         base::BindOnce(&CacheStorageCacheTest::ResponseAndErrorCallback,
                        base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
-
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "Match");
     return callback_error_ == CacheStorageError::kSuccess;
   }
 
   bool MatchAll(const ServiceWorkerFetchRequest& request,
                 blink::mojom::QueryParamsPtr match_params,
                 std::vector<blink::mojom::FetchAPIResponsePtr>* responses) {
+    base::HistogramTester histogram_tester;
     base::RunLoop loop;
     cache_->MatchAll(
         CopyFetchRequest(request), std::move(match_params),
         base::BindOnce(&CacheStorageCacheTest::ResponsesAndErrorCallback,
                        base::Unretained(this), loop.QuitClosure(), responses));
     loop.Run();
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "MatchAll");
+    return callback_error_ == CacheStorageError::kSuccess;
+  }
+
+  bool GetAllMatchedEntries(
+      std::vector<CacheStorageCache::CacheEntry>* cache_entries) {
+    base::RunLoop loop;
+    cache_->GetAllMatchedEntries(
+        nullptr /* request */, nullptr /* options */,
+        base::BindOnce(&CacheStorageCacheTest::CacheEntriesAndErrorCallback,
+                       base::Unretained(this), loop.QuitClosure(),
+                       cache_entries));
+    loop.Run();
     return callback_error_ == CacheStorageError::kSuccess;
   }
 
@@ -559,21 +589,26 @@ class CacheStorageCacheTest : public testing::Test {
 
   bool Delete(const ServiceWorkerFetchRequest& request,
               blink::mojom::QueryParamsPtr match_params = nullptr) {
+    base::HistogramTester histogram_tester;
     blink::mojom::BatchOperationPtr operation =
         blink::mojom::BatchOperation::New();
     operation->operation_type = blink::mojom::OperationType::kDelete;
-    operation->request = request;
+    operation->request =
+        mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(request);
     operation->match_params = std::move(match_params);
 
     std::vector<blink::mojom::BatchOperationPtr> operations;
     operations.emplace_back(std::move(operation));
     CacheStorageError error = BatchOperation(std::move(operations));
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "Delete");
     return error == CacheStorageError::kSuccess;
   }
 
   bool Keys(
       const ServiceWorkerFetchRequest& request = ServiceWorkerFetchRequest(),
       blink::mojom::QueryParamsPtr match_params = nullptr) {
+    base::HistogramTester histogram_tester;
     std::unique_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->Keys(
@@ -581,17 +616,21 @@ class CacheStorageCacheTest : public testing::Test {
         base::BindOnce(&CacheStorageCacheTest::RequestsCallback,
                        base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
-
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "Keys");
     return callback_error_ == CacheStorageError::kSuccess;
   }
 
   bool Close() {
+    base::HistogramTester histogram_tester;
     std::unique_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->Close(base::BindOnce(&CacheStorageCacheTest::CloseCallback,
                                  base::Unretained(this),
                                  base::Unretained(loop.get())));
     loop->Run();
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "Close");
     return callback_closed_;
   }
 
@@ -599,17 +638,20 @@ class CacheStorageCacheTest : public testing::Test {
                      base::Time expected_response_time,
                      scoped_refptr<net::IOBuffer> buffer,
                      int buf_len) {
+    base::HistogramTester histogram_tester;
     base::RunLoop run_loop;
     cache_->WriteSideData(
         base::BindOnce(&CacheStorageCacheTest::ErrorTypeCallback,
                        base::Unretained(this), base::Unretained(&run_loop)),
         url, expected_response_time, buffer, buf_len);
     run_loop.Run();
-
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "WriteSideData");
     return callback_error_ == CacheStorageError::kSuccess;
   }
 
   int64_t Size() {
+    base::HistogramTester histogram_tester;
     // Storage notification happens after an operation completes. Let the any
     // notifications complete before calling Size.
     base::RunLoop().RunUntilIdle();
@@ -621,10 +663,13 @@ class CacheStorageCacheTest : public testing::Test {
         base::BindOnce(&SizeCallback, &run_loop, &callback_called, &result));
     run_loop.Run();
     EXPECT_TRUE(callback_called);
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "Size");
     return result;
   }
 
   int64_t GetSizeThenClose() {
+    base::HistogramTester histogram_tester;
     base::RunLoop run_loop;
     bool callback_called = false;
     int64_t result = 0;
@@ -632,6 +677,8 @@ class CacheStorageCacheTest : public testing::Test {
         base::BindOnce(&SizeCallback, &run_loop, &callback_called, &result));
     run_loop.Run();
     EXPECT_TRUE(callback_called);
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "SizeThenClose");
     return result;
   }
 
@@ -691,6 +738,16 @@ class CacheStorageCacheTest : public testing::Test {
     std::move(quit_closure).Run();
   }
 
+  void CacheEntriesAndErrorCallback(
+      base::OnceClosure quit_closure,
+      std::vector<CacheStorageCache::CacheEntry>* cache_entries_out,
+      CacheStorageError error,
+      std::vector<CacheStorageCache::CacheEntry> cache_entries) {
+    callback_error_ = error;
+    *cache_entries_out = std::move(cache_entries);
+    std::move(quit_closure).Run();
+  }
+
   void CloseCallback(base::RunLoop* run_loop) {
     EXPECT_FALSE(callback_closed_);
     callback_closed_ = true;
@@ -773,29 +830,35 @@ TEST_P(CacheStorageCacheTestP, PutBody_Multiple) {
   blink::mojom::BatchOperationPtr operation1 =
       blink::mojom::BatchOperation::New();
   operation1->operation_type = blink::mojom::OperationType::kPut;
-  operation1->request = body_request_;
-  operation1->request.url = GURL("http://example.com/1");
+  operation1->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
+  operation1->request->url = GURL("http://example.com/1");
   operation1->response = CreateBlobBodyResponse();
   operation1->response->url_list.push_back(GURL("http://example.com/1"));
-  ServiceWorkerFetchRequest request1 = operation1->request;
+  ServiceWorkerFetchRequest request1 =
+      mojo::ConvertTo<ServiceWorkerFetchRequest>(*(operation1->request));
 
   blink::mojom::BatchOperationPtr operation2 =
       blink::mojom::BatchOperation::New();
   operation2->operation_type = blink::mojom::OperationType::kPut;
-  operation2->request = body_request_;
-  operation2->request.url = GURL("http://example.com/2");
+  operation2->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
+  operation2->request->url = GURL("http://example.com/2");
   operation2->response = CreateBlobBodyResponse();
   operation2->response->url_list.push_back(GURL("http://example.com/2"));
-  ServiceWorkerFetchRequest request2 = operation2->request;
+  ServiceWorkerFetchRequest request2 =
+      mojo::ConvertTo<ServiceWorkerFetchRequest>(*(operation2->request));
 
   blink::mojom::BatchOperationPtr operation3 =
       blink::mojom::BatchOperation::New();
   operation3->operation_type = blink::mojom::OperationType::kPut;
-  operation3->request = body_request_;
-  operation3->request.url = GURL("http://example.com/3");
+  operation3->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
+  operation3->request->url = GURL("http://example.com/3");
   operation3->response = CreateBlobBodyResponse();
   operation3->response->url_list.push_back(GURL("http://example.com/3"));
-  ServiceWorkerFetchRequest request3 = operation3->request;
+  ServiceWorkerFetchRequest request3 =
+      mojo::ConvertTo<ServiceWorkerFetchRequest>(*(operation3->request));
 
   std::vector<blink::mojom::BatchOperationPtr> operations;
   operations.push_back(std::move(operation1));
@@ -902,7 +965,8 @@ TEST_P(CacheStorageCacheTestP, PutBodyDropBlobRef) {
   blink::mojom::BatchOperationPtr operation =
       blink::mojom::BatchOperation::New();
   operation->operation_type = blink::mojom::OperationType::kPut;
-  operation->request = body_request_;
+  operation->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
   operation->response = CreateBlobBodyResponse();
 
   std::vector<blink::mojom::BatchOperationPtr> operations;
@@ -927,13 +991,16 @@ TEST_P(CacheStorageCacheTestP, PutBadMessage) {
   // Two unique puts that will collectively overflow unit64_t size of the
   // batch operation.
   blink::mojom::BatchOperationPtr operation1 =
-      blink::mojom::BatchOperation::New(blink::mojom::OperationType::kPut,
-                                        body_request_, CreateBlobBodyResponse(),
-                                        nullptr /* match_params */);
+      blink::mojom::BatchOperation::New(
+          blink::mojom::OperationType::kPut,
+          mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_),
+          CreateBlobBodyResponse(), nullptr /* match_params */);
   operation1->response->blob->size = std::numeric_limits<uint64_t>::max();
   blink::mojom::BatchOperationPtr operation2 =
       blink::mojom::BatchOperation::New(
-          blink::mojom::OperationType::kPut, body_request_with_query_,
+          blink::mojom::OperationType::kPut,
+          mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(
+              body_request_with_query_),
           CreateBlobBodyResponse(), nullptr /* match_params */);
   operation2->response->blob->size = std::numeric_limits<uint64_t>::max();
 
@@ -967,13 +1034,15 @@ TEST_P(CacheStorageCacheTestP, PutReplaceInBatchFails) {
   blink::mojom::BatchOperationPtr operation1 =
       blink::mojom::BatchOperation::New();
   operation1->operation_type = blink::mojom::OperationType::kPut;
-  operation1->request = body_request_;
+  operation1->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
   operation1->response = CreateNoBodyResponse();
 
   blink::mojom::BatchOperationPtr operation2 =
       blink::mojom::BatchOperation::New();
   operation2->operation_type = blink::mojom::OperationType::kPut;
-  operation2->request = body_request_;
+  operation2->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
   operation2->response = CreateBlobBodyResponse();
 
   std::vector<blink::mojom::BatchOperationPtr> operations;
@@ -996,13 +1065,15 @@ TEST_P(CacheStorageCacheTestP, PutReplaceInBatchWithDuplicateCheckingDisabled) {
   blink::mojom::BatchOperationPtr operation1 =
       blink::mojom::BatchOperation::New();
   operation1->operation_type = blink::mojom::OperationType::kPut;
-  operation1->request = body_request_;
+  operation1->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
   operation1->response = CreateNoBodyResponse();
 
   blink::mojom::BatchOperationPtr operation2 =
       blink::mojom::BatchOperation::New();
   operation2->operation_type = blink::mojom::OperationType::kPut;
-  operation2->request = body_request_;
+  operation2->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
   operation2->response = CreateBlobBodyResponse();
 
   std::vector<blink::mojom::BatchOperationPtr> operations;
@@ -1140,6 +1211,25 @@ TEST_P(CacheStorageCacheTestP, Match_IgnoreVary) {
   EXPECT_TRUE(Match(body_request_, std::move(match_params)));
 }
 
+TEST_P(CacheStorageCacheTestP, GetAllMatchedEntries_RequestsIncluded) {
+  EXPECT_TRUE(Put(body_request_, CreateBlobBodyResponse()));
+
+  std::vector<CacheStorageCache::CacheEntry> cache_entries;
+  EXPECT_TRUE(GetAllMatchedEntries(&cache_entries));
+
+  ASSERT_EQ(1u, cache_entries.size());
+  const auto& request = cache_entries[0].first;
+  EXPECT_EQ(request->url, body_request_.url);
+  EXPECT_EQ(request->headers, body_request_.headers);
+  EXPECT_EQ(request->method, body_request_.method);
+
+  auto& response = cache_entries[0].second;
+  EXPECT_TRUE(ResponseMetadataEqual(*SetCacheName(CreateBlobBodyResponse()),
+                                    *response));
+  blink::mojom::BlobPtr blob(std::move(response->blob->blob));
+  EXPECT_TRUE(ResponseBodiesEqual(expected_blob_data_, blob.get()));
+}
+
 TEST_P(CacheStorageCacheTestP, Keys_IgnoreSearch) {
   EXPECT_TRUE(Put(body_request_with_query_, CreateBlobBodyResponseWithQuery()));
 
@@ -1512,7 +1602,7 @@ TEST_P(CacheStorageCacheTestP, QuickStressBody) {
 
 TEST_P(CacheStorageCacheTestP, PutResponseType) {
   EXPECT_TRUE(TestResponseType(network::mojom::FetchResponseType::kBasic));
-  EXPECT_TRUE(TestResponseType(network::mojom::FetchResponseType::kCORS));
+  EXPECT_TRUE(TestResponseType(network::mojom::FetchResponseType::kCors));
   EXPECT_TRUE(TestResponseType(network::mojom::FetchResponseType::kDefault));
   EXPECT_TRUE(TestResponseType(network::mojom::FetchResponseType::kError));
   EXPECT_TRUE(TestResponseType(network::mojom::FetchResponseType::kOpaque));
@@ -1586,7 +1676,8 @@ TEST_P(CacheStorageCacheTestP, PutWithSideData_BadMessage) {
   blink::mojom::BatchOperationPtr operation =
       blink::mojom::BatchOperation::New();
   operation->operation_type = blink::mojom::OperationType::kPut;
-  operation->request = body_request_;
+  operation->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
   operation->response = std::move(response);
   operation->response->blob->size = std::numeric_limits<uint64_t>::max();
 
@@ -1945,7 +2036,8 @@ TEST_P(CacheStorageCacheTestP, VerifySerialScheduling) {
   blink::mojom::BatchOperationPtr operation1 =
       blink::mojom::BatchOperation::New();
   operation1->operation_type = blink::mojom::OperationType::kPut;
-  operation1->request = body_request_;
+  operation1->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
   operation1->response = CreateBlobBodyResponse();
 
   std::unique_ptr<base::RunLoop> close_loop1(new base::RunLoop());
@@ -1964,7 +2056,8 @@ TEST_P(CacheStorageCacheTestP, VerifySerialScheduling) {
   blink::mojom::BatchOperationPtr operation2 =
       blink::mojom::BatchOperation::New();
   operation2->operation_type = blink::mojom::OperationType::kPut;
-  operation2->request = body_request_;
+  operation2->request =
+      mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(body_request_);
   operation2->response = CreateBlobBodyResponse();
 
   delayable_backend->set_delay_open_entry(false);
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 ffc6bc04f4b..a69ebddca11 100644
--- a/chromium/content/browser/cache_storage/cache_storage_context_impl.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_context_impl.cc
@@ -13,7 +13,6 @@
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/quota/special_storage_policy.h"
@@ -71,28 +70,28 @@ CacheStorageManager* CacheStorageContextImpl::cache_manager() const {
 }
 
 void CacheStorageContextImpl::SetBlobParametersForCache(
-    net::URLRequestContextGetter* request_context_getter,
     ChromeBlobStorageContext* blob_storage_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  if (cache_manager_ && request_context_getter && blob_storage_context) {
+  if (cache_manager_ && blob_storage_context) {
     cache_manager_->SetBlobParametersForCache(
-        request_context_getter, blob_storage_context->context()->AsWeakPtr());
+        blob_storage_context->context()->AsWeakPtr());
   }
 }
 
 void CacheStorageContextImpl::GetAllOriginsInfo(
-    const CacheStorageContext::GetUsageInfoCallback& callback) {
+    CacheStorageContext::GetUsageInfoCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!cache_manager_) {
     base::PostTaskWithTraits(
         FROM_HERE, {BrowserThread::IO},
-        base::BindOnce(callback, std::vector<CacheStorageUsageInfo>()));
+        base::BindOnce(std::move(callback), std::vector<StorageUsageInfo>()));
     return;
   }
 
-  cache_manager_->GetAllOriginsUsage(CacheStorageOwner::kCacheAPI, callback);
+  cache_manager_->GetAllOriginsUsage(CacheStorageOwner::kCacheAPI,
+                                     std::move(callback));
 }
 
 void CacheStorageContextImpl::DeleteForOrigin(const GURL& origin) {
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 cedfd960e13..39f1e8889c2 100644
--- a/chromium/content/browser/cache_storage/cache_storage_context_impl.h
+++ b/chromium/content/browser/cache_storage/cache_storage_context_impl.h
@@ -12,17 +12,12 @@
 #include "base/memory/scoped_refptr.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/cache_storage_context.h"
-#include "content/public/browser/cache_storage_usage_info.h"
 
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
 }
 
-namespace net {
-class URLRequestContextGetter;
-}
-
 namespace storage {
 class QuotaManagerProxy;
 }
@@ -66,18 +61,15 @@ class CONTENT_EXPORT CacheStorageContextImpl : public CacheStorageContext {
 
   bool is_incognito() const { return is_incognito_; }
 
-  // The URLRequestContext doesn't exist until after the StoragePartition is
-  // made (which is after this object is made). This function must be called
-  // after this object is created but before any CacheStorageCache operations.
-  // It must be called on the IO thread. If either parameter is NULL the
-  // function immediately returns without forwarding to the
-  // CacheStorageManager.
+  // This function must be called after this object is created but before any
+  // CacheStorageCache operations. It must be called on the IO thread. If
+  // |blob_storage_context| is NULL the function immediately returns without
+  // forwarding to the CacheStorageManager.
   void SetBlobParametersForCache(
-      net::URLRequestContextGetter* request_context_getter,
       ChromeBlobStorageContext* blob_storage_context);
 
   // CacheStorageContext
-  void GetAllOriginsInfo(const GetUsageInfoCallback& callback) override;
+  void GetAllOriginsInfo(GetUsageInfoCallback callback) override;
   void DeleteForOrigin(const GURL& origin) override;
 
   // Only callable on the IO thread.
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 9394792d4bb..dc21e334233 100644
--- a/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.cc
@@ -21,12 +21,16 @@
 #include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/browser/cache_storage/cache_storage_context_impl.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
+#include "content/common/service_worker/service_worker_type_converter.h"
+#include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/origin_util.h"
+#include "content/public/common/referrer_type_converters.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom.h"
+#include "third_party/blink/public/platform/modules/fetch/fetch_api_request.mojom.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
@@ -63,7 +67,7 @@ class CacheStorageDispatcherHost::CacheImpl
   ~CacheImpl() override = default;
 
   // blink::mojom::CacheStorageCache implementation:
-  void Match(const ServiceWorkerFetchRequest& request,
+  void Match(blink::mojom::FetchAPIRequestPtr request,
              blink::mojom::QueryParamsPtr match_params,
              MatchCallback callback) override {
     content::CacheStorageCache* cache = cache_handle_.value();
@@ -74,8 +78,9 @@ class CacheStorageDispatcherHost::CacheImpl
     }
 
     auto scoped_request = std::make_unique<ServiceWorkerFetchRequest>(
-        request.url, request.method, request.headers, request.referrer,
-        request.is_reload);
+        request->url, request->method,
+        ServiceWorkerUtils::ToServiceWorkerHeaderMap(request->headers),
+        request->referrer.To<Referrer>(), request->is_reload);
 
     cache->Match(
         std::move(scoped_request), std::move(match_params),
@@ -96,7 +101,7 @@ class CacheStorageDispatcherHost::CacheImpl
         blink::mojom::MatchResult::NewResponse(std::move(response)));
   }
 
-  void MatchAll(const base::Optional<ServiceWorkerFetchRequest>& request,
+  void MatchAll(blink::mojom::FetchAPIRequestPtr request,
                 blink::mojom::QueryParamsPtr match_params,
                 MatchAllCallback callback) override {
     content::CacheStorageCache* cache = cache_handle_.value();
@@ -110,8 +115,9 @@ class CacheStorageDispatcherHost::CacheImpl
 
     if (request && !request->url.is_empty()) {
       request_ptr = std::make_unique<ServiceWorkerFetchRequest>(
-          request->url, request->method, request->headers, request->referrer,
-          request->is_reload);
+          request->url, request->method,
+          ServiceWorkerUtils::ToServiceWorkerHeaderMap(request->headers),
+          request->referrer.To<Referrer>(), request->is_reload);
     }
 
     cache->MatchAll(
@@ -134,7 +140,7 @@ class CacheStorageDispatcherHost::CacheImpl
         blink::mojom::MatchAllResult::NewResponses(std::move(responses)));
   }
 
-  void Keys(const base::Optional<ServiceWorkerFetchRequest>& request,
+  void Keys(blink::mojom::FetchAPIRequestPtr request,
             blink::mojom::QueryParamsPtr match_params,
             KeysCallback callback) override {
     content::CacheStorageCache* cache = cache_handle_.value();
@@ -145,12 +151,13 @@ class CacheStorageDispatcherHost::CacheImpl
     }
 
     std::unique_ptr<ServiceWorkerFetchRequest> request_ptr;
-
     if (request) {
       request_ptr = std::make_unique<ServiceWorkerFetchRequest>(
-          request->url, request->method, request->headers, request->referrer,
-          request->is_reload);
+          request->url, request->method,
+          ServiceWorkerUtils::ToServiceWorkerHeaderMap(request->headers),
+          request->referrer.To<Referrer>(), request->is_reload);
     }
+
     cache->Keys(
         std::move(request_ptr), std::move(match_params),
         base::BindOnce(&CacheImpl::OnCacheKeysCallback,
@@ -165,8 +172,14 @@ class CacheStorageDispatcherHost::CacheImpl
       std::move(callback).Run(blink::mojom::CacheKeysResult::NewStatus(error));
       return;
     }
+    std::vector<blink::mojom::FetchAPIRequestPtr> requests_;
+    for (auto request : *requests) {
+      requests_.push_back(
+          mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(request));
+    }
 
-    std::move(callback).Run(blink::mojom::CacheKeysResult::NewKeys(*requests));
+    std::move(callback).Run(
+        blink::mojom::CacheKeysResult::NewKeys(std::move(requests_)));
   }
 
   void Batch(std::vector<blink::mojom::BatchOperationPtr> batch_operations,
@@ -296,7 +309,7 @@ void CacheStorageDispatcherHost::Keys(
 }
 
 void CacheStorageDispatcherHost::Match(
-    const content::ServiceWorkerFetchRequest& request,
+    blink::mojom::FetchAPIRequestPtr request,
     blink::mojom::QueryParamsPtr match_params,
     blink::mojom::CacheStorage::MatchCallback callback) {
   TRACE_EVENT0("CacheStorage",
@@ -309,8 +322,9 @@ void CacheStorageDispatcherHost::Match(
   if (!ValidState())
     return;
   auto scoped_request = std::make_unique<ServiceWorkerFetchRequest>(
-      request.url, request.method, request.headers, request.referrer,
-      request.is_reload);
+      request->url, request->method,
+      ServiceWorkerUtils::ToServiceWorkerHeaderMap(request->headers),
+      request->referrer.To<Referrer>(), request->is_reload);
 
   if (!match_params->cache_name) {
     context_->cache_manager()->MatchAllCaches(
diff --git a/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.h b/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.h
index ade31c52d76..4e72d5ec8fb 100644
--- a/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.h
+++ b/chromium/content/browser/cache_storage/cache_storage_dispatcher_host.h
@@ -20,6 +20,7 @@
 #include "mojo/public/cpp/bindings/associated_binding_set.h"
 #include "mojo/public/cpp/bindings/strong_associated_binding_set.h"
 #include "mojo/public/cpp/bindings/strong_binding_set.h"
+#include "third_party/blink/public/platform/modules/fetch/fetch_api_request.mojom.h"
 
 namespace url {
 class Origin;
@@ -69,7 +70,7 @@ class CONTENT_EXPORT CacheStorageDispatcherHost
               blink::mojom::CacheStorage::DeleteCallback callback) override;
   void Has(const base::string16& cache_name,
            blink::mojom::CacheStorage::HasCallback callback) override;
-  void Match(const content::ServiceWorkerFetchRequest& request,
+  void Match(blink::mojom::FetchAPIRequestPtr request,
              blink::mojom::QueryParamsPtr match_params,
              blink::mojom::CacheStorage::MatchCallback callback) override;
   void Open(const base::string16& cache_name,
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 3743d0d3e35..80380db74e7 100644
--- a/chromium/content/browser/cache_storage/cache_storage_histogram_utils.h
+++ b/chromium/content/browser/cache_storage/cache_storage_histogram_utils.h
@@ -6,7 +6,7 @@
 #define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_HISTOGRAM_UTILS_H_
 
 #include "base/metrics/histogram_macros.h"
-#include "content/browser/cache_storage/cache_storage_scheduler_client.h"
+#include "content/browser/cache_storage/cache_storage_scheduler_types.h"
 #include "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom.h"
 
 namespace content {
@@ -36,37 +36,112 @@ enum class ErrorStorageType {
   kDeleteImplBackendClosed = 20,
   kKeysImplBackendClosed = 21,
   kCreateBackendDidCreateFailed = 22,
-  kMaxValue = kCreateBackendDidCreateFailed,
+  kStorageGetAllMatchedEntriesBackendClosed = 23,
+  kMaxValue = kStorageGetAllMatchedEntriesBackendClosed,
 };
 
 blink::mojom::CacheStorageError MakeErrorStorage(ErrorStorageType type);
 
 // Metrics to make it easier to write histograms for several clients.
-#define CACHE_STORAGE_SCHEDULER_UMA_THUNK(uma_type, args) \
+#define CACHE_STORAGE_SCHEDULER_UMA_THUNK2(uma_type, args) \
   UMA_HISTOGRAM_##uma_type args
-#define CACHE_STORAGE_SCHEDULER_UMA(uma_type, uma_name, client_type, ...)     \
-  do {                                                                        \
-    switch (client_type) {                                                    \
-      case CacheStorageSchedulerClient::CLIENT_STORAGE:                       \
-        CACHE_STORAGE_SCHEDULER_UMA_THUNK(                                    \
-            uma_type, ("ServiceWorkerCache.CacheStorage.Scheduler." uma_name, \
-                       ##__VA_ARGS__));                                       \
-        break;                                                                \
-      case CacheStorageSchedulerClient::CLIENT_CACHE:                         \
-        CACHE_STORAGE_SCHEDULER_UMA_THUNK(                                    \
-            uma_type,                                                         \
-            ("ServiceWorkerCache.Cache.Scheduler." uma_name, ##__VA_ARGS__)); \
-        break;                                                                \
-      case CacheStorageSchedulerClient::CLIENT_BACKGROUND_SYNC:               \
-        CACHE_STORAGE_SCHEDULER_UMA_THUNK(                                    \
-            uma_type,                                                         \
-            ("ServiceWorkerCache.BackgroundSyncManager.Scheduler." uma_name,  \
-             ##__VA_ARGS__));                                                 \
-        break;                                                                \
-      default:                                                                \
-        NOTREACHED();                                                         \
-        break;                                                                \
-    }                                                                         \
+
+#define CACHE_STORAGE_SCHEDULER_UMA_THUNK(uma_type, op_type, histogram_name, \
+                                          ...)                               \
+  CACHE_STORAGE_SCHEDULER_UMA_THUNK2(uma_type,                               \
+                                     (histogram_name, ##__VA_ARGS__));       \
+  do {                                                                       \
+    switch (op_type) {                                                       \
+      case CacheStorageSchedulerOp::kBackgroundSync:                         \
+        /* do not record op-specific histograms for background sync */       \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kClose:                                  \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".Close", ##__VA_ARGS__));             \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kDelete:                                 \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".Delete", ##__VA_ARGS__));            \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kGetAllMatched:                          \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".GetAllMatched", ##__VA_ARGS__));     \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kHas:                                    \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".Has", ##__VA_ARGS__));               \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kInit:                                   \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".Init", ##__VA_ARGS__));              \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kKeys:                                   \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".Keys", ##__VA_ARGS__));              \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kMatch:                                  \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".Match", ##__VA_ARGS__));             \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kMatchAll:                               \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".MatchAll", ##__VA_ARGS__));          \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kOpen:                                   \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".Open", ##__VA_ARGS__));              \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kPut:                                    \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".Put", ##__VA_ARGS__));               \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kSize:                                   \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".Size", ##__VA_ARGS__));              \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kSizeThenClose:                          \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".SizeThenClose", ##__VA_ARGS__));     \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kTest:                                   \
+        /* do not record op-specific histograms for test ops */              \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kWriteIndex:                             \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".WriteIndex", ##__VA_ARGS__));        \
+        break;                                                               \
+      case CacheStorageSchedulerOp::kWriteSideData:                          \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK2(                                  \
+            uma_type, (histogram_name ".WriteSideData", ##__VA_ARGS__));     \
+        break;                                                               \
+    }                                                                        \
+  } while (0)
+
+#define CACHE_STORAGE_SCHEDULER_UMA(uma_type, uma_name, client_type, op_type,  \
+                                    ...)                                       \
+  /* Only the Cache and CacheStorage clients should have specific op types */  \
+  DCHECK(client_type != CacheStorageSchedulerClient::kBackgroundSync ||        \
+         op_type == CacheStorageSchedulerOp::kBackgroundSync);                 \
+  do {                                                                         \
+    switch (client_type) {                                                     \
+      case CacheStorageSchedulerClient::kStorage:                              \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK(                                     \
+            uma_type, op_type,                                                 \
+            "ServiceWorkerCache.CacheStorage.Scheduler." uma_name,             \
+            ##__VA_ARGS__);                                                    \
+        break;                                                                 \
+      case CacheStorageSchedulerClient::kCache:                                \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK(                                     \
+            uma_type, op_type, "ServiceWorkerCache.Cache.Scheduler." uma_name, \
+            ##__VA_ARGS__);                                                    \
+        break;                                                                 \
+      case CacheStorageSchedulerClient::kBackgroundSync:                       \
+        CACHE_STORAGE_SCHEDULER_UMA_THUNK(                                     \
+            uma_type, op_type,                                                 \
+            "ServiceWorkerCache.BackgroundSyncManager.Scheduler." uma_name,    \
+            ##__VA_ARGS__);                                                    \
+        break;                                                                 \
+    }                                                                          \
   } while (0)
 
 }  // namespace content
diff --git a/chromium/content/browser/cache_storage/cache_storage_manager.cc b/chromium/content/browser/cache_storage/cache_storage_manager.cc
index 2b5c01e2362..ffa1104c1d9 100644
--- a/chromium/content/browser/cache_storage/cache_storage_manager.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_manager.cc
@@ -70,7 +70,7 @@ int64_t GetCacheStorageSize(const proto::CacheStorageIndex& index) {
 // Open the various cache directories' index files and extract their origins,
 // sizes (if current), and last modified times.
 void ListOriginsAndLastModifiedOnTaskRunner(
-    std::vector<CacheStorageUsageInfo>* usages,
+    std::vector<StorageUsageInfo>* usages,
     base::FilePath root_path,
     CacheStorageOwner owner) {
   base::FileEnumerator file_enum(root_path, false /* recursive */,
@@ -96,7 +96,7 @@ void ListOriginsAndLastModifiedOnTaskRunner(
             int64_t storage_size = CacheStorage::kSizeUnknown;
             if (file_info.last_modified < index_last_modified)
               storage_size = GetCacheStorageSize(index);
-            usages->push_back(CacheStorageUsageInfo(
+            usages->push_back(StorageUsageInfo(
                 GURL(index.origin()), storage_size, file_info.last_modified));
           }
         }
@@ -107,11 +107,11 @@ void ListOriginsAndLastModifiedOnTaskRunner(
 
 std::set<url::Origin> ListOriginsOnTaskRunner(base::FilePath root_path,
                                               CacheStorageOwner owner) {
-  std::vector<CacheStorageUsageInfo> usages;
+  std::vector<StorageUsageInfo> usages;
   ListOriginsAndLastModifiedOnTaskRunner(&usages, root_path, owner);
 
   std::set<url::Origin> out_origins;
-  for (const CacheStorageUsageInfo& usage : usages)
+  for (const StorageUsageInfo& usage : usages)
     out_origins.insert(url::Origin::Create(usage.origin));
 
   return out_origins;
@@ -131,7 +131,7 @@ void GetOriginsForHostDidListOrigins(
 }
 
 void AllOriginSizesReported(
-    std::unique_ptr<std::vector<CacheStorageUsageInfo>> usages,
+    std::unique_ptr<std::vector<StorageUsageInfo>> usages,
     CacheStorageContext::GetUsageInfoCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ -140,7 +140,7 @@ void AllOriginSizesReported(
 }
 
 void OneOriginSizeReported(base::OnceClosure callback,
-                           CacheStorageUsageInfo* usage,
+                           StorageUsageInfo* usage,
                            int64_t size) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ -174,8 +174,7 @@ scoped_refptr<CacheStorageManager> CacheStorageManager::Create(
       old_manager->quota_manager_proxy_.get()));
   // These values may be NULL, in which case this will be called again later by
   // the dispatcher host per usual.
-  manager->SetBlobParametersForCache(old_manager->url_request_context_getter(),
-                                     old_manager->blob_storage_context());
+  manager->SetBlobParametersForCache(old_manager->blob_storage_context());
   return manager;
 }
 
@@ -267,14 +266,10 @@ void CacheStorageManager::WriteToCache(
 }
 
 void CacheStorageManager::SetBlobParametersForCache(
-    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(cache_storage_map_.empty());
-  DCHECK(!request_context_getter_ ||
-         request_context_getter_.get() == request_context_getter.get());
   DCHECK(!blob_context_ || blob_context_.get() == blob_storage_context.get());
-  request_context_getter_ = std::move(request_context_getter);
   blob_context_ = blob_storage_context;
 }
 
@@ -305,22 +300,21 @@ void CacheStorageManager::GetAllOriginsUsage(
     CacheStorageContext::GetUsageInfoCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  std::unique_ptr<std::vector<CacheStorageUsageInfo>> usages(
-      new std::vector<CacheStorageUsageInfo>());
+  auto usages = std::make_unique<std::vector<StorageUsageInfo>>();
 
   if (IsMemoryBacked()) {
     for (const auto& origin_details : cache_storage_map_) {
       if (origin_details.first.second != owner)
         continue;
-      usages->push_back(CacheStorageUsageInfo(
-          origin_details.first.first.GetURL(), 0 /* size */,
-          base::Time() /* last modified */));
+      usages->emplace_back(origin_details.first.first.GetURL(),
+                           /*total_size_bytes=*/0,
+                           /*last_modified=*/base::Time());
     }
     GetAllOriginsUsageGetSizes(std::move(usages), std::move(callback));
     return;
   }
 
-  std::vector<CacheStorageUsageInfo>* usages_ptr = usages.get();
+  std::vector<StorageUsageInfo>* usages_ptr = usages.get();
   cache_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::BindOnce(&ListOriginsAndLastModifiedOnTaskRunner, usages_ptr,
@@ -331,14 +325,14 @@ void CacheStorageManager::GetAllOriginsUsage(
 }
 
 void CacheStorageManager::GetAllOriginsUsageGetSizes(
-    std::unique_ptr<std::vector<CacheStorageUsageInfo>> usages,
+    std::unique_ptr<std::vector<StorageUsageInfo>> usages,
     CacheStorageContext::GetUsageInfoCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(usages);
 
   // The origin GURL and last modified times are set in |usages| but not the
   // size in bytes. Call each CacheStorage's Size() function to fill that out.
-  std::vector<CacheStorageUsageInfo>* usages_ptr = usages.get();
+  std::vector<StorageUsageInfo>* usages_ptr = usages.get();
 
   if (usages->empty()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ -351,7 +345,7 @@ void CacheStorageManager::GetAllOriginsUsageGetSizes(
       base::BindOnce(&AllOriginSizesReported, std::move(usages),
                      std::move(callback)));
 
-  for (CacheStorageUsageInfo& usage : *usages_ptr) {
+  for (StorageUsageInfo& usage : *usages_ptr) {
     if (usage.total_size_bytes != CacheStorage::kSizeUnknown) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, barrier_closure);
       continue;
@@ -501,13 +495,12 @@ CacheStorage* CacheStorageManager::FindOrCreateCacheStorage(
     const url::Origin& origin,
     CacheStorageOwner owner) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(request_context_getter_);
   CacheStorageMap::const_iterator it = cache_storage_map_.find({origin, owner});
   if (it == cache_storage_map_.end()) {
     CacheStorage* cache_storage = new CacheStorage(
         ConstructOriginPath(root_path_, origin, owner), IsMemoryBacked(),
-        cache_task_runner_.get(), request_context_getter_, quota_manager_proxy_,
-        blob_context_, this, origin, owner);
+        cache_task_runner_.get(), quota_manager_proxy_, blob_context_, this,
+        origin, owner);
     cache_storage_map_[{origin, owner}] = base::WrapUnique(cache_storage);
     return cache_storage;
   }
diff --git a/chromium/content/browser/cache_storage/cache_storage_manager.h b/chromium/content/browser/cache_storage/cache_storage_manager.h
index d08b84a5e3e..d3a7aa7327e 100644
--- a/chromium/content/browser/cache_storage/cache_storage_manager.h
+++ b/chromium/content/browser/cache_storage/cache_storage_manager.h
@@ -19,8 +19,7 @@
 #include "content/common/content_export.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cache_storage_context.h"
-#include "content/public/browser/cache_storage_usage_info.h"
-#include "net/url_request/url_request_context_getter.h"
+#include "content/public/browser/storage_usage_info.h"
 #include "storage/browser/quota/quota_client.h"
 #include "url/origin.h"
 
@@ -116,7 +115,6 @@ class CONTENT_EXPORT CacheStorageManager
   // This must be called before creating any of the public *Cache functions
   // above.
   void SetBlobParametersForCache(
-      scoped_refptr<net::URLRequestContextGetter> request_context_getter,
       base::WeakPtr<storage::BlobStorageContext> blob_storage_context);
 
   void AddObserver(CacheStorageContextImpl::Observer* observer);
@@ -159,7 +157,7 @@ class CONTENT_EXPORT CacheStorageManager
   void GetAllOriginsUsage(CacheStorageOwner owner,
                           CacheStorageContext::GetUsageInfoCallback callback);
   void GetAllOriginsUsageGetSizes(
-      std::unique_ptr<std::vector<CacheStorageUsageInfo>> usage_info,
+      std::unique_ptr<std::vector<StorageUsageInfo>> usage_info,
       CacheStorageContext::GetUsageInfoCallback callback);
 
   void GetOriginUsage(const url::Origin& origin_url,
@@ -180,11 +178,6 @@ class CONTENT_EXPORT CacheStorageManager
                             std::unique_ptr<CacheStorage> cache_storage,
                             int64_t origin_size);
 
-  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter()
-      const {
-    return request_context_getter_;
-  }
-
   base::WeakPtr<storage::BlobStorageContext> blob_storage_context() const {
     return blob_context_;
   }
@@ -206,7 +199,6 @@ class CONTENT_EXPORT CacheStorageManager
 
   base::ObserverList<CacheStorageContextImpl::Observer>::Unchecked observers_;
 
-  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   base::WeakPtr<storage::BlobStorageContext> blob_context_;
 
   base::WeakPtrFactory<CacheStorageManager> weak_ptr_factory_;
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 9c9f451e123..1171be3c2fd 100644
--- a/chromium/content/browser/cache_storage/cache_storage_manager_unittest.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_manager_unittest.cc
@@ -23,6 +23,8 @@
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/test/bind_test_util.h"
+#include "base/test/metrics/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/cache_storage/cache_storage.h"
@@ -31,9 +33,10 @@
 #include "content/browser/cache_storage/cache_storage_context_impl.h"
 #include "content/browser/cache_storage/cache_storage_index.h"
 #include "content/browser/cache_storage/cache_storage_quota_client.h"
+#include "content/common/service_worker/service_worker_type_converter.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/cache_storage_usage_info.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/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
@@ -54,6 +57,7 @@
 #include "storage/common/blob_storage/blob_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom.h"
+#include "third_party/blink/public/platform/modules/fetch/fetch_api_request.mojom.h"
 #include "url/origin.h"
 
 using blink::mojom::CacheStorageError;
@@ -272,8 +276,6 @@ class CacheStorageManagerTest : public testing::Test {
         quota_manager_proxy_);
 
     cache_manager_->SetBlobParametersForCache(
-        BrowserContext::GetDefaultStoragePartition(&browser_context_)
-            ->GetURLRequestContext(),
         blob_storage_context->context()->AsWeakPtr());
   }
 
@@ -311,9 +313,20 @@ class CacheStorageManagerTest : public testing::Test {
     cache_manager_ = nullptr;
   }
 
+  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);
+    histogram_tester.ExpectTotalCount(base + "QueueLength." + op_name, 1);
+  }
+
   bool Open(const url::Origin& origin,
             const std::string& cache_name,
             CacheStorageOwner owner = CacheStorageOwner::kCacheAPI) {
+    base::HistogramTester histogram_tester;
     base::RunLoop loop;
     cache_manager_->OpenCache(
         origin, owner, cache_name,
@@ -322,47 +335,53 @@ class CacheStorageManagerTest : public testing::Test {
     loop.Run();
 
     bool error = callback_error_ != CacheStorageError::kSuccess;
-    if (error)
+    if (error) {
       EXPECT_FALSE(callback_cache_handle_.value());
-    else
+    } else {
       EXPECT_TRUE(callback_cache_handle_.value());
+      CheckOpHistograms(histogram_tester, "Open");
+    }
     return !error;
   }
 
   bool Has(const url::Origin& origin,
            const std::string& cache_name,
            CacheStorageOwner owner = CacheStorageOwner::kCacheAPI) {
+    base::HistogramTester histogram_tester;
     base::RunLoop loop;
     cache_manager_->HasCache(
         origin, owner, cache_name,
         base::BindOnce(&CacheStorageManagerTest::BoolAndErrorCallback,
                        base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
-
+    CheckOpHistograms(histogram_tester, "Has");
     return callback_bool_;
   }
 
   bool Delete(const url::Origin& origin,
               const std::string& cache_name,
               CacheStorageOwner owner = CacheStorageOwner::kCacheAPI) {
+    base::HistogramTester histogram_tester;
     base::RunLoop loop;
     cache_manager_->DeleteCache(
         origin, owner, cache_name,
         base::BindOnce(&CacheStorageManagerTest::ErrorCallback,
                        base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
-
+    CheckOpHistograms(histogram_tester, "Delete");
     return callback_bool_;
   }
 
   size_t Keys(const url::Origin& origin,
               CacheStorageOwner owner = CacheStorageOwner::kCacheAPI) {
+    base::HistogramTester histogram_tester;
     base::RunLoop loop;
     cache_manager_->EnumerateCaches(
         origin, owner,
         base::BindOnce(&CacheStorageManagerTest::CacheMetadataCallback,
                        base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
+    CheckOpHistograms(histogram_tester, "Keys");
     return callback_cache_index_.num_entries();
   }
 
@@ -383,6 +402,7 @@ class CacheStorageManagerTest : public testing::Test {
       const ServiceWorkerFetchRequest& request,
       blink::mojom::QueryParamsPtr match_params = nullptr,
       CacheStorageOwner owner = CacheStorageOwner::kCacheAPI) {
+    base::HistogramTester histogram_tester;
     std::unique_ptr<ServiceWorkerFetchRequest> unique_request =
         std::make_unique<ServiceWorkerFetchRequest>(request);
 
@@ -393,7 +413,8 @@ class CacheStorageManagerTest : public testing::Test {
         base::BindOnce(&CacheStorageManagerTest::CacheMatchCallback,
                        base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
-
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "Match");
     return callback_error_ == CacheStorageError::kSuccess;
   }
 
@@ -410,6 +431,7 @@ class CacheStorageManagerTest : public testing::Test {
       const ServiceWorkerFetchRequest& request,
       blink::mojom::QueryParamsPtr match_params = nullptr,
       CacheStorageOwner owner = CacheStorageOwner::kCacheAPI) {
+    base::HistogramTester histogram_tester;
     std::unique_ptr<ServiceWorkerFetchRequest> unique_request =
         std::make_unique<ServiceWorkerFetchRequest>(request);
     base::RunLoop loop;
@@ -418,7 +440,8 @@ class CacheStorageManagerTest : public testing::Test {
         base::BindOnce(&CacheStorageManagerTest::CacheMatchCallback,
                        base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
-
+    if (callback_error_ == CacheStorageError::kSuccess)
+      CheckOpHistograms(histogram_tester, "MatchAll");
     return callback_error_ == CacheStorageError::kSuccess;
   }
 
@@ -491,7 +514,8 @@ class CacheStorageManagerTest : public testing::Test {
     blink::mojom::BatchOperationPtr operation =
         blink::mojom::BatchOperation::New();
     operation->operation_type = blink::mojom::OperationType::kPut;
-    operation->request = request;
+    operation->request =
+        mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(request);
     operation->response = std::move(response);
 
     std::vector<blink::mojom::BatchOperationPtr> operations;
@@ -514,7 +538,8 @@ class CacheStorageManagerTest : public testing::Test {
     blink::mojom::BatchOperationPtr operation =
         blink::mojom::BatchOperation::New();
     operation->operation_type = blink::mojom::OperationType::kDelete;
-    operation->request = request;
+    operation->request =
+        mojo::ConvertTo<blink::mojom::FetchAPIRequestPtr>(request);
     operation->response = blink::mojom::FetchAPIResponse::New();
 
     std::vector<blink::mojom::BatchOperationPtr> operations;
@@ -566,23 +591,19 @@ class CacheStorageManagerTest : public testing::Test {
     run_loop->Quit();
   }
 
-  std::vector<CacheStorageUsageInfo> GetAllOriginsUsage(
+  std::vector<StorageUsageInfo> GetAllOriginsUsage(
       CacheStorageOwner owner = CacheStorageOwner::kCacheAPI) {
     base::RunLoop loop;
     cache_manager_->GetAllOriginsUsage(
-        owner, base::Bind(&CacheStorageManagerTest::AllOriginsUsageCallback,
-                          base::Unretained(this), base::Unretained(&loop)));
+        owner, base::BindLambdaForTesting(
+                   [&](const std::vector<StorageUsageInfo>& usage) {
+                     callback_all_origins_usage_ = usage;
+                     loop.Quit();
+                   }));
     loop.Run();
     return callback_all_origins_usage_;
   }
 
-  void AllOriginsUsageCallback(
-      base::RunLoop* run_loop,
-      const std::vector<CacheStorageUsageInfo>& usage) {
-    callback_all_origins_usage_ = usage;
-    run_loop->Quit();
-  }
-
   int64_t GetSizeThenCloseAllCaches(const url::Origin& origin) {
     base::RunLoop loop;
     CacheStorage* cache_storage = CacheStorageForOrigin(origin);
@@ -650,7 +671,7 @@ class CacheStorageManagerTest : public testing::Test {
   const url::Origin origin2_;
 
   int64_t callback_usage_;
-  std::vector<CacheStorageUsageInfo> callback_all_origins_usage_;
+  std::vector<StorageUsageInfo> callback_all_origins_usage_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CacheStorageManagerTest);
@@ -1194,7 +1215,7 @@ TEST_F(CacheStorageManagerTest, QuotaCorrectAfterReopen) {
 
   // Choose a response type that will not be padded so that the expected
   // cache size can be calculated.
-  const FetchResponseType response_type = FetchResponseType::kCORS;
+  const FetchResponseType response_type = FetchResponseType::kCors;
 
   // Create a new cache.
   int64_t cache_size;
@@ -1342,7 +1363,7 @@ TEST_P(CacheStorageManagerTestP, GetAllOriginsUsage) {
   EXPECT_TRUE(
       CachePut(callback_cache_handle_.value(), GURL("http://example.com/bar")));
 
-  std::vector<CacheStorageUsageInfo> usage = GetAllOriginsUsage();
+  std::vector<StorageUsageInfo> usage = GetAllOriginsUsage();
   EXPECT_EQ(2ULL, usage.size());
 
   int origin1_index = url::Origin::Create(usage[0].origin) == origin1_ ? 0 : 1;
@@ -1380,10 +1401,10 @@ TEST_P(CacheStorageManagerTestP, GetAllOriginsUsageDifferentOwners) {
   EXPECT_TRUE(
       CachePut(callback_cache_handle_.value(), GURL("http://example.com/bar")));
 
-  std::vector<CacheStorageUsageInfo> usage_cache =
+  std::vector<StorageUsageInfo> usage_cache =
       GetAllOriginsUsage(CacheStorageOwner::kCacheAPI);
   EXPECT_EQ(1ULL, usage_cache.size());
-  std::vector<CacheStorageUsageInfo> usage_bgf =
+  std::vector<StorageUsageInfo> usage_bgf =
       GetAllOriginsUsage(CacheStorageOwner::kBackgroundFetch);
   EXPECT_EQ(2ULL, usage_bgf.size());
 
@@ -1447,7 +1468,7 @@ TEST_F(CacheStorageManagerTest, GetAllOriginsUsageWithOldIndex) {
   EXPECT_TRUE(CachePut(original_handle.value(), kBarURL));
   original_handle = CacheStorageCacheHandle();
 
-  std::vector<CacheStorageUsageInfo> usage = GetAllOriginsUsage();
+  std::vector<StorageUsageInfo> usage = GetAllOriginsUsage();
   ASSERT_EQ(1ULL, usage.size());
   int64_t usage_before_close = usage[0].total_size_bytes;
   EXPECT_GT(usage_before_close, 0);
diff --git a/chromium/content/browser/cache_storage/cache_storage_operation.cc b/chromium/content/browser/cache_storage/cache_storage_operation.cc
index 38ea200db9e..b06572034ae 100644
--- a/chromium/content/browser/cache_storage/cache_storage_operation.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_operation.cc
@@ -15,20 +15,21 @@ const int kNumSecondsForSlowOperation = 10;
 CacheStorageOperation::CacheStorageOperation(
     base::OnceClosure closure,
     CacheStorageSchedulerClient client_type,
+    CacheStorageSchedulerOp op_type,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : closure_(std::move(closure)),
       creation_ticks_(base::TimeTicks::Now()),
       client_type_(client_type),
+      op_type_(op_type),
       task_runner_(std::move(task_runner)),
       weak_ptr_factory_(this) {}
 
 CacheStorageOperation::~CacheStorageOperation() {
-  CACHE_STORAGE_SCHEDULER_UMA(TIMES, "OperationDuration", client_type_,
-                              base::TimeTicks::Now() - start_ticks_);
+  CACHE_STORAGE_SCHEDULER_UMA(LONG_TIMES, "OperationDuration2", client_type_,
+                              op_type_, base::TimeTicks::Now() - start_ticks_);
 
   if (!was_slow_)
-    CACHE_STORAGE_SCHEDULER_UMA(BOOLEAN, "IsOperationSlow", client_type_,
-                                false);
+    RecordOperationSlowness();
 }
 
 void CacheStorageOperation::Run() {
@@ -44,7 +45,13 @@ void CacheStorageOperation::Run() {
 
 void CacheStorageOperation::NotifyOperationSlow() {
   was_slow_ = true;
-  CACHE_STORAGE_SCHEDULER_UMA(BOOLEAN, "IsOperationSlow", client_type_, true);
+  RecordOperationSlowness();
+}
+
+void CacheStorageOperation::RecordOperationSlowness() {
+  // Wrap the UMA macro in a method to reduce code bloat.
+  CACHE_STORAGE_SCHEDULER_UMA(BOOLEAN, "IsOperationSlow", 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 741f5e86265..d469966ee46 100644
--- a/chromium/content/browser/cache_storage/cache_storage_operation.h
+++ b/chromium/content/browser/cache_storage/cache_storage_operation.h
@@ -11,7 +11,7 @@
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
-#include "content/browser/cache_storage/cache_storage_scheduler_client.h"
+#include "content/browser/cache_storage/cache_storage_scheduler_types.h"
 #include "content/common/content_export.h"
 
 namespace content {
@@ -23,6 +23,7 @@ class CONTENT_EXPORT CacheStorageOperation {
   CacheStorageOperation(
       base::OnceClosure closure,
       CacheStorageSchedulerClient client_type,
+      CacheStorageSchedulerOp op_type,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
   ~CacheStorageOperation();
@@ -31,12 +32,14 @@ class CONTENT_EXPORT CacheStorageOperation {
   void Run();
 
   base::TimeTicks creation_ticks() const { return creation_ticks_; }
+  CacheStorageSchedulerOp op_type() const { return op_type_; }
   base::WeakPtr<CacheStorageOperation> AsWeakPtr() {
     return weak_ptr_factory_.GetWeakPtr();
   }
 
  private:
   void NotifyOperationSlow();
+  void RecordOperationSlowness();
 
   // The operation's closure to run.
   base::OnceClosure closure_;
@@ -50,7 +53,8 @@ class CONTENT_EXPORT CacheStorageOperation {
   // If the operation took a long time to run.
   bool was_slow_ = false;
 
-  CacheStorageSchedulerClient client_type_;
+  const CacheStorageSchedulerClient client_type_;
+  const CacheStorageSchedulerOp op_type_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   base::WeakPtrFactory<CacheStorageOperation> weak_ptr_factory_;
 
diff --git a/chromium/content/browser/cache_storage/cache_storage_operation_unittest.cc b/chromium/content/browser/cache_storage/cache_storage_operation_unittest.cc
index 5f9597f21cc..b82da9be03e 100644
--- a/chromium/content/browser/cache_storage/cache_storage_operation_unittest.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_operation_unittest.cc
@@ -39,7 +39,8 @@ class CacheStorageOperationTest : public testing::Test {
       : mock_task_runner_(new base::TestMockTimeTaskRunner()) {
     operation_ = std::make_unique<CacheStorageOperation>(
         base::BindOnce(&TestTask::Run, base::Unretained(&task_)),
-        CacheStorageSchedulerClient::CLIENT_STORAGE, mock_task_runner_);
+        CacheStorageSchedulerClient::kStorage, CacheStorageSchedulerOp::kTest,
+        mock_task_runner_);
   }
 
   base::HistogramTester histogram_tester_;
diff --git a/chromium/content/browser/cache_storage/cache_storage_ref.h b/chromium/content/browser/cache_storage/cache_storage_ref.h
new file mode 100644
index 00000000000..cc4ce58eb39
--- /dev/null
+++ b/chromium/content/browser/cache_storage/cache_storage_ref.h
@@ -0,0 +1,63 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_REF_H_
+#define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_REF_H_
+
+#include "base/memory/weak_ptr.h"
+
+namespace content {
+
+// Define a templated type to track references to a parameterized target type.
+// The target type must provide AddHandleRef() methods and DropHandleRef()
+// methods that will be called when the CacheStorageRef<> object is created
+// and destroyed.
+//
+// Note, the reference being tracked by CacheStorageRef is intended to
+// represent high level references from DOM objects exposed to javascript
+// and does not correspond to typical smart pointer reference counts.
+// Internally this class uses a WeakPtr<> to the target and cache_storage
+// must manager the target life cycle through other mechanisms.
+//
+// Currently this is only used to track references to CacheStorageCache
+// target objects, but will soon be used to track references to CacheStorage
+// targets as well.
+template <typename TargetType>
+class CacheStorageRef {
+ public:
+  CacheStorageRef() = default;
+
+  explicit CacheStorageRef(base::WeakPtr<TargetType> target)
+      : target_(std::move(target)) {
+    target_->AddHandleRef();
+  }
+
+  CacheStorageRef(CacheStorageRef&& rhs) noexcept
+      : target_(std::move(rhs.target_)) {}
+
+  CacheStorageRef& operator=(CacheStorageRef&& rhs) {
+    if (target_)
+      target_->DropHandleRef();
+    target_ = std::move(rhs.target_);
+    return *this;
+  }
+
+  ~CacheStorageRef() {
+    if (target_)
+      target_->DropHandleRef();
+  }
+
+  TargetType* value() { return target_.get(); }
+
+  CacheStorageRef Clone() const { return CacheStorageRef(target_); }
+
+ private:
+  base::WeakPtr<TargetType> target_;
+
+  DISALLOW_COPY_AND_ASSIGN(CacheStorageRef);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_REF_H_
diff --git a/chromium/content/browser/cache_storage/cache_storage_scheduler.cc b/chromium/content/browser/cache_storage/cache_storage_scheduler.cc
index 28215800d27..d57466ccbdb 100644
--- a/chromium/content/browser/cache_storage/cache_storage_scheduler.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_scheduler.cc
@@ -23,12 +23,14 @@ CacheStorageScheduler::CacheStorageScheduler(
 
 CacheStorageScheduler::~CacheStorageScheduler() {}
 
-void CacheStorageScheduler::ScheduleOperation(base::OnceClosure closure) {
+void CacheStorageScheduler::ScheduleOperation(CacheStorageSchedulerOp op_type,
+                                              base::OnceClosure closure) {
   CACHE_STORAGE_SCHEDULER_UMA(COUNTS_10000, "QueueLength", client_type_,
-                              pending_operations_.size());
+                              op_type, pending_operations_.size());
 
   pending_operations_.push_back(std::make_unique<CacheStorageOperation>(
-      std::move(closure), client_type_, base::ThreadTaskRunnerHandle::Get()));
+      std::move(closure), client_type_, op_type,
+      base::ThreadTaskRunnerHandle::Get()));
   RunOperationIfIdle();
 }
 
@@ -50,7 +52,8 @@ void CacheStorageScheduler::RunOperationIfIdle() {
     pending_operations_.pop_front();
 
     CACHE_STORAGE_SCHEDULER_UMA(
-        TIMES, "QueueDuration", client_type_,
+        LONG_TIMES, "QueueDuration2", client_type_,
+        running_operation_->op_type(),
         base::TimeTicks::Now() - running_operation_->creation_ticks());
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
diff --git a/chromium/content/browser/cache_storage/cache_storage_scheduler.h b/chromium/content/browser/cache_storage/cache_storage_scheduler.h
index 85e173cbaa2..416d160cda5 100644
--- a/chromium/content/browser/cache_storage/cache_storage_scheduler.h
+++ b/chromium/content/browser/cache_storage/cache_storage_scheduler.h
@@ -12,7 +12,7 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
-#include "content/browser/cache_storage/cache_storage_scheduler_client.h"
+#include "content/browser/cache_storage/cache_storage_scheduler_types.h"
 #include "content/common/content_export.h"
 
 namespace content {
@@ -34,7 +34,8 @@ class CONTENT_EXPORT CacheStorageScheduler {
 
   // Adds the operation to the tail of the queue and starts it if the scheduler
   // is idle.
-  void ScheduleOperation(base::OnceClosure closure);
+  void ScheduleOperation(CacheStorageSchedulerOp op_type,
+                         base::OnceClosure closure);
 
   // Call this after each operation completes. It cleans up the current
   // operation and starts the next.
diff --git a/chromium/content/browser/cache_storage/cache_storage_scheduler_client.h b/chromium/content/browser/cache_storage/cache_storage_scheduler_client.h
deleted file mode 100644
index 67db7e41e48..00000000000
--- a/chromium/content/browser/cache_storage/cache_storage_scheduler_client.h
+++ /dev/null
@@ -1,18 +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.
-
-#ifndef CONTENT_BROWSER_CACHE_STORAGE_SCHEDULER_CLIENT_H_
-#define CONTENT_BROWSER_CACHE_STORAGE_SCHEDULER_CLIENT_H_
-
-namespace content {
-
-enum class CacheStorageSchedulerClient {
-  CLIENT_STORAGE = 0,
-  CLIENT_CACHE = 1,
-  CLIENT_BACKGROUND_SYNC = 2
-};
-
-}  // namespace content
-
-#endif  // CONTENT_BROWSER_CACHE_STORAGE_SCHEDULER_CLIENT_H_
diff --git a/chromium/content/browser/cache_storage/cache_storage_scheduler_types.h b/chromium/content/browser/cache_storage/cache_storage_scheduler_types.h
new file mode 100644
index 00000000000..6d562f2dfc5
--- /dev/null
+++ b/chromium/content/browser/cache_storage/cache_storage_scheduler_types.h
@@ -0,0 +1,47 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_SCHEDULER_TYPES_H_
+#define CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_SCHEDULER_TYPES_H_
+
+namespace content {
+
+// Define the types of clients that might own a scheduler.  This enum is used
+// to populate histogram names and must be kept in sync with the function
+// in cache_storage_histogram_utils.cc.  Please keep this list sorted.  It is
+// ok to renumber the enumeration since it is converted to a string and not
+// directly recorded in the histogram.
+enum class CacheStorageSchedulerClient {
+  kBackgroundSync = 0,
+  kCache = 1,
+  kStorage = 2,
+};
+
+// Define the different types of operations that can be scheduled.  This enum
+// is used to populate histogram names and must be kept in sync with the
+// function in cache_storage_histogram_utils.cc.  Please keep this list sorted.
+// It is ok to renumber the enumeration since it is converted to a string and
+// not directly recorded in the histogram.
+enum class CacheStorageSchedulerOp {
+  kBackgroundSync = 0,
+  kClose = 1,
+  kDelete = 2,
+  kGetAllMatched = 3,
+  kHas = 4,
+  kInit = 5,
+  kKeys = 6,
+  kMatch = 7,
+  kMatchAll = 8,
+  kOpen = 9,
+  kPut = 10,
+  kSize = 11,
+  kSizeThenClose = 12,
+  kTest = 13,
+  kWriteIndex = 14,
+  kWriteSideData = 15,
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_CACHE_STORAGE_CACHE_STORAGE_SCHEDULER_TYPES_H_
diff --git a/chromium/content/browser/cache_storage/cache_storage_scheduler_unittest.cc b/chromium/content/browser/cache_storage/cache_storage_scheduler_unittest.cc
index fe95587d2b5..50918cfbd07 100644
--- a/chromium/content/browser/cache_storage/cache_storage_scheduler_unittest.cc
+++ b/chromium/content/browser/cache_storage/cache_storage_scheduler_unittest.cc
@@ -32,7 +32,7 @@ class CacheStorageSchedulerTest : public testing::Test {
  protected:
   CacheStorageSchedulerTest()
       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
-        scheduler_(CacheStorageSchedulerClient::CLIENT_STORAGE),
+        scheduler_(CacheStorageSchedulerClient::kStorage),
         task1_(TestTask(&scheduler_)),
         task2_(TestTask(&scheduler_)) {}
 
@@ -44,6 +44,7 @@ class CacheStorageSchedulerTest : public testing::Test {
 
 TEST_F(CacheStorageSchedulerTest, ScheduleOne) {
   scheduler_.ScheduleOperation(
+      CacheStorageSchedulerOp::kTest,
       base::BindOnce(&TestTask::Run, base::Unretained(&task1_)));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, task1_.callback_count());
@@ -51,8 +52,10 @@ TEST_F(CacheStorageSchedulerTest, ScheduleOne) {
 
 TEST_F(CacheStorageSchedulerTest, ScheduleTwo) {
   scheduler_.ScheduleOperation(
+      CacheStorageSchedulerOp::kTest,
       base::BindOnce(&TestTask::Run, base::Unretained(&task1_)));
   scheduler_.ScheduleOperation(
+      CacheStorageSchedulerOp::kTest,
       base::BindOnce(&TestTask::Run, base::Unretained(&task2_)));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, task1_.callback_count());
@@ -67,6 +70,7 @@ TEST_F(CacheStorageSchedulerTest, ScheduleTwo) {
 
 TEST_F(CacheStorageSchedulerTest, ScheduledOperations) {
   scheduler_.ScheduleOperation(
+      CacheStorageSchedulerOp::kTest,
       base::BindOnce(&TestTask::Run, base::Unretained(&task1_)));
   EXPECT_TRUE(scheduler_.ScheduledOperations());
   base::RunLoop().RunUntilIdle();