Add callbacks to ScriptCustomElementDefinition

third_party/WebKit/Source/bindings/core/v8/ScriptCustomElementDefinitionBuilder.cpp

Index: third_party/WebKit/Source/bindings/core/v8/ScriptCustomElementDefinitionBuilder.cpp
diff --git a/third_party/WebKit/Source/bindings/core/v8/ScriptCustomElementDefinitionBuilder.cpp b/third_party/WebKit/Source/bindings/core/v8/ScriptCustomElementDefinitionBuilder.cpp
index 3a4d686dc4ef14b2ab0168d66e18eb396a6650ae..7c3d868e39d551a1ca84dfa38bd5fe444d530508 100644
--- a/third_party/WebKit/Source/bindings/core/v8/ScriptCustomElementDefinitionBuilder.cpp
+++ b/third_party/WebKit/Source/bindings/core/v8/ScriptCustomElementDefinitionBuilder.cpp
@@ -81,17 +81,21 @@ bool ScriptCustomElementDefinitionBuilder::checkConstructorNotRegistered()
     return true;
 }
 
-bool ScriptCustomElementDefinitionBuilder::checkPrototype()
+bool ScriptCustomElementDefinitionBuilder::valueForName(
+    const v8::Local<v8::Object>& object, const String& name,
+    v8::Local<v8::Value>& value) const
 {
     v8::Isolate* isolate = m_scriptState->isolate();
     v8::Local<v8::Context> context = m_scriptState->context();
-    v8::Local<v8::String> prototypeString =
-        v8AtomicString(isolate, "prototype");
+    v8::Local<v8::String> nameString = v8String(isolate, name);
+    return v8Call(object->Get(context, nameString), value);

[haraken, 2016/06/06 11:45:52]

Use v8CallOrCrash.

[kojii, 2016/06/06 13:10:40]

Done.

[kojii, 2016/06/06 14:43:33]

Oh, no, I had to revert this in PS11. The spec defines "rethrow any exceptions"
during the Get():
https://html.spec.whatwg.org/multipage/scripting.html#element-definition
and the test has a case where getter throws an exception:
imported/wpt/custom-elements/custom-elements-registry/define.html
so changing this to v8CallOrCrash() crashed the test.

We do check the return value, and the exception is stored in m_exceptionState to
rethrow. I assume v8call() is fine as long as we handle the exceptions
appropriately.

+}
+
+bool ScriptCustomElementDefinitionBuilder::checkPrototype()
+{
     v8::Local<v8::Value> prototypeValue;
-    if (!v8Call(
-        m_constructor->Get(context, prototypeString), prototypeValue)) {
+    if (!valueForName(m_constructor, "prototype", prototypeValue))
         return false;
-    }
     if (!prototypeValue->IsObject()) {
         m_exceptionState.throwTypeError(
             "constructor prototype is not an object");
@@ -103,6 +107,61 @@ bool ScriptCustomElementDefinitionBuilder::checkPrototype()
     return true;
 }
 
+bool ScriptCustomElementDefinitionBuilder::callableForName(const String& name,
+    v8::Local<v8::Object>& callback) const
+{
+    v8::Local<v8::Value> value;
+    if (!valueForName(m_prototype, name, value))
+        return false;
+    // "undefined" means "omitted", so return true.
+    if (value->IsUndefined())
+        return true;
+    if (!value->IsObject()) {
+        m_exceptionState.throwTypeError(
+            String::format("\"%s\" is not an object", name.ascii().data()));
+        return false;
+    }
+    callback = value.As<v8::Object>();
+    if (!callback->IsCallable()) {
+        m_exceptionState.throwTypeError(
+            String::format("\"%s\" is not callable", name.ascii().data()));
+        return false;
+    }
+    return true;
+}
+
+bool ScriptCustomElementDefinitionBuilder::retrieveObservedAttributes()
+{
+    const String kObservedAttributes = "observedAttributes";
+    v8::Local<v8::Value> observedAttributesValue;
+    if (!valueForName(m_constructor, kObservedAttributes, observedAttributesValue))
+        return false;
+    if (observedAttributesValue->IsUndefined())
+        return true;
+    Vector<AtomicString> list = toImplArray<Vector<AtomicString>>(
+        observedAttributesValue, 0, m_scriptState->isolate(), m_exceptionState);
+    if (m_exceptionState.hadException())
+        return false;
+    if (list.isEmpty())
+        return true;
+    m_observedAttributes.reserveCapacityForSize(list.size());
+    for (const auto& attribute : list)
+        m_observedAttributes.add(attribute);
+    return true;
+}
+
+bool ScriptCustomElementDefinitionBuilder::retrieveProperties()
+{
+
+    const String kConnectedCallback = "connectedCallback";
+    const String kDisconnectedCallback = "disconnectedCallback";
+    const String kAttributeChangedCallback = "attributeChangedCallback";
+    return retrieveObservedAttributes()
+        && callableForName(kConnectedCallback, m_connectedCallback)
+        && callableForName(kDisconnectedCallback, m_disconnectedCallback)
+        && callableForName(kAttributeChangedCallback, m_attributeChangedCallback);
+}
+
 CustomElementDefinition* ScriptCustomElementDefinitionBuilder::build(
     const CustomElementDescriptor& descriptor)
 {
@@ -111,7 +170,11 @@ CustomElementDefinition* ScriptCustomElementDefinitionBuilder::build(
         m_registry,
         descriptor,
         m_constructor,
-        m_prototype);
+        m_prototype,
+        m_connectedCallback,
+        m_disconnectedCallback,
+        m_attributeChangedCallback,
+        m_observedAttributes);
 }
 
 } // namespace blink