Worker: Deduplicate WebWorkerFetchContext creation code

There are duplicate code between RenderFrameImpl::CreateWorkerFetchContext() and
EmbeddedSharedWorkerStub::CreateWorkerFetchContext(). This CL factors them out
into WebWorkerFetchContext::Create() for cleanup.

Bug: 906991
Change-Id: Ic912e6b7b62777c2334ec51e21036b129296eb1a
Reviewed-on: https://chromium-review.googlesource.com/c/1405123
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@{#622802}

content/renderer/loader/web_worker_fetch_context_impl.cc

@@ -13,9 +13,11 @@
 #include "content/child/thread_safe_sender.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/frame_messages.h"
+#include "content/public/common/content_client.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/origin_util.h"
 #include "content/public/common/service_names.mojom.h"
+#include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/url_loader_throttle_provider.h"
 #include "content/public/renderer/websocket_handshake_throttle_provider.h"
 #include "content/renderer/loader/code_cache_loader_impl.h"
@@ -25,6 +27,7 @@
 #include "content/renderer/loader/web_url_loader_impl.h"
 #include "content/renderer/loader/web_url_request_util.h"
 #include "content/renderer/service_worker/controller_service_worker_connector.h"
+#include "content/renderer/service_worker/service_worker_provider_context.h"
 #include "content/renderer/service_worker/service_worker_subresource_loader.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
@@ -147,6 +150,47 @@ class WebWorkerFetchContextImpl::Factory : public blink::WebURLLoaderFactory {
   DISALLOW_COPY_AND_ASSIGN(Factory);
 };
 
+scoped_refptr<WebWorkerFetchContextImpl> WebWorkerFetchContextImpl::Create(
+    ServiceWorkerProviderContext* provider_context,
+    RendererPreferences renderer_preferences,
+    mojom::RendererPreferenceWatcherRequest watcher_request,
+    std::unique_ptr<network::SharedURLLoaderFactoryInfo> loader_factory_info,
+    std::unique_ptr<network::SharedURLLoaderFactoryInfo>
+        fallback_factory_info) {
+  blink::mojom::ServiceWorkerWorkerClientRequest service_worker_client_request;
+  blink::mojom::ServiceWorkerWorkerClientRegistryPtrInfo
+      service_worker_worker_client_registry_ptr_info;
+  blink::mojom::ServiceWorkerContainerHostPtrInfo container_host_ptr_info;
+
+  // 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->CloneWorkerClientRegistry(
+        mojo::MakeRequest(&service_worker_worker_client_registry_ptr_info));
+
+    blink::mojom::ServiceWorkerWorkerClientPtr worker_client_ptr;
+    service_worker_client_request = mojo::MakeRequest(&worker_client_ptr);
+    provider_context->RegisterWorkerClient(std::move(worker_client_ptr));
+
+    if (blink::ServiceWorkerUtils::IsServicificationEnabled())
+      container_host_ptr_info = provider_context->CloneContainerHostPtrInfo();
+  }
+
+  return base::AdoptRef(new WebWorkerFetchContextImpl(
+      std::move(renderer_preferences), std::move(watcher_request),
+      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),
+      GetContentClient()->renderer()->CreateURLLoaderThrottleProvider(
+          URLLoaderThrottleProviderType::kWorker),
+      GetContentClient()
+          ->renderer()
+          ->CreateWebSocketHandshakeThrottleProvider(),
+      ChildThreadImpl::current()->thread_safe_sender(),
+      ChildThreadImpl::current()->GetConnector()->Clone()));
+}
+
 WebWorkerFetchContextImpl::WebWorkerFetchContextImpl(
     RendererPreferences renderer_preferences,
     mojom::RendererPreferenceWatcherRequest preference_watcher_request,
@@ -208,7 +252,7 @@ WebWorkerFetchContextImpl::CloneForNestedWorker() {
   }
 
   mojom::RendererPreferenceWatcherPtr preference_watcher;
-  auto new_context = base::MakeRefCounted<WebWorkerFetchContextImpl>(
+  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),
@@ -218,7 +262,7 @@ WebWorkerFetchContextImpl::CloneForNestedWorker() {
       websocket_handshake_throttle_provider_
           ? websocket_handshake_throttle_provider_->Clone()
           : nullptr,
-      thread_safe_sender_.get(), service_manager_connection_->Clone());
+      thread_safe_sender_.get(), service_manager_connection_->Clone()));
   new_context->service_worker_provider_id_ = service_worker_provider_id_;
   new_context->is_controlled_by_service_worker_ =
       is_controlled_by_service_worker_;

content/renderer/loader/web_worker_fetch_context_impl.h

@@ -34,6 +34,7 @@ namespace content {
 
 class FrameRequestBlocker;
 class ResourceDispatcher;
+class ServiceWorkerProviderContext;
 class ThreadSafeSender;
 class URLLoaderThrottleProvider;
 class WebSocketHandshakeThrottleProvider;
@@ -47,11 +48,14 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
       public blink::mojom::ServiceWorkerWorkerClient,
       public mojom::RendererPreferenceWatcher {
  public:
-  // |service_worker_client_request| is bound to |this| to receive
-  // OnControllerChanged() notifications.
-  // |service_worker_worker_client_registry_info| is a host pointer to register
-  // a new ServiceWorkerWorkerClient, which is needed when creating a nested
-  // worker. |loader_factory_info| is used for regular loading by the worker.
+  // Creates a new fetch context for a worker.
+  //
+  // |provider_context| is the ServiceWorkerProviderContext of the worker and is
+  // used to route requests to its controller service worker. It can be null if
+  // this worker is never associated with service workers, for example, when a
+  // dedicated worker is created from a sandboxed iframe that doesn't have a
+  // service worker provider context.
+  // |loader_factory_info| is used for regular loading by the worker.
   //
   // S13nServiceWorker:
   // If the worker is controlled by a service worker, this class makes another
@@ -65,23 +69,13 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
   // |fallback_factory_info| might not be simply the direct network factory,
   // because it might additionally support non-NetworkService schemes (e.g.,
   // chrome-extension://).
-  WebWorkerFetchContextImpl(
+  static scoped_refptr<WebWorkerFetchContextImpl> Create(
+      ServiceWorkerProviderContext* provider_context,
       RendererPreferences renderer_preferences,
       mojom::RendererPreferenceWatcherRequest watcher_request,
-      blink::mojom::ServiceWorkerWorkerClientRequest
-          service_worker_client_request,
-      blink::mojom::ServiceWorkerWorkerClientRegistryPtrInfo
-          service_worker_worker_client_registry_info,
-      blink::mojom::ServiceWorkerContainerHostPtrInfo
-          service_worker_container_host_info,
       std::unique_ptr<network::SharedURLLoaderFactoryInfo> loader_factory_info,
       std::unique_ptr<network::SharedURLLoaderFactoryInfo>
-          fallback_factory_info,
-      std::unique_ptr<URLLoaderThrottleProvider> throttle_provider,
-      std::unique_ptr<WebSocketHandshakeThrottleProvider>
-          websocket_handshake_throttle_provider,
-      ThreadSafeSender* thread_safe_sender,
-      std::unique_ptr<service_manager::Connector> service_manager_connection);
+          fallback_factory_info);
 
   // blink::WebWorkerFetchContext implementation:
   scoped_refptr<blink::WebWorkerFetchContext> CloneForNestedWorker() override;
@@ -137,6 +131,31 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
  private:
   class Factory;
 
+  // - |service_worker_client_request| is bound to |this| to receive
+  //   OnControllerChanged() notifications.
+  // - |service_worker_worker_client_registry_info| is a host pointer to
+  //   register a new ServiceWorkerWorkerClient, which is needed when creating a
+  //   nested worker.
+  //
+  // Regarding the rest of params, see the comments on Create().
+  WebWorkerFetchContextImpl(
+      RendererPreferences renderer_preferences,
+      mojom::RendererPreferenceWatcherRequest watcher_request,
+      blink::mojom::ServiceWorkerWorkerClientRequest
+          service_worker_client_request,
+      blink::mojom::ServiceWorkerWorkerClientRegistryPtrInfo
+          service_worker_worker_client_registry_info,
+      blink::mojom::ServiceWorkerContainerHostPtrInfo
+          service_worker_container_host_info,
+      std::unique_ptr<network::SharedURLLoaderFactoryInfo> loader_factory_info,
+      std::unique_ptr<network::SharedURLLoaderFactoryInfo>
+          fallback_factory_info,
+      std::unique_ptr<URLLoaderThrottleProvider> throttle_provider,
+      std::unique_ptr<WebSocketHandshakeThrottleProvider>
+          websocket_handshake_throttle_provider,
+      ThreadSafeSender* thread_safe_sender,
+      std::unique_ptr<service_manager::Connector> service_manager_connection);
+
   ~WebWorkerFetchContextImpl() override;
 
   bool Send(IPC::Message* message);

content/renderer/render_frame_impl.cc

@@ -3762,43 +3762,18 @@ RenderFrameImpl::CreateWorkerFetchContext() {
   ServiceWorkerNetworkProvider* provider =
       ServiceWorkerNetworkProvider::FromWebServiceWorkerNetworkProvider(
           web_provider);
-  blink::mojom::ServiceWorkerWorkerClientRequest service_worker_client_request;
-  blink::mojom::ServiceWorkerWorkerClientRegistryPtrInfo
-      service_worker_worker_client_registry_ptr_info;
-  blink::mojom::ServiceWorkerContainerHostPtrInfo container_host_ptr_info;
   ServiceWorkerProviderContext* provider_context = provider->context();
-  // 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->CloneWorkerClientRegistry(
-        mojo::MakeRequest(&service_worker_worker_client_registry_ptr_info));
-
-    blink::mojom::ServiceWorkerWorkerClientPtr worker_client_ptr;
-    service_worker_client_request = mojo::MakeRequest(&worker_client_ptr);
-    provider_context->RegisterWorkerClient(std::move(worker_client_ptr));
-
-    if (blink::ServiceWorkerUtils::IsServicificationEnabled())
-      container_host_ptr_info = provider_context->CloneContainerHostPtrInfo();
-  }
 
   mojom::RendererPreferenceWatcherPtr watcher;
   mojom::RendererPreferenceWatcherRequest watcher_request =
       mojo::MakeRequest(&watcher);
   render_view()->RegisterRendererPreferenceWatcherForWorker(std::move(watcher));
 
-  auto worker_fetch_context = base::MakeRefCounted<WebWorkerFetchContextImpl>(
-      render_view_->renderer_preferences(), std::move(watcher_request),
-      std::move(service_worker_client_request),
-      std::move(service_worker_worker_client_registry_ptr_info),
-      std::move(container_host_ptr_info), GetLoaderFactoryBundle()->Clone(),
-      GetLoaderFactoryBundle()->CloneWithoutAppCacheFactory(),
-      GetContentClient()->renderer()->CreateURLLoaderThrottleProvider(
-          URLLoaderThrottleProviderType::kWorker),
-      GetContentClient()
-          ->renderer()
-          ->CreateWebSocketHandshakeThrottleProvider(),
-      ChildThreadImpl::current()->thread_safe_sender(),
-      ChildThreadImpl::current()->GetConnector()->Clone());
+  scoped_refptr<WebWorkerFetchContextImpl> worker_fetch_context =
+      WebWorkerFetchContextImpl::Create(
+          provider_context, render_view_->renderer_preferences(),
+          std::move(watcher_request), GetLoaderFactoryBundle()->Clone(),
+          GetLoaderFactoryBundle()->CloneWithoutAppCacheFactory());
 
   worker_fetch_context->set_ancestor_frame_id(routing_id_);
   worker_fetch_context->set_frame_request_blocker(frame_request_blocker_);

content/renderer/shared_worker/embedded_shared_worker_stub.cc

@@ -12,13 +12,11 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/common/possibly_associated_wrapper_shared_url_loader_factory.h"
 #include "content/public/common/appcache_info.h"
-#include "content/public/common/content_client.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/network_service_util.h"
 #include "content/public/common/origin_util.h"
 #include "content/public/common/renderer_preferences.h"
-#include "content/public/renderer/content_renderer_client.h"
 #include "content/renderer/appcache/appcache_frontend_impl.h"
 #include "content/renderer/appcache/web_application_cache_host_impl.h"
 #include "content/renderer/loader/child_url_loader_factory_bundle.h"
@@ -275,44 +273,21 @@ scoped_refptr<blink::WebWorkerFetchContext>
 EmbeddedSharedWorkerStub::CreateWorkerFetchContext(
     blink::WebServiceWorkerNetworkProvider* web_network_provider) {
   DCHECK(web_network_provider);
-  ServiceWorkerProviderContext* context =
-      static_cast<WebServiceWorkerNetworkProviderImplForWorker*>(
+  ServiceWorkerProviderContext* provider_context =
+      ServiceWorkerNetworkProvider::FromWebServiceWorkerNetworkProvider(
           web_network_provider)
-          ->provider()
           ->context();
 
-  blink::mojom::ServiceWorkerWorkerClientRegistryPtrInfo
-      worker_client_registry_ptr_info;
-  context->CloneWorkerClientRegistry(
-      mojo::MakeRequest(&worker_client_registry_ptr_info));
-
-  blink::mojom::ServiceWorkerWorkerClientPtr worker_client_ptr;
-  blink::mojom::ServiceWorkerWorkerClientRequest worker_client_request =
-      mojo::MakeRequest(&worker_client_ptr);
-  context->RegisterWorkerClient(std::move(worker_client_ptr));
-
-  blink::mojom::ServiceWorkerContainerHostPtrInfo container_host_ptr_info;
-  if (blink::ServiceWorkerUtils::IsServicificationEnabled())
-    container_host_ptr_info = context->CloneContainerHostPtrInfo();
-
   // Make the factory used for service worker network fallback (that should
   // skip AppCache if it is provided).
   std::unique_ptr<network::SharedURLLoaderFactoryInfo> fallback_factory =
       subresource_loader_factories_->CloneWithoutAppCacheFactory();
 
-  auto worker_fetch_context = base::MakeRefCounted<WebWorkerFetchContextImpl>(
-      std::move(renderer_preferences_), std::move(preference_watcher_request_),
-      std::move(worker_client_request),
-      std::move(worker_client_registry_ptr_info),
-      std::move(container_host_ptr_info),
-      subresource_loader_factories_->Clone(), std::move(fallback_factory),
-      GetContentClient()->renderer()->CreateURLLoaderThrottleProvider(
-          URLLoaderThrottleProviderType::kWorker),
-      GetContentClient()
-          ->renderer()
-          ->CreateWebSocketHandshakeThrottleProvider(),
-      ChildThreadImpl::current()->thread_safe_sender(),
-      ChildThreadImpl::current()->GetConnector()->Clone());
+  scoped_refptr<WebWorkerFetchContextImpl> worker_fetch_context =
+      WebWorkerFetchContextImpl::Create(
+          provider_context, std::move(renderer_preferences_),
+          std::move(preference_watcher_request_),
+          subresource_loader_factories_->Clone(), std::move(fallback_factory));
 
   // 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.
@@ -326,12 +301,13 @@ EmbeddedSharedWorkerStub::CreateWorkerFetchContext(
   // https://w3c.github.io/webappsec-secure-contexts/#examples-shared-workers
   worker_fetch_context->set_is_secure_context(IsOriginSecure(url_));
   worker_fetch_context->set_origin_url(url_.GetOrigin());
-  worker_fetch_context->set_service_worker_provider_id(context->provider_id());
+  worker_fetch_context->set_service_worker_provider_id(
+      provider_context->provider_id());
   worker_fetch_context->set_is_controlled_by_service_worker(
-      context->IsControlledByServiceWorker());
-  worker_fetch_context->set_client_id(context->client_id());
+      provider_context->IsControlledByServiceWorker());
+  worker_fetch_context->set_client_id(provider_context->client_id());
 
-  return std::move(worker_fetch_context);
+  return worker_fetch_context;
 }
 
 void EmbeddedSharedWorkerStub::ConnectToChannel(