[DONT COMMIT] Worklet: Implement "addModule()" algorithm for main thread worklets

third_party/WebKit/Source/core/workers/MainThreadWorklet.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/MainThreadWorklet.h"
 
 #include "bindings/core/v8/ScriptSourceCode.h"
 #include "bindings/core/v8/V8BindingForCore.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/frame/LocalFrame.h"
 #include "core/workers/WorkletGlobalScopeProxy.h"
 #include "platform/wtf/WTF.h"
 
 namespace blink {
 
 namespace {
 
 int32_t GetNextRequestId() {
   DCHECK(IsMainThread());
   static int32_t next_request_id = 1;
   CHECK_LT(next_request_id, std::numeric_limits<int32_t>::max());
   return next_request_id++;
 }
 
 }  // namespace
 
+// Implementation of the "pending tasks struct":
+// https://drafts.css-houdini.org/worklets/#pending-tasks-struct
+struct MainThreadWorklet::PendingTasks : public GarbageCollected<PendingTasks> {

[kouhei (in TOK), 2017/04/25 11:55:17]

please make this a proper class

+  PendingTasks(int counter, ScriptPromiseResolver* resolver)
+      : counter(counter), resolver(resolver) {}
+  ~PendingTasks() = default;
+
+  // The number of pending tasks.
+  int counter;
+
+  Member<ScriptPromiseResolver> resolver;
+
+  DEFINE_INLINE_VIRTUAL_TRACE() { visitor->Trace(resolver); }
+};
+
 MainThreadWorklet::MainThreadWorklet(LocalFrame* frame) : Worklet(frame) {
-  DCHECK(resolver_map_.IsEmpty());
+  DCHECK(pending_tasks_map_.IsEmpty());

[kouhei (in TOK), 2017/04/25 11:55:18]

I think we can safely omit this DCHECK.

 }
 
+// Implementation of the "addModule" algorithm:
+// https://drafts.css-houdini.org/worklets/#dom-worklet-addmodule
 ScriptPromise MainThreadWorklet::addModule(ScriptState* script_state,
                                            const String& url) {
   DCHECK(IsMainThread());

[kouhei (in TOK), 2017/04/25 11:55:17]

Optional: I'd prefer to have all the steps in the algorithm listed.

   if (!GetExecutionContext()) {
     return ScriptPromise::RejectWithDOMException(
         script_state, DOMException::Create(kInvalidStateError,
                                            "This frame is already detached"));
   }
 
+  // Step 4: "If moduleURLRecord is failure, then reject promise with a

[kouhei (in TOK), 2017/04/25 11:55:18]

Can we rename the script_url var to module_url_record? and url -> module_url?

+  // "SyntaxError" DOMException and return promise."
   KURL script_url = GetExecutionContext()->CompleteURL(url);

[kouhei (in TOK), 2017/04/25 11:55:17]

Looks like CompleteURL part is the Step 3?

   if (!script_url.IsValid()) {
     return ScriptPromise::RejectWithDOMException(
         script_state, DOMException::Create(
                           kSyntaxError, "'" + url + "' is not a valid URL."));
   }
 
-  if (!IsInitialized())
-    Initialize();
+  // Step 10: "If the worklet's WorkletGlobalScopes is empty, run the following
+  // steps:"
+  //   10.1: "Create a WorkletGlobalScope given workletGlobalScopeType,
+  //          moduleResponsesMap, and outsideSettings."

[kouhei (in TOK), 2017/04/25 11:55:18]

Add TODO(nhiroki) comment about the workletGlobalScopeType, moduleResponsesMap,
and outsideSettings

+  //   10.2: "Add the WorkletGlobalScope to worklet's WorkletGlobalScopes."
+  if (global_scope_proxies_.IsEmpty())
+    CreateWorkletGlobalScope();
+  DCHECK(!global_scope_proxies_.IsEmpty());
 
-  int32_t request_id = GetNextRequestId();
+  // Step 11: "Let pendingTaskStruct be a new pending tasks struct with counter
+  // initialized to the length of worklet' s WorkletGlobalScopes."
+  const int32_t request_id = GetNextRequestId();
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
+  pending_tasks_map_.Set(
+      request_id, new PendingTasks(global_scope_proxies_.size(), resolver));
+
+  // Step 12: "For each workletGlobalScope in the worklet's
+  // WorkletGlobalScopes, queue a task on the workletGlobalScope to fetch and
+  // invoke a worklet script given workletGlobalScope, moduleURLRecord,
+  // moduleResponsesMap, credentialOptions, outsideSettings, pendingTaskStruct,
+  // and promise."
   ScriptPromise promise = resolver->Promise();
-  resolver_map_.Set(request_id, resolver);
-  GetWorkletGlobalScopeProxy()->FetchAndInvokeScript(request_id, script_url);
+  for (const auto& proxy : global_scope_proxies_)
+    proxy->FetchAndInvokeScript(request_id, script_url);
+
   return promise;
 }
 
+// Worklet-side implementation of the "fetch and invoke a worklet script"
+// algorithm:
+// https://drafts.css-houdini.org/worklets/#fetch-and-invoke-a-worklet-script
 void MainThreadWorklet::DidFetchAndInvokeScript(int32_t request_id,
                                                 bool success) {
   DCHECK(IsMainThread());
-  ScriptPromiseResolver* resolver = resolver_map_.at(request_id);
-  if (!resolver)
+  PendingTasks* pending_tasks = pending_tasks_map_.at(request_id);

[kouhei (in TOK), 2017/04/25 11:55:18]

Optional: map_.Find here to get iterator

+  if (!pending_tasks)
     return;
-  resolver_map_.erase(request_id);
+
+  // Step 3: "If script is null, then queue a task on outsideSettings's
+  // responsible event loop to run these steps:"

[kouhei (in TOK), 2017/04/25 11:55:18]

Add TODO(nhiroki) or add note to justify not queuing a task?

+  //   3.1.2: "Reject promise with an "AbortError" DOMException."
   if (!success) {
-    resolver->Reject(DOMException::Create(kNetworkError));
+    pending_tasks_map_.erase(request_id);

[kouhei (in TOK), 2017/04/25 11:55:18]

and trigger erase on the iterator?

+    // TODO(nhiroki): This should be kAbortError.
+    pending_tasks->resolver->Reject(DOMException::Create(kNetworkError));
     return;
   }
-  resolver->Resolve();
+
+  // Step 5: "Queue a task on outsideSettings's responsible event loop to run
+  // these steps:"

[kouhei (in TOK), 2017/04/25 11:55:17]

Ditto.

+  //   5.1.1: "Decrement pendingTaskStruct's counter by 1."
+  //   5.1.2: "If pendingTaskStruct's counter is 0, then resolve promise."
+  DCHECK_GT(0, pending_tasks->counter);
+  --pending_tasks->counter;
+  if (pending_tasks->counter == 0) {
+    pending_tasks_map_.erase(request_id);
+    pending_tasks->resolver->Resolve();
+  }
+}
+
+void MainThreadWorklet::CreateWorkletGlobalScope() {
+  if (!IsInitialized())
+    Initialize();
 }
 
 void MainThreadWorklet::ContextDestroyed(ExecutionContext* execution_context) {
   DCHECK(IsMainThread());
-  resolver_map_.clear();
+  pending_tasks_map_.clear();
+  for (const auto& proxy : global_scope_proxies_)
+    proxy->TerminateWorkletGlobalScope();
   Worklet::ContextDestroyed(execution_context);
 }
 
 DEFINE_TRACE(MainThreadWorklet) {
-  visitor->Trace(resolver_map_);
+  visitor->Trace(pending_tasks_map_);
   Worklet::Trace(visitor);
 }
 
 }  // namespace blink