Worklet: Enqueue tasks into outsideSetting's event loop

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

 // Copyright 2017 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/WorkletModuleTreeClient.h"
 
 #include "core/dom/ModuleScript.h"
+#include "core/dom/TaskRunnerHelper.h"
+#include "platform/CrossThreadFunctional.h"
 
 namespace blink {
 
 WorkletModuleTreeClient::WorkletModuleTreeClient(
     Modulator* modulator,
+    ParentFrameTaskRunners* task_runners,
     WorkletPendingTasks* pending_tasks)
-    : modulator_(modulator), pending_tasks_(pending_tasks) {}
+    : modulator_(modulator),
+      task_runners_(task_runners),
+      pending_tasks_(pending_tasks) {}
 
 // 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 WorkletModuleTreeClient::NotifyModuleTreeLoadFinished(
     ModuleScript* module_script) {
-  DCHECK(IsMainThread());
   if (!module_script) {
     // 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().

[kinuko, 2017/05/30 02:32:58]

The spec seems to say 'responsible event loop' is a newly created
workletEventLoop (am I following right?), is kUnspecedLoading the right one?

[nhiroki, 2017/05/30 04:03:40]

According to [1], "workletEventLoop" is the message loop for "insideSettings"
(i.e., WorkeltGlobalScope). We're posting a task to the message loop for
"outsideSettings" (i.e., Document).

The spec doesn't clearly say about the task type like this[2]:

  "A responsible event loop: An event loop that is used when it would not be
immediately clear what event loop to use."

kUnspecedLoading is used in MainThreadWorklet::addModule() because this is a
part of module loading. That's the reason why I chose it here.

[1] https://drafts.css-houdini.org/worklets/#creating-a-workletglobalscope
[2]
https://html.spec.whatwg.org/multipage/webappapis.html#responsible-event-loop

-    // TODO(nhiroki): Queue a task instead of executing this here.
-    pending_tasks_->Abort();
+    task_runners_->Get(TaskType::kUnspecedLoading)
+        ->PostTask(
+            BLINK_FROM_HERE,
+            CrossThreadBind(&WorkletPendingTasks::Abort,
+                            WrapCrossThreadPersistent(pending_tasks_.Get())));
     return;
   }
 
   // Step 4: "Run a module script given script."
   modulator_->ExecuteModule(module_script);
 
   // Step 5: "Queue a task on outsideSettings's responsible event loop to run
   // these steps:"
   // The steps are implemented in WorkletPendingTasks::DecrementCounter().
-  // TODO(nhiroki): Queue a task instead of executing this here.
-  pending_tasks_->DecrementCounter();
+  task_runners_->Get(TaskType::kUnspecedLoading)
+      ->PostTask(
+          BLINK_FROM_HERE,
+          CrossThreadBind(&WorkletPendingTasks::DecrementCounter,
+                          WrapCrossThreadPersistent(pending_tasks_.Get())));
 };
 
 DEFINE_TRACE(WorkletModuleTreeClient) {
   visitor->Trace(modulator_);
-  visitor->Trace(pending_tasks_);
   ModuleTreeClient::Trace(visitor);
 }
 
 }  // namespace blink