Implement PaintWorkletGlobalScope#registerPaint() for the CSS Paint API

third_party/WebKit/Source/modules/csspaint/PaintWorkletGlobalScope.cpp

Index: third_party/WebKit/Source/modules/csspaint/PaintWorkletGlobalScope.cpp
diff --git a/third_party/WebKit/Source/modules/csspaint/PaintWorkletGlobalScope.cpp b/third_party/WebKit/Source/modules/csspaint/PaintWorkletGlobalScope.cpp
index ec5f583315f21d4b9b1c2d6de82d3f185336f81b..85c4f63a12e708ed226e28f9502f1043e58e3d43 100644
--- a/third_party/WebKit/Source/modules/csspaint/PaintWorkletGlobalScope.cpp
+++ b/third_party/WebKit/Source/modules/csspaint/PaintWorkletGlobalScope.cpp
@@ -4,8 +4,11 @@
 
 #include "modules/csspaint/PaintWorkletGlobalScope.h"
 
+#include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
+#include "core/dom/ExceptionCode.h"
 #include "core/inspector/MainThreadDebugger.h"
+#include "modules/csspaint/CSSPaintDefinition.h"
 
 namespace blink {
 
@@ -27,4 +30,101 @@ PaintWorkletGlobalScope::~PaintWorkletGlobalScope()
 {
 }
 
+void PaintWorkletGlobalScope::dispose()
+{
+    // Explicitly clear the paint defininitions to break a reference cycle
+    // between them and this global scope.
+    m_paintDefinitions.clear();
+
+    WorkletGlobalScope::dispose();
+}
+
+void PaintWorkletGlobalScope::registerPaint(const String& name, const ScriptValue& ctorValue, ExceptionState& exceptionState)
+{
+    if (m_paintDefinitions.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::TryCatch block(isolate);

[haraken, 2016/04/01 00:16:06]

I don't think you need this TryCatch block.

[ikilpatrick, 2016/04/01 03:08:43]

Done.

+    v8::Local<v8::Context> context = scriptController()->context();
+
+    ASSERT(ctorValue.v8Value()->IsFunction());
+    v8::Local<v8::Function> constructor = v8::Local<v8::Function>::Cast(ctorValue.v8Value());
+
+    v8::Local<v8::Value> inputPropertiesValue;
+    if (!constructor->Get(context, v8String(isolate, "inputProperties")).ToLocal(&inputPropertiesValue)) {

[haraken, 2016/04/01 00:16:06]

Would you use v8Call macros in V8BindingMacros.h?

I think you can just use v8CallOrCrash(). Get can fail only when workers are
forcibly terminated. It's extremely rare and we don't want to mess up the code
base to handle such extremely rare cases.

[ikilpatrick, 2016/04/01 03:08:43]

Get can also fail if the developer does something nasty like:

registerPaint('foo', class {
  get paint() { throw Error('would crash'); }
});

I've switched to v8Call.

+        exceptionState.rethrowV8Exception(block.Exception());
+        return;
+    }
+
+    if (!isUndefinedOrNull(inputPropertiesValue)) {
+        toImplArray<Vector<String>>(inputPropertiesValue, 0, isolate, exceptionState);
+
+        if (exceptionState.hadException())
+            return;
+
+        // TODO(ikilpatrick): Hook up invalidation based on these inputProperties.
+    }
+
+    v8::Local<v8::Value> prototypeValue;
+    if (!constructor->Get(context, v8String(isolate, "prototype")).ToLocal(&prototypeValue)) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        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> paintValue;
+    if (!prototype->Get(context, v8String(isolate, "paint")).ToLocal(&paintValue)) {
+        exceptionState.rethrowV8Exception(block.Exception());
+        return;
+    }
+
+    if (isUndefinedOrNull(paintValue)) {
+        exceptionState.throwTypeError("The 'paint' function on the prototype does not exist.");
+        return;
+    }
+
+    if (!paintValue->IsFunction()) {
+        exceptionState.throwTypeError("The 'paint' property on the prototype is not a function.");
+        return;
+    }
+
+    v8::Local<v8::Function> paint = v8::Local<v8::Function>::Cast(paintValue);
+
+    RefPtrWillBeRawPtr<CSSPaintDefinition> definition = CSSPaintDefinition::create(scriptController()->getScriptState(), constructor, paint);
+    m_paintDefinitions.set(name, definition);
+}
+
+CSSPaintDefinition* PaintWorkletGlobalScope::findDefinition(const String& name)
+{
+    return m_paintDefinitions.get(name);
+}
+
+DEFINE_TRACE(PaintWorkletGlobalScope)
+{
+#if ENABLE(OILPAN)
+    visitor->trace(m_paintDefinitions);
+#endif
+    WorkletGlobalScope::trace(visitor);
+}
+
 } // namespace blink