CustomElements: createCustomElementSync accepts a definition

third_party/WebKit/Source/core/dom/custom/CustomElement.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/CustomElement.h"
 
 #include "core/HTMLElementFactory.h"
 #include "core/HTMLElementTypeHelpers.h"
 #include "core/dom/Document.h"
 #include "core/dom/QualifiedName.h"
@@ skipping 43 matching lines @@
   // first.
   DEFINE_STATIC_LOCAL(HashSet<AtomicString>, hyphenatedSpecElementNames,
                       ({
                           "annotation-xml", "color-profile", "font-face",
                           "font-face-src", "font-face-uri", "font-face-format",
                           "font-face-name", "missing-glyph",
                       }));
   return hyphenatedSpecElementNames.contains(name);
 }
 
-bool CustomElement::shouldCreateCustomElement(const AtomicString& localName) {
-  return RuntimeEnabledFeatures::customElementsV1Enabled() &&
-         isValidName(localName);
+bool CustomElement::shouldCreateCustomElement(const AtomicString& name) {
+  return RuntimeEnabledFeatures::customElementsV1Enabled() && isValidName(name);
 }
 
 bool CustomElement::shouldCreateCustomElement(const QualifiedName& tagName) {
   return shouldCreateCustomElement(tagName.localName()) &&
          tagName.namespaceURI() == HTMLNames::xhtmlNamespaceURI;
 }
 
+bool CustomElement::shouldCreateCustomizedBuiltinElement(
+    const AtomicString& localName) {
+  return htmlElementTypeForTag(localName) !=
+             HTMLElementType::kHTMLUnknownElement &&
+         RuntimeEnabledFeatures::customElementsBuiltinEnabled();
+}
+
+bool CustomElement::shouldCreateCustomizedBuiltinElement(
+    const QualifiedName& tagName) {
+  return shouldCreateCustomizedBuiltinElement(tagName.localName()) &&
+         tagName.namespaceURI() == HTMLNames::xhtmlNamespaceURI;
+}
+
 static CustomElementDefinition* definitionFor(
     const Document& document,
     const CustomElementDescriptor desc) {
   if (CustomElementRegistry* registry = CustomElement::registry(document))
     return registry->definitionFor(desc);
   return nullptr;
 }
 
 HTMLElement* CustomElement::createCustomElementSync(
     Document& document,
+    const QualifiedName& tagName) {
+  CustomElementDefinition* definition = nullptr;
+  CustomElementRegistry* registry = CustomElement::registry(document);
+  if (registry) {
+    definition = registry->definitionFor(
+        CustomElementDescriptor(tagName.localName(), tagName.localName()));
+  }
+  return createCustomElementSync(document, tagName, definition);
+}
+
+HTMLElement* CustomElement::createCustomElementSync(
+    Document& document,
     const AtomicString& localName,
-    const AtomicString& is) {
+    CustomElementDefinition* definition) {
   return createCustomElementSync(
       document,
-      QualifiedName(nullAtom, localName, HTMLNames::xhtmlNamespaceURI), is);
+      QualifiedName(nullAtom, localName, HTMLNames::xhtmlNamespaceURI),
+      definition);
 }
 
 // https://dom.spec.whatwg.org/#concept-create-element
 HTMLElement* CustomElement::createCustomElementSync(
     Document& document,
     const QualifiedName& tagName,
-    const AtomicString& is) {
-  const AtomicString& name =
-      (is.isNull() || is.isEmpty()) ? tagName.localName() : is;
-  DCHECK(shouldCreateCustomElement(name));
-  const CustomElementDescriptor desc(name, tagName.localName());
-  CustomElementDefinition* definition = definitionFor(document, desc);
+    CustomElementDefinition* definition) {
+  DCHECK(shouldCreateCustomElement(tagName) ||
+         shouldCreateCustomizedBuiltinElement(tagName));
   HTMLElement* element;
 
-  if (definition && desc.isAutonomous()) {
+  if (definition && definition->descriptor().isAutonomous()) {
     // 6. If definition is non-null and we have an autonomous custom element
     element = definition->createElementSync(document, tagName);
   } else if (definition) {
     // 5. If definition is non-null and we have a customized built-in element
     element = createUndefinedElement(document, tagName);
     definition->upgrade(element);
   } else {
     // 7. Otherwise
     element = createUndefinedElement(document, tagName);
   }
@@ skipping 14 matching lines @@
           CustomElementDescriptor(tagName.localName(), tagName.localName())))
     return definition->createElementAsync(document, tagName);
 
   return createUndefinedElement(document, tagName);
 }
 
 // Create a HTMLElement
 HTMLElement* CustomElement::createUndefinedElement(
     Document& document,
     const QualifiedName& tagName) {
-  bool shouldCreateBuiltin =
-      htmlElementTypeForTag(tagName.localName()) !=
-          HTMLElementType::kHTMLUnknownElement &&
-      RuntimeEnabledFeatures::customElementsBuiltinEnabled();
+  bool shouldCreateBuiltin = shouldCreateCustomizedBuiltinElement(tagName);
   DCHECK(shouldCreateCustomElement(tagName) || shouldCreateBuiltin);
 
   HTMLElement* element;
   if (V0CustomElement::isValidName(tagName.localName()) &&
       document.registrationContext()) {
     Element* v0element = document.registrationContext()->createCustomTagElement(
         document, tagName);
     SECURITY_DCHECK(v0element->isHTMLElement());
     element = toHTMLElement(v0element);
   } else if (shouldCreateBuiltin) {
@@ skipping 87 matching lines @@
   if (!registry)
     return;
   if (CustomElementDefinition* definition = registry->definitionFor(
           CustomElementDescriptor(element->localName(), element->localName())))
     definition->enqueueUpgradeReaction(element);
   else
     registry->addCandidate(element);
 }
 
 }  // namespace blink