[OnionSoup] Move WebWorkerFetchContextImpl into blink

Per OnionSoup project, we are going to move WebWorkerFetchContextImpl
into blink, which blocks the Onion Soup tasks for workers.

This patch makes the changes:

- Adds a new interface WebDedicatedAndSharedWorkerFetchContext that
inherits the WebWorkerFetchContext used to exposes the necessary methods
to //content.
- Adds the following methods into platform API:
  - CreateURLLoaderThrottleProviderForWorker()
  - CreateWebSocketHandshakeThrottleProvider()
  - OriginCanAccessServiceWorkers()
  - CreateServiceWorkerSubresourceLoaderFactory()
  - CloneServiceWorkerContainerHost() used to clone a
    ServiceWorkerContainerHost.
- Finally, moves the WebWorkerFetchContextImpl to
  blink/renderer/platform/loader/fetch/url_loader/ and renames to
  DedicatedOrSharedWorkerFetchContextImpl that implements
  WebDedicatedAndSharedWorkerFetchContext.

The class hierarchy before this patch looks like:

                       +---------------------------+
                       | blink::WorkerFetchContext |
                       +-----^-----------------^---+
                             |                 |
                             |                 |
                             |                 |
                             |                 |
+----------------------------+-----+           |
|content::WebWorkerFetchContextImpl|           |
+----------------------------------+           |
                                               |
                +------------------------------+------+
                |  blink::WebServiceWorkerFetchContext|
                +-------------------------------------+
and after this patch:
      +-----------------------------------+
      |blink::WebServiceWorkerFetchContext+----+
      +-----------------------------------+    |
                                               |
                                               |
                                               |
         +----------------------------+        |
         |blink::WebWorkerFetchContext<--------+
         +------------^---------------+
                      |
+---------------------+------------------------+
|blink::WebDedicatedAndSharedWorkerFetchContext|
+---------------------^------------------------+
                      |
+---------------------+-------------------------+
| blink::DedicatedOrSharedWorkerFetchContextImpl|
+-----------------------------------------------+

Change-Id: I35e3eada352a1510b2fd9764a58e4e01177fee32
Bug: 1110176
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2755169
Commit-Queue: Minggang Wang <minggang.wang@intel.com>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#885013}

content/renderer/BUILD.gn

@@ -76,8 +76,6 @@ target(link_target_type, "renderer") {
     "internal_document_state_data.h",
     "loader/navigation_body_loader.cc",
     "loader/navigation_body_loader.h",
-    "loader/web_worker_fetch_context_impl.cc",
-    "loader/web_worker_fetch_context_impl.h",
     "media/audio_decoder.cc",
     "media/audio_decoder.h",
     "media/batching_media_log.cc",

content/renderer/render_frame_impl.cc

@@ -89,7 +89,6 @@
 #include "content/renderer/gpu_benchmarking_extension.h"
 #include "content/renderer/internal_document_state_data.h"
 #include "content/renderer/loader/navigation_body_loader.h"
-#include "content/renderer/loader/web_worker_fetch_context_impl.h"
 #include "content/renderer/media/media_permission_dispatcher.h"
 #include "content/renderer/mhtml_handle_writer.h"
 #include "content/renderer/mojo/blink_interface_registry_impl.h"
@@ -172,6 +171,7 @@
 #include "third_party/blink/public/platform/weak_wrapper_resource_load_info_notifier.h"
 #include "third_party/blink/public/platform/web_back_forward_cache_loader_helper.h"
 #include "third_party/blink/public/platform/web_data.h"
+#include "third_party/blink/public/platform/web_dedicated_or_shared_worker_fetch_context.h"
 #include "third_party/blink/public/platform/web_http_body.h"
 #include "third_party/blink/public/platform/web_media_player.h"
 #include "third_party/blink/public/platform/web_media_player_source.h"
@@ -3243,28 +3243,42 @@ RenderFrameImpl::CreateWorkerFetchContext() {
       pending_resource_load_info_notifier.InitWithNewPipeAndPassReceiver(),
       agent_scheduling_group_.agent_group_scheduler().DefaultTaskRunner());
 
+  std::vector<std::string> cors_exempt_header_list =
+      RenderThreadImpl::current()->cors_exempt_header_list();
+  blink::WebVector<blink::WebString> web_cors_exempt_header_list(
+      cors_exempt_header_list.size());
+  std::transform(cors_exempt_header_list.begin(), cors_exempt_header_list.end(),
+                 web_cors_exempt_header_list.begin(), [](const std::string& h) {
+                   return blink::WebString::FromLatin1(h);
+                 });
+
   // |pending_subresource_loader_updater| and
   // |pending_resource_load_info_notifier| are not used for
   // non-PlzDedicatedWorker and worklets.
-  scoped_refptr<WebWorkerFetchContextImpl> worker_fetch_context =
-      WebWorkerFetchContextImpl::Create(
-          provider->context(), GetWebView()->GetRendererPreferences(),
-          std::move(watcher_receiver), GetLoaderFactoryBundle()->Clone(),
-          GetLoaderFactoryBundle()->CloneWithoutAppCacheFactory(),
-          /*pending_subresource_loader_updater=*/mojo::NullReceiver(),
-          RenderThreadImpl::current()->cors_exempt_header_list(),
-          std::move(pending_resource_load_info_notifier));
+  scoped_refptr<blink::WebDedicatedOrSharedWorkerFetchContext>
+      web_dedicated_or_shared_worker_fetch_context =
+          blink::WebDedicatedOrSharedWorkerFetchContext::Create(
+              provider->context(), GetWebView()->GetRendererPreferences(),
+              std::move(watcher_receiver), GetLoaderFactoryBundle()->Clone(),
+              GetLoaderFactoryBundle()->CloneWithoutAppCacheFactory(),
+              /*pending_subresource_loader_updater=*/mojo::NullReceiver(),
+              web_cors_exempt_header_list,
+              std::move(pending_resource_load_info_notifier));
 
-  worker_fetch_context->set_ancestor_frame_id(routing_id_);
-  worker_fetch_context->set_frame_request_blocker(frame_request_blocker_);
-  worker_fetch_context->set_site_for_cookies(
+  web_dedicated_or_shared_worker_fetch_context->set_ancestor_frame_id(
+      routing_id_);
+  web_dedicated_or_shared_worker_fetch_context->set_frame_request_blocker(
+      frame_request_blocker_);
+  web_dedicated_or_shared_worker_fetch_context->set_site_for_cookies(
       frame_->GetDocument().SiteForCookies());
-  worker_fetch_context->set_top_frame_origin(
+  web_dedicated_or_shared_worker_fetch_context->set_top_frame_origin(
       frame_->GetDocument().TopFrameOrigin());
 
-  for (auto& observer : observers_)
-    observer.WillCreateWorkerFetchContext(worker_fetch_context.get());
-  return worker_fetch_context;
+  for (auto& observer : observers_) {
+    observer.WillCreateWorkerFetchContext(
+        web_dedicated_or_shared_worker_fetch_context.get());
+  }
+  return web_dedicated_or_shared_worker_fetch_context;
 }
 
 scoped_refptr<blink::WebWorkerFetchContext>
@@ -3285,23 +3299,28 @@ RenderFrameImpl::CreateWorkerFetchContextForPlzDedicatedWorker(
       pending_resource_load_info_notifier.InitWithNewPipeAndPassReceiver(),
       agent_scheduling_group_.agent_group_scheduler().DefaultTaskRunner());
 
-  scoped_refptr<WebWorkerFetchContextImpl> worker_fetch_context =
-      static_cast<DedicatedWorkerHostFactoryClient*>(factory_client)
-          ->CreateWorkerFetchContext(
-              GetWebView()->GetRendererPreferences(),
-              std::move(watcher_receiver),
-              std::move(pending_resource_load_info_notifier));
+  scoped_refptr<blink::WebDedicatedOrSharedWorkerFetchContext>
+      web_dedicated_or_shared_worker_fetch_context =
+          static_cast<DedicatedWorkerHostFactoryClient*>(factory_client)
+              ->CreateWorkerFetchContext(
+                  GetWebView()->GetRendererPreferences(),
+                  std::move(watcher_receiver),
+                  std::move(pending_resource_load_info_notifier));
 
-  worker_fetch_context->set_ancestor_frame_id(routing_id_);
-  worker_fetch_context->set_frame_request_blocker(frame_request_blocker_);
-  worker_fetch_context->set_site_for_cookies(
+  web_dedicated_or_shared_worker_fetch_context->set_ancestor_frame_id(
+      routing_id_);
+  web_dedicated_or_shared_worker_fetch_context->set_frame_request_blocker(
+      frame_request_blocker_);
+  web_dedicated_or_shared_worker_fetch_context->set_site_for_cookies(
       frame_->GetDocument().SiteForCookies());
-  worker_fetch_context->set_top_frame_origin(
+  web_dedicated_or_shared_worker_fetch_context->set_top_frame_origin(
       frame_->GetDocument().TopFrameOrigin());
 
-  for (auto& observer : observers_)
-    observer.WillCreateWorkerFetchContext(worker_fetch_context.get());
-  return worker_fetch_context;
+  for (auto& observer : observers_) {
+    observer.WillCreateWorkerFetchContext(
+        web_dedicated_or_shared_worker_fetch_context.get());
+  }
+  return web_dedicated_or_shared_worker_fetch_context;
 }
 
 std::unique_ptr<blink::WebPrescientNetworking>

content/renderer/renderer_blink_platform_impl.cc

@@ -36,6 +36,7 @@
 #include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/gpu_stream_constants.h"
+#include "content/public/common/origin_util.h"
 #include "content/public/common/url_utils.h"
 #include "content/public/common/webplugininfo.h"
 #include "content/public/renderer/content_renderer_client.h"
@@ -47,6 +48,8 @@
 #include "content/renderer/media/renderer_webaudiodevice_impl.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
+#include "content/renderer/service_worker/controller_service_worker_connector.h"
+#include "content/renderer/service_worker/service_worker_subresource_loader.h"
 #include "content/renderer/storage_util.h"
 #include "content/renderer/v8_value_converter_impl.h"
 #include "content/renderer/variations_render_thread_observer.h"
@@ -78,6 +81,7 @@
 #include "third_party/blink/public/common/security/protocol_handler_security_level.h"
 #include "third_party/blink/public/common/thread_safe_browser_interface_broker_proxy.h"
 #include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom.h"
+#include "third_party/blink/public/mojom/service_worker/service_worker_provider.mojom.h"
 #include "third_party/blink/public/platform/blame_context.h"
 #include "third_party/blink/public/platform/file_path_conversion.h"
 #include "third_party/blink/public/platform/modules/video_capture/web_video_capture_impl_manager.h"
@@ -369,6 +373,20 @@ void RendererBlinkPlatformImpl::AppendVariationsThrottles(
   VariationsRenderThreadObserver::AppendThrottleIfNeeded(top_origin, throttles);
 }
 
+std::unique_ptr<blink::URLLoaderThrottleProvider>
+RendererBlinkPlatformImpl::CreateURLLoaderThrottleProviderForWorker(
+    blink::URLLoaderThrottleProviderType provider_type) {
+  return GetContentClient()->renderer()->CreateURLLoaderThrottleProvider(
+      blink::URLLoaderThrottleProviderType::kWorker);
+}
+
+std::unique_ptr<blink::WebSocketHandshakeThrottleProvider>
+RendererBlinkPlatformImpl::CreateWebSocketHandshakeThrottleProvider() {
+  return GetContentClient()
+      ->renderer()
+      ->CreateWebSocketHandshakeThrottleProvider();
+}
+
 void RendererBlinkPlatformImpl::CacheMetadataInCacheStorage(
     const blink::WebURL& url,
     base::Time response_time,
@@ -955,6 +973,55 @@ bool RendererBlinkPlatformImpl::IsExcludedHeaderForServiceWorkerFetchEvent(
       ->IsExcludedHeaderForServiceWorkerFetchEvent(header_name.Ascii());
 }
 
+bool RendererBlinkPlatformImpl::OriginCanAccessServiceWorkers(
+    const blink::WebURL& url) {
+  return content::OriginCanAccessServiceWorkers(url);
+}
+
+std::tuple<blink::CrossVariantMojoRemote<
+               blink::mojom::ServiceWorkerContainerHostInterfaceBase>,
+           blink::CrossVariantMojoRemote<
+               blink::mojom::ServiceWorkerContainerHostInterfaceBase>>
+RendererBlinkPlatformImpl::CloneServiceWorkerContainerHost(
+    blink::CrossVariantMojoRemote<
+        blink::mojom::ServiceWorkerContainerHostInterfaceBase>
+        service_worker_container_host) {
+  mojo::Remote<blink::mojom::ServiceWorkerContainerHost>
+      service_worker_container_host_remote(
+          std::move(service_worker_container_host));
+  mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
+      service_worker_container_host_pending_remote;
+
+  service_worker_container_host_remote->CloneContainerHost(
+      service_worker_container_host_pending_remote
+          .InitWithNewPipeAndPassReceiver());
+  return std::make_tuple(
+      service_worker_container_host_remote.Unbind(),
+      std::move(service_worker_container_host_pending_remote));
+}
+
+void RendererBlinkPlatformImpl::CreateServiceWorkerSubresourceLoaderFactory(
+    blink::CrossVariantMojoRemote<
+        blink::mojom::ServiceWorkerContainerHostInterfaceBase>
+        service_worker_container_host,
+    const blink::WebString& client_id,
+    std::unique_ptr<network::PendingSharedURLLoaderFactory> fallback_factory,
+    mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver,
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
+    scoped_refptr<base::SequencedTaskRunner> worker_timing_callback_task_runner,
+    base::RepeatingCallback<
+        void(int, mojo::PendingReceiver<blink::mojom::WorkerTimingContainer>)>
+        worker_timing_callback) {
+  ServiceWorkerSubresourceLoaderFactory::Create(
+      base::MakeRefCounted<ControllerServiceWorkerConnector>(
+          std::move(service_worker_container_host),
+          /*remote_controller=*/mojo::NullRemote(), client_id.Utf8()),
+      network::SharedURLLoaderFactory::Create(std::move(fallback_factory)),
+      std::move(receiver), std::move(task_runner),
+      std::move(worker_timing_callback_task_runner),
+      std::move(worker_timing_callback));
+}
+
 //------------------------------------------------------------------------------
 
 void RendererBlinkPlatformImpl::RecordMetricsForBackgroundedRendererPurge() {

content/renderer/renderer_blink_platform_impl.h

@@ -105,6 +105,11 @@ class CONTENT_EXPORT RendererBlinkPlatformImpl : public BlinkPlatformImpl {
       const url::Origin& top_origin,
       std::vector<std::unique_ptr<blink::URLLoaderThrottle>>* throttles)
       override;
+  std::unique_ptr<blink::URLLoaderThrottleProvider>
+  CreateURLLoaderThrottleProviderForWorker(
+      blink::URLLoaderThrottleProviderType provider_type) override;
+  std::unique_ptr<blink::WebSocketHandshakeThrottleProvider>
+  CreateWebSocketHandshakeThrottleProvider() override;
   blink::WebString DefaultLocale() override;
   void SuddenTerminationChanged(bool enabled) override;
   blink::WebString DatabaseCreateOriginIdentifier(
@@ -206,6 +211,28 @@ class CONTENT_EXPORT RendererBlinkPlatformImpl : public BlinkPlatformImpl {
       override;
   bool IsExcludedHeaderForServiceWorkerFetchEvent(
       const blink::WebString& header_name) override;
+  bool OriginCanAccessServiceWorkers(const blink::WebURL& url) override;
+  std::tuple<blink::CrossVariantMojoRemote<
+                 blink::mojom::ServiceWorkerContainerHostInterfaceBase>,
+             blink::CrossVariantMojoRemote<
+                 blink::mojom::ServiceWorkerContainerHostInterfaceBase>>
+  CloneServiceWorkerContainerHost(
+      blink::CrossVariantMojoRemote<
+          blink::mojom::ServiceWorkerContainerHostInterfaceBase>
+          service_worker_container_host) override;
+  void CreateServiceWorkerSubresourceLoaderFactory(
+      blink::CrossVariantMojoRemote<
+          blink::mojom::ServiceWorkerContainerHostInterfaceBase>
+          service_worker_container_host,
+      const blink::WebString& client_id,
+      std::unique_ptr<network::PendingSharedURLLoaderFactory> fallback_factory,
+      mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver,
+      scoped_refptr<base::SequencedTaskRunner> task_runner,
+      scoped_refptr<base::SequencedTaskRunner>
+          worker_timing_callback_task_runner,
+      base::RepeatingCallback<
+          void(int, mojo::PendingReceiver<blink::mojom::WorkerTimingContainer>)>
+          worker_timing_callback) override;
   void RecordMetricsForBackgroundedRendererPurge() override;
   std::unique_ptr<blink::WebCodeCacheLoader> CreateCodeCacheLoader() override;
   std::unique_ptr<blink::WebURLLoaderFactory> WrapURLLoaderFactory(

content/renderer/service_worker/service_worker_provider_context.cc

@@ -279,8 +279,10 @@ blink::CrossVariantMojoRemote<
     blink::mojom::ServiceWorkerContainerHostInterfaceBase>
 ServiceWorkerProviderContext::CloneRemoteContainerHost() {
   DCHECK(main_thread_task_runner_->RunsTasksInCurrentSequence());
-  if (!container_host_)
-    return mojo::NullRemote();
+  if (!container_host_) {
+    return blink::CrossVariantMojoRemote<
+        blink::mojom::ServiceWorkerContainerHostInterfaceBase>();
+  }
   mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
       remote_container_host;
   container_host_->CloneContainerHost(

content/renderer/worker/dedicated_worker_host_factory_client.cc

@@ -4,8 +4,8 @@
 
 #include "content/renderer/worker/dedicated_worker_host_factory_client.h"
 
+#include <algorithm>
 #include <utility>
-#include "content/renderer/loader/web_worker_fetch_context_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/service_worker/service_worker_provider_context.h"
 #include "content/renderer/worker/fetch_client_settings_object_helpers.h"
@@ -16,11 +16,14 @@
 #include "third_party/blink/public/common/tokens/tokens_mojom_traits.h"
 #include "third_party/blink/public/mojom/blob/blob_url_store.mojom.h"
 #include "third_party/blink/public/mojom/loader/fetch_client_settings_object.mojom.h"
+#include "third_party/blink/public/mojom/renderer_preference_watcher.mojom.h"
 #include "third_party/blink/public/mojom/service_worker/controller_service_worker.mojom.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker_provider.mojom.h"
 #include "third_party/blink/public/mojom/tokens/tokens.mojom.h"
+#include "third_party/blink/public/mojom/worker/subresource_loader_updater.mojom.h"
 #include "third_party/blink/public/mojom/worker/worker_main_script_load_params.mojom.h"
 #include "third_party/blink/public/platform/child_url_loader_factory_bundle.h"
+#include "third_party/blink/public/platform/web_dedicated_or_shared_worker_fetch_context.h"
 #include "third_party/blink/public/platform/web_dedicated_worker.h"
 #include "third_party/blink/public/platform/web_url.h"
 
@@ -71,10 +74,12 @@ scoped_refptr<blink::WebWorkerFetchContext>
 DedicatedWorkerHostFactoryClient::CloneWorkerFetchContext(
     blink::WebWorkerFetchContext* web_worker_fetch_context,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  scoped_refptr<WebWorkerFetchContextImpl> worker_fetch_context;
+  scoped_refptr<blink::WebDedicatedOrSharedWorkerFetchContext>
+      cloned_web_dedicated_or_shared_worker_fetch_context;
   if (base::FeatureList::IsEnabled(blink::features::kPlzDedicatedWorker)) {
-    worker_fetch_context =
-        static_cast<WebWorkerFetchContextImpl*>(web_worker_fetch_context)
+    cloned_web_dedicated_or_shared_worker_fetch_context =
+        static_cast<blink::WebDedicatedOrSharedWorkerFetchContext*>(
+            web_worker_fetch_context)
             ->CloneForNestedWorker(
                 service_worker_provider_context_.get(),
                 subresource_loader_factory_bundle_->Clone(),
@@ -83,14 +88,15 @@ DedicatedWorkerHostFactoryClient::CloneWorkerFetchContext(
                 std::move(pending_subresource_loader_updater_),
                 std::move(task_runner));
   } else {
-    worker_fetch_context =
-        static_cast<WebWorkerFetchContextImpl*>(web_worker_fetch_context)
+    cloned_web_dedicated_or_shared_worker_fetch_context =
+        static_cast<blink::WebDedicatedOrSharedWorkerFetchContext*>(
+            web_worker_fetch_context)
             ->CloneForNestedWorkerDeprecated(std::move(task_runner));
   }
-  return worker_fetch_context;
+  return cloned_web_dedicated_or_shared_worker_fetch_context;
 }
 
-scoped_refptr<WebWorkerFetchContextImpl>
+scoped_refptr<blink::WebDedicatedOrSharedWorkerFetchContext>
 DedicatedWorkerHostFactoryClient::CreateWorkerFetchContext(
     const blink::RendererPreferences& renderer_preference,
     mojo::PendingReceiver<blink::mojom::RendererPreferenceWatcher>
@@ -99,17 +105,25 @@ DedicatedWorkerHostFactoryClient::CreateWorkerFetchContext(
         pending_resource_load_info_notifier) {
   DCHECK(base::FeatureList::IsEnabled(blink::features::kPlzDedicatedWorker));
   DCHECK(subresource_loader_factory_bundle_);
-  scoped_refptr<WebWorkerFetchContextImpl> worker_fetch_context =
-      WebWorkerFetchContextImpl::Create(
-          service_worker_provider_context_.get(), renderer_preference,
-          std::move(watcher_receiver),
-          subresource_loader_factory_bundle_->Clone(),
-          subresource_loader_factory_bundle_->CloneWithoutAppCacheFactory(),
-          std::move(pending_subresource_loader_updater_),
-          RenderThreadImpl::current()
-              ->cors_exempt_header_list(),
-          std::move(pending_resource_load_info_notifier));
-  return worker_fetch_context;
+  std::vector<std::string> cors_exempt_header_list =
+      RenderThreadImpl::current()->cors_exempt_header_list();
+  blink::WebVector<blink::WebString> web_cors_exempt_header_list(
+      cors_exempt_header_list.size());
+  std::transform(cors_exempt_header_list.begin(), cors_exempt_header_list.end(),
+                 web_cors_exempt_header_list.begin(), [](const std::string& h) {
+                   return blink::WebString::FromLatin1(h);
+                 });
+  scoped_refptr<blink::WebDedicatedOrSharedWorkerFetchContext>
+      web_dedicated_or_shared_worker_fetch_context =
+          blink::WebDedicatedOrSharedWorkerFetchContext::Create(
+              service_worker_provider_context_.get(), renderer_preference,
+              std::move(watcher_receiver),
+              subresource_loader_factory_bundle_->Clone(),
+              subresource_loader_factory_bundle_->CloneWithoutAppCacheFactory(),
+              std::move(pending_subresource_loader_updater_),
+              web_cors_exempt_header_list,
+              std::move(pending_resource_load_info_notifier));
+  return web_dedicated_or_shared_worker_fetch_context;
 }
 
 void DedicatedWorkerHostFactoryClient::OnWorkerHostCreated(

content/renderer/worker/dedicated_worker_host_factory_client.h

@@ -20,14 +20,13 @@
 
 namespace blink {
 class ChildURLLoaderFactoryBundle;
+class WebDedicatedOrSharedWorkerFetchContext;
 class WebDedicatedWorker;
-class WebWorkerFetchContext;
 }  // namespace blink
 
 namespace content {
 
 class ServiceWorkerProviderContext;
-class WebWorkerFetchContextImpl;
 
 // DedicatedWorkerHostFactoryClient intermediates between
 // blink::(Web)DedicatedWorker and content::DedicatedWorkerHostFactory. This
@@ -60,7 +59,8 @@ class DedicatedWorkerHostFactoryClient final
       blink::WebWorkerFetchContext* web_worker_fetch_context,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
 
-  scoped_refptr<WebWorkerFetchContextImpl> CreateWorkerFetchContext(
+  scoped_refptr<blink::WebDedicatedOrSharedWorkerFetchContext>
+  CreateWorkerFetchContext(
       const blink::RendererPreferences& renderer_preference,
       mojo::PendingReceiver<blink::mojom::RendererPreferenceWatcher>
           watcher_receiver,

content/renderer/worker/embedded_shared_worker_stub.cc

@@ -11,7 +11,6 @@
 #include "base/feature_list.h"
 #include "content/public/common/network_service_util.h"
 #include "content/renderer/content_security_policy_util.h"
-#include "content/renderer/loader/web_worker_fetch_context_impl.h"
 #include "content/renderer/worker/fetch_client_settings_object_helpers.h"
 #include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "third_party/blink/public/common/features.h"
@@ -20,9 +19,11 @@
 #include "third_party/blink/public/common/messaging/message_port_descriptor.h"
 #include "third_party/blink/public/mojom/browser_interface_broker.mojom.h"
 #include "third_party/blink/public/mojom/devtools/devtools_agent.mojom.h"
+#include "third_party/blink/public/mojom/renderer_preference_watcher.mojom.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker_object.mojom.h"
 #include "third_party/blink/public/mojom/worker/worker_content_settings_proxy.mojom.h"
 #include "third_party/blink/public/platform/child_url_loader_factory_bundle.h"
+#include "third_party/blink/public/platform/web_dedicated_or_shared_worker_fetch_context.h"
 #include "third_party/blink/public/platform/web_fetch_client_settings_object.h"
 #include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/web/web_shared_worker.h"
@@ -107,7 +108,7 @@ EmbeddedSharedWorkerStub::EmbeddedSharedWorkerStub(
             std::move(controller_info), subresource_loader_factory_bundle_);
   }
 
-  scoped_refptr<blink::WebWorkerFetchContext> worker_fetch_context =
+  scoped_refptr<blink::WebWorkerFetchContext> web_worker_fetch_context =
       CreateWorkerFetchContext(info->url, std::move(renderer_preferences),
                                std::move(preference_watcher_receiver),
                                cors_exempt_header_list);
@@ -124,7 +125,8 @@ EmbeddedSharedWorkerStub::EmbeddedSharedWorkerStub(
       appcache_host_id, devtools_worker_token, std::move(content_settings),
       std::move(browser_interface_broker), pause_on_start,
       std::move(worker_main_script_load_params),
-      std::move(worker_fetch_context), std::move(host), this, ukm_source_id);
+      std::move(web_worker_fetch_context), std::move(host), this,
+      ukm_source_id);
 
   // If the host drops its connection, then self-destruct.
   receiver_.set_disconnect_handler(base::BindOnce(
@@ -152,25 +154,34 @@ EmbeddedSharedWorkerStub::CreateWorkerFetchContext(
   std::unique_ptr<network::PendingSharedURLLoaderFactory> fallback_factory =
       subresource_loader_factory_bundle_->CloneWithoutAppCacheFactory();
 
+  blink::WebVector<blink::WebString> web_cors_exempt_header_list(
+      cors_exempt_header_list.size());
+  std::transform(cors_exempt_header_list.begin(), cors_exempt_header_list.end(),
+                 web_cors_exempt_header_list.begin(), [](const std::string& h) {
+                   return blink::WebString::FromLatin1(h);
+                 });
+
   // |pending_subresource_loader_updater| and
   // |pending_resource_load_info_notifier| are not used for shared workers.
-  scoped_refptr<WebWorkerFetchContextImpl> worker_fetch_context =
-      WebWorkerFetchContextImpl::Create(
-          service_worker_provider_context_.get(), renderer_preferences,
-          std::move(preference_watcher_receiver),
-          subresource_loader_factory_bundle_->Clone(),
-          std::move(fallback_factory),
-          /*pending_subresource_loader_updater=*/mojo::NullReceiver(),
-          cors_exempt_header_list,
-          /*pending_resource_load_info_notifier=*/mojo::NullRemote());
+  scoped_refptr<blink::WebDedicatedOrSharedWorkerFetchContext>
+      web_dedicated_or_shared_worker_fetch_context =
+          blink::WebDedicatedOrSharedWorkerFetchContext::Create(
+              service_worker_provider_context_.get(), renderer_preferences,
+              std::move(preference_watcher_receiver),
+              subresource_loader_factory_bundle_->Clone(),
+              std::move(fallback_factory),
+              /*pending_subresource_loader_updater=*/mojo::NullReceiver(),
+              web_cors_exempt_header_list,
+              /*pending_resource_load_info_notifier=*/mojo::NullRemote());
 
   // TODO(horo): To get the correct first_party_to_cookies for the shared
   // worker, we need to check the all documents bounded by the shared worker.
   // (crbug.com/723553)
   // https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-07#section-2.1.2
-  worker_fetch_context->set_site_for_cookies(net::SiteForCookies::FromUrl(url));
+  web_dedicated_or_shared_worker_fetch_context->set_site_for_cookies(
+      net::SiteForCookies::FromUrl(url));
 
-  return worker_fetch_context;
+  return web_dedicated_or_shared_worker_fetch_context;
 }
 
 void EmbeddedSharedWorkerStub::Connect(int connection_request_id,

content/web_test/renderer/web_test_content_renderer_client.cc

@@ -13,7 +13,6 @@
 #include "build/build_config.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
-#include "content/renderer/loader/web_worker_fetch_context_impl.h"
 #include "content/shell/common/shell_switches.h"
 #include "content/shell/renderer/shell_render_frame_observer.h"
 #include "content/web_test/common/web_test_switches.h"
@@ -26,6 +25,7 @@
 #include "media/media_buildflags.h"
 #include "third_party/blink/public/common/unique_name/unique_name_helper.h"
 #include "third_party/blink/public/platform/web_audio_latency_hint.h"
+#include "third_party/blink/public/platform/web_dedicated_or_shared_worker_fetch_context.h"
 #include "third_party/blink/public/platform/web_runtime_features.h"
 #include "third_party/blink/public/test/frame_widget_test_helper.h"
 #include "third_party/blink/public/web/blink.h"
@@ -89,7 +89,8 @@ WebTestContentRendererClient::WebTestContentRendererClient() {
   blink::InstallCreateWebFrameWidgetHook(&create_widget_callback_);
 
   blink::UniqueNameHelper::PreserveStableUniqueNameForTesting();
-  WebWorkerFetchContextImpl::InstallRewriteURLFunction(RewriteWebTestsURL);
+  blink::WebDedicatedOrSharedWorkerFetchContext::InstallRewriteURLFunction(
+      RewriteWebTestsURL);
 }
 
 WebTestContentRendererClient::~WebTestContentRendererClient() {

third_party/blink/public/BUILD.gn

@@ -191,6 +191,7 @@ source_set("blink_headers") {
     "platform/web_crypto_key_algorithm.h",
     "platform/web_crypto_key_algorithm_params.h",
     "platform/web_data.h",
+    "platform/web_dedicated_or_shared_worker_fetch_context.h",
     "platform/web_dedicated_worker.h",
     "platform/web_dedicated_worker_host_factory_client.h",
     "platform/web_distillability.h",

third_party/blink/public/platform/platform.h

@@ -32,6 +32,7 @@
 #define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_PLATFORM_H_
 
 #include <memory>
+#include <tuple>
 #include <vector>
 
 #include "base/callback.h"
@@ -43,13 +44,17 @@
 #include "media/base/audio_latency.h"
 #include "media/base/audio_renderer_sink.h"
 #include "media/base/media_log.h"
+#include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
 #include "third_party/blink/public/common/security/protocol_handler_security_level.h"
 #include "third_party/blink/public/common/user_agent/user_agent_metadata.h"
 #include "third_party/blink/public/mojom/loader/code_cache.mojom-forward.h"
+#include "third_party/blink/public/mojom/service_worker/service_worker_container.mojom-shared.h"
+#include "third_party/blink/public/mojom/timing/worker_timing_container.mojom-forward.h"
 #include "third_party/blink/public/platform/audio/web_audio_device_source_type.h"
 #include "third_party/blink/public/platform/blame_context.h"
 #include "third_party/blink/public/platform/cross_variant_mojo_util.h"
+#include "third_party/blink/public/platform/url_loader_throttle_provider.h"
 #include "third_party/blink/public/platform/web_audio_device.h"
 #include "third_party/blink/public/platform/web_code_cache_loader.h"
 #include "third_party/blink/public/platform/web_common.h"
@@ -58,6 +63,7 @@
 #include "third_party/blink/public/platform/web_string.h"
 #include "third_party/blink/public/platform/web_url_loader_factory.h"
 #include "third_party/blink/public/platform/web_v8_value_converter.h"
+#include "third_party/blink/public/platform/websocket_handshake_throttle_provider.h"
 #include "third_party/webrtc/api/video/video_codec_type.h"
 #include "ui/base/resource/scale_factor.h"
 
@@ -367,6 +373,21 @@ class BLINK_PLATFORM_EXPORT Platform {
   // May return null on some platforms.
   virtual WebPublicSuffixList* PublicSuffixList() { return nullptr; }
 
+  // Allows the embedder to return a (possibly null)
+  // blink::URLLoaderThrottleProvider for a worker.
+  virtual std::unique_ptr<URLLoaderThrottleProvider>
+  CreateURLLoaderThrottleProviderForWorker(
+      URLLoaderThrottleProviderType provider_type) {
+    return nullptr;
+  }
+
+  // Allows the embedder to provide a WebSocketHandshakeThrottleProvider. If it
+  // returns nullptr then none will be used.
+  virtual std::unique_ptr<WebSocketHandshakeThrottleProvider>
+  CreateWebSocketHandshakeThrottleProvider() {
+    return nullptr;
+  }
+
   // Resources -----------------------------------------------------------
 
   // Returns a localized string resource (with substitution parameters).
@@ -727,6 +748,45 @@ class BLINK_PLATFORM_EXPORT Platform {
     return false;
   }
 
+  // Returns true if the origin can register a service worker. Scheme must be
+  // http (localhost only), https, or a custom-set secure scheme.
+  virtual bool OriginCanAccessServiceWorkers(const WebURL& url) {
+    return false;
+  }
+
+  // Clones the current `service_worker_container_host` and returns the original
+  // host and the cloned one together.
+  //
+  // TODO(https://crbug.com/1110176): Remove this method once the mojom
+  // interface ServiceWorkerContainerHost is moved out of mojom_core, which is
+  // not available from renderer/platform.
+  virtual std::tuple<
+      CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>,
+      CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>>
+  CloneServiceWorkerContainerHost(
+      CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
+          service_worker_container_host) {
+    return std::make_tuple(
+        /*original_service_worker_container_host=*/CrossVariantMojoRemote<
+            mojom::ServiceWorkerContainerHostInterfaceBase>(),
+        /*cloned_service_worker_container_host=*/CrossVariantMojoRemote<
+            mojom::ServiceWorkerContainerHostInterfaceBase>());
+  }
+
+  // Creates a ServiceWorkerSubresourceLoaderFactory.
+  virtual void CreateServiceWorkerSubresourceLoaderFactory(
+      CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
+          service_worker_container_host,
+      const WebString& client_id,
+      std::unique_ptr<network::PendingSharedURLLoaderFactory> fallback_factory,
+      mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver,
+      scoped_refptr<base::SequencedTaskRunner> task_runner,
+      scoped_refptr<base::SequencedTaskRunner>
+          worker_timing_callback_task_runner,
+      base::RepeatingCallback<
+          void(int, mojo::PendingReceiver<blink::mojom::WorkerTimingContainer>)>
+          worker_timing_callback) {}
+
   // WebCrypto ----------------------------------------------------------
 
   virtual WebCrypto* Crypto() { return nullptr; }

third_party/blink/public/platform/web_dedicated_or_shared_worker_fetch_context.h

@@ -0,0 +1,109 @@
+// Copyright 2021 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 THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_DEDICATED_OR_SHARED_WORKER_FETCH_CONTEXT_H_
+#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_DEDICATED_OR_SHARED_WORKER_FETCH_CONTEXT_H_
+
+#include <memory>
+
+#include "mojo/public/cpp/bindings/pending_remote.h"
+#include "services/network/public/cpp/shared_url_loader_factory.h"
+#include "third_party/blink/public/common/renderer_preferences/renderer_preferences.h"
+#include "third_party/blink/public/mojom/loader/resource_load_info_notifier.mojom-forward.h"
+#include "third_party/blink/public/mojom/renderer_preference_watcher.mojom-shared.h"
+#include "third_party/blink/public/mojom/worker/subresource_loader_updater.mojom-shared.h"
+#include "third_party/blink/public/platform/cross_variant_mojo_util.h"
+#include "third_party/blink/public/platform/web_common.h"
+#include "third_party/blink/public/platform/web_worker_fetch_context.h"
+
+namespace blink {
+
+class WebFrameRequestBlocker;
+class WebString;
+template <typename T>
+class WebVector;
+class WebServiceWorkerProviderContext;
+
+// Worker fetch context for dedicated worker or shared worker.
+class BLINK_PLATFORM_EXPORT WebDedicatedOrSharedWorkerFetchContext
+    : public WebWorkerFetchContext {
+ public:
+  // Creates a new fetch context for a worker.
+  //
+  // |provider_context| is used to set up information for using service workers.
+  // It can be null if the worker is not allowed to use service workers due to
+  // security reasons like sandboxed iframes, insecure origins etc.
+  // |pending_loader_factory| is used for regular loading by the worker.
+  //
+  // If the worker is controlled by a service worker, this class makes another
+  // loader factory which sends requests to the service worker, and passes
+  // |pending_fallback_factory| to that factory to use for network fallback.
+  //
+  // |pending_loader_factory| and |pending_fallback_factory| are different
+  // because |pending_loader_factory| can possibly include a default factory
+  // like AppCache, while |pending_fallback_factory| should not have such a
+  // default factory and instead go directly to network for http(s) requests.
+  // |pending_fallback_factory| might not be simply the direct network factory,
+  // because it might additionally support non-NetworkService schemes (e.g.,
+  // chrome-extension://).
+  static scoped_refptr<WebDedicatedOrSharedWorkerFetchContext> Create(
+      WebServiceWorkerProviderContext* provider_context,
+      const RendererPreferences& renderer_preferences,
+      CrossVariantMojoReceiver<mojom::RendererPreferenceWatcherInterfaceBase>
+          watcher_receiver,
+      std::unique_ptr<network::PendingSharedURLLoaderFactory>
+          pending_loader_factory,
+      std::unique_ptr<network::PendingSharedURLLoaderFactory>
+          pending_fallback_factory,
+      CrossVariantMojoReceiver<mojom::SubresourceLoaderUpdaterInterfaceBase>
+          pending_subresource_loader_updater,
+      const WebVector<WebString>& cors_exempt_header_list,
+      mojo::PendingRemote<mojom::ResourceLoadInfoNotifier>
+          pending_resource_load_info_notifier);
+
+  // Clones this fetch context for a nested worker.
+  // For non-PlzDedicatedWorker. This will be removed once PlzDedicatedWorker is
+  // enabled by default.
+  virtual scoped_refptr<WebDedicatedOrSharedWorkerFetchContext>
+  CloneForNestedWorkerDeprecated(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) = 0;
+
+  // For PlzDedicatedWorker. The cloned fetch context does not inherit some
+  // fields (e.g., blink::WebServiceWorkerProviderContext) from this fetch
+  // context, and instead that takes values passed from the browser process.
+  virtual scoped_refptr<WebDedicatedOrSharedWorkerFetchContext>
+  CloneForNestedWorker(
+      WebServiceWorkerProviderContext* service_worker_provider_context,
+      std::unique_ptr<network::PendingSharedURLLoaderFactory>
+          pending_loader_factory,
+      std::unique_ptr<network::PendingSharedURLLoaderFactory>
+          pending_fallback_factory,
+      CrossVariantMojoReceiver<mojom::SubresourceLoaderUpdaterInterfaceBase>
+          pending_subresource_loader_updater,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) = 0;
+
+  // Sets properties associated with frames.
+  // - For dedicated workers, the property is copied from the ancestor frame
+  //   (directly for non-nested workers, or indirectly via its parent worker for
+  //   nested workers).
+  // - For shared workers, there is no parent frame, so the default value, or a
+  //   value calculated in some way is set.
+  //
+  // TODO(nhiroki): Add more comments about security/privacy implications to
+  // each property, for example, site_for_cookies and top_frame_origin.
+  virtual void set_ancestor_frame_id(int id) = 0;
+  virtual void set_frame_request_blocker(
+      scoped_refptr<WebFrameRequestBlocker> frame_request_blocker) = 0;
+  virtual void set_site_for_cookies(
+      const net::SiteForCookies& site_for_cookies) = 0;
+  virtual void set_top_frame_origin(
+      const blink::WebSecurityOrigin& top_frame_origin) = 0;
+
+  using RewriteURLFunction = WebURL (*)(base::StringPiece, bool);
+  static void InstallRewriteURLFunction(RewriteURLFunction rewrite_url);
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_DEDICATED_OR_SHARED_WORKER_FETCH_CONTEXT_H_

third_party/blink/public/platform/web_worker_fetch_context.h

@@ -1,5 +1,4 @@
 // Copyright 2017 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.
 
@@ -36,8 +35,9 @@ namespace blink {
 class WebURLRequest;
 class WebDocumentSubresourceFilter;
 
-// Helper class allowing WebWorkerFetchContextImpl to notify blink upon an
-// accept languages update. This class will be extended by WorkerNavigator.
+// Helper class allowing DedicatedOrSharedWorkerFetchContextImpl to notify blink
+// upon an accept languages update. This class will be extended by
+// WorkerNavigator.
 class AcceptLanguagesWatcher {
  public:
   virtual void NotifyUpdate() = 0;
@@ -141,7 +141,7 @@ class WebWorkerFetchContext : public base::RefCounted<WebWorkerFetchContext> {
     return nullptr;
   }
 
-  // Returns the current list of user prefered languages.
+  // Returns the current list of user preferred languages.
   virtual blink::WebString GetAcceptLanguages() const = 0;
 
   // Returns the blink::mojom::WorkerTimingContainer receiver for the
@@ -160,6 +160,10 @@ class WebWorkerFetchContext : public base::RefCounted<WebWorkerFetchContext> {
     return std::make_unique<blink::ResourceLoadInfoNotifierWrapper>(
         /*resource_load_info_notifier=*/nullptr);
   }
+
+  virtual bool IsDedicatedWorkerOrSharedWorkerFetchContext() const {
+    return false;
+  }
 };
 
 }  // namespace blink

third_party/blink/renderer/core/workers/dedicated_worker.cc

@@ -51,7 +51,9 @@
 #include "third_party/blink/renderer/platform/instrumentation/use_counter.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_fetcher.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_fetcher_properties.h"
+#include "third_party/blink/renderer/platform/loader/fetch/url_loader/dedicated_or_shared_worker_fetch_context_impl.h"
 #include "third_party/blink/renderer/platform/weborigin/security_policy.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
 
@@ -477,9 +479,12 @@ DedicatedWorker::CreateWebWorkerFetchContext() {
   // This worker is being created by an existing worker (i.e., nested workers).
   // Clone the worker fetch context from the parent's one.
   auto* scope = To<WorkerGlobalScope>(GetExecutionContext());
+  auto& worker_fetch_context =
+      static_cast<WorkerFetchContext&>(scope->Fetcher()->Context());
+
   return factory_client_->CloneWorkerFetchContext(
-      static_cast<WorkerFetchContext&>(scope->Fetcher()->Context())
-          .GetWebWorkerFetchContext(),
+      To<DedicatedOrSharedWorkerFetchContextImpl>(
+          worker_fetch_context.GetWebWorkerFetchContext()),
       scope->GetTaskRunner(TaskType::kNetworking));
 }
 

third_party/blink/renderer/core/workers/worker_navigator.cc

@@ -44,11 +44,11 @@ WorkerNavigator::~WorkerNavigator() = default;
 String WorkerNavigator::GetAcceptLanguages() {
   WorkerOrWorkletGlobalScope* global_scope =
       To<WorkerOrWorkletGlobalScope>(GetExecutionContext());
-  WebWorkerFetchContext* worker_fetch_context =
+  auto* web_worker_fetch_context =
       static_cast<WorkerFetchContext*>(
           (&global_scope->EnsureFetcher()->Context()))
           ->GetWebWorkerFetchContext();
-  return worker_fetch_context->GetAcceptLanguages();
+  return web_worker_fetch_context->GetAcceptLanguages();
 }
 
 void WorkerNavigator::NotifyUpdate() {

third_party/blink/renderer/platform/loader/BUILD.gn

@@ -120,6 +120,8 @@ blink_platform_sources("loader") {
     "fetch/trust_token_params_conversion.h",
     "fetch/unique_identifier.cc",
     "fetch/unique_identifier.h",
+    "fetch/url_loader/dedicated_or_shared_worker_fetch_context_impl.cc",
+    "fetch/url_loader/dedicated_or_shared_worker_fetch_context_impl.h",
     "fetch/url_loader/mojo_url_loader_client.cc",
     "fetch/url_loader/mojo_url_loader_client.h",
     "fetch/url_loader/request_conversion.cc",

third_party/blink/renderer/platform/loader/fetch/url_loader/DEPS

@@ -1,6 +1,8 @@
 include_rules = [
     "+base/atomic_sequence_num.h",
     "+base/containers/queue.h",
+    "+base/strings/string_piece.h",
+    "+base/threading/sequenced_task_runner_handle.h",
     "+net/base/registry_controlled_domains/registry_controlled_domain.h",
     "+net/base/request_priority.h",
     "+net/base/host_port_pair.h",

third_party/blink/renderer/platform/loader/fetch/url_loader/dedicated_or_shared_worker_fetch_context_impl.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/renderer/loader/web_worker_fetch_context_impl.h"
+#include "third_party/blink/renderer/platform/loader/fetch/url_loader/dedicated_or_shared_worker_fetch_context_impl.h"
 
 #include <utility>
 
@@ -11,12 +11,6 @@
 #include "base/task/post_task.h"
 #include "base/task/thread_pool.h"
 #include "base/threading/sequenced_task_runner_handle.h"
-#include "content/child/child_thread_impl.h"
-#include "content/public/common/content_client.h"
-#include "content/public/common/origin_util.h"
-#include "content/public/renderer/content_renderer_client.h"
-#include "content/renderer/service_worker/controller_service_worker_connector.h"
-#include "content/renderer/service_worker/service_worker_subresource_loader.h"
 #include "services/network/public/cpp/wrapper_shared_url_loader_factory.h"
 #include "third_party/blink/public/common/features.h"
 #include "third_party/blink/public/common/loader/loader_constants.h"
@@ -25,6 +19,7 @@
 #include "third_party/blink/public/mojom/timing/worker_timing_container.mojom.h"
 #include "third_party/blink/public/platform/child_url_loader_factory_bundle.h"
 #include "third_party/blink/public/platform/modules/service_worker/web_service_worker_provider_context.h"
+#include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/resource_load_info_notifier_wrapper.h"
 #include "third_party/blink/public/platform/url_loader_throttle_provider.h"
 #include "third_party/blink/public/platform/weak_wrapper_resource_load_info_notifier.h"
@@ -36,18 +31,20 @@
 #include "third_party/blink/public/platform/web_url_loader_factory.h"
 #include "third_party/blink/public/platform/web_url_request_extra_data.h"
 #include "third_party/blink/public/platform/websocket_handshake_throttle_provider.h"
+#include "url/url_constants.h"
 
-namespace content {
+namespace blink {
 
-WebWorkerFetchContextImpl::RewriteURLFunction g_rewrite_url = nullptr;
+DedicatedOrSharedWorkerFetchContextImpl::RewriteURLFunction g_rewrite_url =
+    nullptr;
 
 namespace {
 
 // Runs on a background thread created in ResetServiceWorkerURLLoaderFactory().
 void CreateServiceWorkerSubresourceLoaderFactory(
-    mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
-        remote_container_host,
-    const std::string& client_id,
+    CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
+        service_worker_container_host,
+    const WebString& client_id,
     std::unique_ptr<network::PendingSharedURLLoaderFactory> fallback_factory,
     mojo::PendingReceiver<network::mojom::URLLoaderFactory> receiver,
     scoped_refptr<base::SequencedTaskRunner> task_runner,
@@ -55,49 +52,40 @@ void CreateServiceWorkerSubresourceLoaderFactory(
     base::RepeatingCallback<
         void(int, mojo::PendingReceiver<blink::mojom::WorkerTimingContainer>)>
         worker_timing_callback) {
-  ServiceWorkerSubresourceLoaderFactory::Create(
-      base::MakeRefCounted<ControllerServiceWorkerConnector>(
-          std::move(remote_container_host),
-          mojo::NullRemote() /* remote_controller */, client_id),
-      network::SharedURLLoaderFactory::Create(std::move(fallback_factory)),
-      std::move(receiver), std::move(task_runner),
+  Platform::Current()->CreateServiceWorkerSubresourceLoaderFactory(
+      std::move(service_worker_container_host), client_id,
+      std::move(fallback_factory), std::move(receiver), std::move(task_runner),
       std::move(worker_timing_callback_task_runner),
       std::move(worker_timing_callback));
 }
 
 }  // namespace
 
-// static
-void WebWorkerFetchContextImpl::InstallRewriteURLFunction(
-    RewriteURLFunction rewrite_url) {
-  CHECK(!g_rewrite_url);
-  g_rewrite_url = rewrite_url;
-}
-
 // An implementation of WebURLLoaderFactory that is aware of service workers. In
 // the usual case, it creates a loader that uses |loader_factory_|. But if the
 // worker fetch context is controlled by a service worker, it creates a loader
 // that uses |service_worker_loader_factory_| for requests that should be
 // intercepted by the service worker.
-class WebWorkerFetchContextImpl::Factory : public blink::WebURLLoaderFactory {
+class DedicatedOrSharedWorkerFetchContextImpl::Factory
+    : public WebURLLoaderFactory {
  public:
   Factory(scoped_refptr<network::SharedURLLoaderFactory> loader_factory,
-          const blink::WebVector<blink::WebString>& cors_exempt_header_list,
+          const WebVector<WebString>& cors_exempt_header_list,
           base::WaitableEvent* terminate_sync_load_event)
       : WebURLLoaderFactory(std::move(loader_factory),
                             cors_exempt_header_list,
                             terminate_sync_load_event) {}
   ~Factory() override = default;
 
-  std::unique_ptr<blink::WebURLLoader> CreateURLLoader(
-      const blink::WebURLRequest& request,
+  std::unique_ptr<WebURLLoader> CreateURLLoader(
+      const WebURLRequest& request,
       std::unique_ptr<blink::scheduler::WebResourceLoadingTaskRunnerHandle>
           freezable_task_runner_handle,
       std::unique_ptr<blink::scheduler::WebResourceLoadingTaskRunnerHandle>
           unfreezable_task_runner_handle,
-      blink::CrossVariantMojoRemote<blink::mojom::KeepAliveHandleInterfaceBase>
+      CrossVariantMojoRemote<mojom::KeepAliveHandleInterfaceBase>
           keep_alive_handle,
-      blink::WebBackForwardCacheLoaderHelper back_forward_cache_loader_helper)
+      WebBackForwardCacheLoaderHelper back_forward_cache_loader_helper)
       override {
     DCHECK(freezable_task_runner_handle);
     DCHECK(unfreezable_task_runner_handle);
@@ -105,7 +93,7 @@ class WebWorkerFetchContextImpl::Factory : public blink::WebURLLoaderFactory {
     if (CanCreateServiceWorkerURLLoader(request)) {
       // Create our own URLLoader to route the request to the controller service
       // worker.
-      return std::make_unique<blink::WebURLLoader>(
+      return std::make_unique<WebURLLoader>(
           cors_exempt_header_list_, terminate_sync_load_event_,
           std::move(freezable_task_runner_handle),
           std::move(unfreezable_task_runner_handle),
@@ -113,7 +101,7 @@ class WebWorkerFetchContextImpl::Factory : public blink::WebURLLoaderFactory {
           back_forward_cache_loader_helper);
     }
 
-    return std::make_unique<blink::WebURLLoader>(
+    return std::make_unique<WebURLLoader>(
         cors_exempt_header_list_, terminate_sync_load_event_,
         std::move(freezable_task_runner_handle),
         std::move(unfreezable_task_runner_handle), loader_factory_,
@@ -135,7 +123,7 @@ class WebWorkerFetchContextImpl::Factory : public blink::WebURLLoaderFactory {
   base::WeakPtr<Factory> GetWeakPtr() { return weak_ptr_factory_.GetWeakPtr(); }
 
  private:
-  bool CanCreateServiceWorkerURLLoader(const blink::WebURLRequest& request) {
+  bool CanCreateServiceWorkerURLLoader(const WebURLRequest& request) {
     // TODO(horo): Unify this code path with
     // ServiceWorkerNetworkProviderForFrame::CreateURLLoader that is used
     // for document cases.
@@ -151,8 +139,9 @@ class WebWorkerFetchContextImpl::Factory : public blink::WebURLLoaderFactory {
     // TODO(falken): Let ServiceWorkerSubresourceLoaderFactory handle the
     // request and move this check there (i.e., for such URLs, it should use
     // its fallback factory).
-    if (!GURL(request.Url()).SchemeIsHTTPOrHTTPS() &&
-        !OriginCanAccessServiceWorkers(request.Url())) {
+    if (!request.Url().ProtocolIs(url::kHttpScheme) &&
+        !request.Url().ProtocolIs(url::kHttpsScheme) &&
+        !Platform::Current()->OriginCanAccessServiceWorkers(request.Url())) {
       return false;
     }
 
@@ -168,100 +157,36 @@ class WebWorkerFetchContextImpl::Factory : public blink::WebURLLoaderFactory {
   DISALLOW_COPY_AND_ASSIGN(Factory);
 };
 
-scoped_refptr<WebWorkerFetchContextImpl> WebWorkerFetchContextImpl::Create(
-    blink::WebServiceWorkerProviderContext* provider_context,
-    const blink::RendererPreferences& renderer_preferences,
-    mojo::PendingReceiver<blink::mojom::RendererPreferenceWatcher>
-        watcher_receiver,
-    std::unique_ptr<network::PendingSharedURLLoaderFactory>
-        pending_loader_factory,
-    std::unique_ptr<network::PendingSharedURLLoaderFactory>
-        pending_fallback_factory,
-    mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
-        pending_subresource_loader_updater,
-    const std::vector<std::string>& cors_exempt_header_list,
-    mojo::PendingRemote<blink::mojom::ResourceLoadInfoNotifier>
-        pending_resource_load_info_notifier) {
-  mojo::PendingReceiver<blink::mojom::ServiceWorkerWorkerClient>
-      service_worker_client_receiver;
-  mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClientRegistry>
-      service_worker_worker_client_registry;
-  mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
-      service_worker_container_host;
-
-  // Some sandboxed iframes are not allowed to use service worker so don't have
-  // a real service worker provider, so the provider context is null.
-  if (provider_context) {
-    provider_context->BindServiceWorkerWorkerClientRegistryReceiver(
-        service_worker_worker_client_registry.InitWithNewPipeAndPassReceiver());
-
-    mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClient> worker_client;
-    service_worker_client_receiver =
-        worker_client.InitWithNewPipeAndPassReceiver();
-    provider_context->BindServiceWorkerWorkerClientRemote(
-        std::move(worker_client));
-
-    service_worker_container_host =
-        provider_context->CloneRemoteContainerHost();
-  }
-
-  scoped_refptr<WebWorkerFetchContextImpl> worker_fetch_context =
-      base::AdoptRef(new WebWorkerFetchContextImpl(
-          renderer_preferences, std::move(watcher_receiver),
-          std::move(service_worker_client_receiver),
-          std::move(service_worker_worker_client_registry),
-          std::move(service_worker_container_host),
-          std::move(pending_loader_factory),
-          std::move(pending_fallback_factory),
-          std::move(pending_subresource_loader_updater),
-          GetContentClient()->renderer()->CreateURLLoaderThrottleProvider(
-              blink::URLLoaderThrottleProviderType::kWorker),
-          GetContentClient()
-              ->renderer()
-              ->CreateWebSocketHandshakeThrottleProvider(),
-          cors_exempt_header_list,
-          std::move(pending_resource_load_info_notifier)));
-  if (provider_context) {
-    worker_fetch_context->set_controller_service_worker_mode(
-        provider_context->GetControllerServiceWorkerMode());
-    worker_fetch_context->set_client_id(provider_context->client_id());
-  } else {
-    worker_fetch_context->set_controller_service_worker_mode(
-        blink::mojom::ControllerServiceWorkerMode::kNoController);
-  }
-  return worker_fetch_context;
-}
-
-WebWorkerFetchContextImpl::WebWorkerFetchContextImpl(
-    const blink::RendererPreferences& renderer_preferences,
-    mojo::PendingReceiver<blink::mojom::RendererPreferenceWatcher>
-        preference_watcher_receiver,
-    mojo::PendingReceiver<blink::mojom::ServiceWorkerWorkerClient>
-        service_worker_client_receiver,
-    mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClientRegistry>
-        pending_service_worker_worker_client_registry,
-    mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
-        service_worker_container_host,
-    std::unique_ptr<network::PendingSharedURLLoaderFactory>
-        pending_loader_factory,
-    std::unique_ptr<network::PendingSharedURLLoaderFactory>
-        pending_fallback_factory,
-    mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
-        pending_subresource_loader_updater,
-    std::unique_ptr<blink::URLLoaderThrottleProvider> throttle_provider,
-    std::unique_ptr<blink::WebSocketHandshakeThrottleProvider>
-        websocket_handshake_throttle_provider,
-    const std::vector<std::string>& cors_exempt_header_list,
-    mojo::PendingRemote<blink::mojom::ResourceLoadInfoNotifier>
-        pending_resource_load_info_notifier)
+DedicatedOrSharedWorkerFetchContextImpl::
+    DedicatedOrSharedWorkerFetchContextImpl(
+        const RendererPreferences& renderer_preferences,
+        mojo::PendingReceiver<mojom::blink::RendererPreferenceWatcher>
+            preference_watcher_receiver,
+        mojo::PendingReceiver<mojom::blink::ServiceWorkerWorkerClient>
+            service_worker_client_receiver,
+        mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClientRegistry>
+            pending_service_worker_worker_client_registry,
+        CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
+            service_worker_container_host,
+        std::unique_ptr<network::PendingSharedURLLoaderFactory>
+            pending_loader_factory,
+        std::unique_ptr<network::PendingSharedURLLoaderFactory>
+            pending_fallback_factory,
+        mojo::PendingReceiver<mojom::blink::SubresourceLoaderUpdater>
+            pending_subresource_loader_updater,
+        std::unique_ptr<URLLoaderThrottleProvider> throttle_provider,
+        std::unique_ptr<WebSocketHandshakeThrottleProvider>
+            websocket_handshake_throttle_provider,
+        const WebVector<WebString>& cors_exempt_header_list,
+        mojo::PendingRemote<mojom::ResourceLoadInfoNotifier>
+            pending_resource_load_info_notifier)
     : service_worker_client_receiver_(
           std::move(service_worker_client_receiver)),
       pending_service_worker_worker_client_registry_(
           std::move(pending_service_worker_worker_client_registry)),
-      pending_service_worker_container_host_(
-          std::move(service_worker_container_host)),
       pending_loader_factory_(std::move(pending_loader_factory)),
       pending_fallback_factory_(std::move(pending_fallback_factory)),
+      service_worker_container_host_(std::move(service_worker_container_host)),
       pending_subresource_loader_updater_(
           std::move(pending_subresource_loader_updater)),
       renderer_preferences_(renderer_preferences),
@@ -270,29 +195,25 @@ WebWorkerFetchContextImpl::WebWorkerFetchContextImpl(
       throttle_provider_(std::move(throttle_provider)),
       websocket_handshake_throttle_provider_(
           std::move(websocket_handshake_throttle_provider)),
-      cors_exempt_header_list_(cors_exempt_header_list),
+      cors_exempt_header_list_(cors_exempt_header_list.size()),
       pending_resource_load_info_notifier_(
-          std::move(pending_resource_load_info_notifier)) {}
-
-WebWorkerFetchContextImpl::~WebWorkerFetchContextImpl() = default;
-
-void WebWorkerFetchContextImpl::SetTerminateSyncLoadEvent(
-    base::WaitableEvent* terminate_sync_load_event) {
-  DCHECK(!terminate_sync_load_event_);
-  terminate_sync_load_event_ = terminate_sync_load_event;
+          std::move(pending_resource_load_info_notifier)) {
+  // Make a deep copy because we will visit it on the worker thread.
+  for (const WebString& cors_exempt_header : cors_exempt_header_list)
+    cors_exempt_header_list_.emplace_back(cors_exempt_header.IsolatedCopy());
 }
 
-scoped_refptr<WebWorkerFetchContextImpl>
-WebWorkerFetchContextImpl::CloneForNestedWorkerDeprecated(
+scoped_refptr<WebDedicatedOrSharedWorkerFetchContext>
+DedicatedOrSharedWorkerFetchContextImpl::CloneForNestedWorkerDeprecated(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  DCHECK(!base::FeatureList::IsEnabled(blink::features::kPlzDedicatedWorker));
+  DCHECK(!base::FeatureList::IsEnabled(features::kPlzDedicatedWorker));
 
-  mojo::PendingReceiver<blink::mojom::ServiceWorkerWorkerClient>
+  mojo::PendingReceiver<mojom::blink::ServiceWorkerWorkerClient>
       service_worker_client_receiver;
-  mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClientRegistry>
+  mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClientRegistry>
       service_worker_worker_client_registry;
   if (service_worker_worker_client_registry_) {
-    mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClient>
+    mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClient>
         service_worker_client;
     service_worker_client_receiver =
         service_worker_client.InitWithNewPipeAndPassReceiver();
@@ -302,21 +223,23 @@ WebWorkerFetchContextImpl::CloneForNestedWorkerDeprecated(
         service_worker_worker_client_registry.InitWithNewPipeAndPassReceiver());
   }
 
-  mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
-      service_worker_container_host;
+  CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
+      cloned_service_worker_container_host;
   if (service_worker_container_host_) {
-    service_worker_container_host_->CloneContainerHost(
-        service_worker_container_host.InitWithNewPipeAndPassReceiver());
+    std::tie(service_worker_container_host_,
+             cloned_service_worker_container_host) =
+        Platform::Current()->CloneServiceWorkerContainerHost(
+            std::move(service_worker_container_host_));
   }
 
   // |pending_subresource_loader_updater| is not used for
   // non-PlzDedicatedWorker.
-  scoped_refptr<WebWorkerFetchContextImpl> new_context =
+  scoped_refptr<DedicatedOrSharedWorkerFetchContextImpl> new_context =
       CloneForNestedWorkerInternal(
           std::move(service_worker_client_receiver),
           std::move(service_worker_worker_client_registry),
-          std::move(service_worker_container_host), loader_factory_->Clone(),
-          fallback_factory_->Clone(),
+          std::move(cloned_service_worker_container_host),
+          loader_factory_->Clone(), fallback_factory_->Clone(),
           /*pending_subresource_loader_updater=*/mojo::NullReceiver(),
           std::move(task_runner));
   new_context->controller_service_worker_mode_ =
@@ -325,17 +248,17 @@ WebWorkerFetchContextImpl::CloneForNestedWorkerDeprecated(
   return new_context;
 }
 
-scoped_refptr<WebWorkerFetchContextImpl>
-WebWorkerFetchContextImpl::CloneForNestedWorker(
-    blink::WebServiceWorkerProviderContext* service_worker_provider_context,
+scoped_refptr<WebDedicatedOrSharedWorkerFetchContext>
+DedicatedOrSharedWorkerFetchContextImpl::CloneForNestedWorker(
+    WebServiceWorkerProviderContext* service_worker_provider_context,
     std::unique_ptr<network::PendingSharedURLLoaderFactory>
         pending_loader_factory,
     std::unique_ptr<network::PendingSharedURLLoaderFactory>
         pending_fallback_factory,
-    mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
+    CrossVariantMojoReceiver<mojom::SubresourceLoaderUpdaterInterfaceBase>
         pending_subresource_loader_updater,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  DCHECK(base::FeatureList::IsEnabled(blink::features::kPlzDedicatedWorker));
+  DCHECK(base::FeatureList::IsEnabled(features::kPlzDedicatedWorker));
   DCHECK(pending_loader_factory);
   DCHECK(pending_fallback_factory);
   DCHECK(task_runner);
@@ -344,30 +267,32 @@ WebWorkerFetchContextImpl::CloneForNestedWorker(
     return CloneForNestedWorkerInternal(
         /*service_worker_client_receiver=*/mojo::NullReceiver(),
         /*service_worker_worker_client_registry=*/mojo::NullRemote(),
-        /*container_host=*/mojo::NullRemote(),
+        /*container_host=*/
+        CrossVariantMojoRemote<
+            mojom::ServiceWorkerContainerHostInterfaceBase>(),
         std::move(pending_loader_factory), std::move(pending_fallback_factory),
         std::move(pending_subresource_loader_updater), std::move(task_runner));
   }
 
-  mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClientRegistry>
+  mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClientRegistry>
       service_worker_worker_client_registry;
   service_worker_provider_context
       ->BindServiceWorkerWorkerClientRegistryReceiver(
           service_worker_worker_client_registry
               .InitWithNewPipeAndPassReceiver());
 
-  mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClient> worker_client;
-  mojo::PendingReceiver<blink::mojom::ServiceWorkerWorkerClient>
+  mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClient> worker_client;
+  mojo::PendingReceiver<mojom::blink::ServiceWorkerWorkerClient>
       service_worker_client_receiver =
           worker_client.InitWithNewPipeAndPassReceiver();
   service_worker_provider_context->BindServiceWorkerWorkerClientRemote(
       std::move(worker_client));
 
-  mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
+  CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
       service_worker_container_host =
           service_worker_provider_context->CloneRemoteContainerHost();
 
-  scoped_refptr<WebWorkerFetchContextImpl> new_context =
+  scoped_refptr<DedicatedOrSharedWorkerFetchContextImpl> new_context =
       CloneForNestedWorkerInternal(
           std::move(service_worker_client_receiver),
           std::move(service_worker_worker_client_registry),
@@ -382,8 +307,33 @@ WebWorkerFetchContextImpl::CloneForNestedWorker(
   return new_context;
 }
 
-void WebWorkerFetchContextImpl::InitializeOnWorkerThread(
-    blink::AcceptLanguagesWatcher* watcher) {
+void DedicatedOrSharedWorkerFetchContextImpl::set_ancestor_frame_id(int id) {
+  ancestor_frame_id_ = id;
+}
+
+void DedicatedOrSharedWorkerFetchContextImpl::set_frame_request_blocker(
+    scoped_refptr<WebFrameRequestBlocker> frame_request_blocker) {
+  frame_request_blocker_ = frame_request_blocker;
+}
+
+void DedicatedOrSharedWorkerFetchContextImpl::set_site_for_cookies(
+    const net::SiteForCookies& site_for_cookies) {
+  site_for_cookies_ = site_for_cookies;
+}
+
+void DedicatedOrSharedWorkerFetchContextImpl::set_top_frame_origin(
+    const WebSecurityOrigin& top_frame_origin) {
+  top_frame_origin_ = top_frame_origin;
+}
+
+void DedicatedOrSharedWorkerFetchContextImpl::SetTerminateSyncLoadEvent(
+    base::WaitableEvent* terminate_sync_load_event) {
+  DCHECK(!terminate_sync_load_event_);
+  terminate_sync_load_event_ = terminate_sync_load_event;
+}
+
+void DedicatedOrSharedWorkerFetchContextImpl::InitializeOnWorkerThread(
+    AcceptLanguagesWatcher* watcher) {
   DCHECK(!receiver_.is_bound());
   DCHECK(!preference_watcher_receiver_.is_bound());
 
@@ -407,17 +357,13 @@ void WebWorkerFetchContextImpl::InitializeOnWorkerThread(
         std::move(preference_watcher_pending_receiver_));
   }
 
-  if (pending_service_worker_container_host_) {
-    service_worker_container_host_.Bind(
-        std::move(pending_service_worker_container_host_));
-  }
-
   if (pending_resource_load_info_notifier_) {
     resource_load_info_notifier_.Bind(
         std::move(pending_resource_load_info_notifier_));
-    resource_load_info_notifier_.set_disconnect_handler(base::BindOnce(
-        &WebWorkerFetchContextImpl::ResetWeakWrapperResourceLoadInfoNotifier,
-        base::Unretained(this)));
+    resource_load_info_notifier_.set_disconnect_handler(
+        base::BindOnce(&DedicatedOrSharedWorkerFetchContextImpl::
+                           ResetWeakWrapperResourceLoadInfoNotifier,
+                       base::Unretained(this)));
   }
 
   accept_languages_watcher_ = watcher;
@@ -425,38 +371,38 @@ void WebWorkerFetchContextImpl::InitializeOnWorkerThread(
   DCHECK(loader_factory_);
   DCHECK(!web_loader_factory_);
   web_loader_factory_ = std::make_unique<Factory>(
-      loader_factory_, cors_exempt_header_list(), terminate_sync_load_event_);
+      loader_factory_, cors_exempt_header_list_, terminate_sync_load_event_);
 
   ResetServiceWorkerURLLoaderFactory();
 }
 
-blink::WebURLLoaderFactory* WebWorkerFetchContextImpl::GetURLLoaderFactory() {
+WebURLLoaderFactory*
+DedicatedOrSharedWorkerFetchContextImpl::GetURLLoaderFactory() {
   return web_loader_factory_.get();
 }
 
-std::unique_ptr<blink::WebURLLoaderFactory>
-WebWorkerFetchContextImpl::WrapURLLoaderFactory(
-    blink::CrossVariantMojoRemote<network::mojom::URLLoaderFactoryInterfaceBase>
+std::unique_ptr<WebURLLoaderFactory>
+DedicatedOrSharedWorkerFetchContextImpl::WrapURLLoaderFactory(
+    CrossVariantMojoRemote<network::mojom::URLLoaderFactoryInterfaceBase>
         url_loader_factory) {
-  return std::make_unique<blink::WebURLLoaderFactory>(
+  return std::make_unique<WebURLLoaderFactory>(
       base::MakeRefCounted<network::WrapperSharedURLLoaderFactory>(
           std::move(url_loader_factory)),
-      cors_exempt_header_list(), terminate_sync_load_event_);
+      cors_exempt_header_list_, terminate_sync_load_event_);
 }
 
-std::unique_ptr<blink::WebCodeCacheLoader>
-WebWorkerFetchContextImpl::CreateCodeCacheLoader() {
-  return blink::WebCodeCacheLoader::Create(terminate_sync_load_event_);
+std::unique_ptr<WebCodeCacheLoader>
+DedicatedOrSharedWorkerFetchContextImpl::CreateCodeCacheLoader() {
+  return WebCodeCacheLoader::Create(terminate_sync_load_event_);
 }
 
-void WebWorkerFetchContextImpl::WillSendRequest(blink::WebURLRequest& request) {
+void DedicatedOrSharedWorkerFetchContextImpl::WillSendRequest(
+    WebURLRequest& request) {
   if (renderer_preferences_.enable_do_not_track) {
-    request.SetHttpHeaderField(
-        blink::WebString::FromUTF8(blink::kDoNotTrackHeader), "1");
+    request.SetHttpHeaderField(WebString::FromUTF8(kDoNotTrackHeader), "1");
   }
 
-  auto url_request_extra_data =
-      base::MakeRefCounted<blink::WebURLRequestExtraData>();
+  auto url_request_extra_data = base::MakeRefCounted<WebURLRequestExtraData>();
   url_request_extra_data->set_frame_request_blocker(frame_request_blocker_);
   if (throttle_provider_) {
     url_request_extra_data->set_url_loader_throttles(
@@ -468,51 +414,54 @@ void WebWorkerFetchContextImpl::WillSendRequest(blink::WebURLRequest& request) {
     request.SetUrl(g_rewrite_url(request.Url().GetString().Utf8(), false));
 
   if (!renderer_preferences_.enable_referrers) {
-    request.SetReferrerString(blink::WebString());
+    request.SetReferrerString(WebString());
     request.SetReferrerPolicy(network::mojom::ReferrerPolicy::kNever);
   }
 }
 
-blink::mojom::ControllerServiceWorkerMode
-WebWorkerFetchContextImpl::GetControllerServiceWorkerMode() const {
+mojom::ControllerServiceWorkerMode
+DedicatedOrSharedWorkerFetchContextImpl::GetControllerServiceWorkerMode()
+    const {
   return controller_service_worker_mode_;
 }
 
-void WebWorkerFetchContextImpl::SetIsOnSubframe(bool is_on_sub_frame) {
+void DedicatedOrSharedWorkerFetchContextImpl::SetIsOnSubframe(
+    bool is_on_sub_frame) {
   is_on_sub_frame_ = is_on_sub_frame;
 }
 
-bool WebWorkerFetchContextImpl::IsOnSubframe() const {
+bool DedicatedOrSharedWorkerFetchContextImpl::IsOnSubframe() const {
   return is_on_sub_frame_;
 }
 
-net::SiteForCookies WebWorkerFetchContextImpl::SiteForCookies() const {
+net::SiteForCookies DedicatedOrSharedWorkerFetchContextImpl::SiteForCookies()
+    const {
   return site_for_cookies_;
 }
 
-absl::optional<blink::WebSecurityOrigin>
-WebWorkerFetchContextImpl::TopFrameOrigin() const {
+absl::optional<WebSecurityOrigin>
+DedicatedOrSharedWorkerFetchContextImpl::TopFrameOrigin() const {
   // TODO(jkarlin): set_top_frame_origin is only called for dedicated workers.
   // Determine the top-frame-origin of a shared worker as well. See
   // https://crbug.com/918868.
   return top_frame_origin_;
 }
 
-void WebWorkerFetchContextImpl::SetSubresourceFilterBuilder(
-    std::unique_ptr<blink::WebDocumentSubresourceFilter::Builder>
+void DedicatedOrSharedWorkerFetchContextImpl::SetSubresourceFilterBuilder(
+    std::unique_ptr<WebDocumentSubresourceFilter::Builder>
         subresource_filter_builder) {
   subresource_filter_builder_ = std::move(subresource_filter_builder);
 }
 
-std::unique_ptr<blink::WebDocumentSubresourceFilter>
-WebWorkerFetchContextImpl::TakeSubresourceFilter() {
+std::unique_ptr<WebDocumentSubresourceFilter>
+DedicatedOrSharedWorkerFetchContextImpl::TakeSubresourceFilter() {
   if (!subresource_filter_builder_)
     return nullptr;
   return std::move(subresource_filter_builder_)->Build();
 }
 
-std::unique_ptr<blink::WebSocketHandshakeThrottle>
-WebWorkerFetchContextImpl::CreateWebSocketHandshakeThrottle(
+std::unique_ptr<WebSocketHandshakeThrottle>
+DedicatedOrSharedWorkerFetchContextImpl::CreateWebSocketHandshakeThrottle(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   if (!websocket_handshake_throttle_provider_)
     return nullptr;
@@ -520,9 +469,9 @@ WebWorkerFetchContextImpl::CreateWebSocketHandshakeThrottle(
       ancestor_frame_id_, std::move(task_runner));
 }
 
-blink::CrossVariantMojoReceiver<
-    blink::mojom::WorkerTimingContainerInterfaceBase>
-WebWorkerFetchContextImpl::TakePendingWorkerTimingReceiver(int request_id) {
+CrossVariantMojoReceiver<mojom::WorkerTimingContainerInterfaceBase>
+DedicatedOrSharedWorkerFetchContextImpl::TakePendingWorkerTimingReceiver(
+    int request_id) {
   auto iter = worker_timing_container_receivers_.find(request_id);
   if (iter == worker_timing_container_receivers_.end()) {
     return {};
@@ -532,72 +481,91 @@ WebWorkerFetchContextImpl::TakePendingWorkerTimingReceiver(int request_id) {
   return std::move(receiver);
 }
 
-void WebWorkerFetchContextImpl::SetIsOfflineMode(bool is_offline_mode) {
+void DedicatedOrSharedWorkerFetchContextImpl::SetIsOfflineMode(
+    bool is_offline_mode) {
   // Worker doesn't support offline mode. There should be no callers.
   NOTREACHED();
 }
 
-void WebWorkerFetchContextImpl::set_controller_service_worker_mode(
-    blink::mojom::ControllerServiceWorkerMode mode) {
-  controller_service_worker_mode_ = mode;
-}
-
-void WebWorkerFetchContextImpl::set_ancestor_frame_id(int id) {
-  ancestor_frame_id_ = id;
-}
-
-void WebWorkerFetchContextImpl::set_frame_request_blocker(
-    scoped_refptr<blink::WebFrameRequestBlocker> frame_request_blocker) {
-  frame_request_blocker_ = frame_request_blocker;
-}
-
-void WebWorkerFetchContextImpl::set_site_for_cookies(
-    const net::SiteForCookies& site_for_cookies) {
-  site_for_cookies_ = site_for_cookies;
-}
-
-void WebWorkerFetchContextImpl::set_top_frame_origin(
-    const blink::WebSecurityOrigin& top_frame_origin) {
-  top_frame_origin_ = top_frame_origin;
-}
-
-void WebWorkerFetchContextImpl::set_client_id(
-    const blink::WebString& client_id) {
-  // Make a deep copy because we will visit it on the worker thread.
-  client_id_ = client_id.IsolatedCopy();
-}
-
-void WebWorkerFetchContextImpl::OnControllerChanged(
-    blink::mojom::ControllerServiceWorkerMode mode) {
+void DedicatedOrSharedWorkerFetchContextImpl::OnControllerChanged(
+    mojom::ControllerServiceWorkerMode mode) {
   set_controller_service_worker_mode(mode);
   ResetServiceWorkerURLLoaderFactory();
 }
 
-scoped_refptr<WebWorkerFetchContextImpl>
-WebWorkerFetchContextImpl::CloneForNestedWorkerInternal(
-    mojo::PendingReceiver<blink::mojom::ServiceWorkerWorkerClient>
+void DedicatedOrSharedWorkerFetchContextImpl::
+    set_controller_service_worker_mode(
+        mojom::ControllerServiceWorkerMode mode) {
+  controller_service_worker_mode_ = mode;
+}
+
+void DedicatedOrSharedWorkerFetchContextImpl::set_client_id(
+    const WebString& client_id) {
+  // Make a deep copy because we will visit it on the worker thread.
+  client_id_ = client_id.IsolatedCopy();
+}
+
+WebString DedicatedOrSharedWorkerFetchContextImpl::GetAcceptLanguages() const {
+  return WebString::FromUTF8(renderer_preferences_.accept_languages);
+}
+
+void DedicatedOrSharedWorkerFetchContextImpl::AddPendingWorkerTimingReceiver(
+    int request_id,
+    mojo::PendingReceiver<mojom::WorkerTimingContainer> receiver) {
+  // TODO(https://crbug.com/900700): Handle redirects properly. Currently on
+  // redirect, the receiver is replaced with a new one, discarding the timings
+  // before the redirect.
+  worker_timing_container_receivers_[request_id] = std::move(receiver);
+}
+
+std::unique_ptr<ResourceLoadInfoNotifierWrapper>
+DedicatedOrSharedWorkerFetchContextImpl::
+    CreateResourceLoadInfoNotifierWrapper() {
+  // If |resource_load_info_notifier_| is unbound, we will create
+  // ResourceLoadInfoNotifierWrapper without wrapping a ResourceLoadInfoNotifier
+  // and only collect histograms.
+  if (!resource_load_info_notifier_) {
+    return std::make_unique<ResourceLoadInfoNotifierWrapper>(
+        /*resource_load_info_notifier=*/nullptr);
+  }
+
+  if (!weak_wrapper_resource_load_info_notifier_) {
+    weak_wrapper_resource_load_info_notifier_ =
+        std::make_unique<WeakWrapperResourceLoadInfoNotifier>(
+            resource_load_info_notifier_.get());
+  }
+  return std::make_unique<ResourceLoadInfoNotifierWrapper>(
+      weak_wrapper_resource_load_info_notifier_->AsWeakPtr());
+}
+
+DedicatedOrSharedWorkerFetchContextImpl::
+    ~DedicatedOrSharedWorkerFetchContextImpl() = default;
+
+scoped_refptr<DedicatedOrSharedWorkerFetchContextImpl>
+DedicatedOrSharedWorkerFetchContextImpl::CloneForNestedWorkerInternal(
+    mojo::PendingReceiver<mojom::blink::ServiceWorkerWorkerClient>
         service_worker_client_receiver,
-    mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClientRegistry>
+    mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClientRegistry>
         service_worker_worker_client_registry,
-    mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
+    CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
         service_worker_container_host,
     std::unique_ptr<network::PendingSharedURLLoaderFactory>
         pending_loader_factory,
     std::unique_ptr<network::PendingSharedURLLoaderFactory>
         pending_fallback_factory,
-    mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
+    mojo::PendingReceiver<mojom::blink::SubresourceLoaderUpdater>
         pending_subresource_loader_updater,
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
-  mojo::PendingRemote<blink::mojom::ResourceLoadInfoNotifier>
+  mojo::PendingRemote<mojom::ResourceLoadInfoNotifier>
       pending_resource_load_info_notifier;
   if (resource_load_info_notifier_) {
     resource_load_info_notifier_->Clone(
         pending_resource_load_info_notifier.InitWithNewPipeAndPassReceiver());
   }
 
-  mojo::PendingRemote<blink::mojom::RendererPreferenceWatcher>
+  mojo::PendingRemote<mojom::blink::RendererPreferenceWatcher>
       preference_watcher;
-  auto new_context = base::AdoptRef(new WebWorkerFetchContextImpl(
+  auto new_context = base::AdoptRef(new DedicatedOrSharedWorkerFetchContextImpl(
       renderer_preferences_,
       preference_watcher.InitWithNewPipeAndPassReceiver(),
       std::move(service_worker_client_receiver),
@@ -621,11 +589,12 @@ WebWorkerFetchContextImpl::CloneForNestedWorkerInternal(
   return new_context;
 }
 
-void WebWorkerFetchContextImpl::ResetServiceWorkerURLLoaderFactory() {
+void DedicatedOrSharedWorkerFetchContextImpl::
+    ResetServiceWorkerURLLoaderFactory() {
   if (!web_loader_factory_)
     return;
   if (GetControllerServiceWorkerMode() !=
-      blink::mojom::ControllerServiceWorkerMode::kControlled) {
+      mojom::ControllerServiceWorkerMode::kControlled) {
     web_loader_factory_->SetServiceWorkerURLLoaderFactory(mojo::NullRemote());
     return;
   }
@@ -634,10 +603,13 @@ void WebWorkerFetchContextImpl::ResetServiceWorkerURLLoaderFactory() {
 
   mojo::PendingRemote<network::mojom::URLLoaderFactory>
       service_worker_url_loader_factory;
-  mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
-      service_worker_container_host;
-  service_worker_container_host_->CloneContainerHost(
-      service_worker_container_host.InitWithNewPipeAndPassReceiver());
+  CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
+      cloned_service_worker_container_host;
+  std::tie(service_worker_container_host_,
+           cloned_service_worker_container_host) =
+      Platform::Current()->CloneServiceWorkerContainerHost(
+          std::move(service_worker_container_host_));
+
   // To avoid potential dead-lock while synchronous loading, create the
   // SubresourceLoaderFactory on a background thread.
   auto task_runner = base::ThreadPool::CreateSequencedTaskRunner(
@@ -646,35 +618,35 @@ void WebWorkerFetchContextImpl::ResetServiceWorkerURLLoaderFactory() {
       FROM_HERE,
       base::BindOnce(
           &CreateServiceWorkerSubresourceLoaderFactory,
-          std::move(service_worker_container_host), client_id_.Utf8(),
-          fallback_factory_->Clone(),
+          std::move(cloned_service_worker_container_host),
+          client_id_.IsolatedCopy(), fallback_factory_->Clone(),
           service_worker_url_loader_factory.InitWithNewPipeAndPassReceiver(),
           task_runner, base::SequencedTaskRunnerHandle::Get(),
-          base::BindRepeating(
-              &WebWorkerFetchContextImpl::AddPendingWorkerTimingReceiver,
-              weak_factory_.GetWeakPtr())));
+          base::BindRepeating(&DedicatedOrSharedWorkerFetchContextImpl::
+                                  AddPendingWorkerTimingReceiver,
+                              weak_factory_.GetWeakPtr())));
   web_loader_factory_->SetServiceWorkerURLLoaderFactory(
       std::move(service_worker_url_loader_factory));
 }
 
-void WebWorkerFetchContextImpl::UpdateSubresourceLoaderFactories(
-    std::unique_ptr<blink::PendingURLLoaderFactoryBundle>
+void DedicatedOrSharedWorkerFetchContextImpl::UpdateSubresourceLoaderFactories(
+    std::unique_ptr<PendingURLLoaderFactoryBundle>
         subresource_loader_factories) {
   auto subresource_loader_factory_bundle =
-      base::MakeRefCounted<blink::ChildURLLoaderFactoryBundle>(
-          std::make_unique<blink::ChildPendingURLLoaderFactoryBundle>(
+      base::MakeRefCounted<ChildURLLoaderFactoryBundle>(
+          std::make_unique<ChildPendingURLLoaderFactoryBundle>(
               std::move(subresource_loader_factories)));
   loader_factory_ = network::SharedURLLoaderFactory::Create(
       subresource_loader_factory_bundle->Clone());
   fallback_factory_ = network::SharedURLLoaderFactory::Create(
       subresource_loader_factory_bundle->CloneWithoutAppCacheFactory());
   web_loader_factory_ = std::make_unique<Factory>(
-      loader_factory_, cors_exempt_header_list(), terminate_sync_load_event_);
+      loader_factory_, cors_exempt_header_list_, terminate_sync_load_event_);
   ResetServiceWorkerURLLoaderFactory();
 }
 
-void WebWorkerFetchContextImpl::NotifyUpdate(
-    const blink::RendererPreferences& new_prefs) {
+void DedicatedOrSharedWorkerFetchContextImpl::NotifyUpdate(
+    const RendererPreferences& new_prefs) {
   if (accept_languages_watcher_ &&
       renderer_preferences_.accept_languages != new_prefs.accept_languages)
     accept_languages_watcher_->NotifyUpdate();
@@ -683,51 +655,79 @@ void WebWorkerFetchContextImpl::NotifyUpdate(
     watcher->NotifyUpdate(new_prefs);
 }
 
-blink::WebString WebWorkerFetchContextImpl::GetAcceptLanguages() const {
-  return blink::WebString::FromUTF8(renderer_preferences_.accept_languages);
-}
-
-void WebWorkerFetchContextImpl::ResetWeakWrapperResourceLoadInfoNotifier() {
+void DedicatedOrSharedWorkerFetchContextImpl::
+    ResetWeakWrapperResourceLoadInfoNotifier() {
   weak_wrapper_resource_load_info_notifier_.reset();
 }
 
-blink::WebVector<blink::WebString>
-WebWorkerFetchContextImpl::cors_exempt_header_list() {
-  blink::WebVector<blink::WebString> web_cors_exempt_header_list(
-      cors_exempt_header_list_.size());
-  std::transform(
-      cors_exempt_header_list_.begin(), cors_exempt_header_list_.end(),
-      web_cors_exempt_header_list.begin(),
-      [](const std::string& h) { return blink::WebString::FromLatin1(h); });
-  return web_cors_exempt_header_list;
-}
+// static
+scoped_refptr<WebDedicatedOrSharedWorkerFetchContext>
+WebDedicatedOrSharedWorkerFetchContext::Create(
+    WebServiceWorkerProviderContext* provider_context,
+    const RendererPreferences& renderer_preferences,
+    CrossVariantMojoReceiver<mojom::RendererPreferenceWatcherInterfaceBase>
+        watcher_receiver,
+    std::unique_ptr<network::PendingSharedURLLoaderFactory>
+        pending_loader_factory,
+    std::unique_ptr<network::PendingSharedURLLoaderFactory>
+        pending_fallback_factory,
+    CrossVariantMojoReceiver<mojom::SubresourceLoaderUpdaterInterfaceBase>
+        pending_subresource_loader_updater,
+    const WebVector<WebString>& cors_exempt_header_list,
+    mojo::PendingRemote<mojom::ResourceLoadInfoNotifier>
+        pending_resource_load_info_notifier) {
+  mojo::PendingReceiver<mojom::blink::ServiceWorkerWorkerClient>
+      service_worker_client_receiver;
+  mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClientRegistry>
+      service_worker_worker_client_registry;
+  CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
+      service_worker_container_host;
+  // Some sandboxed iframes are not allowed to use service worker so don't have
+  // a real service worker provider, so the provider context is null.
+  if (provider_context) {
+    provider_context->BindServiceWorkerWorkerClientRegistryReceiver(
+        service_worker_worker_client_registry.InitWithNewPipeAndPassReceiver());
 
-void WebWorkerFetchContextImpl::AddPendingWorkerTimingReceiver(
-    int request_id,
-    mojo::PendingReceiver<blink::mojom::WorkerTimingContainer> receiver) {
-  // TODO(https://crbug.com/900700): Handle redirects properly. Currently on
-  // redirect, the receiver is replaced with a new one, discarding the timings
-  // before the redirect.
-  worker_timing_container_receivers_[request_id] = std::move(receiver);
-}
+    mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClient> worker_client;
+    service_worker_client_receiver =
+        worker_client.InitWithNewPipeAndPassReceiver();
+    provider_context->BindServiceWorkerWorkerClientRemote(
+        std::move(worker_client));
 
-std::unique_ptr<blink::ResourceLoadInfoNotifierWrapper>
-WebWorkerFetchContextImpl::CreateResourceLoadInfoNotifierWrapper() {
-  // If |resource_load_info_notifier_| is unbound, we will create
-  // ResourceLoadInfoNotifierWrapper without wrapping a ResourceLoadInfoNotifier
-  // and only collect histograms.
-  if (!resource_load_info_notifier_) {
-    return std::make_unique<blink::ResourceLoadInfoNotifierWrapper>(
-        /*resource_load_info_notifier=*/nullptr);
+    service_worker_container_host =
+        provider_context->CloneRemoteContainerHost();
   }
 
-  if (!weak_wrapper_resource_load_info_notifier_) {
-    weak_wrapper_resource_load_info_notifier_ =
-        std::make_unique<blink::WeakWrapperResourceLoadInfoNotifier>(
-            resource_load_info_notifier_.get());
+  scoped_refptr<DedicatedOrSharedWorkerFetchContextImpl> worker_fetch_context =
+      base::AdoptRef(new DedicatedOrSharedWorkerFetchContextImpl(
+          renderer_preferences, std::move(watcher_receiver),
+          std::move(service_worker_client_receiver),
+          std::move(service_worker_worker_client_registry),
+          std::move(service_worker_container_host),
+          std::move(pending_loader_factory),
+          std::move(pending_fallback_factory),
+          std::move(pending_subresource_loader_updater),
+          Platform::Current()->CreateURLLoaderThrottleProviderForWorker(
+              URLLoaderThrottleProviderType::kWorker),
+          Platform::Current()->CreateWebSocketHandshakeThrottleProvider(),
+          cors_exempt_header_list,
+          std::move(pending_resource_load_info_notifier)));
+  if (provider_context) {
+    worker_fetch_context->set_controller_service_worker_mode(
+        provider_context->GetControllerServiceWorkerMode());
+    worker_fetch_context->set_client_id(provider_context->client_id());
+  } else {
+    worker_fetch_context->set_controller_service_worker_mode(
+        mojom::ControllerServiceWorkerMode::kNoController);
   }
-  return std::make_unique<blink::ResourceLoadInfoNotifierWrapper>(
-      weak_wrapper_resource_load_info_notifier_->AsWeakPtr());
+  return worker_fetch_context;
 }
 
-}  // namespace content
+// static
+void WebDedicatedOrSharedWorkerFetchContext::InstallRewriteURLFunction(
+    RewriteURLFunction rewrite_url) {
+  CHECK(!g_rewrite_url);
+  g_rewrite_url = rewrite_url;
+}
+
+}  // namespace blink

third_party/blink/renderer/platform/loader/fetch/url_loader/dedicated_or_shared_worker_fetch_context_impl.h

@@ -2,138 +2,142 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef CONTENT_RENDERER_LOADER_WEB_WORKER_FETCH_CONTEXT_IMPL_H_
-#define CONTENT_RENDERER_LOADER_WEB_WORKER_FETCH_CONTEXT_IMPL_H_
-
-#include <memory>
-#include <string>
+#ifndef THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_FETCH_URL_LOADER_DEDICATED_OR_SHARED_WORKER_FETCH_CONTEXT_IMPL_H_
+#define THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_FETCH_URL_LOADER_DEDICATED_OR_SHARED_WORKER_FETCH_CONTEXT_IMPL_H_
 
 #include "base/strings/string_piece.h"
 #include "base/synchronization/waitable_event.h"
-#include "content/common/content_export.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
-#include "mojo/public/cpp/bindings/pending_remote.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "mojo/public/cpp/bindings/remote.h"
 #include "mojo/public/cpp/bindings/remote_set.h"
-#include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "services/network/public/mojom/url_loader_factory.mojom-forward.h"
-#include "third_party/blink/public/common/renderer_preferences/renderer_preferences.h"
 #include "third_party/blink/public/mojom/loader/resource_load_info_notifier.mojom.h"
-#include "third_party/blink/public/mojom/renderer_preference_watcher.mojom.h"
-#include "third_party/blink/public/mojom/service_worker/service_worker_container.mojom.h"
-#include "third_party/blink/public/mojom/service_worker/service_worker_object.mojom-forward.h"
-#include "third_party/blink/public/mojom/service_worker/service_worker_provider.mojom.h"
-#include "third_party/blink/public/mojom/service_worker/service_worker_worker_client.mojom.h"
-#include "third_party/blink/public/mojom/service_worker/service_worker_worker_client_registry.mojom.h"
-#include "third_party/blink/public/mojom/timing/worker_timing_container.mojom-forward.h"
-#include "third_party/blink/public/mojom/worker/subresource_loader_updater.mojom.h"
+#include "third_party/blink/public/mojom/renderer_preference_watcher.mojom-blink.h"
+#include "third_party/blink/public/mojom/service_worker/service_worker_container.mojom-shared.h"
+#include "third_party/blink/public/mojom/service_worker/service_worker_worker_client.mojom-blink.h"
+#include "third_party/blink/public/mojom/service_worker/service_worker_worker_client_registry.mojom-blink.h"
+#include "third_party/blink/public/mojom/timing/worker_timing_container.mojom.h"
+#include "third_party/blink/public/mojom/worker/subresource_loader_updater.mojom-blink.h"
+#include "third_party/blink/public/platform/web_common.h"
+#include "third_party/blink/public/platform/web_dedicated_or_shared_worker_fetch_context.h"
 #include "third_party/blink/public/platform/web_string.h"
-#include "third_party/blink/public/platform/web_worker_fetch_context.h"
-#include "url/gurl.h"
+#include "third_party/blink/renderer/platform/wtf/casting.h"
 
 namespace blink {
+
 class ResourceLoadInfoNotifierWrapper;
 class URLLoaderThrottleProvider;
 class WeakWrapperResourceLoadInfoNotifier;
 class WebFrameRequestBlocker;
 class WebServiceWorkerProviderContext;
 class WebSocketHandshakeThrottleProvider;
-}  // namespace blink
-
-namespace content {
 
 // This class is used for fetching resource requests from workers (dedicated
 // worker and shared worker). This class is created on the main thread and
 // passed to the worker thread. This class is not used for service workers. For
 // service workers, ServiceWorkerFetchContextImpl class is used instead.
-class CONTENT_EXPORT WebWorkerFetchContextImpl
-    : public blink::WebWorkerFetchContext,
-      public blink::mojom::SubresourceLoaderUpdater,
-      public blink::mojom::ServiceWorkerWorkerClient,
-      public blink::mojom::RendererPreferenceWatcher {
+class BLINK_PLATFORM_EXPORT DedicatedOrSharedWorkerFetchContextImpl final
+    : public WebDedicatedOrSharedWorkerFetchContext,
+      public mojom::blink::SubresourceLoaderUpdater,
+      public mojom::blink::ServiceWorkerWorkerClient,
+      public mojom::blink::RendererPreferenceWatcher {
  public:
-  // Creates a new fetch context for a worker.
+  // - |service_worker_client_receiver| receives OnControllerChanged()
+  //   notifications.
+  // - |service_worker_worker_client_registry| is used to register new
+  //   ServiceWorkerWorkerClients, which is needed when creating a
+  //   nested worker.
   //
-  // |provider_context| is used to set up information for using service workers.
-  // It can be null if the worker is not allowed to use service workers due to
-  // security reasons like sandboxed iframes, insecure origins etc.
-  // |pending_loader_factory| is used for regular loading by the worker.
-  //
-  // If the worker is controlled by a service worker, this class makes another
-  // loader factory which sends requests to the service worker, and passes
-  // |pending_fallback_factory| to that factory to use for network fallback.
-  //
-  // |pending_loader_factory| and |pending_fallback_factory| are different
-  // because |pending_loader_factory| can possibly include a default factory
-  // like AppCache, while |pending_fallback_factory| should not have such a
-  // default factory and instead go directly to network for http(s) requests.
-  // |pending_fallback_factory| might not be simply the direct network factory,
-  // because it might additionally support non-NetworkService schemes (e.g.,
-  // chrome-extension://).
-  static scoped_refptr<WebWorkerFetchContextImpl> Create(
-      blink::WebServiceWorkerProviderContext* provider_context,
-      const blink::RendererPreferences& renderer_preferences,
-      mojo::PendingReceiver<blink::mojom::RendererPreferenceWatcher>
-          watcher_receiver,
+  // Regarding the rest of params, see the comments on Create().
+  DedicatedOrSharedWorkerFetchContextImpl(
+      const RendererPreferences& renderer_preferences,
+      mojo::PendingReceiver<mojom::blink::RendererPreferenceWatcher>
+          preference_watcher_receiver,
+      mojo::PendingReceiver<mojom::blink::ServiceWorkerWorkerClient>
+          service_worker_client_receiver,
+      mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClientRegistry>
+          pending_service_worker_worker_client_registry,
+      CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
+          service_worker_container_host,
       std::unique_ptr<network::PendingSharedURLLoaderFactory>
           pending_loader_factory,
       std::unique_ptr<network::PendingSharedURLLoaderFactory>
           pending_fallback_factory,
-      mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
+      mojo::PendingReceiver<mojom::blink::SubresourceLoaderUpdater>
           pending_subresource_loader_updater,
-      const std::vector<std::string>& cors_exempt_header_list,
-      mojo::PendingRemote<blink::mojom::ResourceLoadInfoNotifier>
+      std::unique_ptr<URLLoaderThrottleProvider> throttle_provider,
+      std::unique_ptr<WebSocketHandshakeThrottleProvider>
+          websocket_handshake_throttle_provider,
+      const WebVector<WebString>& cors_exempt_header_list,
+      mojo::PendingRemote<mojom::ResourceLoadInfoNotifier>
           pending_resource_load_info_notifier);
 
+  // WebDedicatedOrSharedWorkerFetchContext implementation:
   // Clones this fetch context for a nested worker.
   // For non-PlzDedicatedWorker. This will be removed once PlzDedicatedWorker is
   // enabled by default.
-  scoped_refptr<WebWorkerFetchContextImpl> CloneForNestedWorkerDeprecated(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+  scoped_refptr<WebDedicatedOrSharedWorkerFetchContext>
+  CloneForNestedWorkerDeprecated(
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
   // For PlzDedicatedWorker. The cloned fetch context does not inherit some
   // fields (e.g., blink::WebServiceWorkerProviderContext) from this fetch
   // context, and instead that takes values passed from the browser process.
-  scoped_refptr<WebWorkerFetchContextImpl> CloneForNestedWorker(
-      blink::WebServiceWorkerProviderContext* service_worker_provider_context,
+  scoped_refptr<WebDedicatedOrSharedWorkerFetchContext> CloneForNestedWorker(
+      WebServiceWorkerProviderContext* service_worker_provider_context,
       std::unique_ptr<network::PendingSharedURLLoaderFactory>
           pending_loader_factory,
       std::unique_ptr<network::PendingSharedURLLoaderFactory>
           pending_fallback_factory,
-      mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
+      CrossVariantMojoReceiver<mojom::SubresourceLoaderUpdaterInterfaceBase>
           pending_subresource_loader_updater,
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
+  // Sets properties associated with frames.
+  // - For dedicated workers, the property is copied from the ancestor frame
+  //   (directly for non-nested workers, or indirectly via its parent worker for
+  //   nested workers).
+  // - For shared workers, there is no parent frame, so the default value, or a
+  //   value calculated in some way is set.
+  //
+  // TODO(nhiroki): Add more comments about security/privacy implications to
+  // each property, for example, site_for_cookies and top_frame_origin.
+  void set_ancestor_frame_id(int id) override;
+  void set_frame_request_blocker(
+      scoped_refptr<WebFrameRequestBlocker> frame_request_blocker) override;
+  void set_site_for_cookies(
+      const net::SiteForCookies& site_for_cookies) override;
+  void set_top_frame_origin(const WebSecurityOrigin& top_frame_origin) override;
 
-  // blink::WebWorkerFetchContext implementation:
+  // WebWorkerFetchContext implementation:
   void SetTerminateSyncLoadEvent(base::WaitableEvent*) override;
-  void InitializeOnWorkerThread(blink::AcceptLanguagesWatcher*) override;
-  blink::WebURLLoaderFactory* GetURLLoaderFactory() override;
-  std::unique_ptr<blink::WebURLLoaderFactory> WrapURLLoaderFactory(
-      blink::CrossVariantMojoRemote<
-          network::mojom::URLLoaderFactoryInterfaceBase> url_loader_factory)
-      override;
-  std::unique_ptr<blink::WebCodeCacheLoader> CreateCodeCacheLoader() override;
-  void WillSendRequest(blink::WebURLRequest&) override;
-  blink::mojom::ControllerServiceWorkerMode GetControllerServiceWorkerMode()
+  void InitializeOnWorkerThread(AcceptLanguagesWatcher*) override;
+  WebURLLoaderFactory* GetURLLoaderFactory() override;
+  std::unique_ptr<WebURLLoaderFactory> WrapURLLoaderFactory(
+      CrossVariantMojoRemote<network::mojom::URLLoaderFactoryInterfaceBase>
+          url_loader_factory) override;
+  std::unique_ptr<WebCodeCacheLoader> CreateCodeCacheLoader() override;
+  void WillSendRequest(WebURLRequest&) override;
+  mojom::ControllerServiceWorkerMode GetControllerServiceWorkerMode()
       const override;
   void SetIsOnSubframe(bool) override;
   bool IsOnSubframe() const override;
   net::SiteForCookies SiteForCookies() const override;
-  absl::optional<blink::WebSecurityOrigin> TopFrameOrigin() const override;
+  absl::optional<WebSecurityOrigin> TopFrameOrigin() const override;
   void SetSubresourceFilterBuilder(
-      std::unique_ptr<blink::WebDocumentSubresourceFilter::Builder>) override;
-  std::unique_ptr<blink::WebDocumentSubresourceFilter> TakeSubresourceFilter()
+      std::unique_ptr<WebDocumentSubresourceFilter::Builder>) override;
+  std::unique_ptr<WebDocumentSubresourceFilter> TakeSubresourceFilter()
       override;
-  std::unique_ptr<blink::WebSocketHandshakeThrottle>
-  CreateWebSocketHandshakeThrottle(
+  std::unique_ptr<WebSocketHandshakeThrottle> CreateWebSocketHandshakeThrottle(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
-  blink::CrossVariantMojoReceiver<
-      blink::mojom::WorkerTimingContainerInterfaceBase>
+  CrossVariantMojoReceiver<mojom::WorkerTimingContainerInterfaceBase>
   TakePendingWorkerTimingReceiver(int request_id) override;
   void SetIsOfflineMode(bool is_offline_mode) override;
+  bool IsDedicatedWorkerOrSharedWorkerFetchContext() const override {
+    return true;
+  }
 
-  // blink::mojom::ServiceWorkerWorkerClient implementation:
-  void OnControllerChanged(blink::mojom::ControllerServiceWorkerMode) override;
+  // mojom::blink::ServiceWorkerWorkerClient implementation:
+  void OnControllerChanged(mojom::ControllerServiceWorkerMode) override;
 
   // Sets the controller service worker mode.
   // - For dedicated workers (non-PlzDedicatedWorker), they depend on the
@@ -144,90 +148,43 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
   //   controller mode is passed from the browser processw when starting the
   //   worker.
   void set_controller_service_worker_mode(
-      blink::mojom::ControllerServiceWorkerMode mode);
+      mojom::ControllerServiceWorkerMode mode);
 
-  // Sets properties associated with frames.
-  // - For dedicated workers, the property is copied from the ancestor frame
-  //   (directly for non-nested workers, or indirectly via its parent worker for
-  //   nested workers).
-  // - For shared workers, there is no parent frame, so the default value, or a
-  //   value calculated in some way is set.
-  //
-  // TODO(nhiroki): Add more comments about security/privacy implications to
-  // each property, for example, site_for_cookies and top_frame_origin.
-  void set_ancestor_frame_id(int id);
-  void set_frame_request_blocker(
-      scoped_refptr<blink::WebFrameRequestBlocker> frame_request_blocker);
-  void set_site_for_cookies(const net::SiteForCookies& site_for_cookies);
-  void set_top_frame_origin(const blink::WebSecurityOrigin& top_frame_origin);
+  void set_client_id(const WebString& client_id);
 
-  void set_client_id(const blink::WebString& client_id);
-
-  using RewriteURLFunction = blink::WebURL (*)(base::StringPiece, bool);
-  static void InstallRewriteURLFunction(RewriteURLFunction rewrite_url);
-
-  blink::WebString GetAcceptLanguages() const override;
+  WebString GetAcceptLanguages() const override;
 
   // Sets up |receiver| to receive resource performance timings for the given
   // |request_id|. This receiver will be taken later by
   // TakePendingWorkerTimingReceiver().
   void AddPendingWorkerTimingReceiver(
       int request_id,
-      mojo::PendingReceiver<blink::mojom::WorkerTimingContainer> receiver);
+      mojo::PendingReceiver<mojom::WorkerTimingContainer> receiver);
 
-  std::unique_ptr<blink::ResourceLoadInfoNotifierWrapper>
+  std::unique_ptr<ResourceLoadInfoNotifierWrapper>
   CreateResourceLoadInfoNotifierWrapper() override;
 
  private:
   class Factory;
   using WorkerTimingContainerReceiverMap =
       std::map<int /* request_id */,
-               mojo::PendingReceiver<blink::mojom::WorkerTimingContainer>>;
+               mojo::PendingReceiver<mojom::WorkerTimingContainer>>;
 
-  // - |service_worker_client_receiver| receives OnControllerChanged()
-  //   notifications.
-  // - |service_worker_worker_client_registry| is used to register new
-  //   ServiceWorkerWorkerClients, which is needed when creating a
-  //   nested worker.
-  //
-  // Regarding the rest of params, see the comments on Create().
-  WebWorkerFetchContextImpl(
-      const blink::RendererPreferences& renderer_preferences,
-      mojo::PendingReceiver<blink::mojom::RendererPreferenceWatcher>
-          watcher_receiver,
-      mojo::PendingReceiver<blink::mojom::ServiceWorkerWorkerClient>
+  ~DedicatedOrSharedWorkerFetchContextImpl() override;
+
+  scoped_refptr<DedicatedOrSharedWorkerFetchContextImpl>
+  CloneForNestedWorkerInternal(
+      mojo::PendingReceiver<mojom::blink::ServiceWorkerWorkerClient>
           service_worker_client_receiver,
-      mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClientRegistry>
+      mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClientRegistry>
           service_worker_worker_client_registry,
-      mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
+      CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
           service_worker_container_host,
       std::unique_ptr<network::PendingSharedURLLoaderFactory>
           pending_loader_factory,
       std::unique_ptr<network::PendingSharedURLLoaderFactory>
           pending_fallback_factory,
-      mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
-          pending_subresource_loader_updater,
-      std::unique_ptr<blink::URLLoaderThrottleProvider> throttle_provider,
-      std::unique_ptr<blink::WebSocketHandshakeThrottleProvider>
-          websocket_handshake_throttle_provider,
-      const std::vector<std::string>& cors_exempt_header_list,
-      mojo::PendingRemote<blink::mojom::ResourceLoadInfoNotifier>
-          pending_resource_load_info_notifier);
-
-  ~WebWorkerFetchContextImpl() override;
-
-  scoped_refptr<WebWorkerFetchContextImpl> CloneForNestedWorkerInternal(
-      mojo::PendingReceiver<blink::mojom::ServiceWorkerWorkerClient>
-          service_worker_client_receiver,
-      mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClientRegistry>
-          service_worker_worker_client_registry,
-      mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
-          service_worker_container_host,
-      std::unique_ptr<network::PendingSharedURLLoaderFactory>
-          pending_loader_factory,
-      std::unique_ptr<network::PendingSharedURLLoaderFactory>
-          pending_fallback_factory,
-      mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
+      mojo::PendingReceiver<mojom::blink::SubresourceLoaderUpdater>
           pending_subresource_loader_updater,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
@@ -237,34 +194,31 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
   // controlled by a service worker.
   void ResetServiceWorkerURLLoaderFactory();
 
-  // Implements blink::mojom::SubresourceLoaderUpdater.
+  // Implements mojom::blink::SubresourceLoaderUpdater.
   void UpdateSubresourceLoaderFactories(
-      std::unique_ptr<blink::PendingURLLoaderFactoryBundle>
+      std::unique_ptr<PendingURLLoaderFactoryBundle>
           subresource_loader_factories) override;
 
-  // Implements blink::mojom::RendererPreferenceWatcher.
-  void NotifyUpdate(const blink::RendererPreferences& new_prefs) override;
+  // Implements mojom::blink::RendererPreferenceWatcher.
+  void NotifyUpdate(const RendererPreferences& new_prefs) override;
 
   void ResetWeakWrapperResourceLoadInfoNotifier();
 
-  blink::WebVector<blink::WebString> cors_exempt_header_list();
-
   // |receiver_| and |service_worker_worker_client_registry_| may be null if
   // this context can't use service workers. See comments for Create().
-  mojo::Receiver<blink::mojom::ServiceWorkerWorkerClient> receiver_{this};
-  mojo::Remote<blink::mojom::ServiceWorkerWorkerClientRegistry>
+  mojo::Receiver<mojom::blink::ServiceWorkerWorkerClient> receiver_{this};
+  mojo::Remote<mojom::blink::ServiceWorkerWorkerClientRegistry>
       service_worker_worker_client_registry_;
 
   // Bound to |this| on the worker thread.
-  mojo::PendingReceiver<blink::mojom::ServiceWorkerWorkerClient>
+  mojo::PendingReceiver<mojom::blink::ServiceWorkerWorkerClient>
       service_worker_client_receiver_;
+
   // Consumed on the worker thread to create
   // |service_worker_worker_client_registry_|.
-  mojo::PendingRemote<blink::mojom::ServiceWorkerWorkerClientRegistry>
+  mojo::PendingRemote<mojom::blink::ServiceWorkerWorkerClientRegistry>
       pending_service_worker_worker_client_registry_;
-  // Consumed on the worker thread to create |service_worker_container_host_|.
-  mojo::PendingRemote<blink::mojom::ServiceWorkerContainerHost>
-      pending_service_worker_container_host_;
+
   // Consumed on the worker thread to create |loader_factory_|.
   std::unique_ptr<network::PendingSharedURLLoaderFactory>
       pending_loader_factory_;
@@ -272,20 +226,19 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
   std::unique_ptr<network::PendingSharedURLLoaderFactory>
       pending_fallback_factory_;
 
-  blink::mojom::ControllerServiceWorkerMode controller_service_worker_mode_ =
-      blink::mojom::ControllerServiceWorkerMode::kNoController;
-
-  // Initialized on the worker thread when InitializeOnWorkerThread() is called.
   // This can be null if the |provider_context| passed to Create() was null or
   // already being destructed (see
   // content::ServiceWorkerProviderContext::OnNetworkProviderDestroyed()).
-  mojo::Remote<blink::mojom::ServiceWorkerContainerHost>
+  CrossVariantMojoRemote<mojom::ServiceWorkerContainerHostInterfaceBase>
       service_worker_container_host_;
 
+  mojom::ControllerServiceWorkerMode controller_service_worker_mode_ =
+      mojom::ControllerServiceWorkerMode::kNoController;
+
   // The Client#id value of the shared worker or dedicated worker (since
   // dedicated workers are not yet service worker clients, it is the parent
   // document's id in that case). Passed to ControllerServiceWorkerConnector.
-  blink::WebString client_id_;
+  WebString client_id_;
 
   // Initialized on the worker thread when InitializeOnWorkerThread() is called.
   // |loader_factory_| is used for regular loading by the worker. In
@@ -305,12 +258,12 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
   // loaders via Host/TrackedChildURLLoaderFactoryBundle. For shared workers,
   // the renderer process detects the crash, and terminates the worker instead
   // of recovery.
-  mojo::PendingReceiver<blink::mojom::SubresourceLoaderUpdater>
+  mojo::PendingReceiver<mojom::blink::SubresourceLoaderUpdater>
       pending_subresource_loader_updater_;
-  mojo::Receiver<blink::mojom::SubresourceLoaderUpdater>
+  mojo::Receiver<mojom::blink::SubresourceLoaderUpdater>
       subresource_loader_updater_{this};
 
-  std::unique_ptr<blink::WebDocumentSubresourceFilter::Builder>
+  std::unique_ptr<WebDocumentSubresourceFilter::Builder>
       subresource_filter_builder_;
   // For dedicated workers, this is the ancestor frame (the parent frame for
   // non-nested workers, the closest ancestor for nested workers). For shared
@@ -320,59 +273,66 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
   // Set to non-null if the ancestor frame has an associated RequestBlocker,
   // which blocks requests from this worker too when the ancestor frame is
   // blocked.
-  scoped_refptr<blink::WebFrameRequestBlocker> frame_request_blocker_;
+  scoped_refptr<WebFrameRequestBlocker> frame_request_blocker_;
   net::SiteForCookies site_for_cookies_;
   absl::optional<url::Origin> top_frame_origin_;
 
-  blink::RendererPreferences renderer_preferences_;
+  RendererPreferences renderer_preferences_;
 
   // |preference_watcher_receiver_| and |child_preference_watchers_| are for
   // keeping track of updates in the renderer preferences.
-  mojo::Receiver<blink::mojom::RendererPreferenceWatcher>
+  mojo::Receiver<mojom::blink::RendererPreferenceWatcher>
       preference_watcher_receiver_{this};
   // Kept while staring up the worker thread. Valid until
   // InitializeOnWorkerThread().
-  mojo::PendingReceiver<blink::mojom::RendererPreferenceWatcher>
+  mojo::PendingReceiver<mojom::blink::RendererPreferenceWatcher>
       preference_watcher_pending_receiver_;
-  mojo::RemoteSet<blink::mojom::RendererPreferenceWatcher>
+  mojo::RemoteSet<mojom::blink::RendererPreferenceWatcher>
       child_preference_watchers_;
 
   // This is owned by ThreadedMessagingProxyBase on the main thread.
   base::WaitableEvent* terminate_sync_load_event_ = nullptr;
 
-  // The blink::WebURLLoaderFactory which was created and passed to
+  // The WebURLLoaderFactory which was created and passed to
   // Blink by GetURLLoaderFactory().
   std::unique_ptr<Factory> web_loader_factory_;
 
-  std::unique_ptr<blink::URLLoaderThrottleProvider> throttle_provider_;
-  std::unique_ptr<blink::WebSocketHandshakeThrottleProvider>
+  std::unique_ptr<URLLoaderThrottleProvider> throttle_provider_;
+  std::unique_ptr<WebSocketHandshakeThrottleProvider>
       websocket_handshake_throttle_provider_;
 
-  std::vector<std::string> cors_exempt_header_list_;
+  WebVector<WebString> cors_exempt_header_list_;
 
-  mojo::PendingRemote<blink::mojom::ResourceLoadInfoNotifier>
+  mojo::PendingRemote<mojom::ResourceLoadInfoNotifier>
       pending_resource_load_info_notifier_;
 
   // Used to notify the loading stats by ResourceLoadInfo struct for dedicated
   // workers.
-  mojo::Remote<blink::mojom::ResourceLoadInfoNotifier>
-      resource_load_info_notifier_;
+  mojo::Remote<mojom::ResourceLoadInfoNotifier> resource_load_info_notifier_;
 
   // Wrap a raw blink::mojom::ResourceLoadInfoNotifier pointer directed at
   // |resource_load_info_notifier_|'s receiver.
-  std::unique_ptr<blink::WeakWrapperResourceLoadInfoNotifier>
+  std::unique_ptr<WeakWrapperResourceLoadInfoNotifier>
       weak_wrapper_resource_load_info_notifier_;
 
-  blink::AcceptLanguagesWatcher* accept_languages_watcher_ = nullptr;
+  AcceptLanguagesWatcher* accept_languages_watcher_ = nullptr;
 
   // Contains pending receivers whose corresponding requests are still
   // in-flight. The pending receivers are taken by
   // TakePendingWorkerTimingReceiver() when the request is completed.
   WorkerTimingContainerReceiverMap worker_timing_container_receivers_;
 
-  base::WeakPtrFactory<WebWorkerFetchContextImpl> weak_factory_{this};
+  base::WeakPtrFactory<DedicatedOrSharedWorkerFetchContextImpl> weak_factory_{
+      this};
 };
 
-}  // namespace content
+template <>
+struct DowncastTraits<DedicatedOrSharedWorkerFetchContextImpl> {
+  static bool AllowFrom(const WebWorkerFetchContext& context) {
+    return context.IsDedicatedWorkerOrSharedWorkerFetchContext();
+  }
+};
 
-#endif  // CONTENT_RENDERER_LOADER_WEB_WORKER_FETCH_CONTEXT_IMPL_H_
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_PLATFORM_LOADER_FETCH_URL_LOADER_DEDICATED_OR_SHARED_WORKER_FETCH_CONTEXT_IMPL_H_