Worklet: Move loader client impl from ThreadedWorklet to ThreadedWorkletMessagingProxy

third_party/WebKit/Source/core/workers/ThreadedWorkletMessagingProxy.cpp

 // Copyright 2016 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.
 
 #include "core/workers/ThreadedWorkletMessagingProxy.h"
 
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "core/dom/Document.h"
 #include "core/dom/SecurityContext.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
+#include "core/loader/WorkletScriptLoader.h"
 #include "core/origin_trials/OriginTrialContext.h"
 #include "core/workers/ThreadedWorkletObjectProxy.h"
 #include "core/workers/WorkerInspectorProxy.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "core/workers/WorkletGlobalScope.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WebTaskRunner.h"
 
 namespace blink {
 
+namespace {
+
+// Implementation of the second half of the "fetch and invoke a worklet script"
+// algorithm:
+// https://drafts.css-houdini.org/worklets/#fetch-and-invoke-a-worklet-script
+// TODO(nhiroki): This should be in sync with WorkletModuleTreeClient as much as
+// possible because this will be replaced with that when module loading is ready
+// for threaded worklets (https://crbug.com/727194).
+class LoaderClient final : public GarbageCollectedFinalized<LoaderClient>,
+                           public WorkletScriptLoader::Client {
+  USING_GARBAGE_COLLECTED_MIXIN(LoaderClient);
+
+ public:
+  LoaderClient(RefPtr<WebTaskRunner> outside_settings_task_runner,
+               WorkletPendingTasks* pending_tasks,
+               ThreadedWorkletMessagingProxy* proxy)
+      : outside_settings_task_runner_(std::move(outside_settings_task_runner)),
+        pending_tasks_(pending_tasks),
+        proxy_(proxy) {}
+
+  // Implementation of the second half of the "fetch and invoke a worklet
+  // script" algorithm:
+  // https://drafts.css-houdini.org/worklets/#fetch-and-invoke-a-worklet-script
+  void NotifyWorkletScriptLoadingFinished(
+      WorkletScriptLoader* script_loader,
+      const ScriptSourceCode& source_code) final {
+    DCHECK(IsMainThread());
+    if (!script_loader->WasScriptLoadSuccessful()) {
+      // Step 3: "If script is null, then queue a task on outsideSettings's
+      // responsible event loop to run these steps:"
+      // The steps are implemented in WorkletPendingTasks::Abort().
+      outside_settings_task_runner_->PostTask(
+          BLINK_FROM_HERE, WTF::Bind(&WorkletPendingTasks::Abort,
+                                     WrapPersistent(pending_tasks_.Get())));
+      return;
+    }
+
+    // Step 4: "Run a module script given script."
+    proxy_->EvaluateScript(source_code);
+
+    // Step 5: "Queue a task on outsideSettings's responsible event loop to run
+    // these steps:"
+    // The steps are implemented in WorkletPendingTasks::DecrementCounter().
+    outside_settings_task_runner_->PostTask(
+        BLINK_FROM_HERE, WTF::Bind(&WorkletPendingTasks::DecrementCounter,
+                                   WrapPersistent(pending_tasks_.Get())));
+  }
+
+  DEFINE_INLINE_TRACE() { visitor->Trace(pending_tasks_); }
+
+ private:
+  RefPtr<WebTaskRunner> outside_settings_task_runner_;
+  Member<WorkletPendingTasks> pending_tasks_;
+  ThreadedWorkletMessagingProxy* proxy_;
+};
+
+}  // namespace
+
 ThreadedWorkletMessagingProxy::ThreadedWorkletMessagingProxy(
     ExecutionContext* execution_context)
     : ThreadedMessagingProxyBase(execution_context), weak_ptr_factory_(this) {
   worklet_object_proxy_ = ThreadedWorkletObjectProxy::Create(
       weak_ptr_factory_.CreateWeakPtr(), GetParentFrameTaskRunners());
 }
 
 void ThreadedWorkletMessagingProxy::Initialize() {
-  DCHECK(IsParentContextThread());
+  DCHECK(IsMainThread());
   if (AskedToTerminate())
     return;
 
   Document* document = ToDocument(GetExecutionContext());
   SecurityOrigin* starter_origin = document->GetSecurityOrigin();
   KURL script_url = document->Url();
 
   ContentSecurityPolicy* csp = document->GetContentSecurityPolicy();
   DCHECK(csp);
 
   WorkerThreadStartMode start_mode =
       GetWorkerInspectorProxy()->WorkerStartMode(document);
   std::unique_ptr<WorkerSettings> worker_settings =
       WTF::WrapUnique(new WorkerSettings(document->GetSettings()));
 
   // TODO(ikilpatrick): Decide on sensible a value for referrerPolicy.
   std::unique_ptr<WorkerThreadStartupData> startup_data =
       WorkerThreadStartupData::Create(
           script_url, document->UserAgent(), String(), nullptr, start_mode,
           csp->Headers().get(), /* referrerPolicy */ String(), starter_origin,
           nullptr, document->AddressSpace(),
           OriginTrialContext::GetTokens(document).get(),
           std::move(worker_settings), WorkerV8Settings::Default());
 
   InitializeWorkerThread(std::move(startup_data));
   GetWorkerInspectorProxy()->WorkerThreadCreated(document, GetWorkerThread(),
                                                  script_url);
 }
 
+void ThreadedWorkletMessagingProxy::FetchAndInvokeScript(
+    const KURL& module_url_record,
+    WebURLRequest::FetchCredentialsMode credentials_mode,
+    RefPtr<WebTaskRunner> outside_settings_task_runner,
+    WorkletPendingTasks* pending_tasks) {
+  DCHECK(IsMainThread());
+  LoaderClient* client = new LoaderClient(
+      std::move(outside_settings_task_runner), pending_tasks, this);
+  WorkletScriptLoader* script_loader = WorkletScriptLoader::Create(
+      ToDocument(GetExecutionContext())->Fetcher(), client);
+  script_loader->FetchScript(module_url_record);
+}
+
 void ThreadedWorkletMessagingProxy::EvaluateScript(
     const ScriptSourceCode& script_source_code) {
+  DCHECK(IsMainThread());
   TaskRunnerHelper::Get(TaskType::kMiscPlatformAPI, GetWorkerThread())
       ->PostTask(
           BLINK_FROM_HERE,
           CrossThreadBind(&ThreadedWorkletObjectProxy::EvaluateScript,
                           CrossThreadUnretained(worklet_object_proxy_.get()),
                           script_source_code.Source(), script_source_code.Url(),
                           CrossThreadUnretained(GetWorkerThread())));
 }
 
 void ThreadedWorkletMessagingProxy::TerminateWorkletGlobalScope() {
+  DCHECK(IsMainThread());
   TerminateGlobalScope();
 }
 
 }  // namespace blink