Custom Elements: Check Definition in createElement, Create Customized Built-in Elements Sync

third_party/WebKit/Source/core/dom/Document.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
@@ skipping 26 matching lines @@
 #include "bindings/core/v8/Microtask.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/StringOrDictionary.h"
 #include "bindings/core/v8/V0CustomElementConstructorBuilder.h"
 #include "bindings/core/v8/V8DOMWrapper.h"
 #include "bindings/core/v8/V8ElementCreationOptions.h"
 #include "bindings/core/v8/V8PerIsolateData.h"
 #include "bindings/core/v8/WindowProxy.h"
 #include "core/HTMLElementFactory.h"
+#include "core/HTMLElementTypeHelpers.h"
 #include "core/HTMLNames.h"
 #include "core/SVGElementFactory.h"
 #include "core/SVGNames.h"
 #include "core/XMLNSNames.h"
 #include "core/XMLNames.h"
 #include "core/animation/CompositorPendingAnimations.h"
 #include "core/animation/DocumentAnimations.h"
 #include "core/animation/DocumentTimeline.h"
 #include "core/css/CSSFontSelector.h"
 #include "core/css/CSSStyleDeclaration.h"
@@ skipping 48 matching lines @@
 #include "core/dom/StaticNodeList.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/dom/StyleEngine.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/dom/TouchList.h"
 #include "core/dom/TransformSource.h"
 #include "core/dom/TreeWalker.h"
 #include "core/dom/VisitedLinkState.h"
 #include "core/dom/XMLDocument.h"
 #include "core/dom/custom/CustomElement.h"
+#include "core/dom/custom/CustomElementDefinition.h"
+#include "core/dom/custom/CustomElementDescriptor.h"
 #include "core/dom/custom/CustomElementRegistry.h"
 #include "core/dom/custom/V0CustomElementMicrotaskRunQueue.h"
 #include "core/dom/custom/V0CustomElementRegistrationContext.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/DragCaretController.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
@@ skipping 578 matching lines @@
                                      exceptionState);
     if (impl.hasIs())
       return impl.is();
 
     return toCoreString(dict.v8Value()->ToString());
   }
 
   return emptyString();
 }
 
+// https://dom.spec.whatwg.org/#dom-document-createelement
 Element* Document::createElement(const AtomicString& localName,
                                  const StringOrDictionary& stringOrOptions,
                                  ExceptionState& exceptionState) {
+  bool isV1 = stringOrOptions.isDictionary() || !registrationContext();

[dominicc (has gone to gerrit), 2016/11/15 07:39:53]

This v0, v1 split thing is very tricky.

The way you have it here makes sense--for v0, use createElement(string, string);
for v1, use createElement(string, dictionary).

The downside with that is that authors have to switch from document.register and
createElement(string,string) to customElements.define and createElement(string,
dictionary) in one go, which will be hard.

On the other hand it has many benefits. You can implement the synchronous
exception for missing definitions accurately, for example.

I think you have made the right decision. I've updated a slide deck describing
custom elements stuff to allude to this and when it lands I'll send mail to
devrel and some users.

In hindsight I'm a bit sad with how the spec for customized built-in elements
has turned out; throwing an exception instead of doing upgrade will make them
difficult to use.

+  // 1. If localName does not match Name production, throw InvalidCharacterError
   if (!isValidName(localName)) {
     exceptionState.throwDOMException(
         InvalidCharacterError,
         "The tag name provided ('" + localName + "') is not a valid name.");
     return nullptr;
   }
 
+  // 2. localName converted to ASCII lowercase
+  const AtomicString& convertedLocalName = convertLocalName(localName);
+
+  // 3.
+  const AtomicString& is = convertLocalName(
+      AtomicString(getTypeExtension(this, stringOrOptions, exceptionState)));
+  const AtomicString& name = is.isNull() ? convertedLocalName : is;
+
+  // 4. Let definition be result of lookup up custom element definition
+  CustomElementDefinition* definition = nullptr;
+  if (isV1) {
+    // Is the runtime flag enabled for customized builtin elements?
+    const CustomElementDescriptor desc =
+        RuntimeEnabledFeatures::customElementsBuiltinEnabled()
+            ? CustomElementDescriptor(name, convertedLocalName)
+            : CustomElementDescriptor(convertedLocalName, convertedLocalName);
+    definition = CustomElement::registry(*this)->definitionFor(desc);
+    // 5. If 'is' is non-null and definition is null, throw NotFoundError
+    if (!definition && !is.isNull() && stringOrOptions.isDictionary()) {
+      exceptionState.throwDOMException(NotFoundError,
+                                       "Custom element definition not found.");
+      return nullptr;
+    }
+  }
+
+  // 7. Let element be the result of creating an element
   Element* element;
 
-  if (CustomElement::shouldCreateCustomElement(convertLocalName(localName))) {
-    element = CustomElement::createCustomElementSync(
-        *this, convertLocalName(localName));
+  if (definition) {
+    element =
+        CustomElement::createCustomElementSync(*this, convertedLocalName, name);
   } else if (V0CustomElement::isValidName(localName) && registrationContext()) {
     element = registrationContext()->createCustomTagElement(
-        *this, QualifiedName(nullAtom, convertLocalName(localName),
-                             xhtmlNamespaceURI));
+        *this, QualifiedName(nullAtom, convertedLocalName, xhtmlNamespaceURI));
   } else {
     element = createElement(localName, exceptionState);
     if (exceptionState.hadException())
       return nullptr;
   }
 
-  String typeExtention =
-      getTypeExtension(this, stringOrOptions, exceptionState);
-  if (!typeExtention.isEmpty()) {
-    V0CustomElementRegistrationContext::setIsAttributeAndTypeExtension(
-        element, AtomicString(typeExtention));
+  // 8. If 'is' is non-null, set 'is' attribute
+  if (!is.isEmpty()) {
+    if (stringOrOptions.isString()) {
+      V0CustomElementRegistrationContext::setIsAttributeAndTypeExtension(
+          element, is);
+    } else if (stringOrOptions.isDictionary()) {
+      element->setAttribute(HTMLNames::isAttr, is);
+    }
   }
 
   return element;
 }
 
 static inline QualifiedName createQualifiedName(
     const AtomicString& namespaceURI,
     const AtomicString& qualifiedName,
     ExceptionState& exceptionState) {
   AtomicString prefix, localName;
@@ skipping 20 matching lines @@
   QualifiedName qName(
       createQualifiedName(namespaceURI, qualifiedName, exceptionState));
   if (qName == QualifiedName::null())
     return nullptr;
 
   if (CustomElement::shouldCreateCustomElement(qName))
     return CustomElement::createCustomElementSync(*this, qName);
   return createElement(qName, CreatedByCreateElement);
 }
 
+// https://dom.spec.whatwg.org/#internal-createelementns-steps
 Element* Document::createElementNS(const AtomicString& namespaceURI,
                                    const AtomicString& qualifiedName,
                                    const StringOrDictionary& stringOrOptions,
                                    ExceptionState& exceptionState) {
+  bool isV1 = stringOrOptions.isDictionary() || !registrationContext();
+  // 1. Validate and extract

[dominicc (has gone to gerrit), 2016/11/15 07:39:54]

These comments seem incomplete?

+
+  // 2.
+  const AtomicString& is =
+      AtomicString(getTypeExtension(this, stringOrOptions, exceptionState));
+  const AtomicString& name = is.isNull() ? qualifiedName : is;
+
+  if (!isValidName(qualifiedName)) {
+    exceptionState.throwDOMException(
+        InvalidCharacterError,
+        "The tag name provided ('" + qualifiedName + "') is not a valid name.");
+    return nullptr;
+  }
+
   QualifiedName qName(
       createQualifiedName(namespaceURI, qualifiedName, exceptionState));
   if (qName == QualifiedName::null())
     return nullptr;
 
+  // 3. Let definition be result of lookup up custom element definition

[dominicc (has gone to gerrit), 2016/11/15 07:39:54]

Transcribe these carefully.

+  CustomElementDefinition* definition = nullptr;
+  if (isV1) {
+    const CustomElementDescriptor desc =
+        RuntimeEnabledFeatures::customElementsBuiltinEnabled()
+            ? CustomElementDescriptor(name, qualifiedName)
+            : CustomElementDescriptor(qualifiedName, qualifiedName);
+    definition = CustomElement::registry(*this)->definitionFor(desc);
+
+    // 4. If 'is' is non-null and definition is null, throw NotFoundError
+    if (!definition && !is.isNull()) {
+      exceptionState.throwDOMException(NotFoundError,
+                                       "Custom element definition not found.");
+      return nullptr;
+    }
+  }
+
+  // 5. Let element be the result of creating an element
   Element* element;
-  if (CustomElement::shouldCreateCustomElement(qName))
-    element = CustomElement::createCustomElementSync(*this, qName);
-  else if (V0CustomElement::isValidName(qName.localName()) &&
-           registrationContext())
+
+  bool shouldCreateBuiltin =
+      isV1 && RuntimeEnabledFeatures::customElementsBuiltinEnabled();
+
+  if (CustomElement::shouldCreateCustomElement(qName) || shouldCreateBuiltin) {
+    element = CustomElement::createCustomElementSync(*this, qName, is);
+  } else if (V0CustomElement::isValidName(qName.localName()) &&
+             registrationContext()) {
     element = registrationContext()->createCustomTagElement(*this, qName);
-  else
+  } else {
     element = createElement(qName, CreatedByCreateElement);
+  }
 
-  String typeExtention =
-      getTypeExtension(this, stringOrOptions, exceptionState);
-  if (!typeExtention.isEmpty()) {
-    V0CustomElementRegistrationContext::setIsAttributeAndTypeExtension(
-        element, AtomicString(typeExtention));
+  // 6. If 'is' is non-null, set 'is' attribute
+  if (!is.isEmpty()) {
+    if (element->getCustomElementState() != CustomElementState::Custom) {
+      V0CustomElementRegistrationContext::setIsAttributeAndTypeExtension(
+          element, is);
+    } else if (stringOrOptions.isDictionary()) {
+      element->setAttribute(HTMLNames::isAttr, is);
+    }
   }
 
   return element;
 }
 
 ScriptValue Document::registerElement(ScriptState* scriptState,
                                       const AtomicString& name,
                                       const ElementRegistrationOptions& options,
                                       ExceptionState& exceptionState,
                                       V0CustomElement::NameSet validNames) {
@@ skipping 5622 matching lines @@
 }
 
 void showLiveDocumentInstances() {
   WeakDocumentSet& set = liveDocumentSet();
   fprintf(stderr, "There are %u documents currently alive:\n", set.size());
   for (Document* document : set)
     fprintf(stderr, "- Document %p URL: %s\n", document,
             document->url().getString().utf8().data());
 }
 #endif