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/CSSPaintBinding.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::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);
+    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)) {
+        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);

[haraken, 2016/03/31 02:01:59]

Just to confirm: Once registerPaint is called, you want to keep alive the
|constructor| and |paint| until the worklet dies, right?

If that is the cause, a better idea would be:

1) Introduce WorkletGlobalScope::dispose (see WorkerGlobalScope::dispose:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...).
WorkletGlobalScope::dispose must be called explicitly when the worklet dies
(i.e., the timing must not depend on any destructor).

2) CSSPaintDefinition can keep strong persistents to |constructor| and |paint|.
Clear the persistents WorkletGlobalScope::dispose.

What do you think?

[ikilpatrick, 2016/03/31 21:59:05]

Yes that's correct. Sounds good. Done.

+    m_paintDefinitions.set(name, definition);
+
+    setBindingOnPerContextData(CSSPaintBinding::create(isolate, constructor, paint));
+}
+
+CSSPaintDefinition* PaintWorkletGlobalScope::findDefinition(const String& name)
+{
+    return m_paintDefinitions.get(name);
+}
+
+void PaintWorkletGlobalScope::setBindingOnPerContextData(PassOwnPtr<CSSPaintBinding> binding)
+{
+    v8::Local<v8::Context> context = scriptController()->getScriptState()->context();
+    ASSERT(!context.IsEmpty());
+
+    V8PerContextData* perContextData = V8PerContextData::from(context);
+    ASSERT(perContextData);
+
+    // The context is responsible for keeping the constructor and paint
+    // functions alive.
+    perContextData->addCSSPaintBinding(std::move(binding));
+}
+
+DEFINE_TRACE(PaintWorkletGlobalScope)
+{
+#if ENABLE(OILPAN)
+    visitor->trace(m_paintDefinitions);
+#endif
+    WorkletGlobalScope::trace(visitor);
+}
+
 } // namespace blink