service worker: Eagerly provide CacheStoragePtr at worker startup.

Most service workers will need CacheStoragePtr in a performance
sensitive way. We discovered there is slowness using InterfaceProvider
to get the ptr on first use after worker startup.

Bug: 854905
Change-Id: Iefcd8910d1b8b6ba1cfcc4df79c213abde0f9e3a
Reviewed-on: https://chromium-review.googlesource.com/1124130
Commit-Queue: Matt Falkenhagen <falken@chromium.org>
Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#572544}

content/browser/renderer_host/render_process_host_impl.h

@@ -218,6 +218,8 @@ class CONTENT_EXPORT RenderProcessHostImpl
 
   bool HostHasNotBeenUsed() override;
   void LockToOrigin(const GURL& lock_url) override;
+  void BindCacheStorage(blink::mojom::CacheStorageRequest request,
+                        const url::Origin& origin) override;
 
   mojom::RouteProvider* GetRemoteRouteProvider();
 
@@ -405,11 +407,6 @@ class CONTENT_EXPORT RenderProcessHostImpl
 
   bool is_initialized() const { return is_initialized_; }
 
-  // Binds Mojo request to Mojo implementation CacheStorageDispatcherHost
-  // instance, binding is sent to IO thread.
-  void BindCacheStorage(blink::mojom::CacheStorageRequest request,
-                        const url::Origin& origin);
-
   // Ensures that this process is kept alive for the specified amount of time.
   // This is used to ensure that unload handlers have a chance to execute
   // before the process shuts down.

content/browser/service_worker/embedded_worker_instance.cc

@@ -81,7 +81,8 @@ using SetupProcessCallback = base::OnceCallback<void(
     mojom::EmbeddedWorkerStartParamsPtr,
     std::unique_ptr<ServiceWorkerProcessManager::AllocatedProcessInfo>,
     std::unique_ptr<EmbeddedWorkerInstance::DevToolsProxy>,
-    std::unique_ptr<URLLoaderFactoryBundleInfo>)>;
+    std::unique_ptr<URLLoaderFactoryBundleInfo>,
+    blink::mojom::CacheStoragePtrInfo)>;
 
 // Allocates a renderer process for starting a worker and does setup like
 // registering with DevTools. Called on the UI thread. Calls |callback| on the
@@ -106,7 +107,8 @@ void SetupOnUIThread(base::WeakPtr<ServiceWorkerProcessManager> process_manager,
         base::BindOnce(std::move(callback),
                        blink::ServiceWorkerStatusCode::kErrorAbort,
                        std::move(params), std::move(process_info),
-                       std::move(devtools_proxy), std::move(factory_bundle)));
+                       std::move(devtools_proxy), std::move(factory_bundle),
+                       nullptr /* cache_storage */));
     return;
   }
 
@@ -120,7 +122,7 @@ void SetupOnUIThread(base::WeakPtr<ServiceWorkerProcessManager> process_manager,
         BrowserThread::IO, FROM_HERE,
         base::BindOnce(std::move(callback), status, std::move(params),
                        std::move(process_info), std::move(devtools_proxy),
-                       std::move(factory_bundle)));
+                       std::move(factory_bundle), nullptr /* cache_storage */));
     return;
   }
   const int process_id = process_info->process_id;
@@ -130,6 +132,17 @@ void SetupOnUIThread(base::WeakPtr<ServiceWorkerProcessManager> process_manager,
   // rph->IsInitializedAndNotDead().
   CHECK(rph);
 
+  // Create cache storage now as an optimization, so the service worker can use
+  // the Cache Storage API immediately on startup. Don't do this when
+  // byte-to-byte check will be performed on the worker (|pause_after_download|)
+  // as most of those workers will have byte-to-byte equality and abort instead
+  // of running.
+  blink::mojom::CacheStoragePtr cache_storage;
+  if (!params->pause_after_download) {
+    rph->BindCacheStorage(mojo::MakeRequest(&cache_storage),
+                          url::Origin::Create(params->script_url));
+  }
+
   // Bind |request|, which is attached to |EmbeddedWorkerInstance::client_|, to
   // the process. If the process dies, |client_|'s connection error callback
   // will be called on the IO thread.
@@ -209,7 +222,7 @@ void SetupOnUIThread(base::WeakPtr<ServiceWorkerProcessManager> process_manager,
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(std::move(callback), status, std::move(params),
                      std::move(process_info), std::move(devtools_proxy),
-                     std::move(factory_bundle)));
+                     std::move(factory_bundle), cache_storage.PassInterface()));
 }
 
 bool HasSentStartWorker(EmbeddedWorkerInstance::StartingPhase phase) {
@@ -457,7 +470,8 @@ class EmbeddedWorkerInstance::StartTask {
       std::unique_ptr<ServiceWorkerProcessManager::AllocatedProcessInfo>
           process_info,
       std::unique_ptr<EmbeddedWorkerInstance::DevToolsProxy> devtools_proxy,
-      std::unique_ptr<URLLoaderFactoryBundleInfo> factory_bundle) {
+      std::unique_ptr<URLLoaderFactoryBundleInfo> factory_bundle,
+      blink::mojom::CacheStoragePtrInfo cache_storage) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     std::unique_ptr<WorkerProcessHandle> process_handle;
@@ -513,7 +527,8 @@ class EmbeddedWorkerInstance::StartTask {
     }
 
     instance_->SendStartWorker(std::move(params),
-                               std::move(factory_for_new_scripts));
+                               std::move(factory_for_new_scripts),
+                               std::move(cache_storage));
 
     TRACE_EVENT_NESTABLE_ASYNC_BEGIN0("ServiceWorker",
                                       "INITIALIZING_ON_RENDERER", this);
@@ -684,7 +699,8 @@ void EmbeddedWorkerInstance::OnRegisteredToDevToolsManager(
 
 void EmbeddedWorkerInstance::SendStartWorker(
     mojom::EmbeddedWorkerStartParamsPtr params,
-    scoped_refptr<network::SharedURLLoaderFactory> factory) {
+    scoped_refptr<network::SharedURLLoaderFactory> factory,
+    blink::mojom::CacheStoragePtrInfo cache_storage) {
   DCHECK(context_);
   DCHECK(params->dispatcher_request.is_pending());
   DCHECK(params->controller_request.is_pending());
@@ -700,6 +716,7 @@ void EmbeddedWorkerInstance::SendStartWorker(
   inflight_start_task_->set_start_worker_sent_time(base::TimeTicks::Now());
   params->provider_info =
       std::move(provider_info_getter_).Run(process_id(), std::move(factory));
+  params->provider_info->cache_storage = std::move(cache_storage);
   client_->StartWorker(std::move(params));
   registry_->BindWorkerToProcess(process_id(), embedded_worker_id());
 

content/browser/service_worker/embedded_worker_instance.h

@@ -31,6 +31,7 @@
 #include "third_party/blink/public/common/service_worker/service_worker_status_code.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker.mojom.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker_installed_scripts_manager.mojom.h"
+#include "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom.h"
 #include "url/gurl.h"
 
 namespace content {
@@ -239,12 +240,16 @@ class CONTENT_EXPORT EmbeddedWorkerInstance
 
   // Sends the StartWorker message to the renderer.
   //
+  // |cache_storage| is an optional optimization so the service worker can
+  // use the Cache Storage API immediately upon startup.
+  //
   // S13nServiceWorker:
   // |factory| is used for loading non-installed scripts. It can internally be a
   // bundle of factories instead of just the direct network factory to support
   // non-NetworkService schemes like chrome-extension:// URLs.
   void SendStartWorker(mojom::EmbeddedWorkerStartParamsPtr params,
-                       scoped_refptr<network::SharedURLLoaderFactory> factory);
+                       scoped_refptr<network::SharedURLLoaderFactory> factory,
+                       blink::mojom::CacheStoragePtrInfo cache_storage);
 
   // Implements mojom::EmbeddedWorkerInstanceHost.
   // These functions all run on the IO thread.

content/browser/service_worker/embedded_worker_instance_unittest.cc

@@ -948,4 +948,99 @@ TEST_F(EmbeddedWorkerInstanceTest, AddMessageToConsole) {
   EXPECT_EQ(EmbeddedWorkerStatus::STOPPED, worker->status());
 }
 
+// Records whether a CacheStoragePtr was sent as part of StartWorker.
+class RecordCacheStorageHelper : public EmbeddedWorkerTestHelper {
+ public:
+  RecordCacheStorageHelper() : EmbeddedWorkerTestHelper(base::FilePath()) {}
+  ~RecordCacheStorageHelper() override {}
+
+  void OnStartWorker(
+      int embedded_worker_id,
+      int64_t service_worker_version_id,
+      const GURL& scope,
+      const GURL& script_url,
+      bool pause_after_download,
+      mojom::ServiceWorkerEventDispatcherRequest dispatcher_request,
+      mojom::ControllerServiceWorkerRequest controller_request,
+      mojom::EmbeddedWorkerInstanceHostAssociatedPtrInfo instance_host,
+      mojom::ServiceWorkerProviderInfoForStartWorkerPtr provider_info,
+      blink::mojom::ServiceWorkerInstalledScriptsInfoPtr installed_scripts_info)
+      override {
+    had_cache_storage_ = !!provider_info->cache_storage;
+    EmbeddedWorkerTestHelper::OnStartWorker(
+        embedded_worker_id, service_worker_version_id, scope, script_url,
+        pause_after_download, std::move(dispatcher_request),
+        std::move(controller_request), std::move(instance_host),
+        std::move(provider_info), std::move(installed_scripts_info));
+  }
+
+  bool had_cache_storage() const { return had_cache_storage_; }
+
+ private:
+  bool had_cache_storage_ = false;
+};
+
+// Test that the worker is given a CacheStoragePtr during startup, when
+// |pause_after_download| is false.
+TEST_F(EmbeddedWorkerInstanceTest, CacheStorageOptimization) {
+  const GURL scope("http://example.com/");
+  const GURL url("http://example.com/worker.js");
+  auto helper = std::make_unique<RecordCacheStorageHelper>();
+  auto* helper_rawptr = helper.get();
+  helper_ = std::move(helper);
+
+  RegistrationAndVersionPair pair = PrepareRegistrationAndVersion(scope, url);
+  const int64_t version_id = pair.second->version_id();
+  std::unique_ptr<EmbeddedWorkerInstance> worker =
+      embedded_worker_registry()->CreateWorker(pair.second.get());
+
+  // First, test a worker without pause after download.
+  {
+    // Start the worker.
+    blink::ServiceWorkerStatusCode status =
+        blink::ServiceWorkerStatusCode::kMax;
+    base::RunLoop run_loop;
+    mojom::EmbeddedWorkerStartParamsPtr params =
+        CreateStartParams(version_id, scope, url);
+    worker->Start(
+        std::move(params), CreateProviderInfoGetter(),
+        base::BindOnce(&SaveStatusAndCall, &status, run_loop.QuitClosure()));
+    run_loop.Run();
+    EXPECT_EQ(blink::ServiceWorkerStatusCode::kOk, status);
+
+    // Cache storage should have been sent.
+    EXPECT_TRUE(helper_rawptr->had_cache_storage());
+
+    // Stop the worker.
+    worker->Stop();
+    base::RunLoop().RunUntilIdle();
+  }
+
+  // Second, test a worker with pause after download.
+  {
+    // Start the worker until paused.
+    blink::ServiceWorkerStatusCode status =
+        blink::ServiceWorkerStatusCode::kMax;
+    mojom::EmbeddedWorkerStartParamsPtr params =
+        CreateStartParams(version_id, scope, url);
+    params->pause_after_download = true;
+    worker->Start(
+        std::move(params), CreateProviderInfoGetter(),
+        base::BindOnce(&SaveStatusAndCall, &status, base::DoNothing::Once<>()));
+    base::RunLoop().RunUntilIdle();
+
+    // Finish starting.
+    worker->ResumeAfterDownload();
+    base::RunLoop().RunUntilIdle();
+    EXPECT_EQ(blink::ServiceWorkerStatusCode::kOk, status);
+
+    // Cache storage should not have been sent.
+    EXPECT_FALSE(helper_rawptr->had_cache_storage());
+
+    // Stop the worker.
+    worker->Stop();
+    base::RunLoop().RunUntilIdle();
+  }
+}
+
 }  // namespace content

content/common/service_worker/service_worker_provider.mojom

@@ -10,6 +10,7 @@ import "services/service_manager/public/mojom/interface_provider.mojom";
 import "third_party/blink/public/mojom/service_worker/service_worker_object.mojom";
 import "third_party/blink/public/mojom/service_worker/service_worker_provider_type.mojom";
 import "third_party/blink/public/mojom/service_worker/service_worker_registration.mojom";
+import "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom";
 
 // The name of the InterfaceProviderSpec in service manifests used by the
 // frame tree to expose service-worker-specific interfaces between renderer
@@ -40,6 +41,13 @@ struct ServiceWorkerProviderInfoForStartWorker {
   // importScripts().
   associated network.mojom.URLLoaderFactory? script_loader_factory_ptr_info;
 
+  // |cache_storage| is an optional optimization so the service worker can use
+  // the Cache Storage API immediately without using InterfaceProvider. May be
+  // null for service workers created for update checks, as the optimization
+  // would be wasteful because these workers usually are aborted after the
+  // byte-to-byte update check before running.
+  blink.mojom.CacheStorage? cache_storage;
+
   service_manager.mojom.InterfaceProvider interface_provider;
 };
 

content/public/browser/render_process_host.h

@@ -23,6 +23,7 @@
 #include "ipc/ipc_sender.h"
 #include "media/media_buildflags.h"
 #include "services/network/public/mojom/url_loader_factory.mojom.h"
+#include "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom.h"
 #include "ui/gfx/native_widget_types.h"
 
 #if defined(OS_ANDROID)
@@ -435,6 +436,12 @@ class CONTENT_EXPORT RenderProcessHost : public IPC::Sender,
   // https://crbug.com/846155.
   virtual void LockToOrigin(const GURL& lock_url) = 0;
 
+  // Binds |request| to the CacheStorageDispatcherHost instance. The binding is
+  // sent to the IO thread. This is for internal use only, and is only exposed
+  // here to support MockRenderProcessHost usage in tests.
+  virtual void BindCacheStorage(blink::mojom::CacheStorageRequest request,
+                                const url::Origin& origin) = 0;
+
   // Returns the current number of active views in this process.  Excludes
   // any RenderViewHosts that are swapped out.
   size_t GetActiveViewCount();

content/public/test/mock_render_process_host.cc

@@ -424,6 +424,12 @@ void MockRenderProcessHost::LockToOrigin(const GURL& lock_url) {
     is_renderer_locked_to_site_ = true;
 }
 
+void MockRenderProcessHost::BindCacheStorage(
+    blink::mojom::CacheStorageRequest request,
+    const url::Origin& origin) {
+  cache_storage_request_ = std::move(request);
+}
+
 void MockRenderProcessHost::FilterURL(bool empty_allowed, GURL* url) {
   RenderProcessHostImpl::FilterURL(this, empty_allowed, url);
 }

content/public/test/mock_render_process_host.h

@@ -144,6 +144,8 @@ class MockRenderProcessHost : public RenderProcessHost {
 
   bool HostHasNotBeenUsed() override;
   void LockToOrigin(const GURL& lock_url) override;
+  void BindCacheStorage(blink::mojom::CacheStorageRequest request,
+                        const url::Origin& origin) override;
 
   // IPC::Sender via RenderProcessHost.
   bool Send(IPC::Message* msg) override;
@@ -212,6 +214,7 @@ class MockRenderProcessHost : public RenderProcessHost {
   service_manager::Identity child_identity_;
   bool is_renderer_locked_to_site_ = false;
   network::mojom::URLLoaderFactory* url_loader_factory_;
+  blink::mojom::CacheStorageRequest cache_storage_request_;
   base::WeakPtrFactory<MockRenderProcessHost> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MockRenderProcessHost);

content/renderer/service_worker/embedded_worker_instance_client_impl.cc

@@ -55,8 +55,10 @@ void EmbeddedWorkerInstanceClientImpl::StartWorker(
                "EmbeddedWorkerInstanceClientImpl::StartWorker");
   auto start_timing = mojom::EmbeddedWorkerStartTiming::New();
   start_timing->start_worker_received_time = base::TimeTicks::Now();
-  service_manager::mojom::InterfaceProviderPtr interface_provider(
-      std::move(params->provider_info->interface_provider));
+  blink::mojom::CacheStoragePtrInfo cache_storage =
+      std::move(params->provider_info->cache_storage);
+  service_manager::mojom::InterfaceProviderPtrInfo interface_provider =
+      std::move(params->provider_info->interface_provider);
 
   auto client = std::make_unique<ServiceWorkerContextClient>(
       params->embedded_worker_id, params->service_worker_version_id,
@@ -77,6 +79,7 @@ void EmbeddedWorkerInstanceClientImpl::StartWorker(
       "ServiceWorker.EmbeddedWorkerInstanceClient.StartWorker", metric,
       StartWorkerHistogramEnum::NUM_TYPES);
   wrapper_ = StartWorkerContext(std::move(params), std::move(client),
+                                std::move(cache_storage),
                                 std::move(interface_provider));
 }
 
@@ -133,7 +136,8 @@ std::unique_ptr<EmbeddedWorkerInstanceClientImpl::WorkerWrapper>
 EmbeddedWorkerInstanceClientImpl::StartWorkerContext(
     mojom::EmbeddedWorkerStartParamsPtr params,
     std::unique_ptr<ServiceWorkerContextClient> context_client,
-    service_manager::mojom::InterfaceProviderPtr interface_provider) {
+    blink::mojom::CacheStoragePtrInfo cache_storage,
+    service_manager::mojom::InterfaceProviderPtrInfo interface_provider) {
   std::unique_ptr<blink::WebServiceWorkerInstalledScriptsManager> manager;
   // |installed_scripts_info| is null if scripts should be served by net layer,
   // when the worker is not installed, or the worker is launched for checking
@@ -147,7 +151,7 @@ EmbeddedWorkerInstanceClientImpl::StartWorkerContext(
       std::make_unique<WorkerWrapper>(blink::WebEmbeddedWorker::Create(
           std::move(context_client), std::move(manager),
           params->content_settings_proxy.PassHandle(),
-          interface_provider.PassInterface().PassHandle()));
+          cache_storage.PassHandle(), interface_provider.PassHandle()));
 
   blink::WebEmbeddedWorkerStartData start_data;
   start_data.script_url = params->script_url;

content/renderer/service_worker/embedded_worker_instance_client_impl.h

@@ -101,7 +101,8 @@ class EmbeddedWorkerInstanceClientImpl
   std::unique_ptr<WorkerWrapper> StartWorkerContext(
       mojom::EmbeddedWorkerStartParamsPtr params,
       std::unique_ptr<ServiceWorkerContextClient> context_client,
-      service_manager::mojom::InterfaceProviderPtr interface_provider);
+      blink::mojom::CacheStoragePtrInfo cache_storage,
+      service_manager::mojom::InterfaceProviderPtrInfo interface_provider);
 
   mojo::Binding<mojom::EmbeddedWorkerInstanceClient> binding_;
 

third_party/blink/public/web/web_embedded_worker.h

@@ -57,6 +57,7 @@ class BLINK_EXPORT WebEmbeddedWorker {
       std::unique_ptr<WebServiceWorkerContextClient>,
       std::unique_ptr<WebServiceWorkerInstalledScriptsManager>,
       mojo::ScopedMessagePipeHandle content_settings_handle,
+      mojo::ScopedMessagePipeHandle cache_storage,
       mojo::ScopedMessagePipeHandle interface_provider);
 
   virtual ~WebEmbeddedWorker() = default;

third_party/blink/renderer/modules/cache_storage/cache_storage.cc

@@ -17,6 +17,7 @@
 #include "third_party/blink/renderer/core/fetch/response.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
 #include "third_party/blink/renderer/modules/cache_storage/cache_storage_error.h"
+#include "third_party/blink/renderer/modules/serviceworkers/service_worker_global_scope.h"
 #include "third_party/blink/renderer/platform/bindings/script_state.h"
 #include "third_party/blink/renderer/platform/network/http_names.h"
 
@@ -210,6 +211,18 @@ ScriptPromise CacheStorage::MatchImpl(ScriptState* script_state,
 CacheStorage::CacheStorage(ExecutionContext* context,
                            GlobalFetch::ScopedFetcher* fetcher)
     : scoped_fetcher_(fetcher) {
+  // Service workers may already have a CacheStoragePtr provided as an
+  // optimization.
+  if (context->IsServiceWorkerGlobalScope()) {
+    auto* service_worker = ToServiceWorkerGlobalScope(context);
+    mojom::blink::CacheStoragePtrInfo info = service_worker->TakeCacheStorage();
+    if (info) {
+      cache_storage_ptr_ = RevocableInterfacePtr<mojom::blink::CacheStorage>(
+          std::move(info), context->GetInterfaceInvalidator());
+      return;
+    }
+  }
+
   context->GetInterfaceProvider()->GetInterface(
       MakeRequest(&cache_storage_ptr_, context->GetInterfaceInvalidator()));
 }

third_party/blink/renderer/modules/exported/web_embedded_worker_impl.cc

@@ -77,13 +77,17 @@ std::unique_ptr<WebEmbeddedWorker> WebEmbeddedWorker::Create(
     std::unique_ptr<WebServiceWorkerInstalledScriptsManager>
         installed_scripts_manager,
     mojo::ScopedMessagePipeHandle content_settings_handle,
+    mojo::ScopedMessagePipeHandle cache_storage,
     mojo::ScopedMessagePipeHandle interface_provider) {
   return std::make_unique<WebEmbeddedWorkerImpl>(
       std::move(client), std::move(installed_scripts_manager),
       std::make_unique<ServiceWorkerContentSettingsProxy>(
           // Chrome doesn't use interface versioning.
+          // TODO(falken): Is that comment about versioning correct?
           mojom::blink::WorkerContentSettingsProxyPtrInfo(
               std::move(content_settings_handle), 0u)),
+      mojom::blink::CacheStoragePtrInfo(std::move(cache_storage),
+                                        mojom::blink::CacheStorage::Version_),
       service_manager::mojom::blink::InterfaceProviderPtrInfo(
           std::move(interface_provider),
           service_manager::mojom::blink::InterfaceProvider::Version_));
@@ -94,6 +98,7 @@ WebEmbeddedWorkerImpl::WebEmbeddedWorkerImpl(
     std::unique_ptr<WebServiceWorkerInstalledScriptsManager>
         installed_scripts_manager,
     std::unique_ptr<ServiceWorkerContentSettingsProxy> content_settings_client,
+    mojom::blink::CacheStoragePtrInfo cache_storage_info,
     service_manager::mojom::blink::InterfaceProviderPtrInfo
         interface_provider_info)
     : worker_context_client_(std::move(client)),
@@ -101,6 +106,7 @@ WebEmbeddedWorkerImpl::WebEmbeddedWorkerImpl(
       worker_inspector_proxy_(WorkerInspectorProxy::Create()),
       pause_after_download_state_(kDontPauseAfterDownload),
       waiting_for_debugger_state_(kNotWaitingForDebugger),
+      cache_storage_info_(std::move(cache_storage_info)),
       interface_provider_info_(std::move(interface_provider_info)) {
   if (installed_scripts_manager) {
     installed_scripts_manager_ =
@@ -408,7 +414,7 @@ void WebEmbeddedWorkerImpl::StartWorkerThread() {
   worker_thread_ = std::make_unique<ServiceWorkerThread>(
       ThreadableLoadingContext::Create(*document),
       ServiceWorkerGlobalScopeProxy::Create(*this, *worker_context_client_),
-      std::move(installed_scripts_manager_));
+      std::move(installed_scripts_manager_), std::move(cache_storage_info_));
 
   // We have a dummy document here for loading but it doesn't really represent
   // the document/frame of associated document(s) for this worker. Here we

third_party/blink/renderer/modules/exported/web_embedded_worker_impl.h

@@ -34,6 +34,7 @@
 #include <memory>
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "services/service_manager/public/mojom/interface_provider.mojom-blink.h"
+#include "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom-blink.h"
 #include "third_party/blink/public/web/web_embedded_worker.h"
 #include "third_party/blink/public/web/web_embedded_worker_start_data.h"
 #include "third_party/blink/renderer/core/exported/worker_shadow_page.h"
@@ -61,6 +62,7 @@ class MODULES_EXPORT WebEmbeddedWorkerImpl final
       std::unique_ptr<WebServiceWorkerContextClient>,
       std::unique_ptr<WebServiceWorkerInstalledScriptsManager>,
       std::unique_ptr<ServiceWorkerContentSettingsProxy>,
+      mojom::blink::CacheStoragePtrInfo,
       service_manager::mojom::blink::InterfaceProviderPtrInfo);
   ~WebEmbeddedWorkerImpl() override;
 
@@ -129,6 +131,8 @@ class MODULES_EXPORT WebEmbeddedWorkerImpl final
   // to the same worker.
   base::UnguessableToken devtools_worker_token_;
 
+  mojom::blink::CacheStoragePtrInfo cache_storage_info_;
+
   service_manager::mojom::blink::InterfaceProviderPtrInfo
       interface_provider_info_;
 };

third_party/blink/renderer/modules/serviceworkers/service_worker_global_scope.cc

@@ -75,6 +75,7 @@ namespace blink {
 ServiceWorkerGlobalScope* ServiceWorkerGlobalScope::Create(
     ServiceWorkerThread* thread,
     std::unique_ptr<GlobalScopeCreationParams> creation_params,
+    mojom::blink::CacheStoragePtrInfo cache_storage_info,
     base::TimeTicks time_origin) {
   // If the script is being loaded via script streaming, the script is not yet
   // loaded.
@@ -88,14 +89,17 @@ ServiceWorkerGlobalScope* ServiceWorkerGlobalScope::Create(
     DCHECK(creation_params->origin_trial_tokens->IsEmpty());
   }
   return new ServiceWorkerGlobalScope(std::move(creation_params), thread,
+                                      std::move(cache_storage_info),
                                       time_origin);
 }
 
 ServiceWorkerGlobalScope::ServiceWorkerGlobalScope(
     std::unique_ptr<GlobalScopeCreationParams> creation_params,
     ServiceWorkerThread* thread,
+    mojom::blink::CacheStoragePtrInfo cache_storage_info,
     base::TimeTicks time_origin)
-    : WorkerGlobalScope(std::move(creation_params), thread, time_origin) {}
+    : WorkerGlobalScope(std::move(creation_params), thread, time_origin),
+      cache_storage_info_(std::move(cache_storage_info)) {}
 
 ServiceWorkerGlobalScope::~ServiceWorkerGlobalScope() = default;
 
@@ -388,4 +392,8 @@ void ServiceWorkerGlobalScope::SetIsInstalling(bool is_installing) {
   }
 }
 
+mojom::blink::CacheStoragePtrInfo ServiceWorkerGlobalScope::TakeCacheStorage() {
+  return std::move(cache_storage_info_);
+}
+
 }  // namespace blink

third_party/blink/renderer/modules/serviceworkers/service_worker_global_scope.h

@@ -31,6 +31,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_SERVICEWORKERS_SERVICE_WORKER_GLOBAL_SCOPE_H_
 
 #include <memory>
+#include "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom-blink.h"
 #include "third_party/blink/public/platform/modules/serviceworker/web_service_worker_registration.h"
 #include "third_party/blink/renderer/bindings/core/v8/request_or_usv_string.h"
 #include "third_party/blink/renderer/core/workers/worker_global_scope.h"
@@ -60,6 +61,7 @@ class MODULES_EXPORT ServiceWorkerGlobalScope final : public WorkerGlobalScope {
   static ServiceWorkerGlobalScope* Create(
       ServiceWorkerThread*,
       std::unique_ptr<GlobalScopeCreationParams>,
+      mojom::blink::CacheStoragePtrInfo,
       base::TimeTicks time_origin);
 
   ~ServiceWorkerGlobalScope() override;
@@ -117,6 +119,8 @@ class MODULES_EXPORT ServiceWorkerGlobalScope final : public WorkerGlobalScope {
   void CountCacheStorageInstalledScript(uint64_t script_size,
                                         uint64_t script_metadata_size);
 
+  mojom::blink::CacheStoragePtrInfo TakeCacheStorage();
+
   DEFINE_ATTRIBUTE_EVENT_LISTENER(install);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(activate);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(fetch);
@@ -134,6 +138,7 @@ class MODULES_EXPORT ServiceWorkerGlobalScope final : public WorkerGlobalScope {
  private:
   ServiceWorkerGlobalScope(std::unique_ptr<GlobalScopeCreationParams>,
                            ServiceWorkerThread*,
+                           mojom::blink::CacheStoragePtrInfo,
                            base::TimeTicks time_origin);
   void importScripts(const Vector<String>& urls, ExceptionState&) override;
   SingleCachedMetadataHandler* CreateWorkerScriptCachedMetadataHandler(
@@ -158,6 +163,11 @@ class MODULES_EXPORT ServiceWorkerGlobalScope final : public WorkerGlobalScope {
 
   bool evaluate_script_ready_ = false;
   base::OnceClosure evaluate_script_;
+
+  // May be provided in the constructor as an optimization so InterfaceProvider
+  // doesn't need to be used. Taken at the initial call to
+  // ServiceWorkerGlobalScope#caches.
+  mojom::blink::CacheStoragePtrInfo cache_storage_info_;
 };
 
 DEFINE_TYPE_CASTS(ServiceWorkerGlobalScope,

third_party/blink/renderer/modules/serviceworkers/service_worker_thread.cc

@@ -44,12 +44,14 @@ ServiceWorkerThread::ServiceWorkerThread(
     ThreadableLoadingContext* loading_context,
     ServiceWorkerGlobalScopeProxy* global_scope_proxy,
     std::unique_ptr<ServiceWorkerInstalledScriptsManager>
-        installed_scripts_manager)
+        installed_scripts_manager,
+    mojom::blink::CacheStoragePtrInfo cache_storage_info)
     : WorkerThread(loading_context, *global_scope_proxy),
       global_scope_proxy_(global_scope_proxy),
       worker_backing_thread_(WorkerBackingThread::Create(
           WebThreadCreationParams(GetThreadType()))),
-      installed_scripts_manager_(std::move(installed_scripts_manager)) {}
+      installed_scripts_manager_(std::move(installed_scripts_manager)),
+      cache_storage_info_(std::move(cache_storage_info)) {}
 
 ServiceWorkerThread::~ServiceWorkerThread() {
   global_scope_proxy_->Detach();
@@ -71,6 +73,7 @@ void ServiceWorkerThread::TerminateForTesting() {
 WorkerOrWorkletGlobalScope* ServiceWorkerThread::CreateWorkerGlobalScope(
     std::unique_ptr<GlobalScopeCreationParams> creation_params) {
   return ServiceWorkerGlobalScope::Create(this, std::move(creation_params),
+                                          std::move(cache_storage_info_),
                                           time_origin_);
 }
 

third_party/blink/renderer/modules/serviceworkers/service_worker_thread.h

@@ -31,6 +31,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_MODULES_SERVICEWORKERS_SERVICE_WORKER_THREAD_H_
 
 #include <memory>
+#include "third_party/blink/public/platform/modules/cache_storage/cache_storage.mojom-blink.h"
 #include "third_party/blink/renderer/core/frame/csp/content_security_policy.h"
 #include "third_party/blink/renderer/core/workers/worker_thread.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
@@ -49,7 +50,8 @@ class MODULES_EXPORT ServiceWorkerThread final : public WorkerThread {
   // Persistent.
   ServiceWorkerThread(ThreadableLoadingContext*,
                       ServiceWorkerGlobalScopeProxy*,
-                      std::unique_ptr<ServiceWorkerInstalledScriptsManager>);
+                      std::unique_ptr<ServiceWorkerInstalledScriptsManager>,
+                      mojom::blink::CacheStoragePtrInfo cache_storage_info);
   ~ServiceWorkerThread() override;
 
   WorkerBackingThread& GetWorkerBackingThread() override {
@@ -71,6 +73,7 @@ class MODULES_EXPORT ServiceWorkerThread final : public WorkerThread {
   std::unique_ptr<WorkerBackingThread> worker_backing_thread_;
   std::unique_ptr<ServiceWorkerInstalledScriptsManager>
       installed_scripts_manager_;
+  mojom::blink::CacheStoragePtrInfo cache_storage_info_;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/serviceworkers/web_embedded_worker_impl_test.cc

@@ -126,7 +126,8 @@ class WebEmbeddedWorkerImplTest : public testing::Test {
     mock_installed_scripts_manager_ = installed_scripts_manager.get();
     worker_ = WebEmbeddedWorker::Create(
         std::move(client), std::move(installed_scripts_manager),
-        mojo::ScopedMessagePipeHandle(), mojo::ScopedMessagePipeHandle());
+        mojo::ScopedMessagePipeHandle(), mojo::ScopedMessagePipeHandle(),
+        mojo::ScopedMessagePipeHandle());
 
     WebURL script_url = URLTestHelpers::ToKURL("https://www.example.com/sw.js");
     WebURLResponse response;