The HTML parser synchronously creates custom elements

third_party/WebKit/Source/core/html/parser/HTMLConstructionSite.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL GOOGLE INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/html/parser/HTMLConstructionSite.h"
 
+#include "bindings/core/v8/Microtask.h"
+#include "bindings/core/v8/V8PerIsolateData.h"
 #include "core/HTMLElementFactory.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Comment.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/DocumentType.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementTraversal.h"
+#include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
 #include "core/dom/ScriptLoader.h"
 #include "core/dom/TemplateContentDocumentFragment.h"
 #include "core/dom/Text.h"
+#include "core/dom/custom/CEReactionsScope.h"
+#include "core/dom/custom/CustomElementDefinition.h"
+#include "core/dom/custom/CustomElementDescriptor.h"
+#include "core/dom/custom/CustomElementsRegistry.h"
+#include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLHtmlElement.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/html/HTMLScriptElement.h"
 #include "core/html/HTMLTemplateElement.h"
+#include "core/html/HTMLUnknownElement.h"
 #include "core/html/parser/AtomicHTMLToken.h"
 #include "core/html/parser/HTMLParserIdioms.h"
+#include "core/html/parser/HTMLParserReentryPermit.h"
 #include "core/html/parser/HTMLStackItem.h"
 #include "core/html/parser/HTMLToken.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/svg/SVGScriptElement.h"
 #include "platform/text/TextBreakIterator.h"
 #include <limits>
 
 namespace blink {
 
@@ skipping 250 matching lines @@
     // re-enters the parser.
     TaskQueue queue;
     queue.swap(m_taskQueue);
 
     for (size_t i = 0; i < size; ++i)
         executeTask(queue[i]);
 
     // We might be detached now.
 }
 
-HTMLConstructionSite::HTMLConstructionSite(Document& document, ParserContentPolicy parserContentPolicy)
-    : m_document(&document)
+HTMLConstructionSite::HTMLConstructionSite(HTMLParserReentryPermit* reentryPermit, Document& document, ParserContentPolicy parserContentPolicy)
+    : m_reentryPermit(reentryPermit)
+    , m_document(&document)
     , m_attachmentRoot(document)
     , m_parserContentPolicy(parserContentPolicy)
     , m_isParsingFragment(false)
     , m_redirectAttachToFosterParent(false)
     , m_inQuirksMode(document.inQuirksMode())
 {
     ASSERT(m_document->isHTMLDocument() || m_document->isXHTMLDocument());
 }
 
 void HTMLConstructionSite::initFragmentParsing(DocumentFragment* fragment, Element* contextElement)
@@ skipping 16 matching lines @@
     // Depending on why we're being destroyed it might be OK
     // to forget queued tasks, but currently we don't expect to.
     ASSERT(m_taskQueue.isEmpty());
     // Currently we assume that text will never be the last token in the
     // document and that we'll always queue some additional task to cause it to flush.
     ASSERT(m_pendingText.isEmpty());
 }
 
 DEFINE_TRACE(HTMLConstructionSite)
 {
+    visitor->trace(m_reentryPermit);
     visitor->trace(m_document);
     visitor->trace(m_attachmentRoot);
     visitor->trace(m_head);
     visitor->trace(m_form);
     visitor->trace(m_openElements);
     visitor->trace(m_activeFormattingElements);
     visitor->trace(m_taskQueue);
     visitor->trace(m_pendingText);
 }
 
@@ skipping 375 matching lines @@
     return element;
 }
 
 inline Document& HTMLConstructionSite::ownerDocumentForCurrentNode()
 {
     if (isHTMLTemplateElement(*currentNode()))
         return toHTMLTemplateElement(currentElement())->content()->document();
     return currentNode()->document();
 }
 
+// "look up a custom element definition" for a token
+// https://html.spec.whatwg.org/#look-up-a-custom-element-definition
+CustomElementDefinition* HTMLConstructionSite::lookUpCustomElementDefinition(Document& document, AtomicHTMLToken* token)
+{
+    // TODO(dominicc): Add a namespace parameter and check when foreign
+    // and HTML element creation is unified.
+
+    // "2. If document does not have a browsing context, return null."
+    LocalDOMWindow* window = document.domWindow();
+    if (!window)
+        return nullptr;
+
+    // "3. Let registry be document's browsing context's Window's
+    // CustomElementsRegistry object."
+    CustomElementsRegistry* registry = window->maybeCustomElements();
+    if (!registry)
+        return nullptr;
+
+    const AtomicString& localName = token->name();
+    const Attribute* isAttribute = token->getAttributeItem(HTMLNames::isAttr);
+    const AtomicString& name = isAttribute ? isAttribute->value() : localName;
+    CustomElementDescriptor descriptor(name, localName);
+
+    // 4.-6.
+    return registry->definitionFor(descriptor);
+}
+
+// "create an element for a token"
+// https://html.spec.whatwg.org/#create-an-element-for-the-token
+// TODO(dominicc): When form association is separate from creation, unify
+// this with foreign element creation.
 HTMLElement* HTMLConstructionSite::createHTMLElement(AtomicHTMLToken* token)
 {
+    // "1. Let document be intended parent's node document."
     Document& document = ownerDocumentForCurrentNode();
+
     // Only associate the element with the current form if we're creating the new element
     // in a document with a browsing context (rather than in <template> contents).
+    // TODO(dominicc): Change form to happen after element creation when
+    // implementing customized built-in elements.
     HTMLFormElement* form = document.frame() ? m_form.get() : nullptr;
-    // FIXME: This can't use HTMLConstructionSite::createElement because we
-    // have to pass the current form element.  We should rework form association
-    // to occur after construction to allow better code sharing here.
-    HTMLElement* element = HTMLElementFactory::createHTMLElement(token->name(), document, form, getCreateElementFlags());
-    setAttributes(element, token, m_parserContentPolicy);
+
+    // "2. Let local name be the tag name of the token."
+    // "3. Let is be the value of the "is" attribute in the giev token ..." etc.
+    // "4. Let definition be the result of looking up a custom element ..." etc.
+    CustomElementDefinition* definition = m_isParsingFragment ? nullptr : lookUpCustomElementDefinition(document, token);
+    // "5. If definition is non-null and the parser was not originally created
+    // for the HTML fragment parsing algorithm, then let will execute script
+    // be true."
+    bool willExecuteScript = definition && !m_isParsingFragment;
+
+    HTMLElement* element;
+
+    if (willExecuteScript) {
+        // "6.1 Increment the parser's script nesting level."
+        HTMLParserReentryPermit::ScriptNestingLevelIncrementer incrementScriptNestingLevel = m_reentryPermit->incrementScriptNestingLevel();
+
+        // "6.2 Set the parser pause flag to true."
+        m_reentryPermit->pause();
+
+        // TODO(dominicc): Change this once resolved:
+        // https://github.com/whatwg/html/issues/1630
+        IgnoreDestructiveWriteCountIncrementer ignoreDestructiveWrites(
+            &document);
+
+        // "6.3 If the JavaScript execution context stack is empty,
+        // then perform a microtask checkpoint."
+
+        // TODO(dominicc): This is the way the Blink HTML parser
+        // performs checkpoints, but note the spec is different--it
+        // talks about the JavaScript stack, not the script nesting
+        // level.
+        if (1u == m_reentryPermit->scriptNestingLevel())
+            Microtask::performCheckpoint(V8PerIsolateData::mainThreadIsolate());
+
+        // "6.4 Push a new element queue onto the custom element
+        // reactions stack."
+        CEReactionsScope reactions;
+
+        QualifiedName elementQName(nullAtom, token->name(), HTMLNames::xhtmlNamespaceURI);
+        element = definition->createElementSync(document, elementQName);
+
+        // TODO(dominicc): When ScriptCustomElementDefinition reports
+        // exceptions from runConstructor, add a test that an
+        // exception is reported here.
+        if (!element) {

[kojii, 2016/08/08 07:47:30]

ScriptCustomElementDefinition::createElementSync, when you call without
ExceptionState, should handle this, including creating Failed element on
failure, so I think you can just DCHECK(element) here. The error reporting is
broken atm but we have a bug for it.

[dominicc (has gone to gerrit), 2016/08/15 01:33:15]

Good point! Done.

+            // "7. (cont'd) ... let element be instead a new element
+            // that implements HTMLUnknownElement, with no attributes,
+            // namespace set to given namespace, namespace prefix set
+            // to null, custom element state set to failed, custom
+            // element definition set to null, and node document set
+            // to document."
+            element = HTMLUnknownElement::create(elementQName, document);
+            element->setCustomElementState(CustomElementState::Failed);
+        }
+
+        // "8. Append each attribute in the given token to element."
+        // We don't use setAttributes here because the custom element
+        // constructor may have manipulated attributes.
+        for (const auto& attribute : token->attributes()) {
+            element->setAttribute(attribute.name(), attribute.value());
+        }
+
+        // "9. If will execute script is true, then ..." etc. The
+        // CEReactionsScope and ScriptNestingLevelIncrementer
+        // destructors implement steps 9.1-4.
+    } else {
+        // FIXME: This can't use
+        // HTMLConstructionSite::createElement because we have to
+        // pass the current form element. We should rework form
+        // association to occur after construction to allow better
+        // code sharing here.
+        element = HTMLElementFactory::createHTMLElement(token->name(), document, form, getCreateElementFlags());
+
+        // "8. Append each attribute in the given token to element."
+        setAttributes(element, token, m_parserContentPolicy);
+    }
+
+    // TODO(dominicc): Implement steps 10-12 when customized built-in
+    // elements are implemented.
+
     return element;
 }
 
 HTMLStackItem* HTMLConstructionSite::createElementFromSavedToken(HTMLStackItem* item)
 {
     Element* element;
     // NOTE: Moving from item -> token -> item copies the Attribute vector twice!
     AtomicHTMLToken fakeToken(HTMLToken::StartTag, item->localName(), item->attributes());
     if (item->namespaceURI() == HTMLNames::xhtmlNamespaceURI)
         element = createHTMLElement(&fakeToken);
@@ skipping 104 matching lines @@
     queueTask(task);
 }
 
 DEFINE_TRACE(HTMLConstructionSite::PendingText)
 {
     visitor->trace(parent);
     visitor->trace(nextChild);
 }
 
 } // namespace blink