Worker: Implement PlzDedicatedWorker for nested dedicated workers

This CL implements PlzDedicatedWorker for nested dedicated workers. This new
path is used only when the runtime flags
(kOffMainThreadDedicatedWorkerScriptFetch + kPlzDedicatedWorker) are enabled.

// Technical details

Specifically, this CL associates WebWorkerFetchContext cloned for nested
dedicated workers with a script response fetched by the browser process (i.e.,
PlzDedicatedWorker).

 - Before this CL, WebWorkerFetchContext for nested dedicated workers is just
   cloned from a parent worker's fetch context. This means nested dedicated
   workers directly fetch the worker script without using the browser-fetched
   script.
 - After this CL, the fetch context is still cloned from the parent's one, but
   some fields of that take different values passed from the browser process
   (e.g., service worker provider info and loader factory info). The fetch
   context loads the browser-fetched script in response to a resource request
   from Blink.

This doesn't change results of existing tests because this change is not
sufficient to fix (service) worker tests disabled for PlzDedicatedWorker.
Subsequent CLs will fix them.

Design doc:
https://docs.google.com/document/d/1fWsD0oIa5sNDfUFWGJZ41pDo3zzsbFGyQSNdV8nOG4I/edit#

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

content/renderer/loader/web_worker_fetch_context_impl.cc

@@ -242,9 +242,11 @@ void WebWorkerFetchContextImpl::SetTerminateSyncLoadEvent(
   terminate_sync_load_event_ = terminate_sync_load_event;
 }
 
-scoped_refptr<blink::WebWorkerFetchContext>
-WebWorkerFetchContextImpl::CloneForNestedWorker(
+scoped_refptr<WebWorkerFetchContextImpl>
+WebWorkerFetchContextImpl::CloneForNestedWorkerDeprecated(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(!blink::features::IsPlzDedicatedWorkerEnabled());
+
   blink::mojom::ServiceWorkerWorkerClientRequest service_worker_client_request;
   blink::mojom::ServiceWorkerWorkerClientRegistryPtrInfo
       service_worker_worker_client_registry_ptr_info;
@@ -264,28 +266,52 @@ WebWorkerFetchContextImpl::CloneForNestedWorker(
         mojo::MakeRequest(&host_ptr_info));
   }
 
-  blink::mojom::RendererPreferenceWatcherPtr preference_watcher;
-  auto new_context = base::AdoptRef(new WebWorkerFetchContextImpl(
-      renderer_preferences_, mojo::MakeRequest(&preference_watcher),
-      std::move(service_worker_client_request),
-      std::move(service_worker_worker_client_registry_ptr_info),
-      std::move(host_ptr_info), loader_factory_->Clone(),
-      fallback_factory_->Clone(),
-      throttle_provider_ ? throttle_provider_->Clone() : nullptr,
-      websocket_handshake_throttle_provider_
-          ? websocket_handshake_throttle_provider_->Clone(
-                std::move(task_runner))
-          : nullptr,
-      thread_safe_sender_.get(), service_manager_connection_->Clone()));
+  scoped_refptr<WebWorkerFetchContextImpl> new_context =
+      CloneForNestedWorkerInternal(
+          std::move(service_worker_client_request),
+          std::move(service_worker_worker_client_registry_ptr_info),
+          std::move(host_ptr_info), loader_factory_->Clone(),
+          fallback_factory_->Clone(), std::move(task_runner));
   new_context->is_controlled_by_service_worker_ =
       is_controlled_by_service_worker_;
-  new_context->is_on_sub_frame_ = is_on_sub_frame_;
-  new_context->ancestor_frame_id_ = ancestor_frame_id_;
-  new_context->frame_request_blocker_ = frame_request_blocker_;
-  new_context->appcache_host_id_ = appcache_host_id_;
-  new_context->top_frame_origin_ = top_frame_origin_;
 
-  child_preference_watchers_.AddPtr(std::move(preference_watcher));
+  return new_context;
+}
+
+scoped_refptr<WebWorkerFetchContextImpl>
+WebWorkerFetchContextImpl::CloneForNestedWorker(
+    ServiceWorkerProviderContext* service_worker_provider_context,
+    std::unique_ptr<network::SharedURLLoaderFactoryInfo> loader_factory_info,
+    std::unique_ptr<network::SharedURLLoaderFactoryInfo> fallback_factory_info,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  DCHECK(blink::features::IsPlzDedicatedWorkerEnabled());
+  DCHECK(service_worker_provider_context);
+  DCHECK(loader_factory_info);
+  DCHECK(fallback_factory_info);
+  DCHECK(task_runner);
+
+  blink::mojom::ServiceWorkerWorkerClientRegistryPtrInfo
+      service_worker_worker_client_registry_ptr_info;
+  service_worker_provider_context->CloneWorkerClientRegistry(
+      mojo::MakeRequest(&service_worker_worker_client_registry_ptr_info));
+
+  blink::mojom::ServiceWorkerWorkerClientPtr worker_client_ptr;
+  blink::mojom::ServiceWorkerWorkerClientRequest service_worker_client_request =
+      mojo::MakeRequest(&worker_client_ptr);
+  service_worker_provider_context->RegisterWorkerClient(
+      std::move(worker_client_ptr));
+
+  blink::mojom::ServiceWorkerContainerHostPtrInfo container_host_ptr_info =
+      service_worker_provider_context->CloneContainerHostPtrInfo();
+
+  scoped_refptr<WebWorkerFetchContextImpl> new_context =
+      CloneForNestedWorkerInternal(
+          std::move(service_worker_client_request),
+          std::move(service_worker_worker_client_registry_ptr_info),
+          std::move(container_host_ptr_info), std::move(loader_factory_info),
+          std::move(fallback_factory_info), std::move(task_runner));
+  new_context->is_controlled_by_service_worker_ =
+      service_worker_provider_context->IsControlledByServiceWorker();
 
   return new_context;
 }
@@ -508,6 +534,38 @@ void WebWorkerFetchContextImpl::OnControllerChanged(
   ResetServiceWorkerURLLoaderFactory();
 }
 
+scoped_refptr<WebWorkerFetchContextImpl>
+WebWorkerFetchContextImpl::CloneForNestedWorkerInternal(
+    blink::mojom::ServiceWorkerWorkerClientRequest
+        service_worker_client_request,
+    blink::mojom::ServiceWorkerWorkerClientRegistryPtrInfo
+        service_worker_worker_client_registry_ptr_info,
+    blink::mojom::ServiceWorkerContainerHostPtrInfo container_host_ptr_info,
+    std::unique_ptr<network::SharedURLLoaderFactoryInfo> loader_factory_info,
+    std::unique_ptr<network::SharedURLLoaderFactoryInfo> fallback_factory_info,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  blink::mojom::RendererPreferenceWatcherPtr preference_watcher;
+  auto new_context = base::AdoptRef(new WebWorkerFetchContextImpl(
+      renderer_preferences_, mojo::MakeRequest(&preference_watcher),
+      std::move(service_worker_client_request),
+      std::move(service_worker_worker_client_registry_ptr_info),
+      std::move(container_host_ptr_info), std::move(loader_factory_info),
+      std::move(fallback_factory_info),
+      throttle_provider_ ? throttle_provider_->Clone() : nullptr,
+      websocket_handshake_throttle_provider_
+          ? websocket_handshake_throttle_provider_->Clone(
+                std::move(task_runner))
+          : nullptr,
+      thread_safe_sender_.get(), service_manager_connection_->Clone()));
+  new_context->is_on_sub_frame_ = is_on_sub_frame_;
+  new_context->ancestor_frame_id_ = ancestor_frame_id_;
+  new_context->frame_request_blocker_ = frame_request_blocker_;
+  new_context->appcache_host_id_ = appcache_host_id_;
+  new_context->top_frame_origin_ = top_frame_origin_;
+  child_preference_watchers_.AddPtr(std::move(preference_watcher));
+  return new_context;
+}
+
 bool WebWorkerFetchContextImpl::Send(IPC::Message* message) {
   return thread_safe_sender_->Send(message);
 }

content/renderer/loader/web_worker_fetch_context_impl.h

@@ -77,9 +77,22 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
       std::unique_ptr<network::SharedURLLoaderFactoryInfo>
           fallback_factory_info);
 
+  // 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);
+  // For PlzDedicatedWorker. The cloned fetch context does not inherit some
+  // fields (e.g., ServiceWorkerProviderContext) from this fetch context, and
+  // instead that takes values passed from the browser process.
+  scoped_refptr<WebWorkerFetchContextImpl> CloneForNestedWorker(
+      ServiceWorkerProviderContext* service_worker_provider_context,
+      std::unique_ptr<network::SharedURLLoaderFactoryInfo> loader_factory_info,
+      std::unique_ptr<network::SharedURLLoaderFactoryInfo>
+          fallback_factory_info,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
   // blink::WebWorkerFetchContext implementation:
-  scoped_refptr<blink::WebWorkerFetchContext> CloneForNestedWorker(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
   void SetTerminateSyncLoadEvent(base::WaitableEvent*) override;
   void InitializeOnWorkerThread(blink::AcceptLanguagesWatcher*) override;
   blink::WebURLLoaderFactory* GetURLLoaderFactory() override;
@@ -166,6 +179,17 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
 
   ~WebWorkerFetchContextImpl() override;
 
+  scoped_refptr<WebWorkerFetchContextImpl> CloneForNestedWorkerInternal(
+      blink::mojom::ServiceWorkerWorkerClientRequest
+          service_worker_client_request,
+      blink::mojom::ServiceWorkerWorkerClientRegistryPtrInfo
+          service_worker_worker_client_registry_ptr_info,
+      blink::mojom::ServiceWorkerContainerHostPtrInfo container_host_ptr_info,
+      std::unique_ptr<network::SharedURLLoaderFactoryInfo> loader_factory_info,
+      std::unique_ptr<network::SharedURLLoaderFactoryInfo>
+          fallback_factory_info,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
   bool Send(IPC::Message* message);
 
   // Resets the service worker url loader factory of a URLLoaderFactoryImpl

content/renderer/worker/dedicated_worker_host_factory_client.cc

@@ -15,6 +15,8 @@
 #include "third_party/blink/public/mojom/service_worker/service_worker_provider.mojom.h"
 #include "third_party/blink/public/mojom/worker/worker_main_script_load_params.mojom.h"
 #include "third_party/blink/public/platform/web_dedicated_worker.h"
+#include "third_party/blink/public/platform/web_security_origin.h"
+#include "third_party/blink/public/platform/web_url.h"
 
 namespace content {
 
@@ -52,6 +54,29 @@ void DedicatedWorkerHostFactoryClient::CreateWorkerHost(
       std::move(client_ptr));
 }
 
+scoped_refptr<blink::WebWorkerFetchContext>
+DedicatedWorkerHostFactoryClient::CloneWorkerFetchContext(
+    blink::WebWorkerFetchContext* web_worker_fetch_context,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+  scoped_refptr<WebWorkerFetchContextImpl> worker_fetch_context;
+  if (blink::features::IsPlzDedicatedWorkerEnabled()) {
+    worker_fetch_context =
+        static_cast<WebWorkerFetchContextImpl*>(web_worker_fetch_context)
+            ->CloneForNestedWorker(service_worker_provider_context_.get(),
+                                   subresource_loader_factory_bundle_->Clone(),
+                                   subresource_loader_factory_bundle_
+                                       ->CloneWithoutAppCacheFactory(),
+                                   std::move(task_runner));
+    worker_fetch_context->SetResponseOverrideForMainScript(
+        std::move(response_override_for_main_script_));
+  } else {
+    worker_fetch_context =
+        static_cast<WebWorkerFetchContextImpl*>(web_worker_fetch_context)
+            ->CloneForNestedWorkerDeprecated(std::move(task_runner));
+  }
+  return worker_fetch_context;
+}
+
 scoped_refptr<WebWorkerFetchContextImpl>
 DedicatedWorkerHostFactoryClient::CreateWorkerFetchContext(
     blink::mojom::RendererPreferences renderer_preference,

content/renderer/worker/dedicated_worker_host_factory_client.h

@@ -15,6 +15,7 @@
 
 namespace blink {
 class WebDedicatedWorker;
+class WebWorkerFetchContext;
 }  // namespace blink
 
 namespace content {
@@ -44,6 +45,9 @@ class DedicatedWorkerHostFactoryClient final
   void CreateWorkerHost(const blink::WebURL& script_url,
                         const blink::WebSecurityOrigin& script_origin,
                         mojo::ScopedMessagePipeHandle blob_url_token) override;
+  scoped_refptr<blink::WebWorkerFetchContext> CloneWorkerFetchContext(
+      blink::WebWorkerFetchContext* web_worker_fetch_context,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) override;
 
   scoped_refptr<WebWorkerFetchContextImpl> CreateWorkerFetchContext(
       blink::mojom::RendererPreferences renderer_preference,

third_party/blink/public/platform/web_dedicated_worker_host_factory_client.h

@@ -5,12 +5,19 @@
 #ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_DEDICATED_WORKER_HOST_FACTORY_CLIENT_H_
 #define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_WEB_DEDICATED_WORKER_HOST_FACTORY_CLIENT_H_
 
+#include "base/memory/ref_counted.h"
 #include "mojo/public/cpp/system/message_pipe.h"
-#include "third_party/blink/public/platform/web_security_origin.h"
-#include "third_party/blink/public/platform/web_url.h"
+
+namespace base {
+class SingleThreadTaskRunner;
+}
 
 namespace blink {
 
+class WebSecurityOrigin;
+class WebURL;
+class WebWorkerFetchContext;
+
 // PlzDedicatedWorker:
 // WebDedicatedWorkerHostFactoryClient is the interface to access
 // content::DedicatedWorkerHostFactoryClient from blink::DedicatedWorker.
@@ -28,6 +35,11 @@ class WebDedicatedWorkerHostFactoryClient {
       const blink::WebURL& script_url,
       const blink::WebSecurityOrigin& script_origin,
       mojo::ScopedMessagePipeHandle blob_url_token) = 0;
+
+  // Clones the given WebWorkerFetchContext for nested workers.
+  virtual scoped_refptr<WebWorkerFetchContext> CloneWorkerFetchContext(
+      WebWorkerFetchContext*,
+      scoped_refptr<base::SingleThreadTaskRunner>) = 0;
 };
 
 }  // namespace blink

third_party/blink/public/platform/web_worker_fetch_context.h

@@ -56,12 +56,6 @@ class WebWorkerFetchContext : public base::RefCounted<WebWorkerFetchContext> {
 
   virtual ~WebWorkerFetchContext() = default;
 
-  // Used to copy a worker fetch context between worker threads.
-  virtual scoped_refptr<WebWorkerFetchContext> CloneForNestedWorker(
-      scoped_refptr<base::SingleThreadTaskRunner>) {
-    return nullptr;
-  }
-
   // Set a raw pointer of a WaitableEvent which will be signaled from the main
   // thread when the worker's GlobalScope is terminated, which will terminate
   // sync loading requests on the worker thread. It is guaranteed that the

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

@@ -475,12 +475,11 @@ 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.
-  // TODO(nhiroki): Create WebWorkerFetchContext using |factory_client_| when
-  // PlzDedicatedWorker is enabled (https://crbug.com/906991).
   auto* scope = To<WorkerGlobalScope>(GetExecutionContext());
-  return static_cast<WorkerFetchContext&>(scope->Fetcher()->Context())
-      .GetWebWorkerFetchContext()
-      ->CloneForNestedWorker(scope->GetTaskRunner(TaskType::kNetworking));
+  return factory_client_->CloneWorkerFetchContext(
+      static_cast<WorkerFetchContext&>(scope->Fetcher()->Context())
+          .GetWebWorkerFetchContext(),
+      scope->GetTaskRunner(TaskType::kNetworking));
 }
 
 const AtomicString& DedicatedWorker::InterfaceName() const {