[animation-worklet] Implement registerAnimator in worklet scope

third_party/WebKit/Source/modules/compositorworker/AnimationWorkletGlobalScope.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 "modules/compositorworker/AnimationWorkletGlobalScope.h"
 
 #include "platform/weborigin/SecurityOrigin.h"
 
+#include "bindings/core/v8/ExceptionState.h"
+#include "bindings/core/v8/V8BindingMacros.h"
+#include "bindings/core/v8/WorkerOrWorkletScriptController.h"
+#include "core/dom/ExceptionCode.h"
+
 namespace blink {
 
 AnimationWorkletGlobalScope* AnimationWorkletGlobalScope::create(
     const KURL& url,
     const String& userAgent,
     PassRefPtr<SecurityOrigin> securityOrigin,
     v8::Isolate* isolate,
     WorkerThread* thread) {
   return new AnimationWorkletGlobalScope(
       url, userAgent, std::move(securityOrigin), isolate, thread);
 }
 
 AnimationWorkletGlobalScope::AnimationWorkletGlobalScope(
     const KURL& url,
     const String& userAgent,
     PassRefPtr<SecurityOrigin> securityOrigin,
     v8::Isolate* isolate,
     WorkerThread* thread)
     : ThreadedWorkletGlobalScope(url,
                                  userAgent,
                                  std::move(securityOrigin),
                                  isolate,
                                  thread) {}
 
 AnimationWorkletGlobalScope::~AnimationWorkletGlobalScope() {}
 
+DEFINE_TRACE(AnimationWorkletGlobalScope) {
+  visitor->trace(m_animatorDefinitions);
+  visitor->trace(m_animators);
+  ThreadedWorkletGlobalScope::trace(visitor);
+}
+
+void AnimationWorkletGlobalScope::dispose() {
+  // Clear animators and definitions to avoid reference cycle.
+  m_animatorDefinitions.clear();
+  m_animators.clear();
+  ThreadedWorkletGlobalScope::dispose();
+}
+
+void AnimationWorkletGlobalScope::registerAnimator(
+    const String& name,
+    const ScriptValue& ctorValue,
+    ExceptionState& exceptionState) {
+  if (m_animatorDefinitions.contains(name)) {
+    exceptionState.throwDOMException(
+        NotSupportedError,
+        "A class with name:'" + name + "' is already registered.");
+    return;
+  }
+
+  if (name.isEmpty()) {
+    exceptionState.throwTypeError("The empty string is not a valid name.");
+    return;
+  }
+
+  v8::Isolate* isolate = scriptController()->getScriptState()->isolate();
+  v8::Local<v8::Context> context = scriptController()->context();
+
+  DCHECK(ctorValue.v8Value()->IsFunction());
+  v8::Local<v8::Function> constructor =
+      v8::Local<v8::Function>::Cast(ctorValue.v8Value());
+
+  v8::Local<v8::Value> prototypeValue;
+  if (!v8Call(constructor->Get(context, v8String(isolate, "prototype")),
+              prototypeValue))
+    return;
+
+  if (isUndefinedOrNull(prototypeValue)) {
+    exceptionState.throwTypeError(
+        "The 'prototype' object on the class does not exist.");
+    return;
+  }
+
+  if (!prototypeValue->IsObject()) {
+    exceptionState.throwTypeError(
+        "The 'prototype' property on the class is not an object.");
+    return;
+  }
+
+  v8::Local<v8::Object> prototype = v8::Local<v8::Object>::Cast(prototypeValue);
+
+  v8::Local<v8::Value> animateValue;
+  if (!v8Call(prototype->Get(context, v8String(isolate, "animate")),
+              animateValue))
+    return;
+
+  if (isUndefinedOrNull(animateValue)) {
+    exceptionState.throwTypeError(
+        "The 'animate' function on the prototype does not exist.");
+    return;
+  }
+
+  if (!animateValue->IsFunction()) {
+    exceptionState.throwTypeError(
+        "The 'animate' property on the prototype is not a function.");
+    return;
+  }

[flackr, 2017/03/14 18:30:29]

I still think the assertions about the animate function should be checked in
AnimatorDefinition::create where it will later use the animate function. Note
this isn't a timing change, it's still checked at registration time, just
keeping code locality - checking errors on the animate function in the place
where we will later invoke the animate function.

+
+  v8::Local<v8::Function> animate = v8::Local<v8::Function>::Cast(animateValue);
+
+  AnimatorDefinition* definition = AnimatorDefinition::create(
+      scriptController()->getScriptState(), constructor, animate);
+  m_animatorDefinitions.set(name, definition);
+
+  // Immediately instantiate an animator for the registered definition.
+  // TODO(majidvp): Remove this once you add alternative way to instantiate
+  m_animators.push_back(definition->createInstance());
+}
+
 }  // namespace blink