The HTML parser synchronously creates custom elements

third_party/WebKit/Source/core/dom/custom/CustomElementsRegistry.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/ScriptCustomElementDefinitionBuilder.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementRegistrationOptions.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/custom/CEReactionsScope.h"
 #include "core/dom/custom/CustomElement.h"
 #include "core/dom/custom/CustomElementDefinition.h"
 #include "core/dom/custom/CustomElementDefinitionBuilder.h"
 #include "core/dom/custom/CustomElementDescriptor.h"
 #include "core/dom/custom/CustomElementUpgradeReaction.h"
 #include "core/dom/custom/CustomElementUpgradeSorter.h"
 #include "core/dom/custom/V0CustomElementRegistrationContext.h"
+#include "core/frame/LocalDOMWindow.h"
 #include "wtf/Allocator.h"
 
 namespace blink {
 
 // Returns true if |name| is invalid.
 static bool throwIfInvalidName(
     const AtomicString& name,
     ExceptionState& exceptionState)
 {
     if (CustomElement::isValidName(name))
@@ skipping 23 matching lines @@
     {
         m_registry->m_namesBeingDefined.remove(m_name);
     }
 
 private:
     Member<CustomElementsRegistry> m_registry;
     const AtomicString& m_name;
 };
 
 CustomElementsRegistry* CustomElementsRegistry::create(
-    Document* document)
+    const LocalDOMWindow* owner)
 {
-    CustomElementsRegistry* registry = new CustomElementsRegistry(document);
-    if (V0CustomElementRegistrationContext* v0Context = registry->v0())
-        v0Context->setV1(registry);
+    CustomElementsRegistry* registry = new CustomElementsRegistry(owner);
+    Document* document = owner->document();
+    if (V0CustomElementRegistrationContext* v0 =
+        document ? document->registrationContext() : nullptr)
+        registry->entangle(v0);
     return registry;
 }
 
-CustomElementsRegistry::CustomElementsRegistry(Document* document)
-    : m_document(document)
+CustomElementsRegistry::CustomElementsRegistry(const LocalDOMWindow* owner)
+    : m_owner(owner)
+    , m_v0 (new V0RegistrySet())
     , m_upgradeCandidates(new UpgradeCandidateMap())
 {
 }
 
 DEFINE_TRACE(CustomElementsRegistry)
 {
     visitor->trace(m_definitions);
-    visitor->trace(m_document);
+    visitor->trace(m_owner);
+    visitor->trace(m_v0);
     visitor->trace(m_upgradeCandidates);
     visitor->trace(m_whenDefinedPromiseMap);
 }
 
 void CustomElementsRegistry::define(
     ScriptState* scriptState,
     const AtomicString& name,
     const ScriptValue& constructor,
     const ElementRegistrationOptions& options,
     ExceptionState& exceptionState)
@@ skipping 88 matching lines @@
 {
     CustomElementDefinition* definition = definitionForName(name);
     if (!definition) {
         // Binding layer converts |ScriptValue()| to script specific value,
         // e.g. |undefined| for v8.
         return ScriptValue();
     }
     return definition->getConstructorForScript();
 }
 
+CustomElementDefinition* CustomElementsRegistry::definitionFor(const CustomElementDescriptor& desc) const
+{
+    CustomElementDefinition* definition = definitionForName(desc.name());
+    if (!definition)
+        return nullptr;
+    // The definition for a customized built-in element, such as
+    // <button is="my-button"> should not be provided for an
+    // autonomous element, such as <my-button>, even though the
+    // name "my-button" matches.
+    return definition->descriptor() == desc ? definition : nullptr;
+}
+
 bool CustomElementsRegistry::nameIsDefined(const AtomicString& name) const
 {
     return m_definitions.contains(name);
 }
 
-V0CustomElementRegistrationContext* CustomElementsRegistry::v0()
+void CustomElementsRegistry::entangle(V0CustomElementRegistrationContext* v0)
 {
-    return m_document->registrationContext();
+    m_v0->add(v0);
+    v0->setV1(this);
 }
 
 bool CustomElementsRegistry::v0NameIsDefined(const AtomicString& name)
 {
-    if (V0CustomElementRegistrationContext* v0Context = v0())
-        return v0Context->nameIsDefined(name);
+    for (const auto& v0 : *m_v0) {
+        if (v0->nameIsDefined(name))
+            return true;
+    }
     return false;
 }
 
 CustomElementDefinition* CustomElementsRegistry::definitionForName(
     const AtomicString& name) const
 {
     return m_definitions.get(name);
 }
 
 void CustomElementsRegistry::addCandidate(Element* candidate)
@@ skipping 41 matching lines @@
     if (it == m_upgradeCandidates->end())
         return;
     CustomElementUpgradeSorter sorter;
     for (Element* element : *it.get()->value) {
         if (!element || !desc.matches(*element))
             continue;
         sorter.add(element);
     }
 
     m_upgradeCandidates->remove(it);
-    sorter.sorted(elements, m_document.get());
+
+    Document* document = m_owner->document();
+    if (!document)
+        return;
+
+    sorter.sorted(elements, document);
 }
 
 } // namespace blink