PlzWorker: Use ServiceWorkerNavigationHandle.

This aligns PlzWorker to be more like PlzNavigate for service worker
related objects. This will allow moving service worker to the UI
thread by allowing PlzWorker to use
ServiceWorkerNavigationLoaderInterceptor like navigations do.

Previously, navigations stored ServiceWorkerProviderHost info in
ServiceWorkerNavigationHandle, while PlzWorker did it itself:
WorkerScriptFetchInitiator::CreateScriptLoaderOnIO created
the provider host and passed the host to WorkerScriptLoaderFactory,
and eventually WorkerScriptLoader::CommitCompleted called
host->CompleteWebWorkerPreparation. The host's info was passed to
WorkerScriptFetchInitiator::Start's callback, so the caller could
pass it to the worker in the renderer.

Now, DedicatedWorkerHost or SharedWorkerHost hold the handle and
take the info from it to pass to the renderer on commit.
WorkerScriptLoader::CommitCompleted gets a pointer to the handle
and calls CompleteWebWorkerPreparation on its host.

Refactoring-only. As a result of the refactoring, we no longer
make a ServiceWorkerProviderHost for workers whose URL is not a
service worker supported scheme (essentially https or
chrome-extension). Previously we would make the host but it
wouldn't be used because it would have a blank URL as UpdateUrls()
was never called on it by the interceptor.

Bug: 985259
Change-Id: I999c69f0cb3bc6f37ef854c96322b0774ec84a47
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1712510Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Commit-Queue: Matt Falkenhagen <falken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#680036}

content/browser/service_worker/service_worker_context_wrapper.cc

@@ -1118,19 +1118,6 @@ void ServiceWorkerContextWrapper::RemoveObserver(
   core_observer_list_->RemoveObserver(observer);
 }
 
-base::WeakPtr<ServiceWorkerProviderHost>
-ServiceWorkerContextWrapper::PreCreateHostForWorker(
-    int process_id,
-    blink::mojom::ServiceWorkerProviderType provider_type,
-    blink::mojom::ServiceWorkerProviderInfoForClientPtr* out_provider_info) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  if (!context_core_)
-    return nullptr;
-  return ServiceWorkerProviderHost::PreCreateForWebWorker(
-      context_core_->AsWeakPtr(), process_id, provider_type, out_provider_info);
-}
-
 ServiceWorkerContextWrapper::~ServiceWorkerContextWrapper() {
   for (auto& observer : observer_list_)
     observer.OnDestruct(static_cast<ServiceWorkerContext*>(this));

content/browser/service_worker/service_worker_context_wrapper.h

@@ -296,20 +296,6 @@ class CONTENT_EXPORT ServiceWorkerContextWrapper
 
   bool is_incognito() const { return is_incognito_; }
 
-  // Used for starting a web worker (dedicated worker or shared worker). Returns
-  // a provider host for the worker and fills |out_provider_info| with info to
-  // send to the renderer to connect to the host. The host stays alive as long
-  // as this info stays alive (namely, as long as
-  // |out_provider_info->host_ptr_info| stays alive).
-  //
-  // Returns null if context() is null.
-  //
-  // Must be called on the IO thread.
-  base::WeakPtr<ServiceWorkerProviderHost> PreCreateHostForWorker(
-      int process_id,
-      blink::mojom::ServiceWorkerProviderType provider_type,
-      blink::mojom::ServiceWorkerProviderInfoForClientPtr* out_provider_info);
-
   // The core context is only for use on the IO thread.
   // Can be null before/during init, during/after shutdown, and after
   // DeleteAndStartOver fails.

content/browser/service_worker/service_worker_navigation_handle.h

@@ -7,6 +7,7 @@
 
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
+#include "content/common/content_export.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker_provider.mojom.h"
 
 namespace content {
@@ -15,8 +16,9 @@ class ServiceWorkerContextWrapper;
 class ServiceWorkerNavigationHandleCore;
 
 // This class is used to manage the lifetime of ServiceWorkerProviderHosts
-// created during navigation. This is a UI thread class, with a pendant class
-// on the IO thread, the ServiceWorkerNavigationHandleCore.
+// created for main resource requests (navigations and web workers). This is a
+// UI thread class, with a pendant class on the IO thread, the
+// ServiceWorkerNavigationHandleCore.
 //
 // The lifetime of the ServiceWorkerNavigationHandle, the
 // ServiceWorkerNavigationHandleCore and the ServiceWorkerProviderHost are the
@@ -45,7 +47,9 @@ class ServiceWorkerNavigationHandleCore;
 //   the provider info which in turn leads to the destruction of an unclaimed
 //   ServiceWorkerProviderHost, and posts a task to destroy the
 //   ServiceWorkerNavigationHandleCore on the IO thread.
-class ServiceWorkerNavigationHandle {
+//
+// TODO(falken): Rename ServiceWorkerMainResourceHandle.
+class CONTENT_EXPORT ServiceWorkerNavigationHandle {
  public:
   explicit ServiceWorkerNavigationHandle(
       ServiceWorkerContextWrapper* context_wrapper);
@@ -67,6 +71,10 @@ class ServiceWorkerNavigationHandle {
       int render_frame_id,
       blink::mojom::ServiceWorkerProviderInfoForClientPtr* out_provider_info);
 
+  blink::mojom::ServiceWorkerProviderInfoForClientPtr TakeProviderInfo() {
+    return std::move(provider_info_);
+  }
+
   ServiceWorkerNavigationHandleCore* core() const { return core_; }
 
   const ServiceWorkerContextWrapper* context_wrapper() const {
@@ -75,6 +83,7 @@ class ServiceWorkerNavigationHandle {
 
  private:
   blink::mojom::ServiceWorkerProviderInfoForClientPtr provider_info_;
+
   // TODO(leonhsl): Use std::unique_ptr<ServiceWorkerNavigationHandleCore,
   // BrowserThread::DeleteOnIOThread> instead.
   ServiceWorkerNavigationHandleCore* core_;

content/browser/service_worker/service_worker_navigation_handle_core.cc

@@ -51,4 +51,10 @@ void ServiceWorkerNavigationHandleCore::OnBeginNavigationCommit(
     provider_host_->OnBeginNavigationCommit(render_process_id, render_frame_id);
 }
 
+void ServiceWorkerNavigationHandleCore::OnBeginWorkerCommit() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (provider_host_)
+    provider_host_->CompleteWebWorkerPreparation();
+}
+
 }  // namespace content

content/browser/service_worker/service_worker_navigation_handle_core.h

@@ -32,7 +32,7 @@ class CONTENT_EXPORT ServiceWorkerNavigationHandleCore {
       ServiceWorkerContextWrapper* context_wrapper);
   ~ServiceWorkerNavigationHandleCore();
 
-  // Called when a ServiceWorkerProviderHost was created for the navigation.
+  // Called when a ServiceWorkerProviderHost was created.
   void OnCreatedProviderHost(
       base::WeakPtr<ServiceWorkerProviderHost> provider_host,
       blink::mojom::ServiceWorkerProviderInfoForClientPtr provider_info);
@@ -41,6 +41,8 @@ class CONTENT_EXPORT ServiceWorkerNavigationHandleCore {
   // pre-created provider host.
   void OnBeginNavigationCommit(int render_process_id, int render_frame_id);
 
+  void OnBeginWorkerCommit();
+
   ServiceWorkerContextWrapper* context_wrapper() const {
     return context_wrapper_.get();
   }
@@ -65,6 +67,11 @@ class CONTENT_EXPORT ServiceWorkerNavigationHandleCore {
   ServiceWorkerControlleeRequestHandler* interceptor() {
     return interceptor_.get();
   }
+
+  base::WeakPtr<ServiceWorkerNavigationHandleCore> AsWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+
   /////////////////////////////////////////////////////////////////////////////
 
  private:
@@ -75,6 +82,8 @@ class CONTENT_EXPORT ServiceWorkerNavigationHandleCore {
   // NavigationLoaderOnUI:
   std::unique_ptr<ServiceWorkerControlleeRequestHandler> interceptor_;
 
+  base::WeakPtrFactory<ServiceWorkerNavigationHandleCore> weak_factory_{this};
+
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerNavigationHandleCore);
 };
 

content/browser/service_worker/service_worker_request_handler.cc

@@ -98,15 +98,11 @@ ServiceWorkerRequestHandler::CreateForNavigationIO(
 
 // static
 std::unique_ptr<NavigationLoaderInterceptor>
-ServiceWorkerRequestHandler::CreateForWorker(
+ServiceWorkerRequestHandler::CreateForWorkerIO(
     const network::ResourceRequest& resource_request,
-    ServiceWorkerProviderHost* host) {
-  DCHECK(host);
-  DCHECK(resource_request.resource_type ==
-             static_cast<int>(ResourceType::kWorker) ||
-         resource_request.resource_type ==
-             static_cast<int>(ResourceType::kSharedWorker))
-      << resource_request.resource_type;
+    int process_id,
+    ServiceWorkerNavigationHandleCore* navigation_handle_core) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Create the handler even for insecure HTTP since it's used in the
   // case of redirect to HTTPS.
@@ -115,9 +111,38 @@ ServiceWorkerRequestHandler::CreateForWorker(
     return nullptr;
   }
 
+  auto provider_info = blink::mojom::ServiceWorkerProviderInfoForClient::New();
+  if (!navigation_handle_core->context_wrapper())
+    return nullptr;
+  ServiceWorkerContextCore* context =
+      navigation_handle_core->context_wrapper()->context();
+  if (!context)
+    return nullptr;
+
+  auto resource_type =
+      static_cast<ResourceType>(resource_request.resource_type);
+  auto provider_type = blink::mojom::ServiceWorkerProviderType::kUnknown;
+  switch (resource_type) {
+    case ResourceType::kWorker:
+      provider_type =
+          blink::mojom::ServiceWorkerProviderType::kForDedicatedWorker;
+      break;
+    case ResourceType::kSharedWorker:
+      provider_type = blink::mojom::ServiceWorkerProviderType::kForSharedWorker;
+      break;
+    default:
+      NOTREACHED() << resource_request.resource_type;
+      return nullptr;
+  }
+
+  // Initialize the SWProviderHost.
+  base::WeakPtr<ServiceWorkerProviderHost> host =
+      ServiceWorkerProviderHost::PreCreateForWebWorker(
+          context->AsWeakPtr(), process_id, provider_type, &provider_info);
+  navigation_handle_core->OnCreatedProviderHost(host, std::move(provider_info));
+
   return std::make_unique<ServiceWorkerControlleeRequestHandler>(
-      host->context(), host->AsWeakPtr(),
-      static_cast<ResourceType>(resource_request.resource_type),
+      context->AsWeakPtr(), host, resource_type,
       resource_request.skip_service_worker);
 }
 

content/browser/service_worker/service_worker_request_handler.h

@@ -48,9 +48,10 @@ class CONTENT_EXPORT ServiceWorkerRequestHandler {
 
   // Same as above but for a dedicated worker or shared worker. Called on the IO
   // thread.
-  static std::unique_ptr<NavigationLoaderInterceptor> CreateForWorker(
+  static std::unique_ptr<NavigationLoaderInterceptor> CreateForWorkerIO(
       const network::ResourceRequest& resource_request,
-      ServiceWorkerProviderHost* host);
+      int process_id,
+      ServiceWorkerNavigationHandleCore* navigation_handle_core);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRequestHandler);

content/browser/worker_host/dedicated_worker_host.cc

@@ -15,6 +15,7 @@
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/interface_provider_filtering.h"
 #include "content/browser/renderer_interface_binders.h"
+#include "content/browser/service_worker/service_worker_navigation_handle.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/browser/websockets/websocket_connector_impl.h"
 #include "content/browser/worker_host/worker_script_fetch_initiator.h"
@@ -108,13 +109,16 @@ class DedicatedWorkerHost : public service_manager::mojom::InterfaceProvider {
     appcache_handle_ = std::make_unique<AppCacheNavigationHandle>(
         storage_partition_impl->GetAppCacheService(), worker_process_id_);
 
+    service_worker_handle_ = std::make_unique<ServiceWorkerNavigationHandle>(
+        storage_partition_impl->GetServiceWorkerContext());
+
     WorkerScriptFetchInitiator::Start(
         worker_process_id_, script_url, request_initiator_origin,
         credentials_mode, std::move(outside_fetch_client_settings_object),
         ResourceType::kWorker,
         storage_partition_impl->GetServiceWorkerContext(),
-        appcache_handle_->core(), std::move(blob_url_loader_factory), nullptr,
-        storage_partition_impl,
+        service_worker_handle_.get(), appcache_handle_->core(),
+        std::move(blob_url_loader_factory), nullptr, storage_partition_impl,
         base::BindOnce(&DedicatedWorkerHost::DidStartScriptLoad,
                        weak_factory_.GetWeakPtr()));
   }
@@ -136,10 +140,6 @@ class DedicatedWorkerHost : public service_manager::mojom::InterfaceProvider {
   // Called from WorkerScriptFetchInitiator. Continues starting the dedicated
   // worker in the renderer process.
   //
-  // |service_worker_provider_info| is sent to the renderer process and contains
-  // information about its ServiceWorkerProviderHost, the browser-side host for
-  // supporting the dedicated worker as a service worker client.
-  //
   // |main_script_load_params| is sent to the renderer process and to be used to
   // load the dedicated worker main script pre-requested by the browser process.
   //
@@ -153,8 +153,6 @@ class DedicatedWorkerHost : public service_manager::mojom::InterfaceProvider {
   // a ServiceWorker object about the controller is prepared, it is registered
   // to |controller_service_worker_object_host|.
   void DidStartScriptLoad(
-      blink::mojom::ServiceWorkerProviderInfoForClientPtr
-          service_worker_provider_info,
       std::unique_ptr<blink::URLLoaderFactoryBundleInfo>
           subresource_loader_factories,
       blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,
@@ -197,7 +195,7 @@ class DedicatedWorkerHost : public service_manager::mojom::InterfaceProvider {
       service_worker_state = controller->object_info->state;
     }
 
-    client_->OnScriptLoadStarted(std::move(service_worker_provider_info),
+    client_->OnScriptLoadStarted(service_worker_handle_->TakeProviderInfo(),
                                  std::move(main_script_load_params),
                                  std::move(subresource_loader_factories),
                                  std::move(controller));
@@ -314,6 +312,7 @@ class DedicatedWorkerHost : public service_manager::mojom::InterfaceProvider {
   blink::mojom::DedicatedWorkerHostFactoryClientPtr client_;
 
   std::unique_ptr<AppCacheNavigationHandle> appcache_handle_;
+  std::unique_ptr<ServiceWorkerNavigationHandle> service_worker_handle_;
 
   service_manager::BinderRegistry registry_;
 

content/browser/worker_host/shared_worker_host.cc

@@ -16,6 +16,7 @@
 #include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/interface_provider_filtering.h"
 #include "content/browser/renderer_interface_binders.h"
+#include "content/browser/service_worker/service_worker_navigation_handle.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/browser/worker_host/shared_worker_content_settings_proxy_impl.h"
 #include "content/browser/worker_host/shared_worker_instance.h"
@@ -166,8 +167,6 @@ void SharedWorkerHost::SetNetworkFactoryForTesting(
 
 void SharedWorkerHost::Start(
     blink::mojom::SharedWorkerFactoryPtr factory,
-    blink::mojom::ServiceWorkerProviderInfoForClientPtr
-        service_worker_provider_info,
     blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,
     std::unique_ptr<blink::URLLoaderFactoryBundleInfo>
         subresource_loader_factories,
@@ -175,7 +174,6 @@ void SharedWorkerHost::Start(
     base::WeakPtr<ServiceWorkerObjectHost>
         controller_service_worker_object_host) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(service_worker_provider_info);
   DCHECK(main_script_load_params);
   DCHECK(subresource_loader_factories);
   DCHECK(!subresource_loader_factories->pending_default_factory());
@@ -246,7 +244,7 @@ void SharedWorkerHost::Start(
   factory_->CreateSharedWorker(
       std::move(info), pause_on_start, devtools_worker_token,
       std::move(renderer_preferences), std::move(preference_watcher_request),
-      std::move(content_settings), std::move(service_worker_provider_info),
+      std::move(content_settings), service_worker_handle_->TakeProviderInfo(),
       appcache_handle_
           ? base::make_optional(appcache_handle_->appcache_host_id())
           : base::nullopt,
@@ -520,6 +518,12 @@ void SharedWorkerHost::SetAppCacheHandle(
   appcache_handle_ = std::move(appcache_handle);
 }
 
+void SharedWorkerHost::SetServiceWorkerHandle(
+    std::unique_ptr<ServiceWorkerNavigationHandle> service_worker_handle) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  service_worker_handle_ = std::move(service_worker_handle);
+}
+
 void SharedWorkerHost::OnClientConnectionLost() {
   // We'll get a notification for each dropped connection.
   for (auto it = clients_.begin(); it != clients_.end(); ++it) {

content/browser/worker_host/shared_worker_host.h

@@ -38,6 +38,7 @@ class URLLoaderFactoryBundleInfo;
 namespace content {
 
 class AppCacheNavigationHandle;
+class ServiceWorkerNavigationHandle;
 class ServiceWorkerObjectHost;
 class SharedWorkerContentSettingsProxyImpl;
 class SharedWorkerInstance;
@@ -69,10 +70,6 @@ class CONTENT_EXPORT SharedWorkerHost
 
   // Starts the SharedWorker in the renderer process.
   //
-  // |service_worker_provider_info| is sent to the renderer process and contains
-  // information about its ServiceWorkerProviderHost, the browser-side host for
-  // supporting the shared worker as a service worker client.
-  //
   // |main_script_load_params| is sent to the renderer process and to be used to
   // load the shared worker main script pre-requested by the browser process.
   //
@@ -86,8 +83,6 @@ class CONTENT_EXPORT SharedWorkerHost
   // to |controller_service_worker_object_host|.
   void Start(
       blink::mojom::SharedWorkerFactoryPtr factory,
-      blink::mojom::ServiceWorkerProviderInfoForClientPtr
-          service_worker_provider_info,
       blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,
       std::unique_ptr<blink::URLLoaderFactoryBundleInfo>
           subresource_loader_factories,
@@ -114,6 +109,8 @@ class CONTENT_EXPORT SharedWorkerHost
 
   void SetAppCacheHandle(
       std::unique_ptr<AppCacheNavigationHandle> appcache_handle);
+  void SetServiceWorkerHandle(
+      std::unique_ptr<ServiceWorkerNavigationHandle> service_worker_handle);
 
   SharedWorkerInstance* instance() { return instance_.get(); }
   int worker_process_id() const { return worker_process_id_; }
@@ -204,6 +201,8 @@ class CONTENT_EXPORT SharedWorkerHost
   // renderer after main script loading finishes.
   std::unique_ptr<AppCacheNavigationHandle> appcache_handle_;
 
+  std::unique_ptr<ServiceWorkerNavigationHandle> service_worker_handle_;
+
   Phase phase_ = Phase::kInitial;
 
   base::WeakPtrFactory<SharedWorkerHost> weak_factory_{this};

content/browser/worker_host/shared_worker_host_unittest.cc

@@ -13,6 +13,7 @@
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/navigation_subresource_loader_params.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
+#include "content/browser/service_worker/service_worker_navigation_handle.h"
 #include "content/browser/worker_host/mock_shared_worker.h"
 #include "content/browser/worker_host/shared_worker_connector_impl.h"
 #include "content/browser/worker_host/shared_worker_instance.h"
@@ -76,13 +77,6 @@ class SharedWorkerHostTest : public testing::Test {
 
   void StartWorker(SharedWorkerHost* host,
                    blink::mojom::SharedWorkerFactoryPtr factory) {
-    auto provider_info =
-        blink::mojom::ServiceWorkerProviderInfoForClient::New();
-    ServiceWorkerProviderHost::PreCreateForWebWorker(
-        helper_->context()->AsWeakPtr(), mock_render_process_host_.GetID(),
-        blink::mojom::ServiceWorkerProviderType::kForSharedWorker,
-        &provider_info);
-
     auto main_script_load_params =
         blink::mojom::WorkerMainScriptLoadParams::New();
     auto subresource_loader_factories =
@@ -97,8 +91,21 @@ class SharedWorkerHostTest : public testing::Test {
     subresource_loader_params->pending_appcache_loader_factory =
         loader_factory_ptr.PassInterface();
 
-    host->Start(std::move(factory), std::move(provider_info),
-                std::move(main_script_load_params),
+    // Set up for service worker.
+    auto service_worker_handle =
+        std::make_unique<ServiceWorkerNavigationHandle>(
+            helper_->context_wrapper());
+    auto provider_info =
+        blink::mojom::ServiceWorkerProviderInfoForClient::New();
+    base::WeakPtr<ServiceWorkerProviderHost> service_worker_host =
+        ServiceWorkerProviderHost::PreCreateForWebWorker(
+            helper_->context()->AsWeakPtr(), mock_render_process_host_.GetID(),
+            blink::mojom::ServiceWorkerProviderType::kForSharedWorker,
+            &provider_info);
+    service_worker_handle->OnCreatedProviderHost(std::move(provider_info));
+    host->SetServiceWorkerHandle(std::move(service_worker_handle));
+
+    host->Start(std::move(factory), std::move(main_script_load_params),
                 std::move(subresource_loader_factories),
                 nullptr /* controller */,
                 nullptr /* controller_service_worker_object_host */);

content/browser/worker_host/shared_worker_service_impl.cc

@@ -19,6 +19,7 @@
 #include "content/browser/appcache/appcache_navigation_handle.h"
 #include "content/browser/appcache/appcache_navigation_handle_core.h"
 #include "content/browser/file_url_loader_factory.h"
+#include "content/browser/service_worker/service_worker_navigation_handle.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/browser/url_loader_factory_getter.h"
 #include "content/browser/web_contents/web_contents_impl.h"
@@ -38,7 +39,6 @@
 #include "services/network/public/cpp/features.h"
 #include "third_party/blink/public/common/messaging/message_port_channel.h"
 #include "third_party/blink/public/mojom/loader/fetch_client_settings_object.mojom.h"
-#include "third_party/blink/public/mojom/service_worker/service_worker_provider.mojom.h"
 #include "third_party/blink/public/mojom/worker/shared_worker_client.mojom.h"
 #include "third_party/blink/public/mojom/worker/shared_worker_info.mojom.h"
 #include "url/origin.h"
@@ -213,6 +213,11 @@ void SharedWorkerServiceImpl::CreateWorker(
       appcache_handle->core();
   weak_host->SetAppCacheHandle(std::move(appcache_handle));
 
+  auto service_worker_handle = std::make_unique<ServiceWorkerNavigationHandle>(
+      storage_partition_->GetServiceWorkerContext());
+  auto* service_worker_handle_raw = service_worker_handle.get();
+  weak_host->SetServiceWorkerHandle(std::move(service_worker_handle));
+
   // Fetch classic shared worker script with "same-origin" credentials mode.
   // https://html.spec.whatwg.org/C/#fetch-a-classic-worker-script
   //
@@ -225,8 +230,9 @@ void SharedWorkerServiceImpl::CreateWorker(
       weak_host->instance()->constructor_origin(), credentials_mode,
       std::move(outside_fetch_client_settings_object),
       ResourceType::kSharedWorker, service_worker_context_,
-      appcache_handle_core, std::move(blob_url_loader_factory),
-      url_loader_factory_override_, storage_partition_,
+      service_worker_handle_raw, appcache_handle_core,
+      std::move(blob_url_loader_factory), url_loader_factory_override_,
+      storage_partition_,
       base::BindOnce(&SharedWorkerServiceImpl::DidCreateScriptLoader,
                      weak_factory_.GetWeakPtr(), std::move(instance), weak_host,
                      std::move(client), client_process_id, frame_id,
@@ -240,8 +246,6 @@ void SharedWorkerServiceImpl::DidCreateScriptLoader(
     int process_id,
     int frame_id,
     const blink::MessagePortChannel& message_port,
-    blink::mojom::ServiceWorkerProviderInfoForClientPtr
-        service_worker_provider_info,
     std::unique_ptr<blink::URLLoaderFactoryBundleInfo>
         subresource_loader_factories,
     blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,
@@ -260,7 +264,6 @@ void SharedWorkerServiceImpl::DidCreateScriptLoader(
 
   StartWorker(std::move(instance), std::move(host), std::move(client),
               process_id, frame_id, message_port,
-              std::move(service_worker_provider_info),
               std::move(subresource_loader_factories),
               std::move(main_script_load_params), std::move(controller),
               std::move(controller_service_worker_object_host));
@@ -273,8 +276,6 @@ void SharedWorkerServiceImpl::StartWorker(
     int client_process_id,
     int frame_id,
     const blink::MessagePortChannel& message_port,
-    blink::mojom::ServiceWorkerProviderInfoForClientPtr
-        service_worker_provider_info,
     std::unique_ptr<blink::URLLoaderFactoryBundleInfo>
         subresource_loader_factories,
     blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,
@@ -303,8 +304,7 @@ void SharedWorkerServiceImpl::StartWorker(
   blink::mojom::SharedWorkerFactoryPtr factory;
   BindInterface(worker_process_host, &factory);
 
-  host->Start(std::move(factory), std::move(service_worker_provider_info),
-              std::move(main_script_load_params),
+  host->Start(std::move(factory), std::move(main_script_load_params),
               std::move(subresource_loader_factories), std::move(controller),
               std::move(controller_service_worker_object_host));
   host->AddClient(std::move(client), client_process_id, frame_id, message_port);

content/browser/worker_host/shared_worker_service_impl.h

@@ -18,7 +18,6 @@
 #include "services/network/public/cpp/resource_response.h"
 #include "services/network/public/mojom/url_loader_factory.mojom.h"
 #include "third_party/blink/public/mojom/loader/fetch_client_settings_object.mojom.h"
-#include "third_party/blink/public/mojom/service_worker/service_worker_provider.mojom.h"
 #include "third_party/blink/public/mojom/worker/shared_worker_connector.mojom.h"
 #include "third_party/blink/public/mojom/worker/shared_worker_factory.mojom.h"
 #include "third_party/blink/public/mojom/worker/worker_main_script_load_params.mojom.h"
@@ -97,8 +96,6 @@ class CONTENT_EXPORT SharedWorkerServiceImpl : public SharedWorkerService {
       int client_process_id,
       int frame_id,
       const blink::MessagePortChannel& message_port,
-      blink::mojom::ServiceWorkerProviderInfoForClientPtr
-          service_worker_provider_info,
       std::unique_ptr<blink::URLLoaderFactoryBundleInfo>
           subresource_loader_factories,
       blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,
@@ -113,8 +110,6 @@ class CONTENT_EXPORT SharedWorkerServiceImpl : public SharedWorkerService {
       int client_process_id,
       int frame_id,
       const blink::MessagePortChannel& message_port,
-      blink::mojom::ServiceWorkerProviderInfoForClientPtr
-          service_worker_provider_info,
       std::unique_ptr<blink::URLLoaderFactoryBundleInfo>
           subresource_loader_factories,
       blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,

content/browser/worker_host/worker_script_fetch_initiator.cc

@@ -19,8 +19,11 @@
 #include "content/browser/data_url_loader_factory.h"
 #include "content/browser/file_url_loader_factory.h"
 #include "content/browser/loader/browser_initiated_resource_request.h"
+#include "content/browser/loader/navigation_url_loader_impl.h"
 #include "content/browser/navigation_subresource_loader_params.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/browser/service_worker/service_worker_navigation_handle.h"
+#include "content/browser/service_worker/service_worker_navigation_handle_core.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/browser/url_loader_factory_getter.h"
 #include "content/browser/web_contents/web_contents_impl.h"
@@ -51,6 +54,7 @@
 
 namespace content {
 
+// static
 void WorkerScriptFetchInitiator::Start(
     int worker_process_id,
     const GURL& script_url,
@@ -60,6 +64,7 @@ void WorkerScriptFetchInitiator::Start(
         outside_fetch_client_settings_object,
     ResourceType resource_type,
     scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
+    ServiceWorkerNavigationHandle* service_worker_handle,
     AppCacheNavigationHandleCore* appcache_handle_core,
     scoped_refptr<network::SharedURLLoaderFactory> blob_url_loader_factory,
     scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_override,
@@ -172,7 +177,8 @@ void WorkerScriptFetchInitiator::Start(
           storage_partition->url_loader_factory_getter(),
           std::move(factory_bundle_for_browser),
           std::move(subresource_loader_factories), resource_context,
-          std::move(service_worker_context), appcache_handle_core,
+          std::move(service_worker_context), service_worker_handle->core(),
+          appcache_handle_core,
           blob_url_loader_factory ? blob_url_loader_factory->Clone() : nullptr,
           url_loader_factory_override ? url_loader_factory_override->Clone()
                                       : nullptr,
@@ -259,6 +265,7 @@ void WorkerScriptFetchInitiator::CreateScriptLoaderOnIO(
         subresource_loader_factories,
     ResourceContext* resource_context,
     scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
+    ServiceWorkerNavigationHandleCore* service_worker_handle_core,
     AppCacheNavigationHandleCore* appcache_handle_core,
     std::unique_ptr<network::SharedURLLoaderFactoryInfo>
         blob_url_loader_factory_info,
@@ -267,6 +274,7 @@ void WorkerScriptFetchInitiator::CreateScriptLoaderOnIO(
     CompletionCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(resource_context);
+  DCHECK(service_worker_handle_core);
 
   auto resource_type =
       static_cast<ResourceType>(resource_request->resource_type);
@@ -284,12 +292,6 @@ void WorkerScriptFetchInitiator::CreateScriptLoaderOnIO(
       break;
   }
 
-  // Set up for service worker.
-  auto provider_info = blink::mojom::ServiceWorkerProviderInfoForClient::New();
-  base::WeakPtr<ServiceWorkerProviderHost> service_worker_host =
-      service_worker_context->PreCreateHostForWorker(
-          worker_process_id, provider_type, &provider_info);
-
   // Create the URL loader factory for WorkerScriptLoaderFactory to use to load
   // the main script.
   scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory;
@@ -350,19 +352,17 @@ void WorkerScriptFetchInitiator::CreateScriptLoaderOnIO(
 
   WorkerScriptFetcher::CreateAndStart(
       std::make_unique<WorkerScriptLoaderFactory>(
-          worker_process_id, std::move(service_worker_host),
+          worker_process_id, service_worker_handle_core,
           std::move(appcache_host), resource_context_getter,
           std::move(url_loader_factory)),
       std::move(throttles), std::move(resource_request),
       base::BindOnce(WorkerScriptFetchInitiator::DidCreateScriptLoaderOnIO,
-                     std::move(callback), std::move(provider_info),
+                     std::move(callback),
                      std::move(subresource_loader_factories)));
 }
 
 void WorkerScriptFetchInitiator::DidCreateScriptLoaderOnIO(
     CompletionCallback callback,
-    blink::mojom::ServiceWorkerProviderInfoForClientPtr
-        service_worker_provider_info,
     std::unique_ptr<blink::URLLoaderFactoryBundleInfo>
         subresource_loader_factories,
     blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,
@@ -391,8 +391,7 @@ void WorkerScriptFetchInitiator::DidCreateScriptLoaderOnIO(
   base::PostTaskWithTraits(
       FROM_HERE, {BrowserThread::UI},
       base::BindOnce(
-          std::move(callback), std::move(service_worker_provider_info),
-          std::move(subresource_loader_factories),
+          std::move(callback), std::move(subresource_loader_factories),
           std::move(main_script_load_params), std::move(controller),
           std::move(controller_service_worker_object_host), success));
 }

content/browser/worker_host/worker_script_fetch_initiator.h

@@ -11,6 +11,7 @@
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/common/resource_type.h"
 #include "content/public/common/url_loader_throttle.h"
 #include "services/network/public/cpp/resource_response.h"
@@ -36,6 +37,8 @@ class AppCacheNavigationHandleCore;
 class BrowserContext;
 class ResourceContext;
 class ServiceWorkerContextWrapper;
+class ServiceWorkerNavigationHandle;
+class ServiceWorkerNavigationHandleCore;
 class ServiceWorkerObjectHost;
 class StoragePartitionImpl;
 class URLLoaderFactoryGetter;
@@ -44,10 +47,11 @@ struct SubresourceLoaderParams;
 // PlzWorker:
 // WorkerScriptFetchInitiator is the entry point of browser-side script fetch
 // for WorkerScriptFetcher.
+// TODO(falken): These are all static functions, it should just be a namespace
+// or merged elsewhere.
 class WorkerScriptFetchInitiator {
  public:
   using CompletionCallback = base::OnceCallback<void(
-      blink::mojom::ServiceWorkerProviderInfoForClientPtr,
       std::unique_ptr<blink::URLLoaderFactoryBundleInfo>,
       blink::mojom::WorkerMainScriptLoadParamsPtr,
       blink::mojom::ControllerServiceWorkerInfoPtr,
@@ -65,6 +69,7 @@ class WorkerScriptFetchInitiator {
           outside_fetch_client_settings_object,
       ResourceType resource_type,
       scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
+      ServiceWorkerNavigationHandle* service_worker_handle,
       AppCacheNavigationHandleCore* appcache_handle_core,
       scoped_refptr<network::SharedURLLoaderFactory> blob_url_loader_factory,
       scoped_refptr<network::SharedURLLoaderFactory>
@@ -95,16 +100,16 @@ class WorkerScriptFetchInitiator {
           subresource_loader_factories,
       ResourceContext* resource_context,
       scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
+      ServiceWorkerNavigationHandleCore* service_worker_handle_core,
       AppCacheNavigationHandleCore* appcache_handle_core,
       std::unique_ptr<network::SharedURLLoaderFactoryInfo>
           blob_url_loader_factory_info,
       std::unique_ptr<network::SharedURLLoaderFactoryInfo>
           url_loader_factory_override_info,
       CompletionCallback callback);
+
   static void DidCreateScriptLoaderOnIO(
       CompletionCallback callback,
-      blink::mojom::ServiceWorkerProviderInfoForClientPtr
-          service_worker_provider_info,
       std::unique_ptr<blink::URLLoaderFactoryBundleInfo>
           subresource_loader_factories,
       blink::mojom::WorkerMainScriptLoadParamsPtr main_script_load_params,

content/browser/worker_host/worker_script_loader.cc

@@ -9,7 +9,7 @@
 #include "content/browser/loader/navigation_loader_interceptor.h"
 #include "content/browser/loader/navigation_url_loader_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
-#include "content/browser/service_worker/service_worker_provider_host.h"
+#include "content/browser/service_worker/service_worker_navigation_handle_core.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
 #include "content/public/browser/resource_context.h"
 #include "net/url_request/redirect_util.h"
@@ -24,7 +24,7 @@ WorkerScriptLoader::WorkerScriptLoader(
     uint32_t options,
     const network::ResourceRequest& resource_request,
     network::mojom::URLLoaderClientPtr client,
-    base::WeakPtr<ServiceWorkerProviderHost> service_worker_provider_host,
+    base::WeakPtr<ServiceWorkerNavigationHandleCore> service_worker_handle_core,
     base::WeakPtr<AppCacheHost> appcache_host,
     const ResourceContextGetter& resource_context_getter,
     scoped_refptr<network::SharedURLLoaderFactory> default_loader_factory,
@@ -35,20 +35,26 @@ WorkerScriptLoader::WorkerScriptLoader(
       options_(options),
       resource_request_(resource_request),
       client_(std::move(client)),
-      service_worker_provider_host_(service_worker_provider_host),
+      service_worker_handle_core_(std::move(service_worker_handle_core)),
       resource_context_getter_(resource_context_getter),
       default_loader_factory_(std::move(default_loader_factory)),
       traffic_annotation_(traffic_annotation),
       url_loader_client_binding_(this) {
-  if (service_worker_provider_host_) {
-    std::unique_ptr<NavigationLoaderInterceptor> service_worker_interceptor =
-        ServiceWorkerRequestHandler::CreateForWorker(
-            resource_request_, service_worker_provider_host_.get());
-    if (service_worker_interceptor)
-      interceptors_.push_back(std::move(service_worker_interceptor));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  std::unique_ptr<NavigationLoaderInterceptor> service_worker_interceptor;
+  if (!service_worker_handle_core_) {
+    // The DedicatedWorkerHost or SharedWorkerHost is already destroyed.
+    Abort();
+    return;
   }
 
-  // TODO(http://crbug.com/824858): Run interceptors on UI thread.
+  service_worker_interceptor = ServiceWorkerRequestHandler::CreateForWorkerIO(
+      resource_request_, process_id_, service_worker_handle_core_.get());
+  if (service_worker_interceptor)
+    interceptors_.push_back(std::move(service_worker_interceptor));
+
+  // TODO(http://crbug.com/985259): Run interceptors on UI thread.
   if (!NavigationURLLoaderImpl::IsNavigationLoaderOnUIEnabled() &&
       appcache_host) {
     std::unique_ptr<NavigationLoaderInterceptor> appcache_interceptor =
@@ -67,16 +73,19 @@ base::WeakPtr<WorkerScriptLoader> WorkerScriptLoader::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
+void WorkerScriptLoader::Abort() {
+  CommitCompleted(network::URLLoaderCompletionStatus(net::ERR_ABORTED));
+}
+
 void WorkerScriptLoader::Start() {
   DCHECK(!completed_);
 
   ResourceContext* resource_context = resource_context_getter_.Run();
   if (!resource_context) {
-    CommitCompleted(network::URLLoaderCompletionStatus(net::ERR_ABORTED));
+    Abort();
     return;
   }
 
-  // TODO(http://crbug.com/824840): Support interceptors on the UI thread.
   if (interceptor_index_ < interceptors_.size()) {
     auto* interceptor = interceptors_[interceptor_index_++].get();
     interceptor->MaybeCreateLoader(
@@ -291,8 +300,9 @@ void WorkerScriptLoader::CommitCompleted(
   DCHECK(!completed_);
   completed_ = true;
 
-  if (service_worker_provider_host_ && status.error_code == net::OK)
-    service_worker_provider_host_->CompleteWebWorkerPreparation();
+  if (service_worker_handle_core_ && status.error_code == net::OK)
+    service_worker_handle_core_->OnBeginWorkerCommit();
+
   client_->OnComplete(status);
 
   // We're done. Ensure we no longer send messages to our client, and no longer

content/browser/worker_host/worker_script_loader.h

@@ -29,7 +29,7 @@ class AppCacheHost;
 class ThrottlingURLLoader;
 class NavigationLoaderInterceptor;
 class ResourceContext;
-class ServiceWorkerProviderHost;
+class ServiceWorkerNavigationHandleCore;
 
 // The URLLoader for loading a shared worker script. Only used for the main
 // script request.
@@ -61,7 +61,8 @@ class WorkerScriptLoader : public network::mojom::URLLoader,
       uint32_t options,
       const network::ResourceRequest& resource_request,
       network::mojom::URLLoaderClientPtr client,
-      base::WeakPtr<ServiceWorkerProviderHost> service_worker_provider_host,
+      base::WeakPtr<ServiceWorkerNavigationHandleCore>
+          service_worker_handle_core,
       base::WeakPtr<AppCacheHost> appcache_host,
       const ResourceContextGetter& resource_context_getter,
       scoped_refptr<network::SharedURLLoaderFactory> default_loader_factory,
@@ -114,6 +115,7 @@ class WorkerScriptLoader : public network::mojom::URLLoader,
   bool default_loader_used_ = false;
 
  private:
+  void Abort();
   void Start();
   void MaybeStartLoader(
       NavigationLoaderInterceptor* interceptor,
@@ -134,7 +136,7 @@ class WorkerScriptLoader : public network::mojom::URLLoader,
   const uint32_t options_;
   network::ResourceRequest resource_request_;
   network::mojom::URLLoaderClientPtr client_;
-  base::WeakPtr<ServiceWorkerProviderHost> service_worker_provider_host_;
+  base::WeakPtr<ServiceWorkerNavigationHandleCore> service_worker_handle_core_;
   ResourceContextGetter resource_context_getter_;
   scoped_refptr<network::SharedURLLoaderFactory> default_loader_factory_;
   net::MutableNetworkTrafficAnnotationTag traffic_annotation_;

content/browser/worker_host/worker_script_loader_factory.cc

@@ -5,9 +5,12 @@
 #include "content/browser/worker_host/worker_script_loader_factory.h"
 
 #include <memory>
+
 #include "base/feature_list.h"
+#include "content/browser/service_worker/service_worker_navigation_handle_core.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_version.h"
+#include "content/browser/worker_host/worker_script_fetch_initiator.h"
 #include "content/browser/worker_host/worker_script_loader.h"
 #include "content/public/browser/browser_thread.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
@@ -20,22 +23,18 @@ namespace content {
 
 WorkerScriptLoaderFactory::WorkerScriptLoaderFactory(
     int process_id,
-    base::WeakPtr<ServiceWorkerProviderHost> service_worker_provider_host,
+    ServiceWorkerNavigationHandleCore* service_worker_handle_core,
     base::WeakPtr<AppCacheHost> appcache_host,
     const ResourceContextGetter& resource_context_getter,
     scoped_refptr<network::SharedURLLoaderFactory> loader_factory)
     : process_id_(process_id),
-      service_worker_provider_host_(std::move(service_worker_provider_host)),
       appcache_host_(std::move(appcache_host)),
       resource_context_getter_(resource_context_getter),
       loader_factory_(std::move(loader_factory)) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(base::FeatureList::IsEnabled(network::features::kNetworkService));
-  DCHECK(!service_worker_provider_host_ ||
-         service_worker_provider_host_->provider_type() ==
-             blink::mojom::ServiceWorkerProviderType::kForDedicatedWorker ||
-         service_worker_provider_host_->provider_type() ==
-             blink::mojom::ServiceWorkerProviderType::kForSharedWorker);
+  DCHECK(service_worker_handle_core);
+  service_worker_handle_core_ = service_worker_handle_core->AsWeakPtr();
 }
 
 WorkerScriptLoaderFactory::~WorkerScriptLoaderFactory() {
@@ -61,7 +60,7 @@ void WorkerScriptLoaderFactory::CreateLoaderAndStart(
   // Create a WorkerScriptLoader to load the script.
   auto script_loader = std::make_unique<WorkerScriptLoader>(
       process_id_, routing_id, request_id, options, resource_request,
-      std::move(client), service_worker_provider_host_, appcache_host_,
+      std::move(client), service_worker_handle_core_, appcache_host_,
       resource_context_getter_, loader_factory_, traffic_annotation);
   script_loader_ = script_loader->GetWeakPtr();
   mojo::MakeStrongBinding(std::move(script_loader), std::move(request));

content/browser/worker_host/worker_script_loader_factory.h

@@ -6,6 +6,7 @@
 #define CONTENT_BROWSER_WORKER_HOST_WORKER_SCRIPT_LOADER_FACTORY_H_
 
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "content/browser/navigation_subresource_loader_params.h"
 #include "services/network/public/mojom/url_loader_factory.mojom.h"
 
@@ -16,7 +17,7 @@ class SharedURLLoaderFactory;
 namespace content {
 
 class AppCacheHost;
-class ServiceWorkerProviderHost;
+class ServiceWorkerNavigationHandleCore;
 class ResourceContext;
 class WorkerScriptLoader;
 
@@ -26,8 +27,7 @@ class WorkerScriptLoader;
 // It's an error to call CreateLoaderAndStart() more than a total of one time
 // across this object or any of its clones.
 //
-// This is created per one web worker. All functions of this class must be
-// called on the IO thread.
+// This is created per one web worker. It lives on the IO thread.
 class CONTENT_EXPORT WorkerScriptLoaderFactory
     : public network::mojom::URLLoaderFactory {
  public:
@@ -41,7 +41,7 @@ class CONTENT_EXPORT WorkerScriptLoaderFactory
   // factories used for non-http(s) URLs, e.g., a chrome-extension:// URL.
   WorkerScriptLoaderFactory(
       int process_id,
-      base::WeakPtr<ServiceWorkerProviderHost> service_worker_provider_host,
+      ServiceWorkerNavigationHandleCore* service_worker_handle_core,
       base::WeakPtr<AppCacheHost> appcache_host,
       const ResourceContextGetter& resource_context_getter,
       scoped_refptr<network::SharedURLLoaderFactory> loader_factory);
@@ -62,7 +62,7 @@ class CONTENT_EXPORT WorkerScriptLoaderFactory
 
  private:
   const int process_id_;
-  base::WeakPtr<ServiceWorkerProviderHost> service_worker_provider_host_;
+  base::WeakPtr<ServiceWorkerNavigationHandleCore> service_worker_handle_core_;
   base::WeakPtr<AppCacheHost> appcache_host_;
   ResourceContextGetter resource_context_getter_;
   scoped_refptr<network::SharedURLLoaderFactory> loader_factory_;

content/browser/worker_host/worker_script_loader_factory_unittest.cc

@@ -9,6 +9,8 @@
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/browser/service_worker/service_worker_navigation_handle.h"
+#include "content/browser/service_worker/service_worker_navigation_handle_core.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/fake_network_url_loader_factory.h"
 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
@@ -52,13 +54,8 @@ class WorkerScriptLoaderFactoryTest : public testing::Test {
         network::SharedURLLoaderFactory::Create(std::move(info));
 
     // Set up a service worker host for the shared worker.
-    service_worker_provider_info_ =
-        blink::mojom::ServiceWorkerProviderInfoForClient::New();
-    service_worker_provider_host_ =
-        ServiceWorkerProviderHost::PreCreateForWebWorker(
-            helper_->context()->AsWeakPtr(), kProcessId,
-            blink::mojom::ServiceWorkerProviderType::kForSharedWorker,
-            &service_worker_provider_info_);
+    service_worker_handle_ = std::make_unique<ServiceWorkerNavigationHandle>(
+        helper_->context_wrapper());
   }
 
  protected:
@@ -83,10 +80,7 @@ class WorkerScriptLoaderFactoryTest : public testing::Test {
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
   std::unique_ptr<FakeNetworkURLLoaderFactory> network_loader_factory_instance_;
   scoped_refptr<network::SharedURLLoaderFactory> network_loader_factory_;
-
-  blink::mojom::ServiceWorkerProviderInfoForClientPtr
-      service_worker_provider_info_;
-  base::WeakPtr<ServiceWorkerProviderHost> service_worker_provider_host_;
+  std::unique_ptr<ServiceWorkerNavigationHandle> service_worker_handle_;
 
   WorkerScriptLoaderFactory::ResourceContextGetter resource_context_getter_;
 };
@@ -94,8 +88,9 @@ class WorkerScriptLoaderFactoryTest : public testing::Test {
 TEST_F(WorkerScriptLoaderFactoryTest, ServiceWorkerProviderHost) {
   // Make the factory.
   auto factory = std::make_unique<WorkerScriptLoaderFactory>(
-      kProcessId, service_worker_provider_host_, nullptr /* appcache_host */,
-      resource_context_getter_, network_loader_factory_);
+      kProcessId, service_worker_handle_->core(),
+      /*appcache_host=*/nullptr, resource_context_getter_,
+      network_loader_factory_);
 
   // Load the script.
   GURL url("https://www.example.com/worker.js");
@@ -106,19 +101,25 @@ TEST_F(WorkerScriptLoaderFactoryTest, ServiceWorkerProviderHost) {
   EXPECT_EQ(net::OK, client.completion_status().error_code);
 
   // The provider host should be set up.
-  EXPECT_TRUE(service_worker_provider_host_->is_response_committed());
-  EXPECT_TRUE(service_worker_provider_host_->is_execution_ready());
-  EXPECT_EQ(url, service_worker_provider_host_->url());
+  base::WeakPtr<ServiceWorkerProviderHost> host =
+      service_worker_handle_->core()->provider_host();
+  EXPECT_TRUE(host->is_response_committed());
+  EXPECT_TRUE(host->is_execution_ready());
+  EXPECT_EQ(url, host->url());
 }
 
-// Test a null service worker provider host. This typically only happens during
+// Test a null service worker handle. This typically only happens during
 // shutdown or after a fatal error occurred in the service worker system.
-TEST_F(WorkerScriptLoaderFactoryTest, NullServiceWorkerProviderHost) {
-  // Make the factory with null provider host.
+TEST_F(WorkerScriptLoaderFactoryTest, NullServiceWorkerHandle) {
+  // Make the factory.
   auto factory = std::make_unique<WorkerScriptLoaderFactory>(
-      kProcessId, nullptr /* service_worker_provider_host */,
-      nullptr /* appcache_host */, resource_context_getter_,
-      network_loader_factory_);
+      kProcessId, service_worker_handle_->core(), nullptr /* appcache_host */,
+      resource_context_getter_, network_loader_factory_);
+
+  // Destroy the handle.
+  service_worker_handle_.reset();
+  // Let the IO thread task run to destroy the handle core.
+  base::RunLoop().RunUntilIdle();
 
   // Load the script.
   GURL url("https://www.example.com/worker.js");
@@ -126,7 +127,7 @@ TEST_F(WorkerScriptLoaderFactoryTest, NullServiceWorkerProviderHost) {
   network::mojom::URLLoaderPtr loader =
       CreateTestLoaderAndStart(url, factory.get(), &client);
   client.RunUntilComplete();
-  EXPECT_EQ(net::OK, client.completion_status().error_code);
+  EXPECT_EQ(net::ERR_ABORTED, client.completion_status().error_code);
 }
 
 // Test a null resource context when the request starts. This happens when
@@ -135,7 +136,7 @@ TEST_F(WorkerScriptLoaderFactoryTest, NullServiceWorkerProviderHost) {
 TEST_F(WorkerScriptLoaderFactoryTest, NullResourceContext) {
   // Make the factory.
   auto factory = std::make_unique<WorkerScriptLoaderFactory>(
-      kProcessId, service_worker_provider_host_, nullptr /* appcache_host */,
+      kProcessId, service_worker_handle_->core(), nullptr /* appcache_host */,
       resource_context_getter_, network_loader_factory_);
 
   // Set a null resource context.

content/renderer/loader/web_worker_fetch_context_impl.cc

@@ -282,11 +282,18 @@ WebWorkerFetchContextImpl::CloneForNestedWorker(
     std::unique_ptr<network::SharedURLLoaderFactoryInfo> fallback_factory_info,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   DCHECK(blink::features::IsPlzDedicatedWorkerEnabled());
-  DCHECK(service_worker_provider_context);
   DCHECK(loader_factory_info);
   DCHECK(fallback_factory_info);
   DCHECK(task_runner);
 
+  if (!service_worker_provider_context) {
+    return CloneForNestedWorkerInternal(
+        /*service_worker_client_request=*/nullptr,
+        /*service_worker_worker_client_registry_ptr_info=*/nullptr,
+        /*container_host_ptr_info=*/nullptr, std::move(loader_factory_info),
+        std::move(fallback_factory_info), std::move(task_runner));
+  }
+
   blink::mojom::ServiceWorkerWorkerClientRegistryPtrInfo
       service_worker_worker_client_registry_ptr_info;
   service_worker_provider_context->CloneWorkerClientRegistry(

content/renderer/worker/dedicated_worker_host_factory_client.cc

@@ -120,7 +120,6 @@ void DedicatedWorkerHostFactoryClient::OnScriptLoadStarted(
         subresource_loader_factory_bundle_info,
     blink::mojom::ControllerServiceWorkerInfoPtr controller_info) {
   DCHECK(blink::features::IsPlzDedicatedWorkerEnabled());
-  DCHECK(service_worker_provider_info);
   DCHECK(main_script_load_params);
   DCHECK(subresource_loader_factory_bundle_info);
 
@@ -132,12 +131,14 @@ void DedicatedWorkerHostFactoryClient::OnScriptLoadStarted(
               std::move(subresource_loader_factory_bundle_info)));
 
   DCHECK(!service_worker_provider_context_);
-  service_worker_provider_context_ =
-      base::MakeRefCounted<ServiceWorkerProviderContext>(
-          blink::mojom::ServiceWorkerProviderType::kForDedicatedWorker,
-          std::move(service_worker_provider_info->client_request),
-          std::move(service_worker_provider_info->host_ptr_info),
-          std::move(controller_info), subresource_loader_factory_bundle_);
+  if (service_worker_provider_info) {
+    service_worker_provider_context_ =
+        base::MakeRefCounted<ServiceWorkerProviderContext>(
+            blink::mojom::ServiceWorkerProviderType::kForDedicatedWorker,
+            std::move(service_worker_provider_info->client_request),
+            std::move(service_worker_provider_info->host_ptr_info),
+            std::move(controller_info), subresource_loader_factory_bundle_);
+  }
 
   // Initialize the response override for the main worker script loaded by the
   // browser process.

content/renderer/worker/service_worker_network_provider_for_shared_worker.cc

@@ -24,14 +24,15 @@ ServiceWorkerNetworkProviderForSharedWorker::Create(
     scoped_refptr<network::SharedURLLoaderFactory> fallback_loader_factory,
     bool is_secure_context,
     std::unique_ptr<NavigationResponseOverrideParameters> response_override) {
-  DCHECK(info);
   auto provider =
       base::WrapUnique(new ServiceWorkerNetworkProviderForSharedWorker(
           is_secure_context, std::move(response_override)));
-  provider->context_ = base::MakeRefCounted<ServiceWorkerProviderContext>(
-      blink::mojom::ServiceWorkerProviderType::kForSharedWorker,
-      std::move(info->client_request), std::move(info->host_ptr_info),
-      std::move(controller_info), std::move(fallback_loader_factory));
+  if (info) {
+    provider->context_ = base::MakeRefCounted<ServiceWorkerProviderContext>(
+        blink::mojom::ServiceWorkerProviderType::kForSharedWorker,
+        std::move(info->client_request), std::move(info->host_ptr_info),
+        std::move(controller_info), std::move(fallback_loader_factory));
+  }
   return provider;
 }
 

third_party/blink/public/mojom/worker/dedicated_worker_host_factory.mojom

@@ -35,7 +35,11 @@ interface DedicatedWorkerHostFactoryClient {
   OnScriptLoadStarted(
       // The info about the service worker provider in the browser process that
       // provides support for this worker to be a service worker client.
-      ServiceWorkerProviderInfoForClient service_worker_provider_info,
+      //
+      // This is null if the dedicated worker cannot be a service
+      // worker client, because for example, the worker's URL is
+      // not http(s) or another service worker supported scheme.
+      ServiceWorkerProviderInfoForClient? service_worker_provider_info,
 
       // Used for passing the main script pre-requested by the browser process
       // and its redirect information.

third_party/blink/public/mojom/worker/shared_worker_factory.mojom

@@ -40,7 +40,11 @@ interface SharedWorkerFactory {
 
       // The info about the service worker provider in the browser process that
       // provides support for this worker to be a service worker client.
-      ServiceWorkerProviderInfoForClient service_worker_provider_info,
+      //
+      // This is null if the shared worker cannot be a service
+      // worker client, because for example, the worker's URL is
+      // not http(s) or another service worker supported scheme.
+      ServiceWorkerProviderInfoForClient? service_worker_provider_info,
 
       // The ID of the AppCacheHost in the browser process that serves resources
       // for this shared worker. This is not specified when AppCache doesn't