Rename CustomElementsRegistry to CustomElementRegistry

third_party/WebKit/Source/core/dom/custom/CustomElementRegistryTest.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 "core/dom/custom/CustomElementRegistry.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 CustomElementsRegistryTest : public ::testing::Test {
+class CustomElementRegistryTest : public ::testing::Test {
 protected:
     void SetUp()
     {
         m_page.reset(DummyPageHolder::create(IntSize(1, 1)).release());
     }
 
     void TearDown()
     {
         m_page = nullptr;
     }
 
     Document& document() { return m_page->document(); }
 
-    CustomElementsRegistry& registry()
+    CustomElementRegistry& 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;
 };
 
 TEST_F(
-    CustomElementsRegistryTest,
+    CustomElementRegistryTest,
     collectCandidates_shouldNotIncludeElementsRemovedFromDocument)
 {
     Element* element = CreateElement("a-a").inDocument(&document());
     registry().addCandidate(element);
 
     HeapVector<Member<Element>> elements;
     collectCandidates(
         CustomElementDescriptor("a-a", "a-a"),
         &elements);
 
     EXPECT_TRUE(elements.isEmpty())
         << "no candidates should have been found, but we have "
         << elements.size();
     EXPECT_FALSE(elements.contains(element))
         << "the out-of-document candidate should not have been found";
 }
 
 TEST_F(
-    CustomElementsRegistryTest,
+    CustomElementRegistryTest,
     collectCandidates_shouldNotIncludeElementsInDifferentDocument)
 {
     Element* element = CreateElement("a-a").inDocument(&document());
     registry().addCandidate(element);
 
     Document* otherDocument = HTMLDocument::create();
     otherDocument->appendChild(element);
     EXPECT_EQ(otherDocument, element->ownerDocument())
         << "sanity: another document should have adopted an element on append";
 
     HeapVector<Member<Element>> elements;
     collectCandidates(
         CustomElementDescriptor("a-a", "a-a"),
         &elements);
 
     EXPECT_TRUE(elements.isEmpty())
         << "no candidates should have been found, but we have "
         << elements.size();
     EXPECT_FALSE(elements.contains(element))
         << "the adopted-away candidate should not have been found";
 }
 
 TEST_F(
-    CustomElementsRegistryTest,
+    CustomElementRegistryTest,
     collectCandidates_shouldOnlyIncludeCandidatesMatchingDescriptor)
 {
     CustomElementDescriptor descriptor("hello-world", "hello-world");
 
     // Does not match: namespace is not HTML
     Element* elementA = CreateElement("hello-world")
         .inDocument(&document())
         .inNamespace("data:text/date,1981-03-10");
     // Matches
     Element* elementB = CreateElement("hello-world").inDocument(&document());
@@ skipping 11 matching lines @@
 
     HeapVector<Member<Element>> elements;
     collectCandidates(descriptor, &elements);
 
     EXPECT_EQ(1u, elements.size())
         << "only one candidates should have been found";
     EXPECT_EQ(elementB, elements[0])
         << "the matching element should have been found";
 }
 
-TEST_F(CustomElementsRegistryTest, collectCandidates_oneCandidate)
+TEST_F(CustomElementRegistryTest, collectCandidates_oneCandidate)
 {
     Element* element = CreateElement("a-a").inDocument(&document());
     registry().addCandidate(element);
     document().documentElement()->appendChild(element);
 
     HeapVector<Member<Element>> elements;
     collectCandidates(
         CustomElementDescriptor("a-a", "a-a"),
         &elements);
 
     EXPECT_EQ(1u, elements.size())
         << "exactly one candidate should have been found";
     EXPECT_TRUE(elements.contains(element))
         << "the candidate should be the element that was added";
 }
 
-TEST_F(CustomElementsRegistryTest, collectCandidates_shouldBeInDocumentOrder)
+TEST_F(CustomElementRegistryTest, collectCandidates_shouldBeInDocumentOrder)
 {
     CreateElement factory = CreateElement("a-a");
     factory.inDocument(&document());
     Element* elementA = factory.withId("a");
     Element* elementB = factory.withId("b");
     Element* elementC = factory.withId("c");
 
     registry().addCandidate(elementB);
     registry().addCandidate(elementA);
     registry().addCandidate(elementC);
@@ skipping 144 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(CustomElementsRegistryTest, define_upgradesInDocumentElements)
+TEST_F(CustomElementRegistryTest, 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(CustomElementsRegistryTest, attributeChangedCallback)
+TEST_F(CustomElementRegistryTest, 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(CustomElementsRegistryTest, disconnectedCallback)
+TEST_F(CustomElementRegistryTest, disconnectedCallback)
 {
     ScriptForbiddenScope doNotRelyOnScript;
 
     Element* element = CreateElement("a-a").inDocument(&document());
     document().documentElement()->appendChild(element);
 
     LogUpgradeBuilder builder;
     NonThrowableExceptionState shouldNotThrow;
     {
         CEReactionsScope reactions;
@@ skipping 11 matching lines @@
         CEReactionsScope reactions;
         element->remove(shouldNotThrow);
     }
     EXPECT_EQ(LogUpgradeDefinition::DisconnectedCallback, definition->m_logs[0])
         << "remove() should invoke disconnectedCallback";
 
     EXPECT_EQ(1u, definition->m_logs.size())
         << "remove() should not invoke other callbacks";
 }
 
-TEST_F(CustomElementsRegistryTest, adoptedCallback)
+TEST_F(CustomElementRegistryTest, adoptedCallback)
 {
     ScriptForbiddenScope doNotRelyOnScript;
 
     Element* element = CreateElement("a-a").inDocument(&document());
     document().documentElement()->appendChild(element);
 
     LogUpgradeBuilder builder;
     NonThrowableExceptionState shouldNotThrow;
     {
         CEReactionsScope reactions;
@@ skipping 19 matching lines @@
         << "adoptNode() should invoke adoptedCallback";
 
     EXPECT_EQ(2u, definition->m_logs.size())
         << "adoptNode() should not invoke other callbacks";
 }
 
 // TODO(dominicc): Add tests which adjust the "is" attribute when type
 // extensions are implemented.
 
 } // namespace blink