Introduce WorkerOrWorkletGlobalScope::CreateOutsideSettingsFetcher()

This CL
- Introduces CreateOutsideSettingsFetcher() that will be used in
  https://chromium-review.googlesource.com/1328164
- Extends pause/unpause mechanism that has been implemented for
  existing (insideSettings) ResourceFetcher to cover
  ResourceFetchers created by CreateOutsideSettingsFetcher().

This CL shouldn't change the behavior.

Bug: 880027
Change-Id: Ifa21b4d31f6d01fa7a9021410d5aa95a7bbf0a78
Reviewed-on: https://chromium-review.googlesource.com/c/1328043
Commit-Queue: Hiroshige Hayashizaki <hiroshige@chromium.org>
Reviewed-by: Hiroki Nakagawa <nhiroki@chromium.org>
Reviewed-by: Yutaka Hirano <yhirano@chromium.org>
Cr-Commit-Position: refs/heads/master@{#607939}

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

@@ -39,23 +39,25 @@ WorkerFetchContext::~WorkerFetchContext() = default;
 WorkerFetchContext* WorkerFetchContext::Create(
     WorkerOrWorkletGlobalScope& global_scope,
     scoped_refptr<WebWorkerFetchContext> web_context,
-    SubresourceFilter* subresource_filter) {
+    SubresourceFilter* subresource_filter,
+    FetchClientSettingsObject* fetch_client_settings_object) {
   if (!web_context)
     return nullptr;
   return new WorkerFetchContext(global_scope, std::move(web_context),
-                                subresource_filter);
+                                subresource_filter,
+                                fetch_client_settings_object);
 }
 
 WorkerFetchContext::WorkerFetchContext(
     WorkerOrWorkletGlobalScope& global_scope,
     scoped_refptr<WebWorkerFetchContext> web_context,
-    SubresourceFilter* subresource_filter)
+    SubresourceFilter* subresource_filter,
+    FetchClientSettingsObject* fetch_client_settings_object)
     : 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_)),
+      fetch_client_settings_object_(fetch_client_settings_object),
       save_data_enabled_(GetNetworkStateNotifier().SaveDataEnabled()) {
   DCHECK(global_scope.IsContextThread());
   DCHECK(web_context_);

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

@@ -30,7 +30,8 @@ class WorkerFetchContext final : public BaseFetchContext {
  public:
   static WorkerFetchContext* Create(WorkerOrWorkletGlobalScope&,
                                     scoped_refptr<WebWorkerFetchContext>,
-                                    SubresourceFilter*);
+                                    SubresourceFilter*,
+                                    FetchClientSettingsObject*);
   ~WorkerFetchContext() override;
 
   // BaseFetchContext implementation:
@@ -128,7 +129,8 @@ class WorkerFetchContext final : public BaseFetchContext {
  private:
   WorkerFetchContext(WorkerOrWorkletGlobalScope&,
                      scoped_refptr<WebWorkerFetchContext>,
-                     SubresourceFilter*);
+                     SubresourceFilter*,
+                     FetchClientSettingsObject*);
 
   void SetFirstPartyCookie(ResourceRequest&);
 

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

@@ -14,6 +14,7 @@
 #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/script/fetch_client_settings_object_impl.h"
 #include "third_party/blink/renderer/core/workers/worker_reporting_proxy.h"
 #include "third_party/blink/renderer/core/workers/worker_thread.h"
 #include "third_party/blink/renderer/platform/cross_thread_functional.h"
@@ -117,23 +118,37 @@ void WorkerOrWorkletGlobalScope::InitializeWebFetchContextIfNeeded() {
 
 ResourceFetcher* WorkerOrWorkletGlobalScope::EnsureFetcher() {
   DCHECK(IsContextThread());
-  if (resource_fetcher_)
-    return resource_fetcher_;
+  if (inside_settings_resource_fetcher_)
+    return inside_settings_resource_fetcher_;
+  inside_settings_resource_fetcher_ =
+      CreateFetcherInternal(new FetchClientSettingsObjectImpl(*this));
+  return inside_settings_resource_fetcher_;
+}
 
+ResourceFetcher* WorkerOrWorkletGlobalScope::CreateFetcherInternal(
+    FetchClientSettingsObject* fetch_client_settings_object) {
+  DCHECK(IsContextThread());
   InitializeWebFetchContextIfNeeded();
   WorkerFetchContext* fetch_context = WorkerFetchContext::Create(
-      *this, web_worker_fetch_context_, subresource_filter_);
-  resource_fetcher_ = ResourceFetcher::Create(fetch_context);
+      *this, web_worker_fetch_context_, subresource_filter_,
+      fetch_client_settings_object);
+  ResourceFetcher* resource_fetcher = ResourceFetcher::Create(fetch_context);
   if (IsContextPaused())
-    resource_fetcher_->SetDefersLoading(true);
-  DCHECK(resource_fetcher_);
-  return resource_fetcher_;
+    resource_fetcher->SetDefersLoading(true);
+  resource_fetchers_.insert(resource_fetcher);
+  return resource_fetcher;
 }
 
 ResourceFetcher* WorkerOrWorkletGlobalScope::Fetcher() const {
   DCHECK(IsContextThread());
-  DCHECK(resource_fetcher_);
-  return resource_fetcher_;
+  DCHECK(inside_settings_resource_fetcher_);
+  return inside_settings_resource_fetcher_;
+}
+
+ResourceFetcher* WorkerOrWorkletGlobalScope::CreateOutsideSettingsFetcher(
+    FetchClientSettingsObject* fetch_client_settings_object) {
+  DCHECK(IsContextThread());
+  return CreateFetcherInternal(fetch_client_settings_object);
 }
 
 bool WorkerOrWorkletGlobalScope::IsJSExecutionForbidden() const {
@@ -157,9 +172,9 @@ void WorkerOrWorkletGlobalScope::Dispose() {
   script_controller_->Dispose();
   script_controller_.Clear();
 
-  if (resource_fetcher_) {
-    resource_fetcher_->StopFetching();
-    resource_fetcher_->ClearContext();
+  for (ResourceFetcher* resource_fetcher : resource_fetchers_) {
+    resource_fetcher->StopFetching();
+    resource_fetcher->ClearContext();
   }
 }
 
@@ -227,18 +242,19 @@ void WorkerOrWorkletGlobalScope::FetchModuleScript(
 
 void WorkerOrWorkletGlobalScope::TasksWerePaused() {
   ExecutionContext::TasksWerePaused();
-  if (resource_fetcher_)
-    resource_fetcher_->SetDefersLoading(true);
+  for (ResourceFetcher* resource_fetcher : resource_fetchers_)
+    resource_fetcher->SetDefersLoading(true);
 }
 
 void WorkerOrWorkletGlobalScope::TasksWereUnpaused() {
   ExecutionContext::TasksWereUnpaused();
-  if (resource_fetcher_)
-    resource_fetcher_->SetDefersLoading(false);
+  for (ResourceFetcher* resource_fetcher : resource_fetchers_)
+    resource_fetcher->SetDefersLoading(false);
 }
 
 void WorkerOrWorkletGlobalScope::Trace(blink::Visitor* visitor) {
-  visitor->Trace(resource_fetcher_);
+  visitor->Trace(inside_settings_resource_fetcher_);
+  visitor->Trace(resource_fetchers_);
   visitor->Trace(subresource_filter_);
   visitor->Trace(script_controller_);
   visitor->Trace(modulator_);

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

@@ -23,6 +23,7 @@
 
 namespace blink {
 
+class FetchClientSettingsObject;
 class FetchClientSettingsObjectSnapshot;
 class Modulator;
 class ModuleTreeClient;
@@ -93,6 +94,17 @@ class CORE_EXPORT WorkerOrWorkletGlobalScope : public EventTargetWithInlineData,
   ResourceFetcher* Fetcher() const override;
   ResourceFetcher* EnsureFetcher();
 
+  // ResourceFetcher for off-the-main-thread worker top-level script fetching,
+  // corresponding to "outside" fetch client's settings object.
+  // CreateOutsideSettingsFetcher() is called for each invocation of top-level
+  // script fetch, which can occur multiple times in worklets.
+  // TODO(hiroshige, nhiroki): Currently this outside ResourceFetcher and its
+  // WorkerFetchContext is mostly the copy of the insideSettings
+  // ResourceFetcher, and have dependencies to WorkerOrWorkletGlobalScope. Plumb
+  // more data to the outside ResourceFetcher to fix the behavior and reduce the
+  // dependencies.
+  ResourceFetcher* CreateOutsideSettingsFetcher(FetchClientSettingsObject*);
+
   WorkerClients* Clients() const { return worker_clients_.Get(); }
 
   WorkerOrWorkletScriptController* ScriptController() {
@@ -124,16 +136,23 @@ class CORE_EXPORT WorkerOrWorkletGlobalScope : public EventTargetWithInlineData,
 
  private:
   void InitializeWebFetchContextIfNeeded();
+  ResourceFetcher* CreateFetcherInternal(FetchClientSettingsObject*);
 
   bool web_fetch_context_initialized_ = false;
 
   CrossThreadPersistent<WorkerClients> worker_clients_;
 
-  Member<ResourceFetcher> resource_fetcher_;
+  Member<ResourceFetcher> inside_settings_resource_fetcher_;
+
+  // Keeps track of all ResourceFetchers (including
+  // |inside_settings_resource_fetcher_|) for disposing and pausing/unpausing.
+  HeapHashSet<WeakMember<ResourceFetcher>> resource_fetchers_;
 
   // A WorkerOrWorkletGlobalScope has one WebWorkerFetchContext and one
   // corresponding SubresourceFilter, which are shared by all
-  // WorkerFetchContexts of |this| global scope after crbug.com/880027.
+  // WorkerFetchContexts of |this| global scope, i.e. those behind
+  // ResourceFetchers created by EnsureFetcher() and
+  // CreateOutsideSettingsFetcher().
   // As all references to |web_worker_fetch_context_| are on the context
   // thread, |web_worker_fetch_context_| is destructed on the context
   // thread.