Implement callback reactions for Custom Elements V1

third_party/WebKit/Source/core/dom/custom/CustomElement.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/CustomElement.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/QualifiedName.h"
-#include "core/dom/custom/CEReactionsScope.h"
 #include "core/dom/custom/CustomElementDefinition.h"
-#include "core/dom/custom/CustomElementUpgradeReaction.h"
 #include "core/dom/custom/CustomElementsRegistry.h"
 #include "core/dom/custom/V0CustomElement.h"
 #include "core/dom/custom/V0CustomElementRegistrationContext.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/html/HTMLElement.h"
 #include "platform/text/Character.h"
 #include "wtf/text/AtomicStringHash.h"
 
 namespace blink {
 
 CustomElementsRegistry* CustomElement::registry(const Element& element)
 {
     return registry(element.document());
 }
 
 CustomElementsRegistry* CustomElement::registry(const Document& document)
 {
     if (LocalDOMWindow* window = document.domWindow())
         return window->customElements();
     return nullptr;
 }
 
+CustomElementDefinition* CustomElement::definitionForElement(const Element& element)
+{
+    if (CustomElementsRegistry* registry = CustomElement::registry(element))
+        return registry->definitionForName(element.localName());
+    return nullptr;
+}
+
 bool CustomElement::isValidName(const AtomicString& name)
 {
     if (!name.length() || name[0] < 'a' || name[0] > 'z')
         return false;
 
     bool hasHyphens = false;
     for (size_t i = 1; i < name.length(); ) {
         UChar32 ch;
         if (name.is8Bit())
             ch = name[i++];
@@ skipping 80 matching lines @@
     // 6. If definition is non-null, then:
     // 6.2. If the synchronous custom elements flag is not set:
     // 6.2.1. Set result to a new element that implements the HTMLElement
     // interface, with no attributes, namespace set to the HTML namespace,
     // namespace prefix set to prefix, local name set to localName, custom
     // element state set to "undefined", and node document set to document.
     HTMLElement* element = HTMLElement::create(tagName, document);
     element->setCustomElementState(CustomElementState::Undefined);
     // 6.2.2. Enqueue a custom element upgrade reaction given result and
     // definition.
-    enqueueUpgradeReaction(element, &definition);
+    definition.enqueueUpgradeReaction(element);
     return element;
 }
 
-void CustomElement::enqueueUpgradeReaction(Element* element, CustomElementDefinition* definition)
+void CustomElement::enqueueConnectedCallback(Element* element)
 {
-    // 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,
-        new CustomElementUpgradeReaction(definition));
+    DCHECK_EQ(element->getCustomElementState(), CustomElementState::Custom);
+    CustomElementDefinition* definition = definitionForElement(*element);
+    DCHECK(definition);

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

We will null deref right after this, so this DCHECK does not add much. Also line
156. Just let it run (and crash.)

+    if (definition->hasConnectedCallback())
+        definition->enqueueConnectedCallback(element);
+}
+
+void CustomElement::enqueueDisconnectedCallback(Element* element)
+{
+    DCHECK_EQ(element->getCustomElementState(), CustomElementState::Custom);
+    CustomElementDefinition* definition = definitionForElement(*element);
+    DCHECK(definition);
+    if (definition->hasDisconnectedCallback())
+        definition->enqueueDisconnectedCallback(element);
+}
+
+
+void CustomElement::enqueueAttributeChangedCallback(Element* element,
+    const QualifiedName& name,
+    const AtomicString& oldValue, const AtomicString& newValue)
+{
+    DCHECK_EQ(element->getCustomElementState(), CustomElementState::Custom);
+    CustomElementDefinition* definition = definitionForElement(*element);
+    DCHECK(definition);
+    if (definition->hasAttributeChangedCallback(name))
+        definition->enqueueAttributeChangedCallback(element, name, oldValue, newValue);
 }
 
 } // namespace blink