Implement callback reactions for Custom Elements V1

third_party/WebKit/Source/core/dom/custom/CustomElementsRegistryTest.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/CustomElementsRegistry.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
@@ skipping 250 matching lines @@
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         TestCustomElementDefinition::trace(visitor);
         visitor->trace(m_element);
     }
 
     // TODO(dominicc): Make this class collect a vector of what's
     // upgraded; it will be useful in more tests.
     Member<Element> m_element;
     uint32_t m_invocationCount;

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

WDYT about making this vector<string> or something, so we can write assertions
that show the order of the callbacks and the data in them? The problem with
counts is that it is hard to assert the relative ordering of attribute changed
versus connected, etc.

+    uint32_t m_connectedCount = 0;
+    uint32_t m_disconnectedCount = 0;
+
+    struct AttributeChanged {
+        QualifiedName name;
+        AtomicString oldValue;
+        AtomicString newValue;
+    };
+    Vector<AttributeChanged> m_attributeChanged;
+
+    void clear()
+    {
+        m_invocationCount = m_connectedCount = m_disconnectedCount = 0;
+        m_attributeChanged.clear();
+    }
 
     bool runConstructor(Element* element) override
     {
         m_invocationCount++;
         m_element = element;
         return TestCustomElementDefinition::runConstructor(element);
     }
+
+    bool hasConnectedCallback() const override { return true; }
+    bool hasDisconnectedCallback() const override { return true; }
+    bool hasAttributeChangedCallback(const QualifiedName&) const override { return true; }
+
+    void runConnectedCallback(Element* element) override
+    {
+        m_connectedCount++;
+        EXPECT_EQ(element, m_element);
+    }
+
+    void runDisconnectedCallback(Element* element) override
+    {
+        m_disconnectedCount++;
+        EXPECT_EQ(element, m_element);
+    }
+
+    void runAttributeChangedCallback(Element* element, const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue) override
+    {
+        EXPECT_EQ(element, m_element);
+        m_attributeChanged.append(AttributeChanged { name, oldValue, newValue });
+    }
 };
 
 class LogUpgradeBuilder final : public CustomElementDefinitionBuilder {
     STACK_ALLOCATED();
     WTF_MAKE_NONCOPYABLE(LogUpgradeBuilder);
 public:
     LogUpgradeBuilder() { }
 
     bool checkConstructorIntrinsics() override { return true; }
     bool checkConstructorNotRegistered() override { return true; }
     bool checkPrototype() override { return true; }
     bool rememberOriginalProperties() override { return true; }
     CustomElementDefinition* build(
         const CustomElementDescriptor& descriptor) {
         return new LogUpgradeDefinition(descriptor);
     }
 };
 
 TEST_F(CustomElementsRegistryFrameTest, define_upgradesInDocumentElements)
 {
     ScriptForbiddenScope doNotRelyOnScript;
 
     Element* element = CreateElement("a-a").inDocument(&document());
+    element->setAttribute(QualifiedName(nullAtom, "attr1", HTMLNames::xhtmlNamespaceURI), "v1");
+    element->setBooleanAttribute(HTMLNames::contenteditableAttr, true);
     document().documentElement()->appendChild(element);
 
     LogUpgradeBuilder builder;
     NonThrowableExceptionState shouldNotThrow;
     {
         CEReactionsScope reactions;
         registry().define(
             "a-a",
             builder,
             ElementRegistrationOptions(),
             shouldNotThrow);
     }
     LogUpgradeDefinition* definition =
         static_cast<LogUpgradeDefinition*>(registry().definitionForName("a-a"));
     EXPECT_EQ(1u, definition->m_invocationCount)
         << "defining the element should have 'upgraded' the existing element";
     EXPECT_EQ(element, definition->m_element)
         << "the existing a-a element should have been upgraded";
+    EXPECT_EQ(1u, definition->m_connectedCount)
+        << "upgrade should invoke connectedCallback";
+
+    EXPECT_EQ(2u, definition->m_attributeChanged.size())
+        << "Upgrade should invoke attributeChangedCallback for all attributes";
+    EXPECT_EQ("attr1", definition->m_attributeChanged[0].name);
+    EXPECT_EQ(nullAtom, definition->m_attributeChanged[0].oldValue);
+    EXPECT_EQ("v1", definition->m_attributeChanged[0].newValue);
+    EXPECT_EQ("contenteditable", definition->m_attributeChanged[1].name);
+    EXPECT_EQ(nullAtom, definition->m_attributeChanged[1].oldValue);
+    EXPECT_EQ(emptyAtom, definition->m_attributeChanged[1].newValue);
+
+    EXPECT_EQ(0u, definition->m_disconnectedCount)
+        << "upgrade should not invoke disconnectedCallback";
+}
+
+TEST_F(CustomElementsRegistryFrameTest, attributeChangedCallback)
+{
+    ScriptForbiddenScope doNotRelyOnScript;
+
+    Element* element = CreateElement("a-a").inDocument(&document());
+    document().documentElement()->appendChild(element);
+
+    LogUpgradeBuilder builder;
+    NonThrowableExceptionState shouldNotThrow;
+    {
+        CEReactionsScope reactions;
+        registry().define(
+            "a-a",
+            builder,
+            ElementRegistrationOptions(),
+            shouldNotThrow);
+    }
+    LogUpgradeDefinition* definition =
+        static_cast<LogUpgradeDefinition*>(registry().definitionForName("a-a"));
+
+    definition->clear();
+    {
+        CEReactionsScope reactions;
+        element->setAttribute(QualifiedName(nullAtom, "attr2", HTMLNames::xhtmlNamespaceURI), "v2");
+    }
+    EXPECT_EQ(1u, definition->m_attributeChanged.size())
+        << "Adding an attribute should invoke attributeChangedCallback";
+    EXPECT_EQ("attr2", definition->m_attributeChanged[0].name);
+    EXPECT_EQ(nullAtom, definition->m_attributeChanged[0].oldValue);
+    EXPECT_EQ("v2", definition->m_attributeChanged[0].newValue);
+
+    EXPECT_EQ(0u, definition->m_invocationCount)
+        << "Attribute changes should not invoke upgrade";
+    EXPECT_EQ(0u, definition->m_connectedCount)
+        << "Attribute changes should not invoke connectedCallback";
+    EXPECT_EQ(0u, definition->m_disconnectedCount)
+        << "Attribute changes should invoke disconnectedCallback";
+}
+
+TEST_F(CustomElementsRegistryFrameTest, disconnectedCallback)
+{
+    ScriptForbiddenScope doNotRelyOnScript;
+
+    Element* element = CreateElement("a-a").inDocument(&document());
+    document().documentElement()->appendChild(element);
+
+    LogUpgradeBuilder builder;
+    NonThrowableExceptionState shouldNotThrow;
+    {
+        CEReactionsScope reactions;
+        registry().define(
+            "a-a",
+            builder,
+            ElementRegistrationOptions(),
+            shouldNotThrow);
+    }
+    LogUpgradeDefinition* definition =
+        static_cast<LogUpgradeDefinition*>(registry().definitionForName("a-a"));
+
+    definition->clear();
+    {
+        CEReactionsScope reactions;
+        element->remove(shouldNotThrow);
+    }
+    EXPECT_EQ(1u, definition->m_disconnectedCount)
+        << "remove() should invoke disconnectedCallback";
+
+    EXPECT_EQ(0u, definition->m_invocationCount)
+        << "remove() should not invoke upgrade";
+    EXPECT_EQ(0u, definition->m_connectedCount)
+        << "remove() should not invoke connectedCallback";
+    EXPECT_EQ(0u, definition->m_attributeChanged.size())
+        << "remove() should not invoke attributeChangedCallback";
 }
 
 // TODO(dominicc): Add tests which adjust the "is" attribute when type
 // extensions are implemented.
 
 } // namespace blink