[WIP] Worklet: Merge MainThreadWorklet and ThreadedWorklet into Worklet

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 {
+
+// TODO(nhiroki): This will be replaced with WorkletModuleTreeClient when module
+// loading is ready for threaded worklets.
+class LoaderClient final : public GarbageCollected<LoaderClient>,
+                           public WorkletScriptLoader::Client {
+  USING_GARBAGE_COLLECTED_MIXIN(LoaderClient);
+
+ public:
+  LoaderClient(WorkletPendingTasks* pending_tasks,
+               ThreadedWorkletMessagingProxy* proxy)
+      : pending_tasks_(pending_tasks), proxy_(proxy) {}
+
+  // WorkletScriptLoader::Client
+  void NotifyWorkletScriptLoadingFinished(
+      WorkletScriptLoader* script_loader,
+      const ScriptSourceCode& source_code) final {
+    DCHECK(IsMainThread());
+    if (!script_loader->WasScriptLoadSuccessful()) {
+      pending_tasks_->Abort();
+      return;
+    }
+    proxy_->EvaluateScript(source_code);
+    pending_tasks_->DecrementCounter();
+  }
+
+  DEFINE_INLINE_TRACE() { visitor->Trace(pending_tasks_); }
+
+ private:
+  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());
   if (AskedToTerminate())
@@ skipping 18 matching lines @@
           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,
+    WorkletPendingTasks* pending_tasks) {
+  DCHECK(IsMainThread());
+  LoaderClient* client = new LoaderClient(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