Enable multiple WorkerFetchContext per one global scope

Currently WorkerFetchContext has the ownership of
some objects originated from WebWorkerFetchContext.
To create multiple WorkerFetchContexts
for one WorkerOrWorkletGlobalScope/WebWorkerFetchContext,
this CL moves these ownership outside WorkerFetchContext.
Namely,
- url_loader_factory_ and script_loader_factory_
  from WorkerFetchContext to WebWorketFetchContext subclasses, and
- subresource_filter_ from WorkerFetchContext to
  WorkerOrWorkletGlobalScope.
  Still |WorkerFetchContext::subresource_filter_| is kept, but
  it is created in WorkerOrWorkletGlobalScope and passed to
  WorkerFetchContext.

This CL doesn't change the observable behavior.
This CL creates WebURLLoaderFactory a little more eagerly, i.e.
when WorkerFetchContext is created,
while previously it was created when
WorkerFetchContext::CreateURLLoader() is called for the first time.

Bug: 880027, 903579
Change-Id: I84a8bafee25b7f293201a271d198260e2dfb8e68
Reviewed-on: https://chromium-review.googlesource.com/c/1193385
Commit-Queue: Hiroshige Hayashizaki <hiroshige@chromium.org>
Reviewed-by: Tsuyoshi Horo <horo@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Cr-Commit-Position: refs/heads/master@{#606835}

content/renderer/loader/web_worker_fetch_context_impl.cc

@@ -262,20 +262,18 @@ void WebWorkerFetchContextImpl::InitializeOnWorkerThread() {
         base::RefCountedData<blink::mojom::BlobRegistryPtr>>(
         std::move(blob_registry_ptr));
   }
-}
 
-std::unique_ptr<blink::WebURLLoaderFactory>
-WebWorkerFetchContextImpl::CreateURLLoaderFactory() {
   DCHECK(loader_factory_);
   DCHECK(!web_loader_factory_);
-  auto factory = std::make_unique<Factory>(resource_dispatcher_->GetWeakPtr(),
-                                           loader_factory_);
-  web_loader_factory_ = factory->GetWeakPtr();
+  web_loader_factory_ = std::make_unique<Factory>(
+      resource_dispatcher_->GetWeakPtr(), loader_factory_);
 
   if (blink::ServiceWorkerUtils::IsServicificationEnabled())
     ResetServiceWorkerURLLoaderFactory();
+}
 
-  return factory;
+blink::WebURLLoaderFactory* WebWorkerFetchContextImpl::GetURLLoaderFactory() {
+  return web_loader_factory_.get();
 }
 
 std::unique_ptr<blink::WebURLLoaderFactory>

content/renderer/loader/web_worker_fetch_context_impl.h

@@ -85,7 +85,7 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
   scoped_refptr<blink::WebWorkerFetchContext> CloneForNestedWorker() override;
   void SetTerminateSyncLoadEvent(base::WaitableEvent*) override;
   void InitializeOnWorkerThread() override;
-  std::unique_ptr<blink::WebURLLoaderFactory> CreateURLLoaderFactory() override;
+  blink::WebURLLoaderFactory* GetURLLoaderFactory() override;
   std::unique_ptr<blink::WebURLLoaderFactory> WrapURLLoaderFactory(
       mojo::ScopedMessagePipeHandle url_loader_factory_handle) override;
   std::unique_ptr<blink::CodeCacheLoader> CreateCodeCacheLoader() override;
@@ -231,8 +231,8 @@ class CONTENT_EXPORT WebWorkerFetchContextImpl
   base::WaitableEvent* terminate_sync_load_event_ = nullptr;
 
   // The blink::WebURLLoaderFactory which was created and passed to
-  // Blink by CreateURLLoaderFactory().
-  base::WeakPtr<Factory> web_loader_factory_;
+  // Blink by GetURLLoaderFactory().
+  std::unique_ptr<Factory> web_loader_factory_;
 
   std::unique_ptr<URLLoaderThrottleProvider> throttle_provider_;
   std::unique_ptr<WebSocketHandshakeThrottleProvider>

content/renderer/service_worker/service_worker_fetch_context_impl.cc

@@ -55,19 +55,23 @@ void ServiceWorkerFetchContextImpl::InitializeOnWorkerThread() {
       terminate_sync_load_event_);
   preference_watcher_binding_.Bind(std::move(preference_watcher_request_));
 
-  url_loader_factory_ = network::SharedURLLoaderFactory::Create(
-      std::move(url_loader_factory_info_));
+  web_url_loader_factory_ = std::make_unique<WebURLLoaderFactoryImpl>(
+      resource_dispatcher_->GetWeakPtr(),
+      network::SharedURLLoaderFactory::Create(
+          std::move(url_loader_factory_info_)));
+
   if (script_loader_factory_info_) {
-    script_loader_factory_ = network::SharedURLLoaderFactory::Create(
-        std::move(script_loader_factory_info_));
+    web_script_loader_factory_ =
+        std::make_unique<content::WebURLLoaderFactoryImpl>(
+            resource_dispatcher_->GetWeakPtr(),
+            network::SharedURLLoaderFactory::Create(
+                std::move(script_loader_factory_info_)));
   }
 }
 
-std::unique_ptr<blink::WebURLLoaderFactory>
-ServiceWorkerFetchContextImpl::CreateURLLoaderFactory() {
-  DCHECK(url_loader_factory_);
-  return std::make_unique<WebURLLoaderFactoryImpl>(
-      resource_dispatcher_->GetWeakPtr(), std::move(url_loader_factory_));
+blink::WebURLLoaderFactory*
+ServiceWorkerFetchContextImpl::GetURLLoaderFactory() {
+  return web_url_loader_factory_.get();
 }
 
 std::unique_ptr<blink::WebURLLoaderFactory>
@@ -81,12 +85,9 @@ ServiceWorkerFetchContextImpl::WrapURLLoaderFactory(
               network::mojom::URLLoaderFactory::Version_)));
 }
 
-std::unique_ptr<blink::WebURLLoaderFactory>
-ServiceWorkerFetchContextImpl::CreateScriptLoaderFactory() {
-  if (!script_loader_factory_)
-    return nullptr;
-  return std::make_unique<content::WebURLLoaderFactoryImpl>(
-      resource_dispatcher_->GetWeakPtr(), std::move(script_loader_factory_));
+blink::WebURLLoaderFactory*
+ServiceWorkerFetchContextImpl::GetScriptLoaderFactory() {
+  return web_script_loader_factory_.get();
 }
 
 void ServiceWorkerFetchContextImpl::WillSendRequest(

content/renderer/service_worker/service_worker_fetch_context_impl.h

@@ -44,11 +44,10 @@ class ServiceWorkerFetchContextImpl final
   // blink::WebWorkerFetchContext implementation:
   void SetTerminateSyncLoadEvent(base::WaitableEvent*) override;
   void InitializeOnWorkerThread() override;
-  std::unique_ptr<blink::WebURLLoaderFactory> CreateURLLoaderFactory() override;
+  blink::WebURLLoaderFactory* GetURLLoaderFactory() override;
   std::unique_ptr<blink::WebURLLoaderFactory> WrapURLLoaderFactory(
       mojo::ScopedMessagePipeHandle url_loader_factory_handle) override;
-  std::unique_ptr<blink::WebURLLoaderFactory> CreateScriptLoaderFactory()
-      override;
+  blink::WebURLLoaderFactory* GetScriptLoaderFactory() override;
   void WillSendRequest(blink::WebURLRequest&) override;
   blink::mojom::ControllerServiceWorkerMode IsControlledByServiceWorker()
       const override;
@@ -64,9 +63,9 @@ class ServiceWorkerFetchContextImpl final
 
   RendererPreferences renderer_preferences_;
   const GURL worker_script_url_;
-  // Consumed on the worker thread to create |url_loader_factory_|.
+  // Consumed on the worker thread to create |web_url_loader_factory_|.
   std::unique_ptr<network::SharedURLLoaderFactoryInfo> url_loader_factory_info_;
-  // Consumed on the worker thread to create |script_loader_factory_|.
+  // Consumed on the worker thread to create |web_script_loader_factory_|.
   std::unique_ptr<network::SharedURLLoaderFactoryInfo>
       script_loader_factory_info_;
   const int service_worker_provider_id_;
@@ -75,9 +74,9 @@ class ServiceWorkerFetchContextImpl final
   std::unique_ptr<ResourceDispatcher> resource_dispatcher_;
 
   // Responsible for regular loads from the service worker (i.e., Fetch API).
-  scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_;
+  std::unique_ptr<blink::WebURLLoaderFactory> web_url_loader_factory_;
   // Responsible for handling importScripts().
-  scoped_refptr<network::SharedURLLoaderFactory> script_loader_factory_;
+  std::unique_ptr<blink::WebURLLoaderFactory> web_script_loader_factory_;
 
   std::unique_ptr<URLLoaderThrottleProvider> throttle_provider_;
   std::unique_ptr<WebSocketHandshakeThrottleProvider>

third_party/blink/public/platform/web_worker_fetch_context.h

@@ -38,6 +38,9 @@ class WebDocumentSubresourceFilter;
 // worker script fetch (i.e. fetch as "outsideSettings"), as they both should be
 // e.g. controlled by the same ServiceWorker (if any) and thus can share a
 // single WebURLLoaderFactory.
+//
+// Note that WebWorkerFetchContext and WorkerFetchContext do NOT correspond 1:1
+// as multiple WorkerFetchContext can be created after crbug.com/880027.
 class WebWorkerFetchContext : public base::RefCounted<WebWorkerFetchContext> {
  public:
   REQUIRE_ADOPTION_FOR_REFCOUNTED_TYPE();
@@ -57,9 +60,9 @@ class WebWorkerFetchContext : public base::RefCounted<WebWorkerFetchContext> {
 
   virtual void InitializeOnWorkerThread() = 0;
 
-  // Returns a new WebURLLoaderFactory which is associated with the worker
-  // context. It can be called only once.
-  virtual std::unique_ptr<WebURLLoaderFactory> CreateURLLoaderFactory() = 0;
+  // Returns a WebURLLoaderFactory which is associated with the worker context.
+  // The returned WebURLLoaderFactory is owned by |this|.
+  virtual WebURLLoaderFactory* GetURLLoaderFactory() = 0;
 
   // Returns a new WebURLLoaderFactory that wraps the given
   // network::mojom::URLLoaderFactory.
@@ -73,12 +76,10 @@ class WebWorkerFetchContext : public base::RefCounted<WebWorkerFetchContext> {
     return nullptr;
   };
 
-  // Returns a new WebURLLoaderFactory for loading scripts in this worker
-  // context. Unlike CreateURLLoaderFactory(), this may return nullptr even on
-  // the first call.
-  virtual std::unique_ptr<WebURLLoaderFactory> CreateScriptLoaderFactory() {
-    return nullptr;
-  }
+  // Returns a WebURLLoaderFactory for loading scripts in this worker context.
+  // Unlike GetURLLoaderFactory(), this may return nullptr.
+  // The returned WebURLLoaderFactory is owned by |this|.
+  virtual WebURLLoaderFactory* GetScriptLoaderFactory() { return nullptr; }
 
   // Called when a request is about to be sent out to modify the request to
   // handle the request correctly in the loading stack later. (Example: service

third_party/blink/renderer/core/loader/worker_fetch_context.cc

@@ -37,32 +37,29 @@ WorkerFetchContext::~WorkerFetchContext() = default;
 
 WorkerFetchContext* WorkerFetchContext::Create(
     WorkerOrWorkletGlobalScope& global_scope,
-    scoped_refptr<WebWorkerFetchContext> web_context) {
+    scoped_refptr<WebWorkerFetchContext> web_context,
+    SubresourceFilter* subresource_filter) {
   if (!web_context)
     return nullptr;
-  return new WorkerFetchContext(global_scope, std::move(web_context));
+  return new WorkerFetchContext(global_scope, std::move(web_context),
+                                subresource_filter);
 }
 
 WorkerFetchContext::WorkerFetchContext(
     WorkerOrWorkletGlobalScope& global_scope,
-    scoped_refptr<WebWorkerFetchContext> web_context)
+    scoped_refptr<WebWorkerFetchContext> web_context,
+    SubresourceFilter* subresource_filter)
     : BaseFetchContext(global_scope.GetTaskRunner(TaskType::kInternalLoading)),
       global_scope_(global_scope),
       web_context_(std::move(web_context)),
+      subresource_filter_(subresource_filter),
       fetch_client_settings_object_(
           new FetchClientSettingsObjectImpl(*global_scope_)),
       save_data_enabled_(GetNetworkStateNotifier().SaveDataEnabled()) {
   DCHECK(global_scope.IsContextThread());
   DCHECK(web_context_);
-
-  web_context_->InitializeOnWorkerThread();
-  std::unique_ptr<blink::WebDocumentSubresourceFilter> web_filter =
-      web_context_->TakeSubresourceFilter();
-  if (web_filter) {
-    subresource_filter_ =
-        SubresourceFilter::Create(global_scope, std::move(web_filter));
-  }
 }
+
 const FetchClientSettingsObjectImpl*
 WorkerFetchContext::GetFetchClientSettingsObject() const {
   return fetch_client_settings_object_.Get();
@@ -229,17 +226,13 @@ std::unique_ptr<WebURLLoader> WorkerFetchContext::CreateURLLoader(
   if (request.GetRequestContext() == mojom::RequestContextType::SCRIPT ||
       request.GetRequestContext() ==
           mojom::RequestContextType::SERVICE_WORKER) {
-    if (!script_loader_factory_)
-      script_loader_factory_ = web_context_->CreateScriptLoaderFactory();
-    if (script_loader_factory_) {
-      return script_loader_factory_->CreateURLLoader(
+    if (web_context_->GetScriptLoaderFactory()) {
+      return web_context_->GetScriptLoaderFactory()->CreateURLLoader(
           wrapped, CreateResourceLoadingTaskRunnerHandle());
     }
   }
 
-  if (!url_loader_factory_)
-    url_loader_factory_ = web_context_->CreateURLLoaderFactory();
-  return url_loader_factory_->CreateURLLoader(
+  return web_context_->GetURLLoaderFactory()->CreateURLLoader(
       wrapped, CreateResourceLoadingTaskRunnerHandle());
 }
 

third_party/blink/renderer/core/loader/worker_fetch_context.h

@@ -19,7 +19,6 @@ namespace blink {
 class Resource;
 class SubresourceFilter;
 class WebURLLoader;
-class WebURLLoaderFactory;
 class WebWorkerFetchContext;
 class WorkerContentSettingsClient;
 class WorkerSettings;
@@ -31,7 +30,8 @@ enum class ResourceType : uint8_t;
 class WorkerFetchContext final : public BaseFetchContext {
  public:
   static WorkerFetchContext* Create(WorkerOrWorkletGlobalScope&,
-                                    scoped_refptr<WebWorkerFetchContext>);
+                                    scoped_refptr<WebWorkerFetchContext>,
+                                    SubresourceFilter*);
   ~WorkerFetchContext() override;
 
   // BaseFetchContext implementation:
@@ -128,22 +128,14 @@ class WorkerFetchContext final : public BaseFetchContext {
 
  private:
   WorkerFetchContext(WorkerOrWorkletGlobalScope&,
-                     scoped_refptr<WebWorkerFetchContext>);
+                     scoped_refptr<WebWorkerFetchContext>,
+                     SubresourceFilter*);
 
   void SetFirstPartyCookie(ResourceRequest&);
 
   const Member<WorkerOrWorkletGlobalScope> global_scope_;
-  const scoped_refptr<WebWorkerFetchContext> web_context_;
-
-  // Responsible for regular loads from the worker (i.e., Fetch API).
-  std::unique_ptr<WebURLLoaderFactory> url_loader_factory_;
-
-  // Responsible for handling script loads in certian situations (i.e.,
-  // script import from service workers, which invole special processing
-  // to persist the script in storage). May be null, fallback to
-  // url_loader_factory_ in that case.
-  std::unique_ptr<WebURLLoaderFactory> script_loader_factory_;
 
+  const scoped_refptr<WebWorkerFetchContext> web_context_;
   Member<SubresourceFilter> subresource_filter_;
 
   const Member<FetchClientSettingsObjectImpl> fetch_client_settings_object_;

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

@@ -11,6 +11,7 @@
 #include "third_party/blink/renderer/core/frame/deprecation.h"
 #include "third_party/blink/renderer/core/inspector/console_message.h"
 #include "third_party/blink/renderer/core/loader/modulescript/module_script_fetch_request.h"
+#include "third_party/blink/renderer/core/loader/subresource_filter.h"
 #include "third_party/blink/renderer/core/loader/worker_fetch_context.h"
 #include "third_party/blink/renderer/core/probe/core_probes.h"
 #include "third_party/blink/renderer/core/workers/worker_reporting_proxy.h"
@@ -96,12 +97,32 @@ void WorkerOrWorkletGlobalScope::CountDeprecation(WebFeature feature) {
   ReportingProxy().CountDeprecation(feature);
 }
 
+void WorkerOrWorkletGlobalScope::InitializeWebFetchContextIfNeeded() {
+  if (web_fetch_context_initialized_)
+    return;
+  web_fetch_context_initialized_ = true;
+
+  if (!web_worker_fetch_context_)
+    return;
+
+  DCHECK(!subresource_filter_);
+  web_worker_fetch_context_->InitializeOnWorkerThread();
+  std::unique_ptr<blink::WebDocumentSubresourceFilter> web_filter =
+      web_worker_fetch_context_->TakeSubresourceFilter();
+  if (web_filter) {
+    subresource_filter_ =
+        SubresourceFilter::Create(*this, std::move(web_filter));
+  }
+}
+
 ResourceFetcher* WorkerOrWorkletGlobalScope::EnsureFetcher() {
   DCHECK(IsContextThread());
   if (resource_fetcher_)
     return resource_fetcher_;
-  WorkerFetchContext* fetch_context =
-      WorkerFetchContext::Create(*this, std::move(web_worker_fetch_context_));
+
+  InitializeWebFetchContextIfNeeded();
+  WorkerFetchContext* fetch_context = WorkerFetchContext::Create(
+      *this, web_worker_fetch_context_, subresource_filter_);
   resource_fetcher_ = ResourceFetcher::Create(fetch_context);
   if (IsContextPaused())
     resource_fetcher_->SetDefersLoading(true);
@@ -218,6 +239,7 @@ void WorkerOrWorkletGlobalScope::TasksWereUnpaused() {
 
 void WorkerOrWorkletGlobalScope::Trace(blink::Visitor* visitor) {
   visitor->Trace(resource_fetcher_);
+  visitor->Trace(subresource_filter_);
   visitor->Trace(script_controller_);
   visitor->Trace(modulator_);
   EventTargetWithInlineData::Trace(visitor);

third_party/blink/renderer/core/workers/worker_or_worklet_global_scope.h

@@ -9,6 +9,7 @@
 #include "services/network/public/mojom/fetch_api.mojom-shared.h"
 #include "third_party/blink/public/platform/web_url_request.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_cache_options.h"
+#include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/dom/events/event_target.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
 #include "third_party/blink/renderer/core/execution_context/security_context.h"
@@ -26,6 +27,7 @@ class FetchClientSettingsObjectSnapshot;
 class Modulator;
 class ModuleTreeClient;
 class ResourceFetcher;
+class SubresourceFilter;
 class WebWorkerFetchContext;
 class WorkerOrWorkletScriptController;
 class WorkerReportingProxy;
@@ -121,10 +123,26 @@ class CORE_EXPORT WorkerOrWorkletGlobalScope : public EventTargetWithInlineData,
   void TasksWereUnpaused() override;
 
  private:
+  void InitializeWebFetchContextIfNeeded();
+
+  bool web_fetch_context_initialized_ = false;
+
   CrossThreadPersistent<WorkerClients> worker_clients_;
+
   Member<ResourceFetcher> resource_fetcher_;
 
+  // A WorkerOrWorkletGlobalScope has one WebWorkerFetchContext and one
+  // corresponding SubresourceFilter, which are shared by all
+  // WorkerFetchContexts of |this| global scope after crbug.com/880027.
+  // As all references to |web_worker_fetch_context_| are on the context
+  // thread, |web_worker_fetch_context_| is destructed on the context
+  // thread.
+  //
+  // TODO(crbug/903579): Consider putting WebWorkerFetchContext-originated
+  // things at a single place. Currently they are placed here and subclasses of
+  // WebWorkerFetchContext.
   scoped_refptr<WebWorkerFetchContext> web_worker_fetch_context_;
+  Member<SubresourceFilter> subresource_filter_;
 
   Member<WorkerOrWorkletScriptController> script_controller_;