Implement PaintWorkletGlobalScope#registerPaint() for the CSS Paint API

third_party/WebKit/Source/modules/csspaint/PaintWorkletGlobalScope.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/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 {
 
 // static
 PassRefPtrWillBeRawPtr<PaintWorkletGlobalScope> PaintWorkletGlobalScope::create(LocalFrame* frame, const KURL& url, const String& userAgent, PassRefPtr<SecurityOrigin> securityOrigin, v8::Isolate* isolate)
 {
     RefPtrWillBeRawPtr<PaintWorkletGlobalScope> paintWorkletGlobalScope = adoptRefWillBeNoop(new PaintWorkletGlobalScope(frame, url, userAgent, securityOrigin, isolate));
     paintWorkletGlobalScope->scriptController()->initializeContextIfNeeded();
     MainThreadDebugger::instance()->contextCreated(paintWorkletGlobalScope->scriptController()->getScriptState(), paintWorkletGlobalScope->frame(), paintWorkletGlobalScope->getSecurityOrigin());
     return paintWorkletGlobalScope.release();
 }
 
 PaintWorkletGlobalScope::PaintWorkletGlobalScope(LocalFrame* frame, const KURL& url, const String& userAgent, PassRefPtr<SecurityOrigin> securityOrigin, v8::Isolate* isolate)
     : WorkletGlobalScope(frame, url, userAgent, securityOrigin, isolate)
 {
 }
 
 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