The HTML parser synchronously creates custom elements

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"
 #include "core/dom/ElementRegistrationOptions.h"
 #include "core/dom/custom/CEReactionsScope.h"
 #include "core/dom/custom/CustomElementDefinition.h"
 #include "core/dom/custom/CustomElementDefinitionBuilder.h"
 #include "core/dom/custom/CustomElementDescriptor.h"
 #include "core/dom/custom/CustomElementTestHelpers.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/dom/shadow/ShadowRootInit.h"
 #include "core/testing/DummyPageHolder.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/heap/Handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/text/AtomicString.h"
 #include <memory>
 
 namespace blink {
 
-class CustomElementsRegistryTestBase : public ::testing::Test {
+class CustomElementsRegistryTest : public ::testing::Test {
 protected:
-    virtual Document& document() = 0;
-    virtual CustomElementsRegistry& registry() = 0;
-
-    void collectCandidates(
-        const CustomElementDescriptor& desc,
-        HeapVector<Member<Element>>* elements)
+    void SetUp()
     {
-        registry().collectCandidates(desc, elements);
-    }
-};
-
-class CustomElementsRegistryTest : public CustomElementsRegistryTestBase {
-protected:
-    void SetUp() override
-    {
-        CustomElementsRegistryTestBase::SetUp();
-
-        m_document = HTMLDocument::create();
-        m_document->appendChild(CreateElement("html").inDocument(m_document));
-
-        m_registry = CustomElementsRegistry::create(m_document);
-    }
-
-    void TearDown() override
-    {
-        m_document = nullptr;
-        m_registry = nullptr;
-        CustomElementsRegistryTestBase::TearDown();
-    }
-
-    Document& document() override { return *m_document; }
-    CustomElementsRegistry& registry() override { return *m_registry; }
-
-private:
-    Persistent<Document> m_document;
-    Persistent<CustomElementsRegistry> m_registry;
-};
-
-class CustomElementsRegistryFrameTest : public CustomElementsRegistryTestBase {
-protected:
-    void SetUp() override
-    {
-        CustomElementsRegistryTestBase::SetUp();
         m_page.reset(DummyPageHolder::create(IntSize(1, 1)).release());
     }
 
-    void TearDown() override
+    void TearDown()
     {
         m_page = nullptr;
-        CustomElementsRegistryTestBase::TearDown();
     }
 
-    Document& document() override { return m_page->document(); }
+    Document& document() { return m_page->document(); }
 
-    CustomElementsRegistry& registry() override
+    CustomElementsRegistry& registry()
     {
         return *m_page->frame().localDOMWindow()->customElements();
     }
 
     ScriptState* scriptState()
     {
         return ScriptState::forMainWorld(&m_page->frame());
     }
 
+    void collectCandidates(
+        const CustomElementDescriptor& desc,
+        HeapVector<Member<Element>>* elements)
+    {
+        registry().collectCandidates(desc, elements);
+    }
+
     ShadowRoot* attachShadowTo(Element* element)
     {
         NonThrowableExceptionState noExceptions;
         ShadowRootInit shadowRootInit;
         return
             element->attachShadow(scriptState(), shadowRootInit, noExceptions);
     }
 
 private:
     std::unique_ptr<DummyPageHolder> m_page;
@@ skipping 250 matching lines @@
     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)
+TEST_F(CustomElementsRegistryTest, 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;
@@ skipping 26 matching lines @@
     EXPECT_EQ(2u, definition->m_attributeChanged.size())
         << "Upgrade should invoke attributeChangedCallback for all attributes";
 
     EXPECT_EQ(LogUpgradeDefinition::ConnectedCallback, definition->m_logs[3])
         << "upgrade should invoke connectedCallback";
 
     EXPECT_EQ(4u, definition->m_logs.size())
         << "upgrade should not invoke other callbacks";
 }
 
-TEST_F(CustomElementsRegistryFrameTest, attributeChangedCallback)
+TEST_F(CustomElementsRegistryTest, attributeChangedCallback)
 {
     ScriptForbiddenScope doNotRelyOnScript;
 
     Element* element = CreateElement("a-a").inDocument(&document());
     document().documentElement()->appendChild(element);
 
     LogUpgradeBuilder builder;
     NonThrowableExceptionState shouldNotThrow;
     {
         CEReactionsScope reactions;
@@ skipping 16 matching lines @@
     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(1u, definition->m_logs.size())
         << "upgrade should not invoke other callbacks";
 }
 
-TEST_F(CustomElementsRegistryFrameTest, disconnectedCallback)
+TEST_F(CustomElementsRegistryTest, disconnectedCallback)
 {
     ScriptForbiddenScope doNotRelyOnScript;
 
     Element* element = CreateElement("a-a").inDocument(&document());
     document().documentElement()->appendChild(element);
 
     LogUpgradeBuilder builder;
     NonThrowableExceptionState shouldNotThrow;
     {
         CEReactionsScope reactions;
@@ skipping 15 matching lines @@
         << "remove() should invoke disconnectedCallback";
 
     EXPECT_EQ(1u, definition->m_logs.size())
         << "remove() should not invoke other callbacks";
 }
 
 // TODO(dominicc): Add tests which adjust the "is" attribute when type
 // extensions are implemented.
 
 } // namespace blink