chromium/src/third_party/blink/renderer/core/html/custom/custom_element_registry_test.cc - manifest_repos/chromium_src - Git at Google

 // 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 "third_party/blink/renderer/core/html/custom/custom_element_registry.h"

 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/web/web_custom_element.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_css_style_sheet_init.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_element_definition_options.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_shadow_root_init.h"
 #include "third_party/blink/renderer/core/css/style_sheet_contents.h"
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/dom/element.h"
 #include "third_party/blink/renderer/core/dom/shadow_root.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
 #include "third_party/blink/renderer/core/html/custom/ce_reactions_scope.h"
 #include "third_party/blink/renderer/core/html/custom/custom_element.h"
 #include "third_party/blink/renderer/core/html/custom/custom_element_definition.h"
 #include "third_party/blink/renderer/core/html/custom/custom_element_definition_builder.h"
 #include "third_party/blink/renderer/core/html/custom/custom_element_descriptor.h"
 #include "third_party/blink/renderer/core/html/custom/custom_element_test_helpers.h"
 #include "third_party/blink/renderer/core/html/html_element.h"
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
 #include "third_party/blink/renderer/platform/bindings/exception_state.h"
 #include "third_party/blink/renderer/platform/bindings/script_forbidden_scope.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/blink/renderer/platform/heap/heap.h"
 #include "third_party/blink/renderer/platform/wtf/text/atomic_string.h"

 namespace blink {

 class CustomElementRegistryTest : public PageTestBase {
  protected:
   void SetUp() override { PageTestBase::SetUp(IntSize(1, 1)); }

   CustomElementRegistry& Registry() {
     return *GetFrame().DomWindow()->customElements();
   }

   CustomElementDefinition* Define(const AtomicString& name,
                                   CustomElementDefinitionBuilder& builder,
                                   const ElementDefinitionOptions* options,
                                   ExceptionState& exception_state) {
     return Registry().DefineInternal(GetScriptState(), name, builder, options,
                                      exception_state);
   }

   ScriptState* GetScriptState() {
     return ToScriptStateForMainWorld(&GetFrame());
   }

   void CollectCandidates(const CustomElementDescriptor& desc,
                          HeapVector<Member<Element>>* elements) {
     Registry().CollectCandidates(desc, elements);
   }
 };

 TEST_F(CustomElementRegistryTest,
        collectCandidates_shouldNotIncludeElementsRemovedFromDocument) {
   Element& element = *CreateElement("a-a").InDocument(&GetDocument());
   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(CustomElementRegistryTest,
        collectCandidates_shouldNotIncludeElementsInDifferentDocument) {
   Element* element = CreateElement("a-a").InDocument(&GetDocument());
   Registry().AddCandidate(*element);

   auto* other_document = HTMLDocument::CreateForTest();
   other_document->AppendChild(element);
   EXPECT_EQ(other_document, 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(CustomElementRegistryTest,
        collectCandidates_shouldOnlyIncludeCandidatesMatchingDescriptor) {
   CustomElementDescriptor descriptor("hello-world", "hello-world");

   // Does not match: namespace is not HTML
   Element& element_a = *CreateElement("hello-world")
                             .InDocument(&GetDocument())
                             .InNamespace("data:text/date,1981-03-10");
   // Matches
   Element& element_b = *CreateElement("hello-world").InDocument(&GetDocument());
   // Does not match: local name is not hello-world
   Element& element_c = *CreateElement("button")
                             .InDocument(&GetDocument())
                             .WithIsValue("hello-world");
   GetDocument().documentElement()->AppendChild(&element_a);
   element_a.AppendChild(&element_b);
   element_a.AppendChild(&element_c);

   Registry().AddCandidate(element_a);
   Registry().AddCandidate(element_b);
   Registry().AddCandidate(element_c);

   HeapVector<Member<Element>> elements;
   CollectCandidates(descriptor, &elements);

   EXPECT_EQ(1u, elements.size())
       << "only one candidates should have been found";
   EXPECT_EQ(element_b, elements[0])
       << "the matching element should have been found";
 }

 TEST_F(CustomElementRegistryTest, collectCandidates_oneCandidate) {
   Element& element = *CreateElement("a-a").InDocument(&GetDocument());
   Registry().AddCandidate(element);
   GetDocument().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(CustomElementRegistryTest, collectCandidates_shouldBeInDocumentOrder) {
   CreateElement factory = CreateElement("a-a");
   factory.InDocument(&GetDocument());
   Element* element_a = factory.WithId("a");
   Element* element_b = factory.WithId("b");
   Element* element_c = factory.WithId("c");

   Registry().AddCandidate(*element_b);
   Registry().AddCandidate(*element_a);
   Registry().AddCandidate(*element_c);

   GetDocument().documentElement()->AppendChild(element_a);
   element_a->AppendChild(element_b);
   GetDocument().documentElement()->AppendChild(element_c);

   HeapVector<Member<Element>> elements;
   CollectCandidates(CustomElementDescriptor("a-a", "a-a"), &elements);

   EXPECT_EQ(element_a, elements[0].Get());
   EXPECT_EQ(element_b, elements[1].Get());
   EXPECT_EQ(element_c, elements[2].Get());
 }

 // Classes which use trace macros cannot be local because of the
 // traceImpl template.
 class LogUpgradeDefinition : public TestCustomElementDefinition {
  public:
   LogUpgradeDefinition(const CustomElementDescriptor& descriptor)
       : TestCustomElementDefinition(
             descriptor,
             {
                 "attr1", "attr2", html_names::kContenteditableAttr.LocalName(),
             },
             {}) {}

   void Trace(Visitor* visitor) const override {
     TestCustomElementDefinition::Trace(visitor);
     visitor->Trace(element_);
     visitor->Trace(adopted_);
   }

   // TODO(dominicc): Make this class collect a vector of what's
   // upgraded; it will be useful in more tests.
   Member<Element> element_;
   enum MethodType {
     kConstructor,
     kConnectedCallback,
     kDisconnectedCallback,
     kAdoptedCallback,
     kAttributeChangedCallback,
   };
   Vector<MethodType> logs_;

   struct AttributeChanged {
     QualifiedName name;
     AtomicString old_value;
     AtomicString new_value;
   };
   Vector<AttributeChanged> attribute_changed_;

   struct Adopted : public GarbageCollected<Adopted> {
     Adopted(Document& old_owner, Document& new_owner)
         : old_owner_(old_owner), new_owner_(new_owner) {}

     Member<Document> old_owner_;
     Member<Document> new_owner_;

     void Trace(Visitor* visitor) const {
       visitor->Trace(old_owner_);
       visitor->Trace(new_owner_);
     }
   };
   HeapVector<Member<Adopted>> adopted_;

   void Clear() {
     logs_.clear();
     attribute_changed_.clear();
   }

   bool RunConstructor(Element& element) override {
     logs_.push_back(kConstructor);
     element_ = element;
     return TestCustomElementDefinition::RunConstructor(element);
   }

   bool HasConnectedCallback() const override { return true; }
   bool HasDisconnectedCallback() const override { return true; }
   bool HasAdoptedCallback() const override { return true; }

   void RunConnectedCallback(Element& element) override {
     logs_.push_back(kConnectedCallback);
     EXPECT_EQ(&element, element_);
   }

   void RunDisconnectedCallback(Element& element) override {
     logs_.push_back(kDisconnectedCallback);
     EXPECT_EQ(&element, element_);
   }

   void RunAdoptedCallback(Element& element,
                           Document& old_owner,
                           Document& new_owner) override {
     logs_.push_back(kAdoptedCallback);
     EXPECT_EQ(&element, element_);
     adopted_.push_back(MakeGarbageCollected<Adopted>(old_owner, new_owner));
   }

   void RunAttributeChangedCallback(Element& element,
                                    const QualifiedName& name,
                                    const AtomicString& old_value,
                                    const AtomicString& new_value) override {
     logs_.push_back(kAttributeChangedCallback);
     EXPECT_EQ(&element, element_);
     attribute_changed_.push_back(AttributeChanged{name, old_value, new_value});
   }

   DISALLOW_COPY_AND_ASSIGN(LogUpgradeDefinition);
 };

 class LogUpgradeBuilder final : public TestCustomElementDefinitionBuilder {
   STACK_ALLOCATED();

  public:
   LogUpgradeBuilder() = default;

   CustomElementDefinition* Build(const CustomElementDescriptor& descriptor,
                                  CustomElementDefinition::Id) override {
     return MakeGarbageCollected<LogUpgradeDefinition>(descriptor);
   }

   DISALLOW_COPY_AND_ASSIGN(LogUpgradeBuilder);
 };

 TEST_F(CustomElementRegistryTest, define_upgradesInDocumentElements) {
   ScriptForbiddenScope do_not_rely_on_script;

   Element* element = CreateElement("a-a").InDocument(&GetDocument());
   element->setAttribute(
       QualifiedName(g_null_atom, "attr1", html_names::xhtmlNamespaceURI), "v1");
   element->SetBooleanAttribute(html_names::kContenteditableAttr, true);
   GetDocument().documentElement()->AppendChild(element);

   LogUpgradeBuilder builder;
   NonThrowableExceptionState should_not_throw;
   {
     CEReactionsScope reactions;
     Define("a-a", builder, ElementDefinitionOptions::Create(),
            should_not_throw);
   }
   LogUpgradeDefinition* definition =
       static_cast<LogUpgradeDefinition*>(Registry().DefinitionForName("a-a"));
   EXPECT_EQ(LogUpgradeDefinition::kConstructor, definition->logs_[0])
       << "defining the element should have 'upgraded' the existing element";
   EXPECT_EQ(element, definition->element_)
       << "the existing a-a element should have been upgraded";

   EXPECT_EQ(LogUpgradeDefinition::kAttributeChangedCallback,
             definition->logs_[1])
       << "Upgrade should invoke attributeChangedCallback for all attributes";
   EXPECT_EQ("attr1", definition->attribute_changed_[0].name);
   EXPECT_EQ(g_null_atom, definition->attribute_changed_[0].old_value);
   EXPECT_EQ("v1", definition->attribute_changed_[0].new_value);

   EXPECT_EQ(LogUpgradeDefinition::kAttributeChangedCallback,
             definition->logs_[2])
       << "Upgrade should invoke attributeChangedCallback for all attributes";
   EXPECT_EQ("contenteditable", definition->attribute_changed_[1].name);
   EXPECT_EQ(g_null_atom, definition->attribute_changed_[1].old_value);
   EXPECT_EQ(g_empty_atom, definition->attribute_changed_[1].new_value);
   EXPECT_EQ(2u, definition->attribute_changed_.size())
       << "Upgrade should invoke attributeChangedCallback for all attributes";

   EXPECT_EQ(LogUpgradeDefinition::kConnectedCallback, definition->logs_[3])
       << "upgrade should invoke connectedCallback";

   EXPECT_EQ(4u, definition->logs_.size())
       << "upgrade should not invoke other callbacks";
 }

 TEST_F(CustomElementRegistryTest, attributeChangedCallback) {
   ScriptForbiddenScope do_not_rely_on_script;

   Element* element = CreateElement("a-a").InDocument(&GetDocument());
   GetDocument().documentElement()->AppendChild(element);

   LogUpgradeBuilder builder;
   NonThrowableExceptionState should_not_throw;
   {
     CEReactionsScope reactions;
     Define("a-a", builder, ElementDefinitionOptions::Create(),
            should_not_throw);
   }
   LogUpgradeDefinition* definition =
       static_cast<LogUpgradeDefinition*>(Registry().DefinitionForName("a-a"));

   definition->Clear();
   {
     CEReactionsScope reactions;
     element->setAttribute(
         QualifiedName(g_null_atom, "attr2", html_names::xhtmlNamespaceURI),
         "v2");
   }
   EXPECT_EQ(LogUpgradeDefinition::kAttributeChangedCallback,
             definition->logs_[0])
       << "Adding an attribute should invoke attributeChangedCallback";
   EXPECT_EQ(1u, definition->attribute_changed_.size())
       << "Adding an attribute should invoke attributeChangedCallback";
   EXPECT_EQ("attr2", definition->attribute_changed_[0].name);
   EXPECT_EQ(g_null_atom, definition->attribute_changed_[0].old_value);
   EXPECT_EQ("v2", definition->attribute_changed_[0].new_value);

   EXPECT_EQ(1u, definition->logs_.size())
       << "upgrade should not invoke other callbacks";
 }

 TEST_F(CustomElementRegistryTest, disconnectedCallback) {
   ScriptForbiddenScope do_not_rely_on_script;

   Element* element = CreateElement("a-a").InDocument(&GetDocument());
   GetDocument().documentElement()->AppendChild(element);

   LogUpgradeBuilder builder;
   NonThrowableExceptionState should_not_throw;
   {
     CEReactionsScope reactions;
     Define("a-a", builder, ElementDefinitionOptions::Create(),
            should_not_throw);
   }
   LogUpgradeDefinition* definition =
       static_cast<LogUpgradeDefinition*>(Registry().DefinitionForName("a-a"));

   definition->Clear();
   {
     CEReactionsScope reactions;
     element->remove(should_not_throw);
   }
   EXPECT_EQ(LogUpgradeDefinition::kDisconnectedCallback, definition->logs_[0])
       << "remove() should invoke disconnectedCallback";

   EXPECT_EQ(1u, definition->logs_.size())
       << "remove() should not invoke other callbacks";
 }

 TEST_F(CustomElementRegistryTest, adoptedCallback) {
   ScriptForbiddenScope do_not_rely_on_script;

   Element* element = CreateElement("a-a").InDocument(&GetDocument());
   GetDocument().documentElement()->AppendChild(element);

   LogUpgradeBuilder builder;
   NonThrowableExceptionState should_not_throw;
   {
     CEReactionsScope reactions;
     Define("a-a", builder, ElementDefinitionOptions::Create(),
            should_not_throw);
   }
   LogUpgradeDefinition* definition =
       static_cast<LogUpgradeDefinition*>(Registry().DefinitionForName("a-a"));

   definition->Clear();
   auto* other_document = HTMLDocument::CreateForTest();
   {
     CEReactionsScope reactions;
     other_document->adoptNode(element, ASSERT_NO_EXCEPTION);
   }
   EXPECT_EQ(LogUpgradeDefinition::kDisconnectedCallback, definition->logs_[0])
       << "adoptNode() should invoke disconnectedCallback";

   EXPECT_EQ(LogUpgradeDefinition::kAdoptedCallback, definition->logs_[1])
       << "adoptNode() should invoke adoptedCallback";

   EXPECT_EQ(&GetDocument(), definition->adopted_[0]->old_owner_.Get())
       << "adoptedCallback should have been passed the old owner document";
   EXPECT_EQ(other_document, definition->adopted_[0]->new_owner_.Get())
       << "adoptedCallback should have been passed the new owner document";

   EXPECT_EQ(2u, definition->logs_.size())
       << "adoptNode() should not invoke other callbacks";
 }

 TEST_F(CustomElementRegistryTest, lookupCustomElementDefinition) {
   NonThrowableExceptionState should_not_throw;
   TestCustomElementDefinitionBuilder builder;
   CustomElementDefinition* definition_a = Define(
       "a-a", builder, ElementDefinitionOptions::Create(), should_not_throw);
   ElementDefinitionOptions* options = ElementDefinitionOptions::Create();
   options->setExtends("div");
   CustomElementDefinition* definition_b =
       Define("b-b", builder, options, should_not_throw);
   // look up defined autonomous custom element
   CustomElementDefinition* definition = Registry().DefinitionFor(
       CustomElementDescriptor(CustomElementDescriptor("a-a", "a-a")));
   EXPECT_NE(nullptr, definition) << "a-a, a-a should be registered";
   EXPECT_EQ(definition_a, definition);
   // look up undefined autonomous custom element
   definition = Registry().DefinitionFor(CustomElementDescriptor("a-a", "div"));
   EXPECT_EQ(nullptr, definition) << "a-a, div should not be registered";
   // look up defined customized built-in element
   definition = Registry().DefinitionFor(CustomElementDescriptor("b-b", "div"));
   EXPECT_NE(nullptr, definition) << "b-b, div should be registered";
   EXPECT_EQ(definition_b, definition);
   // look up undefined customized built-in element
   definition = Registry().DefinitionFor(CustomElementDescriptor("a-a", "div"));
   EXPECT_EQ(nullptr, definition) << "a-a, div should not be registered";
 }

 // The embedder may define its own elements via the CustomElementRegistry
 // whose names are not valid custom element names. Ensure that such a
 // definition may be done.
 TEST_F(CustomElementRegistryTest, DefineEmbedderCustomElements) {
   CustomElement::AddEmbedderCustomElementName("embeddercustomelement");

   WebCustomElement::EmbedderNamesAllowedScope embedder_names_scope;

   NonThrowableExceptionState should_not_throw;
   TestCustomElementDefinitionBuilder builder;
   CustomElementDefinition* definition_embedder =
       Define("embeddercustomelement", builder,
              ElementDefinitionOptions::Create(), should_not_throw);
   CustomElementDefinition* definition =
       Registry().DefinitionFor(CustomElementDescriptor(
           "embeddercustomelement", "embeddercustomelement"));
   EXPECT_NE(nullptr, definition)
       << "embeddercustomelement, embeddercustomelement should be registered";
   EXPECT_EQ(definition_embedder, definition);
 }

 // Ensure that even when the embedder has declared that an invalid name may
 // be used for a custom element definition, the caller of |define| may disallow
 // the use of the invalid name (so that we don't expose the ability to use such
 // a name to the web).
 TEST_F(CustomElementRegistryTest, DisallowedEmbedderCustomElements) {
   CustomElement::AddEmbedderCustomElementName("embeddercustomelement");

   // Without a WebCustomElement::EmbedderNamesAllowedScope, this registration
   // is disallowed.

   TestCustomElementDefinitionBuilder builder;
   CustomElementDefinition* definition_embedder =
       Define("embeddercustomelement", builder,
              ElementDefinitionOptions::Create(), IGNORE_EXCEPTION_FOR_TESTING);
   CustomElementDefinition* definition =
       Registry().DefinitionFor(CustomElementDescriptor(
           "embeddercustomelement", "embeddercustomelement"));
   EXPECT_EQ(nullptr, definition) << "embeddercustomelement, "
                                     "embeddercustomelement should not be "
                                     "registered";
   EXPECT_EQ(definition_embedder, definition);
 }

 // TODO(dominicc): Add tests which adjust the "is" attribute when type
 // extensions are implemented.

 }  // namespace blink
	// 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 "third_party/blink/renderer/core/html/custom/custom_element_registry.h"

	#include "base/macros.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "third_party/blink/public/web/web_custom_element.h"
	#include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
	#include "third_party/blink/renderer/bindings/core/v8/v8_css_style_sheet_init.h"
	#include "third_party/blink/renderer/bindings/core/v8/v8_element_definition_options.h"
	#include "third_party/blink/renderer/bindings/core/v8/v8_shadow_root_init.h"
	#include "third_party/blink/renderer/core/css/style_sheet_contents.h"
	#include "third_party/blink/renderer/core/dom/document.h"
	#include "third_party/blink/renderer/core/dom/element.h"
	#include "third_party/blink/renderer/core/dom/shadow_root.h"
	#include "third_party/blink/renderer/core/frame/local_dom_window.h"
	#include "third_party/blink/renderer/core/html/custom/ce_reactions_scope.h"
	#include "third_party/blink/renderer/core/html/custom/custom_element.h"
	#include "third_party/blink/renderer/core/html/custom/custom_element_definition.h"
	#include "third_party/blink/renderer/core/html/custom/custom_element_definition_builder.h"
	#include "third_party/blink/renderer/core/html/custom/custom_element_descriptor.h"
	#include "third_party/blink/renderer/core/html/custom/custom_element_test_helpers.h"
	#include "third_party/blink/renderer/core/html/html_element.h"
	#include "third_party/blink/renderer/core/testing/page_test_base.h"
	#include "third_party/blink/renderer/platform/bindings/exception_state.h"
	#include "third_party/blink/renderer/platform/bindings/script_forbidden_scope.h"
	#include "third_party/blink/renderer/platform/heap/handle.h"
	#include "third_party/blink/renderer/platform/heap/heap.h"
	#include "third_party/blink/renderer/platform/wtf/text/atomic_string.h"

	namespace blink {

	class CustomElementRegistryTest : public PageTestBase {
	protected:
	void SetUp() override { PageTestBase::SetUp(IntSize(1, 1)); }

	CustomElementRegistry& Registry() {
	return *GetFrame().DomWindow()->customElements();
	}

	CustomElementDefinition* Define(const AtomicString& name,
	CustomElementDefinitionBuilder& builder,
	const ElementDefinitionOptions* options,
	ExceptionState& exception_state) {
	return Registry().DefineInternal(GetScriptState(), name, builder, options,
	exception_state);
	}

	ScriptState* GetScriptState() {
	return ToScriptStateForMainWorld(&GetFrame());
	}

	void CollectCandidates(const CustomElementDescriptor& desc,
	HeapVector<Member<Element>>* elements) {
	Registry().CollectCandidates(desc, elements);
	}
	};

	TEST_F(CustomElementRegistryTest,
	collectCandidates_shouldNotIncludeElementsRemovedFromDocument) {
	Element& element = *CreateElement("a-a").InDocument(&GetDocument());
	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(CustomElementRegistryTest,
	collectCandidates_shouldNotIncludeElementsInDifferentDocument) {
	Element* element = CreateElement("a-a").InDocument(&GetDocument());
	Registry().AddCandidate(*element);

	auto* other_document = HTMLDocument::CreateForTest();
	other_document->AppendChild(element);
	EXPECT_EQ(other_document, 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(CustomElementRegistryTest,
	collectCandidates_shouldOnlyIncludeCandidatesMatchingDescriptor) {
	CustomElementDescriptor descriptor("hello-world", "hello-world");

	// Does not match: namespace is not HTML
	Element& element_a = *CreateElement("hello-world")
	.InDocument(&GetDocument())
	.InNamespace("data:text/date,1981-03-10");
	// Matches
	Element& element_b = *CreateElement("hello-world").InDocument(&GetDocument());
	// Does not match: local name is not hello-world
	Element& element_c = *CreateElement("button")
	.InDocument(&GetDocument())
	.WithIsValue("hello-world");
	GetDocument().documentElement()->AppendChild(&element_a);
	element_a.AppendChild(&element_b);
	element_a.AppendChild(&element_c);

	Registry().AddCandidate(element_a);
	Registry().AddCandidate(element_b);
	Registry().AddCandidate(element_c);

	HeapVector<Member<Element>> elements;
	CollectCandidates(descriptor, &elements);

	EXPECT_EQ(1u, elements.size())
	<< "only one candidates should have been found";
	EXPECT_EQ(element_b, elements[0])
	<< "the matching element should have been found";
	}

	TEST_F(CustomElementRegistryTest, collectCandidates_oneCandidate) {
	Element& element = *CreateElement("a-a").InDocument(&GetDocument());
	Registry().AddCandidate(element);
	GetDocument().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(CustomElementRegistryTest, collectCandidates_shouldBeInDocumentOrder) {
	CreateElement factory = CreateElement("a-a");
	factory.InDocument(&GetDocument());
	Element* element_a = factory.WithId("a");
	Element* element_b = factory.WithId("b");
	Element* element_c = factory.WithId("c");

	Registry().AddCandidate(*element_b);
	Registry().AddCandidate(*element_a);
	Registry().AddCandidate(*element_c);

	GetDocument().documentElement()->AppendChild(element_a);
	element_a->AppendChild(element_b);
	GetDocument().documentElement()->AppendChild(element_c);

	HeapVector<Member<Element>> elements;
	CollectCandidates(CustomElementDescriptor("a-a", "a-a"), &elements);

	EXPECT_EQ(element_a, elements[0].Get());
	EXPECT_EQ(element_b, elements[1].Get());
	EXPECT_EQ(element_c, elements[2].Get());
	}

	// Classes which use trace macros cannot be local because of the
	// traceImpl template.
	class LogUpgradeDefinition : public TestCustomElementDefinition {
	public:
	LogUpgradeDefinition(const CustomElementDescriptor& descriptor)
	: TestCustomElementDefinition(
	descriptor,
	{
	"attr1", "attr2", html_names::kContenteditableAttr.LocalName(),
	},
	{}) {}

	void Trace(Visitor* visitor) const override {
	TestCustomElementDefinition::Trace(visitor);
	visitor->Trace(element_);
	visitor->Trace(adopted_);
	}

	// TODO(dominicc): Make this class collect a vector of what's
	// upgraded; it will be useful in more tests.
	Member<Element> element_;
	enum MethodType {
	kConstructor,
	kConnectedCallback,
	kDisconnectedCallback,
	kAdoptedCallback,
	kAttributeChangedCallback,
	};
	Vector<MethodType> logs_;

	struct AttributeChanged {
	QualifiedName name;
	AtomicString old_value;
	AtomicString new_value;
	};
	Vector<AttributeChanged> attribute_changed_;

	struct Adopted : public GarbageCollected<Adopted> {
	Adopted(Document& old_owner, Document& new_owner)
	: old_owner_(old_owner), new_owner_(new_owner) {}

	Member<Document> old_owner_;
	Member<Document> new_owner_;

	void Trace(Visitor* visitor) const {
	visitor->Trace(old_owner_);
	visitor->Trace(new_owner_);
	}
	};
	HeapVector<Member<Adopted>> adopted_;

	void Clear() {
	logs_.clear();
	attribute_changed_.clear();
	}

	bool RunConstructor(Element& element) override {
	logs_.push_back(kConstructor);
	element_ = element;
	return TestCustomElementDefinition::RunConstructor(element);
	}

	bool HasConnectedCallback() const override { return true; }
	bool HasDisconnectedCallback() const override { return true; }
	bool HasAdoptedCallback() const override { return true; }

	void RunConnectedCallback(Element& element) override {
	logs_.push_back(kConnectedCallback);
	EXPECT_EQ(&element, element_);
	}

	void RunDisconnectedCallback(Element& element) override {
	logs_.push_back(kDisconnectedCallback);
	EXPECT_EQ(&element, element_);
	}

	void RunAdoptedCallback(Element& element,
	Document& old_owner,
	Document& new_owner) override {
	logs_.push_back(kAdoptedCallback);
	EXPECT_EQ(&element, element_);
	adopted_.push_back(MakeGarbageCollected<Adopted>(old_owner, new_owner));
	}

	void RunAttributeChangedCallback(Element& element,
	const QualifiedName& name,
	const AtomicString& old_value,
	const AtomicString& new_value) override {
	logs_.push_back(kAttributeChangedCallback);
	EXPECT_EQ(&element, element_);
	attribute_changed_.push_back(AttributeChanged{name, old_value, new_value});
	}

	DISALLOW_COPY_AND_ASSIGN(LogUpgradeDefinition);
	};

	class LogUpgradeBuilder final : public TestCustomElementDefinitionBuilder {
	STACK_ALLOCATED();

	public:
	LogUpgradeBuilder() = default;

	CustomElementDefinition* Build(const CustomElementDescriptor& descriptor,
	CustomElementDefinition::Id) override {
	return MakeGarbageCollected<LogUpgradeDefinition>(descriptor);
	}

	DISALLOW_COPY_AND_ASSIGN(LogUpgradeBuilder);
	};

	TEST_F(CustomElementRegistryTest, define_upgradesInDocumentElements) {
	ScriptForbiddenScope do_not_rely_on_script;

	Element* element = CreateElement("a-a").InDocument(&GetDocument());
	element->setAttribute(
	QualifiedName(g_null_atom, "attr1", html_names::xhtmlNamespaceURI), "v1");
	element->SetBooleanAttribute(html_names::kContenteditableAttr, true);
	GetDocument().documentElement()->AppendChild(element);

	LogUpgradeBuilder builder;
	NonThrowableExceptionState should_not_throw;
	{
	CEReactionsScope reactions;
	Define("a-a", builder, ElementDefinitionOptions::Create(),
	should_not_throw);
	}
	LogUpgradeDefinition* definition =
	static_cast<LogUpgradeDefinition*>(Registry().DefinitionForName("a-a"));
	EXPECT_EQ(LogUpgradeDefinition::kConstructor, definition->logs_[0])
	<< "defining the element should have 'upgraded' the existing element";
	EXPECT_EQ(element, definition->element_)
	<< "the existing a-a element should have been upgraded";

	EXPECT_EQ(LogUpgradeDefinition::kAttributeChangedCallback,
	definition->logs_[1])
	<< "Upgrade should invoke attributeChangedCallback for all attributes";
	EXPECT_EQ("attr1", definition->attribute_changed_[0].name);
	EXPECT_EQ(g_null_atom, definition->attribute_changed_[0].old_value);
	EXPECT_EQ("v1", definition->attribute_changed_[0].new_value);

	EXPECT_EQ(LogUpgradeDefinition::kAttributeChangedCallback,
	definition->logs_[2])
	<< "Upgrade should invoke attributeChangedCallback for all attributes";
	EXPECT_EQ("contenteditable", definition->attribute_changed_[1].name);
	EXPECT_EQ(g_null_atom, definition->attribute_changed_[1].old_value);
	EXPECT_EQ(g_empty_atom, definition->attribute_changed_[1].new_value);
	EXPECT_EQ(2u, definition->attribute_changed_.size())
	<< "Upgrade should invoke attributeChangedCallback for all attributes";

	EXPECT_EQ(LogUpgradeDefinition::kConnectedCallback, definition->logs_[3])
	<< "upgrade should invoke connectedCallback";

	EXPECT_EQ(4u, definition->logs_.size())
	<< "upgrade should not invoke other callbacks";
	}

	TEST_F(CustomElementRegistryTest, attributeChangedCallback) {
	ScriptForbiddenScope do_not_rely_on_script;

	Element* element = CreateElement("a-a").InDocument(&GetDocument());
	GetDocument().documentElement()->AppendChild(element);

	LogUpgradeBuilder builder;
	NonThrowableExceptionState should_not_throw;
	{
	CEReactionsScope reactions;
	Define("a-a", builder, ElementDefinitionOptions::Create(),
	should_not_throw);
	}
	LogUpgradeDefinition* definition =
	static_cast<LogUpgradeDefinition*>(Registry().DefinitionForName("a-a"));

	definition->Clear();
	{
	CEReactionsScope reactions;
	element->setAttribute(
	QualifiedName(g_null_atom, "attr2", html_names::xhtmlNamespaceURI),
	"v2");
	}
	EXPECT_EQ(LogUpgradeDefinition::kAttributeChangedCallback,
	definition->logs_[0])
	<< "Adding an attribute should invoke attributeChangedCallback";
	EXPECT_EQ(1u, definition->attribute_changed_.size())
	<< "Adding an attribute should invoke attributeChangedCallback";
	EXPECT_EQ("attr2", definition->attribute_changed_[0].name);
	EXPECT_EQ(g_null_atom, definition->attribute_changed_[0].old_value);
	EXPECT_EQ("v2", definition->attribute_changed_[0].new_value);

	EXPECT_EQ(1u, definition->logs_.size())
	<< "upgrade should not invoke other callbacks";
	}

	TEST_F(CustomElementRegistryTest, disconnectedCallback) {
	ScriptForbiddenScope do_not_rely_on_script;

	Element* element = CreateElement("a-a").InDocument(&GetDocument());
	GetDocument().documentElement()->AppendChild(element);

	LogUpgradeBuilder builder;
	NonThrowableExceptionState should_not_throw;
	{
	CEReactionsScope reactions;
	Define("a-a", builder, ElementDefinitionOptions::Create(),
	should_not_throw);
	}
	LogUpgradeDefinition* definition =
	static_cast<LogUpgradeDefinition*>(Registry().DefinitionForName("a-a"));

	definition->Clear();
	{
	CEReactionsScope reactions;
	element->remove(should_not_throw);
	}
	EXPECT_EQ(LogUpgradeDefinition::kDisconnectedCallback, definition->logs_[0])
	<< "remove() should invoke disconnectedCallback";

	EXPECT_EQ(1u, definition->logs_.size())
	<< "remove() should not invoke other callbacks";
	}

	TEST_F(CustomElementRegistryTest, adoptedCallback) {
	ScriptForbiddenScope do_not_rely_on_script;

	Element* element = CreateElement("a-a").InDocument(&GetDocument());
	GetDocument().documentElement()->AppendChild(element);

	LogUpgradeBuilder builder;
	NonThrowableExceptionState should_not_throw;
	{
	CEReactionsScope reactions;
	Define("a-a", builder, ElementDefinitionOptions::Create(),
	should_not_throw);
	}
	LogUpgradeDefinition* definition =
	static_cast<LogUpgradeDefinition*>(Registry().DefinitionForName("a-a"));

	definition->Clear();
	auto* other_document = HTMLDocument::CreateForTest();
	{
	CEReactionsScope reactions;
	other_document->adoptNode(element, ASSERT_NO_EXCEPTION);
	}
	EXPECT_EQ(LogUpgradeDefinition::kDisconnectedCallback, definition->logs_[0])
	<< "adoptNode() should invoke disconnectedCallback";

	EXPECT_EQ(LogUpgradeDefinition::kAdoptedCallback, definition->logs_[1])
	<< "adoptNode() should invoke adoptedCallback";

	EXPECT_EQ(&GetDocument(), definition->adopted_[0]->old_owner_.Get())
	<< "adoptedCallback should have been passed the old owner document";
	EXPECT_EQ(other_document, definition->adopted_[0]->new_owner_.Get())
	<< "adoptedCallback should have been passed the new owner document";

	EXPECT_EQ(2u, definition->logs_.size())
	<< "adoptNode() should not invoke other callbacks";
	}

	TEST_F(CustomElementRegistryTest, lookupCustomElementDefinition) {
	NonThrowableExceptionState should_not_throw;
	TestCustomElementDefinitionBuilder builder;
	CustomElementDefinition* definition_a = Define(
	"a-a", builder, ElementDefinitionOptions::Create(), should_not_throw);
	ElementDefinitionOptions* options = ElementDefinitionOptions::Create();
	options->setExtends("div");
	CustomElementDefinition* definition_b =
	Define("b-b", builder, options, should_not_throw);
	// look up defined autonomous custom element
	CustomElementDefinition* definition = Registry().DefinitionFor(
	CustomElementDescriptor(CustomElementDescriptor("a-a", "a-a")));
	EXPECT_NE(nullptr, definition) << "a-a, a-a should be registered";
	EXPECT_EQ(definition_a, definition);
	// look up undefined autonomous custom element
	definition = Registry().DefinitionFor(CustomElementDescriptor("a-a", "div"));
	EXPECT_EQ(nullptr, definition) << "a-a, div should not be registered";
	// look up defined customized built-in element
	definition = Registry().DefinitionFor(CustomElementDescriptor("b-b", "div"));
	EXPECT_NE(nullptr, definition) << "b-b, div should be registered";
	EXPECT_EQ(definition_b, definition);
	// look up undefined customized built-in element
	definition = Registry().DefinitionFor(CustomElementDescriptor("a-a", "div"));
	EXPECT_EQ(nullptr, definition) << "a-a, div should not be registered";
	}

	// The embedder may define its own elements via the CustomElementRegistry
	// whose names are not valid custom element names. Ensure that such a
	// definition may be done.
	TEST_F(CustomElementRegistryTest, DefineEmbedderCustomElements) {
	CustomElement::AddEmbedderCustomElementName("embeddercustomelement");

	WebCustomElement::EmbedderNamesAllowedScope embedder_names_scope;

	NonThrowableExceptionState should_not_throw;
	TestCustomElementDefinitionBuilder builder;
	CustomElementDefinition* definition_embedder =
	Define("embeddercustomelement", builder,
	ElementDefinitionOptions::Create(), should_not_throw);
	CustomElementDefinition* definition =
	Registry().DefinitionFor(CustomElementDescriptor(
	"embeddercustomelement", "embeddercustomelement"));
	EXPECT_NE(nullptr, definition)
	<< "embeddercustomelement, embeddercustomelement should be registered";
	EXPECT_EQ(definition_embedder, definition);
	}

	// Ensure that even when the embedder has declared that an invalid name may
	// be used for a custom element definition, the caller of \|define\| may disallow
	// the use of the invalid name (so that we don't expose the ability to use such
	// a name to the web).
	TEST_F(CustomElementRegistryTest, DisallowedEmbedderCustomElements) {
	CustomElement::AddEmbedderCustomElementName("embeddercustomelement");

	// Without a WebCustomElement::EmbedderNamesAllowedScope, this registration
	// is disallowed.

	TestCustomElementDefinitionBuilder builder;
	CustomElementDefinition* definition_embedder =
	Define("embeddercustomelement", builder,
	ElementDefinitionOptions::Create(), IGNORE_EXCEPTION_FOR_TESTING);
	CustomElementDefinition* definition =
	Registry().DefinitionFor(CustomElementDescriptor(
	"embeddercustomelement", "embeddercustomelement"));
	EXPECT_EQ(nullptr, definition) << "embeddercustomelement, "
	"embeddercustomelement should not be "
	"registered";
	EXPECT_EQ(definition_embedder, definition);
	}

	// TODO(dominicc): Add tests which adjust the "is" attribute when type
	// extensions are implemented.

	} // namespace blink