Implement callback reactions for Custom Elements V1

third_party/WebKit/Source/core/dom/custom/CustomElementDefinition.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 "core/dom/custom/CustomElementDefinition.h"
 
+#include "core/dom/custom/CEReactionsScope.h"
+#include "core/dom/custom/CustomElement.h"
+#include "core/dom/custom/CustomElementAttributeChangedCallbackReaction.h"
+#include "core/dom/custom/CustomElementConnectedCallbackReaction.h"
+#include "core/dom/custom/CustomElementDisconnectedCallbackReaction.h"
+#include "core/dom/custom/CustomElementUpgradeReaction.h"
+
 namespace blink {
 
 CustomElementDefinition::CustomElementDefinition(
     const CustomElementDescriptor& descriptor)
     : m_descriptor(descriptor)
 {
 }
 
 CustomElementDefinition::~CustomElementDefinition()
 {
 }
 
 DEFINE_TRACE(CustomElementDefinition)
 {
     visitor->trace(m_constructionStack);
 }
 
 // https://html.spec.whatwg.org/multipage/scripting.html#concept-upgrade-an-element
 void CustomElementDefinition::upgrade(Element* element)
 {
-    // TODO(dominicc): When the attributeChangedCallback is implemented,
-    // enqueue reactions for attributes here.
-    // TODO(dominicc): When the connectedCallback is implemented, enqueue
-    // reactions here, if applicable.
+    // TODO(kojii): This should be reversed by exposing observedAttributes from

[dominicc (has gone to gerrit), 2016/06/13 07:59:01]

Could we put the observed attributes set on the core/dom side of the definition?

It is assuming we don't have a special attribute that wants to observe *every*
attribute, but I don't think anything like that exists in HTML today?

[kojii, 2016/06/13 14:56:42]

Yes, that's the plan, but it touches bindings/*, so I'll do in the next
script-side patch.

+    // ScriptCustomElementDefinition, because Element::attributes() requires
+    // attribute synchronizations, and generally elements have more attributes
+    // than custom elements observe.
+    for (const auto& attribute : element->attributes()) {
+        if (hasAttributeChangedCallback(attribute.name()))
+            enqueueAttributeChangedCallback(element, attribute.name(), nullAtom, attribute.value());
+    }
+
+    if (element->inShadowIncludingDocument() && hasConnectedCallback())
+        enqueueConnectedCallback(element);
 
     m_constructionStack.append(element);
     size_t depth = m_constructionStack.size();
 
     bool succeeded = runConstructor(element);
 
     // Pop the construction stack.
     if (m_constructionStack.last().get())
         DCHECK_EQ(m_constructionStack.last(), element);
     DCHECK_EQ(m_constructionStack.size(), depth); // It's a *stack*.
     m_constructionStack.removeLast();
 
     if (!succeeded)
         return;
 
     CHECK(element->getCustomElementState() == CustomElementState::Custom);
 }
 
+static void enqueueReaction(Element* element, CustomElementReaction* reaction)
+{
+    // CEReactionsScope must be created by [CEReactions] in IDL,
+    // or callers must setup explicitly if it does not go through bindings.
+    DCHECK(CEReactionsScope::current());
+    CEReactionsScope::current()->enqueue(element, reaction);
+}
+
+void CustomElementDefinition::enqueueUpgradeReaction(Element* element)
+{
+    enqueueReaction(element, new CustomElementUpgradeReaction(this));
+}
+
+void CustomElementDefinition::enqueueConnectedCallback(Element* element)
+{
+    enqueueReaction(element, new CustomElementConnectedCallbackReaction(this));
+}
+
+void CustomElementDefinition::enqueueDisconnectedCallback(Element* element)
+{
+    enqueueReaction(element, new CustomElementDisconnectedCallbackReaction(this));
+}
+
+void CustomElementDefinition::enqueueAttributeChangedCallback(Element* element,
+    const QualifiedName& name,
+    const AtomicString& oldValue, const AtomicString& newValue)
+{
+    enqueueReaction(element, new CustomElementAttributeChangedCallbackReaction(this, name, oldValue, newValue));
+}
+
 } // namespace blink