<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[197463] trunk</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/197463">197463</a></dd>
<dt>Author</dt> <dd>rniwa@webkit.org</dd>
<dt>Date</dt> <dd>2016-03-02 13:56:47 -0800 (Wed, 02 Mar 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Make HTML parser construct custom elements
https://bugs.webkit.org/show_bug.cgi?id=154908
Source/WebCore:
<rdar://problem/24923735>
Reviewed by Antti Koivisto.
Added the support for instantiating custom elements inside the parser. Based on Jan F2F discussion,
the HTML parser is going to synchronously construct custom elements. When a custom element constructor
throws, the HTML parser creates a HTMLUnknownElement instead.
In our implementation, we pause the parser completely and construct custom elements using the same
mechanism used to run author scripts. It's possible that we may want to apply some optimizations to
to make custom element construction but it's probably a good idea to get semantics right first.
Tests: fast/custom-elements/parser/parser-constructs-custom-elements.html
fast/custom-elements/parser/parser-fallsback-to-unknown-element.html
fast/custom-elements/parser/parser-sets-attributes-and-children.html
fast/custom-elements/parser/parser-uses-constructed-element.html
* bindings/js/JSCustomElementInterface.cpp:
(WebCore::JSCustomElementInterface::constructElement): Added ShouldClearException as an argument
to be used by the HTML parser since the parser can't re-throw to anywhere or fail parsing.
* bindings/js/JSCustomElementInterface.h:
(WebCore::JSCustomElementInterface::ShouldClearException): Added.
* dom/Document.cpp:
(WebCore::createHTMLElementWithNameValidation): Do not clear the exception here since createElement
must re-throw the exception thrown by a custom element constructor.
(WebCore::Document::createElementForBindings):
* dom/make_names.pl:
(printFactoryCppFile): Added ConstructorFunctionMapEntry which contains the constructor function
as well as the qualified name.
(printFactoryHeaderFile): Added a variant of createKnownElement and createElement that takes
AtomicString instead of QualifiedName.
* html/parser/HTMLConstructionSite.cpp:
(WebCore::setAttributes): Added a variant that takes Vector<Attribute>.
(WebCore::HTMLConstructionSite::insertHTMLElementOrFindCustomElementInterface): Added. Returns a
custom element interface when the element doesn't match any builtin element and there is a custom
element definition that matches the specified name.
(WebCore::HTMLConstructionSite::insertCustomElement): Added. Like insertElement but also sets the
attributes on the newly created custom element.
(WebCore::HTMLConstructionSite::createHTMLElementOrFindCustomElementInterface): Extracted from
createHTMLElement. When customElementInterface is not nullptr, we optionally find the custom
element interface and return nullptr.
(WebCore::HTMLConstructionSite::createHTMLElement):
* html/parser/HTMLConstructionSite.h:
* html/parser/HTMLDocumentParser.cpp:
(WebCore::HTMLDocumentParser::runScriptsForPausedTreeBuilder): Create a custom element when there
is a pending custom element to create (i.e. m_customElementToConstruct is not empty).
(WebCore::HTMLDocumentParser::isWaitingForScripts):
* html/parser/HTMLStackItem.h:
(WebCore::HTMLStackItem::create): Added a variant used for custom elements.
(WebCore::HTMLStackItem::HTMLStackItem): Ditto.
* html/parser/HTMLTreeBuilder.cpp:
(WebCore::CustomElementConstructionData::CustomElementConstructionData): Added. It needs to be in
the cpp file to avoid introducing more header dependencies in HTMLTreeBuilder.h.
(WebCore::CustomElementConstructionData::~CustomElementConstructionData): Ditto.
(WebCore::HTMLTreeBuilder::processStartTagForInBody): Use insertGenericHTMLElement when creating
a generic element that could be custom elements.
(WebCore::HTMLTreeBuilder::insertGenericHTMLElement): Added. Create and insert a new element
or set m_customElementToConstruct so that the HTMLDocumentParser will create a custom element later.
(WebCore::HTMLTreeBuilder::didCreateCustomOrCallbackElement): Added. Called by HTMLDocumentParser
when it finishes creating a new custom element.
* html/parser/HTMLTreeBuilder.h:
(WebCore::HTMLTreeBuilder::takeCustomElementConstructionData): Added.
(WebCore::HTMLTreeBuilder::hasParserBlockingScriptWork): Renamed from hasParserBlockingScript.
Checks the existence of m_customElementToConstruct as well as m_scriptToProcess.
LayoutTests:
Reviewed by Antti Koivisto.
Added W3C testharness.js based tests for instantiating custom elements inside the HTML parser.
* fast/custom-elements/parser: Added.
* fast/custom-elements/parser/parser-constructs-custom-elements-expected.txt: Added.
* fast/custom-elements/parser/parser-constructs-custom-elements.html: Added.
* fast/custom-elements/parser/parser-fallsback-to-unknown-element-expected.txt: Added.
* fast/custom-elements/parser/parser-fallsback-to-unknown-element.html: Added.
* fast/custom-elements/parser/parser-sets-attributes-and-children-expected.txt: Added.
* fast/custom-elements/parser/parser-sets-attributes-and-children.html: Added.
* fast/custom-elements/parser/parser-uses-constructed-element-expected.txt: Added.
* fast/custom-elements/parser/parser-uses-constructed-element.html: Added.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkLayoutTestsChangeLog">trunk/LayoutTests/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorebindingsjsJSCustomElementInterfacecpp">trunk/Source/WebCore/bindings/js/JSCustomElementInterface.cpp</a></li>
<li><a href="#trunkSourceWebCorebindingsjsJSCustomElementInterfaceh">trunk/Source/WebCore/bindings/js/JSCustomElementInterface.h</a></li>
<li><a href="#trunkSourceWebCoredomDocumentcpp">trunk/Source/WebCore/dom/Document.cpp</a></li>
<li><a href="#trunkSourceWebCoredommake_namespl">trunk/Source/WebCore/dom/make_names.pl</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLConstructionSitecpp">trunk/Source/WebCore/html/parser/HTMLConstructionSite.cpp</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLConstructionSiteh">trunk/Source/WebCore/html/parser/HTMLConstructionSite.h</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLDocumentParsercpp">trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLStackItemh">trunk/Source/WebCore/html/parser/HTMLStackItem.h</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLTreeBuildercpp">trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLTreeBuilderh">trunk/Source/WebCore/html/parser/HTMLTreeBuilder.h</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li>trunk/LayoutTests/fast/custom-elements/parser/</li>
<li><a href="#trunkLayoutTestsfastcustomelementsparserparserconstructscustomelementsexpectedtxt">trunk/LayoutTests/fast/custom-elements/parser/parser-constructs-custom-elements-expected.txt</a></li>
<li><a href="#trunkLayoutTestsfastcustomelementsparserparserconstructscustomelementshtml">trunk/LayoutTests/fast/custom-elements/parser/parser-constructs-custom-elements.html</a></li>
<li><a href="#trunkLayoutTestsfastcustomelementsparserparserfallsbacktounknownelementexpectedtxt">trunk/LayoutTests/fast/custom-elements/parser/parser-fallsback-to-unknown-element-expected.txt</a></li>
<li><a href="#trunkLayoutTestsfastcustomelementsparserparserfallsbacktounknownelementhtml">trunk/LayoutTests/fast/custom-elements/parser/parser-fallsback-to-unknown-element.html</a></li>
<li><a href="#trunkLayoutTestsfastcustomelementsparserparsersetsattributesandchildrenexpectedtxt">trunk/LayoutTests/fast/custom-elements/parser/parser-sets-attributes-and-children-expected.txt</a></li>
<li><a href="#trunkLayoutTestsfastcustomelementsparserparsersetsattributesandchildrenhtml">trunk/LayoutTests/fast/custom-elements/parser/parser-sets-attributes-and-children.html</a></li>
<li><a href="#trunkLayoutTestsfastcustomelementsparserparserusesconstructedelementexpectedtxt">trunk/LayoutTests/fast/custom-elements/parser/parser-uses-constructed-element-expected.txt</a></li>
<li><a href="#trunkLayoutTestsfastcustomelementsparserparserusesconstructedelementhtml">trunk/LayoutTests/fast/custom-elements/parser/parser-uses-constructed-element.html</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkLayoutTestsChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/LayoutTests/ChangeLog (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/ChangeLog 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/LayoutTests/ChangeLog 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -1,3 +1,22 @@
</span><ins>+2016-03-01 Ryosuke Niwa <rniwa@webkit.org>
+
+ Make HTML parser construct custom elements
+ https://bugs.webkit.org/show_bug.cgi?id=154908
+
+ Reviewed by Antti Koivisto.
+
+ Added W3C testharness.js based tests for instantiating custom elements inside the HTML parser.
+
+ * fast/custom-elements/parser: Added.
+ * fast/custom-elements/parser/parser-constructs-custom-elements-expected.txt: Added.
+ * fast/custom-elements/parser/parser-constructs-custom-elements.html: Added.
+ * fast/custom-elements/parser/parser-fallsback-to-unknown-element-expected.txt: Added.
+ * fast/custom-elements/parser/parser-fallsback-to-unknown-element.html: Added.
+ * fast/custom-elements/parser/parser-sets-attributes-and-children-expected.txt: Added.
+ * fast/custom-elements/parser/parser-sets-attributes-and-children.html: Added.
+ * fast/custom-elements/parser/parser-uses-constructed-element-expected.txt: Added.
+ * fast/custom-elements/parser/parser-uses-constructed-element.html: Added.
+
</ins><span class="cx"> 2016-03-02 Chris Dumez <cdumez@apple.com>
</span><span class="cx">
</span><span class="cx"> Align HTMLInputElement.maxLength with the specification
</span></span></pre></div>
<a id="trunkLayoutTestsfastcustomelementsparserparserconstructscustomelementsexpectedtxt"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/fast/custom-elements/parser/parser-constructs-custom-elements-expected.txt (0 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/fast/custom-elements/parser/parser-constructs-custom-elements-expected.txt (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/parser/parser-constructs-custom-elements-expected.txt 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -0,0 +1,4 @@
</span><ins>+
+PASS HTML parser must NOT create a custom element before defineElement is called
+PASS HTML parser must create a defined custom element before executing inline scripts
+
</ins></span></pre></div>
<a id="trunkLayoutTestsfastcustomelementsparserparserconstructscustomelementshtml"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/fast/custom-elements/parser/parser-constructs-custom-elements.html (0 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/fast/custom-elements/parser/parser-constructs-custom-elements.html (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/parser/parser-constructs-custom-elements.html 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -0,0 +1,47 @@
</span><ins>+<!DOCTYPE html>
+<html>
+<head>
+<title>Custom Elements: Changes to the HTML parser</title>
+<meta name="author" title="Ryosuke Niwa" href="mailto:rniwa@webkit.org">
+<meta name="assert" content="HTML parser creates a custom element">
+<script src="../../../resources/testharness.js"></script>
+<script src="../../../resources/testharnessreport.js"></script>
+<link rel='stylesheet' href='../../../resources/testharness.css'>
+</head>
+<body>
+<div id="log"></div>
+<my-custom-element id="instance1"></my-custom-element>
+<script>
+
+class MyCustomElement extends HTMLElement { };
+
+test(function () {
+ var customElement = document.getElementById('instance1');
+
+ assert_true(customElement instanceof HTMLElement, 'An unresolved custom element must be an instance of HTMLElement');
+ assert_false(customElement instanceof MyCustomElement, 'An unresolved custom element must NOT be an instance of that custom element');
+ assert_equals(customElement.localName, 'my-custom-element');
+ assert_equals(customElement.namespaceURI, 'http://www.w3.org/1999/xhtml', 'A custom element HTML must use HTML namespace');
+
+}, 'HTML parser must NOT create a custom element before defineElement is called');
+
+document.defineCustomElement('my-custom-element', MyCustomElement);
+
+</script>
+<my-custom-element id="instance2"></my-custom-element>
+<script>
+
+test(function () {
+ var customElement = document.getElementById('instance2');
+
+ assert_true(customElement instanceof HTMLElement, 'A resolved custom element must be an instance of HTMLElement');
+ assert_false(customElement instanceof HTMLUnknownElement, 'A resolved custom element must NOT be an instance of HTMLUnknownElement');
+ assert_true(customElement instanceof MyCustomElement, 'A resolved custom element must be an instance of that custom element');
+ assert_equals(customElement.localName, 'my-custom-element');
+ assert_equals(customElement.namespaceURI, 'http://www.w3.org/1999/xhtml', 'A custom element HTML must use HTML namespace');
+
+}, 'HTML parser must create a defined custom element before executing inline scripts');
+
+</script>
+</body>
+</html>
</ins></span></pre></div>
<a id="trunkLayoutTestsfastcustomelementsparserparserfallsbacktounknownelementexpectedtxt"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/fast/custom-elements/parser/parser-fallsback-to-unknown-element-expected.txt (0 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/fast/custom-elements/parser/parser-fallsback-to-unknown-element-expected.txt (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/parser/parser-fallsback-to-unknown-element-expected.txt 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -0,0 +1,6 @@
</span><ins>+
+PASS HTML parser must create a fallback HTMLUnknownElement when a custom element constructor returns a Text node
+PASS HTML parser must create a fallback HTMLUnknownElement when a custom element constructor returns non-Element object
+PASS HTML parser must create a fallback HTMLUnknownElement when a custom element constructor does not call super()
+PASS HTML parser must create a fallback HTMLUnknownElement when a custom element constructor throws an exception
+
</ins></span></pre></div>
<a id="trunkLayoutTestsfastcustomelementsparserparserfallsbacktounknownelementhtml"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/fast/custom-elements/parser/parser-fallsback-to-unknown-element.html (0 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/fast/custom-elements/parser/parser-fallsback-to-unknown-element.html (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/parser/parser-fallsback-to-unknown-element.html 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -0,0 +1,88 @@
</span><ins>+<!DOCTYPE html>
+<html>
+<head>
+<title>Custom Elements: Changes to the HTML parser</title>
+<meta name="author" title="Ryosuke Niwa" href="mailto:rniwa@webkit.org">
+<meta name="assert" content="HTML parser must fallback to creating a HTMLUnknownElement when a custom element construction fails">
+<script src="../../../resources/testharness.js"></script>
+<script src="../../../resources/testharnessreport.js"></script>
+<link rel='stylesheet' href='../../../resources/testharness.css'>
+</head>
+<body>
+<div id="log"></div>
+<script>
+
+class ReturnsTextNode extends HTMLElement {
+ constructor() {
+ super();
+ return document.createTextNode('some text');
+ }
+};
+document.defineCustomElement('returns-text', ReturnsTextNode);
+
+class ReturnsNonElementObject extends HTMLElement {
+ constructor() {
+ super();
+ return {};
+ }
+};
+document.defineCustomElement('returns-non-element-object', ReturnsNonElementObject);
+
+class LacksSuperCall extends HTMLElement {
+ constructor() { }
+};
+document.defineCustomElement('lacks-super-call', LacksSuperCall);
+
+class ThrowsException extends HTMLElement {
+ constructor() {
+ throw 'Bad';
+ }
+};
+document.defineCustomElement('throws-exception', ThrowsException);
+
+</script>
+<returns-text></returns-text>
+<returns-non-element-object></returns-non-element-object>
+<lacks-super-call></lacks-super-call>
+<throws-exception></throws-exception>
+<script>
+
+test(function () {
+ var instance = document.querySelector('returns-text');
+
+ assert_false(instance instanceof ReturnsTextNode, 'HTML parser must NOT instantiate a custom element when the constructor returns a Text node');
+ assert_true(instance instanceof HTMLElement, 'The fallback element created by HTML parser must be an instance of HTMLElement');
+ assert_true(instance instanceof HTMLUnknownElement, 'The fallback element created by HTML parser must be an instance of HTMLUnknownElement');
+
+}, 'HTML parser must create a fallback HTMLUnknownElement when a custom element constructor returns a Text node');
+
+test(function () {
+ var instance = document.querySelector('returns-non-element-object');
+
+ assert_false(instance instanceof ReturnsNonElementObject, 'HTML parser must NOT instantiate a custom element when the constructor returns a non-Element object');
+ assert_true(instance instanceof HTMLElement, 'The fallback element created by HTML parser must be an instance of HTMLElement');
+ assert_true(instance instanceof HTMLUnknownElement, 'The fallback element created by HTML parser must be an instance of HTMLUnknownElement');
+
+}, 'HTML parser must create a fallback HTMLUnknownElement when a custom element constructor returns non-Element object');
+
+test(function () {
+ var instance = document.querySelector('lacks-super-call');
+
+ assert_false(instance instanceof LacksSuperCall, 'HTML parser must NOT instantiate a custom element when the constructor does not call super()');
+ assert_true(instance instanceof HTMLElement, 'The fallback element created by HTML parser must be an instance of HTMLElement');
+ assert_true(instance instanceof HTMLUnknownElement, 'The fallback element created by HTML parser must be an instance of HTMLUnknownElement');
+
+}, 'HTML parser must create a fallback HTMLUnknownElement when a custom element constructor does not call super()');
+
+test(function () {
+ var instance = document.querySelector('throws-exception');
+
+ assert_false(instance instanceof ThrowsException, 'HTML parser must NOT instantiate a custom element when the constructor throws an exception');
+ assert_true(instance instanceof HTMLElement, 'The fallback element created by HTML parser must be an instance of HTMLElement');
+ assert_true(instance instanceof HTMLUnknownElement, 'The fallback element created by HTML parser must be an instance of HTMLUnknownElement');
+
+}, 'HTML parser must create a fallback HTMLUnknownElement when a custom element constructor throws an exception');
+
+</script>
+</body>
+</html>
</ins></span></pre></div>
<a id="trunkLayoutTestsfastcustomelementsparserparsersetsattributesandchildrenexpectedtxt"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/fast/custom-elements/parser/parser-sets-attributes-and-children-expected.txt (0 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/fast/custom-elements/parser/parser-sets-attributes-and-children-expected.txt (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/parser/parser-sets-attributes-and-children-expected.txt 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -0,0 +1,6 @@
</span><ins>+hello world
+
+PASS HTML parser must set the attributes
+PASS HTML parser must append child nodes
+PASS HTML parser must set the attributes or append children before calling constructor
+
</ins></span></pre></div>
<a id="trunkLayoutTestsfastcustomelementsparserparsersetsattributesandchildrenhtml"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/fast/custom-elements/parser/parser-sets-attributes-and-children.html (0 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/fast/custom-elements/parser/parser-sets-attributes-and-children.html (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/parser/parser-sets-attributes-and-children.html 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -0,0 +1,63 @@
</span><ins>+<!DOCTYPE html>
+<html>
+<head>
+<title>Custom Elements: Changes to the HTML parser</title>
+<meta name="author" title="Ryosuke Niwa" href="mailto:rniwa@webkit.org">
+<meta name="assert" content="HTML parser must set the attributes and append the children on a custom element">
+<script src="../../../resources/testharness.js"></script>
+<script src="../../../resources/testharnessreport.js"></script>
+<link rel='stylesheet' href='../../../resources/testharness.css'>
+</head>
+<body>
+<div id="log"></div>
+<script>
+
+var numberOfAttributesInConstructor;
+var numberOfChildNodesInConstructor;
+
+class MyCustomElement extends HTMLElement {
+ constructor(...args) {
+ super(...args);
+ numberOfAttributesInConstructor = this.attributes.length;
+ numberOfChildNodesInConstructor = this.childNodes.length;
+ }
+};
+document.defineCustomElement('my-custom-element', MyCustomElement);
+
+</script>
+<my-custom-element id="custom-element-id" class="class1 class2">hello <b>world</b></my-custom-element>
+<script>
+
+var customElement = document.querySelector('my-custom-element');
+
+test(function () {
+ assert_equals(customElement.getAttribute('id'), 'custom-element-id', 'HTML parser must preserve the id attribute');
+ assert_equals(customElement.id, 'custom-element-id', 'HTML parser must preserve the semantics of reflect for the id attribute');
+ assert_equals(customElement.getAttribute('class'), 'class1 class2', 'HTML parser must preserve the class attribute');
+ assert_equals(customElement.classList.length, 2, 'HTML parser must initialize classList on custom elements');
+ assert_equals(customElement.classList[0], 'class1', 'HTML parser must initialize classList on custom elements');
+ assert_equals(customElement.classList[1], 'class2', 'HTML parser must initialize classList on custom elements');
+
+ assert_equals(customElement.childNodes.length, 2, 'HTML parser must append child nodes');
+ assert_equals(customElement.classList[0], 'class1', 'HTML parser must initialize classList on custom elements');
+ assert_equals(customElement.classList[1], 'class2', 'HTML parser must initialize classList on custom elements');
+
+}, 'HTML parser must set the attributes');
+
+test(function () {
+ assert_equals(customElement.childNodes.length, 2, 'HTML parser must append child nodes');
+ assert_true(customElement.firstChild instanceof Text, 'HTML parser must append Text node child to a custom element');
+ assert_equals(customElement.firstChild.data, 'hello ', 'HTML parser must append Text node child to a custom element');
+ assert_true(customElement.lastChild instanceof HTMLElement, 'HTML parser must append a builtin element child to a custom element');
+ assert_true(customElement.lastChild.firstChild instanceof Text, 'HTML parser must preserve grandchild nodes of a custom element');
+ assert_equals(customElement.lastChild.firstChild.data, 'world', 'HTML parser must preserve grandchild nodes of a custom element');
+}, 'HTML parser must append child nodes');
+
+test(function () {
+ assert_equals(numberOfAttributesInConstructor, 0, 'HTML parser must not set attributes on a custom element before invoking the constructor');
+ assert_equals(numberOfChildNodesInConstructor, 0, 'HTML parser must not append child nodes to a custom element before invoking the constructor');
+}, 'HTML parser must set the attributes or append children before calling constructor');
+
+</script>
+</body>
+</html>
</ins></span></pre></div>
<a id="trunkLayoutTestsfastcustomelementsparserparserusesconstructedelementexpectedtxt"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/fast/custom-elements/parser/parser-uses-constructed-element-expected.txt (0 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/fast/custom-elements/parser/parser-uses-constructed-element-expected.txt (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/parser/parser-uses-constructed-element-expected.txt 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -0,0 +1,4 @@
</span><ins>+
+PASS HTML parser must use the returned value of the custom element constructor instead of the one created before super() call
+PASS HTML parser must use the returned value of the custom element constructor instead using the one created in super() call
+
</ins></span></pre></div>
<a id="trunkLayoutTestsfastcustomelementsparserparserusesconstructedelementhtml"></a>
<div class="addfile"><h4>Added: trunk/LayoutTests/fast/custom-elements/parser/parser-uses-constructed-element.html (0 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/LayoutTests/fast/custom-elements/parser/parser-uses-constructed-element.html (rev 0)
+++ trunk/LayoutTests/fast/custom-elements/parser/parser-uses-constructed-element.html 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -0,0 +1,72 @@
</span><ins>+<!DOCTYPE html>
+<html>
+<head>
+<title>Custom Elements: Changes to the HTML parser</title>
+<meta name="author" title="Ryosuke Niwa" href="mailto:rniwa@webkit.org">
+<meta name="assert" content="HTML parser must construct a custom element instead of upgrading">
+<script src="../../../resources/testharness.js"></script>
+<script src="../../../resources/testharnessreport.js"></script>
+<link rel='stylesheet' href='../../../resources/testharness.css'>
+</head>
+<body>
+<div id="log"></div>
+<script>
+
+let anotherElementCreatedBeforeSuperCall = undefined;
+let elementCreatedBySuperCall = undefined;
+let shouldCreateElementBeforeSuperCall = true;
+class InstantiatesItselfBeforeSuper extends HTMLElement {
+ constructor() {
+ if (shouldCreateElementBeforeSuperCall) {
+ shouldCreateElementBeforeSuperCall = false;
+ anotherElementCreatedBeforeSuperCall = new InstantiatesItselfBeforeSuper();
+ }
+ super();
+ elementCreatedBySuperCall = this;
+ }
+};
+document.defineCustomElement('instantiates-itself-before-super', InstantiatesItselfBeforeSuper);
+
+let shouldCreateAnotherInstance = true;
+let anotherInstance = undefined;
+let firstInstance = undefined;
+class ReturnsAnotherInstance extends HTMLElement {
+ constructor() {
+ super();
+ if (shouldCreateAnotherInstance) {
+ shouldCreateAnotherInstance = false;
+ firstInstance = this;
+ anotherInstance = new ReturnsAnotherInstance;
+ return anotherInstance;
+ } else
+ return this;
+ }
+};
+document.defineCustomElement('returns-another-instance', ReturnsAnotherInstance);
+
+</script>
+<instantiates-itself-before-super></instantiates-itself-before-super>
+<returns-another-instance></returns-another-instance>
+<script>
+
+test(function () {
+ var instance = document.querySelector('instantiates-itself-before-super');
+
+ assert_equals(instance, elementCreatedBySuperCall, 'HTML parser must insert the element returned by the custom element constructor');
+ assert_not_equals(instance, anotherElementCreatedBeforeSuperCall, 'HTML parser must not insert another instance of the custom element created before super() call');
+ assert_equals(anotherElementCreatedBeforeSuperCall.parentNode, null, 'HTML parser must not insert another instance of the custom element created before super() call');
+
+}, 'HTML parser must use the returned value of the custom element constructor instead of the one created before super() call');
+
+test(function () {
+ var instance = document.querySelector('returns-another-instance');
+
+ assert_equals(instance, anotherInstance, 'HTML parser must insert the element returned by the custom element constructor');
+ assert_not_equals(instance, firstInstance, 'HTML parser must not insert the element created by super() call if the constructor returned another element');
+ assert_equals(firstInstance.parentNode, null, 'HTML parser must not insert the element created by super() call if the constructor returned another element');
+
+}, 'HTML parser must use the returned value of the custom element constructor instead using the one created in super() call');
+
+</script>
+</body>
+</html>
</ins></span></pre></div>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/ChangeLog 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -1,3 +1,80 @@
</span><ins>+2016-03-01 Ryosuke Niwa <rniwa@webkit.org>
+
+ Make HTML parser construct custom elements
+ https://bugs.webkit.org/show_bug.cgi?id=154908
+ <rdar://problem/24923735>
+
+ Reviewed by Antti Koivisto.
+
+ Added the support for instantiating custom elements inside the parser. Based on Jan F2F discussion,
+ the HTML parser is going to synchronously construct custom elements. When a custom element constructor
+ throws, the HTML parser creates a HTMLUnknownElement instead.
+
+ In our implementation, we pause the parser completely and construct custom elements using the same
+ mechanism used to run author scripts. It's possible that we may want to apply some optimizations to
+ to make custom element construction but it's probably a good idea to get semantics right first.
+
+ Tests: fast/custom-elements/parser/parser-constructs-custom-elements.html
+ fast/custom-elements/parser/parser-fallsback-to-unknown-element.html
+ fast/custom-elements/parser/parser-sets-attributes-and-children.html
+ fast/custom-elements/parser/parser-uses-constructed-element.html
+
+ * bindings/js/JSCustomElementInterface.cpp:
+ (WebCore::JSCustomElementInterface::constructElement): Added ShouldClearException as an argument
+ to be used by the HTML parser since the parser can't re-throw to anywhere or fail parsing.
+
+ * bindings/js/JSCustomElementInterface.h:
+ (WebCore::JSCustomElementInterface::ShouldClearException): Added.
+
+ * dom/Document.cpp:
+ (WebCore::createHTMLElementWithNameValidation): Do not clear the exception here since createElement
+ must re-throw the exception thrown by a custom element constructor.
+ (WebCore::Document::createElementForBindings):
+
+ * dom/make_names.pl:
+ (printFactoryCppFile): Added ConstructorFunctionMapEntry which contains the constructor function
+ as well as the qualified name.
+ (printFactoryHeaderFile): Added a variant of createKnownElement and createElement that takes
+ AtomicString instead of QualifiedName.
+
+ * html/parser/HTMLConstructionSite.cpp:
+ (WebCore::setAttributes): Added a variant that takes Vector<Attribute>.
+ (WebCore::HTMLConstructionSite::insertHTMLElementOrFindCustomElementInterface): Added. Returns a
+ custom element interface when the element doesn't match any builtin element and there is a custom
+ element definition that matches the specified name.
+ (WebCore::HTMLConstructionSite::insertCustomElement): Added. Like insertElement but also sets the
+ attributes on the newly created custom element.
+ (WebCore::HTMLConstructionSite::createHTMLElementOrFindCustomElementInterface): Extracted from
+ createHTMLElement. When customElementInterface is not nullptr, we optionally find the custom
+ element interface and return nullptr.
+ (WebCore::HTMLConstructionSite::createHTMLElement):
+ * html/parser/HTMLConstructionSite.h:
+
+ * html/parser/HTMLDocumentParser.cpp:
+ (WebCore::HTMLDocumentParser::runScriptsForPausedTreeBuilder): Create a custom element when there
+ is a pending custom element to create (i.e. m_customElementToConstruct is not empty).
+ (WebCore::HTMLDocumentParser::isWaitingForScripts):
+
+ * html/parser/HTMLStackItem.h:
+ (WebCore::HTMLStackItem::create): Added a variant used for custom elements.
+ (WebCore::HTMLStackItem::HTMLStackItem): Ditto.
+
+ * html/parser/HTMLTreeBuilder.cpp:
+ (WebCore::CustomElementConstructionData::CustomElementConstructionData): Added. It needs to be in
+ the cpp file to avoid introducing more header dependencies in HTMLTreeBuilder.h.
+ (WebCore::CustomElementConstructionData::~CustomElementConstructionData): Ditto.
+ (WebCore::HTMLTreeBuilder::processStartTagForInBody): Use insertGenericHTMLElement when creating
+ a generic element that could be custom elements.
+ (WebCore::HTMLTreeBuilder::insertGenericHTMLElement): Added. Create and insert a new element
+ or set m_customElementToConstruct so that the HTMLDocumentParser will create a custom element later.
+ (WebCore::HTMLTreeBuilder::didCreateCustomOrCallbackElement): Added. Called by HTMLDocumentParser
+ when it finishes creating a new custom element.
+
+ * html/parser/HTMLTreeBuilder.h:
+ (WebCore::HTMLTreeBuilder::takeCustomElementConstructionData): Added.
+ (WebCore::HTMLTreeBuilder::hasParserBlockingScriptWork): Renamed from hasParserBlockingScript.
+ Checks the existence of m_customElementToConstruct as well as m_scriptToProcess.
+
</ins><span class="cx"> 2016-03-02 Zalan Bujtas <zalan@apple.com>
</span><span class="cx">
</span><span class="cx"> Use IndentTextOrNot instead of passing isFirstLine/shouldIndentText as bool.
</span></span></pre></div>
<a id="trunkSourceWebCorebindingsjsJSCustomElementInterfacecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/bindings/js/JSCustomElementInterface.cpp (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/bindings/js/JSCustomElementInterface.cpp 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/bindings/js/JSCustomElementInterface.cpp 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -55,7 +55,7 @@
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><del>-RefPtr<Element> JSCustomElementInterface::constructElement(const AtomicString& tagName)
</del><ins>+RefPtr<Element> JSCustomElementInterface::constructElement(const AtomicString& tagName, ShouldClearException shouldClearException)
</ins><span class="cx"> {
</span><span class="cx"> if (!canInvokeCallback())
</span><span class="cx"> return nullptr;
</span><span class="lines">@@ -88,6 +88,9 @@
</span><span class="cx"> JSValue newElement = construct(state, m_constructor.get(), constructType, constructData, args);
</span><span class="cx"> InspectorInstrumentation::didCallFunction(cookie, context);
</span><span class="cx">
</span><ins>+ if (shouldClearException == ShouldClearException::Clear && state->hadException())
+ state->clearException();
+
</ins><span class="cx"> if (newElement.isEmpty())
</span><span class="cx"> return nullptr;
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorebindingsjsJSCustomElementInterfaceh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/bindings/js/JSCustomElementInterface.h (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/bindings/js/JSCustomElementInterface.h 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/bindings/js/JSCustomElementInterface.h 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -59,7 +59,8 @@
</span><span class="cx"> return adoptRef(*new JSCustomElementInterface(callback, globalObject));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- RefPtr<Element> constructElement(const AtomicString&);
</del><ins>+ enum class ShouldClearException { Clear, DoNotClear };
+ RefPtr<Element> constructElement(const AtomicString&, ShouldClearException);
</ins><span class="cx">
</span><span class="cx"> ScriptExecutionContext* scriptExecutionContext() const { return ContextDestructionObserver::scriptExecutionContext(); }
</span><span class="cx"> JSC::JSObject* constructor() { return m_constructor.get(); }
</span></span></pre></div>
<a id="trunkSourceWebCoredomDocumentcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/Document.cpp (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/Document.cpp 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/dom/Document.cpp 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -879,35 +879,35 @@
</span><span class="cx"> clearStyleResolver();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static RefPtr<Element> createHTMLElementWithNameValidation(Document& document, const QualifiedName qualifiedName, ExceptionCode& ec)
</del><ins>+static RefPtr<Element> createHTMLElementWithNameValidation(Document& document, const AtomicString& localName, ExceptionCode& ec)
</ins><span class="cx"> {
</span><del>- RefPtr<HTMLElement> element = HTMLElementFactory::createKnownElement(qualifiedName, document);
</del><ins>+ RefPtr<HTMLElement> element = HTMLElementFactory::createKnownElement(localName, document);
</ins><span class="cx"> if (LIKELY(element))
</span><span class="cx"> return element;
</span><span class="cx">
</span><span class="cx"> #if ENABLE(CUSTOM_ELEMENTS)
</span><span class="cx"> auto* definitions = document.customElementDefinitions();
</span><span class="cx"> if (UNLIKELY(definitions)) {
</span><del>- if (auto* interface = definitions->findInterface(qualifiedName))
- return interface->constructElement(qualifiedName.localName());
</del><ins>+ if (auto* interface = definitions->findInterface(localName))
+ return interface->constructElement(localName, JSCustomElementInterface::ShouldClearException::DoNotClear);
</ins><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- if (UNLIKELY(!Document::isValidName(qualifiedName.localName()))) {
</del><ins>+ if (UNLIKELY(!Document::isValidName(localName))) {
</ins><span class="cx"> ec = INVALID_CHARACTER_ERR;
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- return HTMLUnknownElement::create(qualifiedName, document);
</del><ins>+ return HTMLUnknownElement::create(QualifiedName(nullAtom, localName, xhtmlNamespaceURI), document);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<Element> Document::createElementForBindings(const AtomicString& name, ExceptionCode& ec)
</span><span class="cx"> {
</span><span class="cx"> if (isHTMLDocument())
</span><del>- return createHTMLElementWithNameValidation(*this, QualifiedName(nullAtom, name.convertToASCIILowercase(), xhtmlNamespaceURI), ec);
</del><ins>+ return createHTMLElementWithNameValidation(*this, name.convertToASCIILowercase(), ec);
</ins><span class="cx">
</span><span class="cx"> if (isXHTMLDocument())
</span><del>- return createHTMLElementWithNameValidation(*this, QualifiedName(nullAtom, name, xhtmlNamespaceURI), ec);
</del><ins>+ return createHTMLElementWithNameValidation(*this, name, ec);
</ins><span class="cx">
</span><span class="cx"> if (!isValidName(name)) {
</span><span class="cx"> ec = INVALID_CHARACTER_ERR;
</span></span></pre></div>
<a id="trunkSourceWebCoredommake_namespl"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/make_names.pl (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/make_names.pl 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/dom/make_names.pl 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -986,10 +986,28 @@
</span><span class="cx"> $argumentList = "name, document, createdByParser";
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ my $lowercaseNamespacePrefix = lc($parameters{namespacePrefix});
+
</ins><span class="cx"> printConstructors($F, \%tagConstructorMap);
</span><span class="cx">
</span><span class="cx"> print F <<END
</span><del>-static NEVER_INLINE void populate$parameters{namespace}FactoryMap(HashMap<AtomicStringImpl*, $parameters{namespace}ConstructorFunction>& map)
</del><ins>+
+struct ConstructorFunctionMapEntry {
+ ConstructorFunctionMapEntry($parameters{namespace}ConstructorFunction function, const QualifiedName& name)
+ : function(function)
+ , qualifiedName(&name)
+ { }
+
+ ConstructorFunctionMapEntry()
+ : function(nullptr)
+ , qualifiedName(nullptr)
+ { }
+
+ $parameters{namespace}ConstructorFunction function;
+ const QualifiedName* qualifiedName; // Use pointer instead of reference so that emptyValue() in HashMap is cheap to create.
+};
+
+static NEVER_INLINE void populate$parameters{namespace}FactoryMap(HashMap<AtomicStringImpl*, ConstructorFunctionMapEntry>& map)
</ins><span class="cx"> {
</span><span class="cx"> struct TableEntry {
</span><span class="cx"> const QualifiedName& name;
</span><span class="lines">@@ -1006,25 +1024,42 @@
</span><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> for (unsigned i = 0; i < WTF_ARRAY_LENGTH(table); ++i)
</span><del>- map.add(table[i].name.localName().impl(), table[i].function);
</del><ins>+ map.add(table[i].name.localName().impl(), ConstructorFunctionMapEntry(table[i].function, table[i].name));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-RefPtr<$parameters{namespace}Element> $parameters{namespace}ElementFactory::createKnownElement(const QualifiedName& name, Document& document$formElementArgumentForDefinition, bool createdByParser)
</del><ins>+
+static ConstructorFunctionMapEntry find$parameters{namespace}ElementConstructorFunction(const AtomicString& localName)
</ins><span class="cx"> {
</span><del>- static NeverDestroyed<HashMap<AtomicStringImpl*, $parameters{namespace}ConstructorFunction>> functions;
- if (functions.get().isEmpty())
- populate$parameters{namespace}FactoryMap(functions);
- $parameters{namespace}ConstructorFunction function = functions.get().get(name.localName().impl());
- if (LIKELY(function))
- return function($argumentList);
</del><ins>+ static NeverDestroyed<HashMap<AtomicStringImpl*, ConstructorFunctionMapEntry>> map;
+ if (map.get().isEmpty())
+ populate$parameters{namespace}FactoryMap(map);
+ return map.get().get(localName.impl());
+}
+
+RefPtr<$parameters{namespace}Element> $parameters{namespace}ElementFactory::createKnownElement(const AtomicString& localName, Document& document$formElementArgumentForDefinition, bool createdByParser)
+{
+ const ConstructorFunctionMapEntry& entry = find$parameters{namespace}ElementConstructorFunction(localName);
+ if (LIKELY(entry.function)) {
+ ASSERT(entry.qualifiedName);
+ const auto& name = *entry.qualifiedName;
+ return entry.function($argumentList);
+ }
</ins><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-Ref<$parameters{namespace}Element> $parameters{namespace}ElementFactory::createElement(const QualifiedName& name, Document& document$formElementArgumentForDefinition, bool createdByParser)
</del><ins>+Ref<$parameters{namespace}Element> $parameters{namespace}ElementFactory::createElement(const AtomicString& name, Document& document$formElementArgumentForDefinition, bool createdByParser)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<$parameters{namespace}Element> element = $parameters{namespace}ElementFactory::createKnownElement($argumentList);
</span><span class="cx"> if (LIKELY(element))
</span><span class="cx"> return element.releaseNonNull();
</span><ins>+ return $parameters{fallbackInterfaceName}::create(QualifiedName(nullAtom, name, ${lowercaseNamespacePrefix}NamespaceURI), document);
+}
+
+Ref<$parameters{namespace}Element> $parameters{namespace}ElementFactory::createElement(const QualifiedName& name, Document& document$formElementArgumentForDefinition, bool createdByParser)
+{
+ const ConstructorFunctionMapEntry& entry = find$parameters{namespace}ElementConstructorFunction(name.localName());
+ if (LIKELY(entry.function))
+ return entry.function($argumentList);
</ins><span class="cx"> return $parameters{fallbackInterfaceName}::create(name, document);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1065,12 +1100,15 @@
</span><span class="cx"> END
</span><span class="cx"> ;
</span><span class="cx">
</span><del>-print F " static RefPtr<$parameters{namespace}Element> createKnownElement(const QualifiedName&, Document&";
</del><ins>+print F " static RefPtr<$parameters{namespace}Element> createKnownElement(const AtomicString& localName, Document&";
</ins><span class="cx"> print F ", HTMLFormElement* = nullptr" if $parameters{namespace} eq "HTML";
</span><span class="cx"> print F ", bool createdByParser = false);\n\n";
</span><del>-print F " static Ref<$parameters{namespace}Element> createElement(const QualifiedName&, Document&";
</del><ins>+print F " static Ref<$parameters{namespace}Element> createElement(const AtomicString& localName, Document&";
</ins><span class="cx"> print F ", HTMLFormElement* = nullptr" if $parameters{namespace} eq "HTML";
</span><span class="cx"> print F ", bool createdByParser = false);\n";
</span><ins>+print F " static Ref<$parameters{namespace}Element> createElement(const QualifiedName& localName, Document&";
+print F ", HTMLFormElement* = nullptr" if $parameters{namespace} eq "HTML";
+print F ", bool createdByParser = false);\n";
</ins><span class="cx">
</span><span class="cx"> printf F<<END
</span><span class="cx"> };
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLConstructionSitecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLConstructionSite.cpp (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLConstructionSite.cpp 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/html/parser/HTMLConstructionSite.cpp 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -28,6 +28,7 @@
</span><span class="cx"> #include "HTMLTreeBuilder.h"
</span><span class="cx">
</span><span class="cx"> #include "Comment.h"
</span><ins>+#include "CustomElementDefinitions.h"
</ins><span class="cx"> #include "DocumentFragment.h"
</span><span class="cx"> #include "DocumentType.h"
</span><span class="cx"> #include "Frame.h"
</span><span class="lines">@@ -43,6 +44,7 @@
</span><span class="cx"> #include "HTMLPictureElement.h"
</span><span class="cx"> #include "HTMLScriptElement.h"
</span><span class="cx"> #include "HTMLTemplateElement.h"
</span><ins>+#include "HTMLUnknownElement.h"
</ins><span class="cx"> #include "NotImplemented.h"
</span><span class="cx"> #include "SVGElement.h"
</span><span class="cx"> #include "Text.h"
</span><span class="lines">@@ -51,13 +53,18 @@
</span><span class="cx">
</span><span class="cx"> using namespace HTMLNames;
</span><span class="cx">
</span><del>-static inline void setAttributes(Element& element, AtomicHTMLToken* token, ParserContentPolicy parserContentPolicy)
</del><ins>+static inline void setAttributes(Element& element, Vector<Attribute>& attributes, ParserContentPolicy parserContentPolicy)
</ins><span class="cx"> {
</span><span class="cx"> if (!scriptingContentIsAllowed(parserContentPolicy))
</span><del>- element.stripScriptingAttributes(token->attributes());
- element.parserSetAttributes(token->attributes());
</del><ins>+ element.stripScriptingAttributes(attributes);
+ element.parserSetAttributes(attributes);
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+static inline void setAttributes(Element& element, AtomicHTMLToken* token, ParserContentPolicy parserContentPolicy)
+{
+ setAttributes(element, token->attributes(), parserContentPolicy);
+}
+
</ins><span class="cx"> static bool hasImpliedEndTag(const HTMLStackItem& item)
</span><span class="cx"> {
</span><span class="cx"> return item.hasTagName(ddTag)
</span><span class="lines">@@ -482,6 +489,26 @@
</span><span class="cx"> m_openElements.push(HTMLStackItem::create(element.releaseNonNull(), *token));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+#if ENABLE(CUSTOM_ELEMENTS)
+JSCustomElementInterface* HTMLConstructionSite::insertHTMLElementOrFindCustomElementInterface(AtomicHTMLToken* token)
+{
+ JSCustomElementInterface* interface = nullptr;
+ RefPtr<Element> element = createHTMLElementOrFindCustomElementInterface(token, &interface);
+ if (UNLIKELY(interface))
+ return interface;
+ attachLater(&currentNode(), element);
+ m_openElements.push(HTMLStackItem::create(element.releaseNonNull(), *token));
+ return nullptr;
+}
+
+void HTMLConstructionSite::insertCustomElement(Ref<Element>&& element, const AtomicString& localName, Vector<Attribute>& attributes)
+{
+ setAttributes(element.get(), attributes, m_parserContentPolicy);
+ attachLater(&currentNode(), element.ptr());
+ m_openElements.push(HTMLStackItem::create(WTFMove(element), localName, attributes));
+}
+#endif
+
</ins><span class="cx"> void HTMLConstructionSite::insertSelfClosingHTMLElement(AtomicHTMLToken* token)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(token->type() == HTMLToken::StartTag);
</span><span class="lines">@@ -633,28 +660,53 @@
</span><span class="cx"> return currentNode().document();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-Ref<Element> HTMLConstructionSite::createHTMLElement(AtomicHTMLToken* token)
</del><ins>+RefPtr<Element> HTMLConstructionSite::createHTMLElementOrFindCustomElementInterface(
+ AtomicHTMLToken* token, JSCustomElementInterface** customElementInterface)
</ins><span class="cx"> {
</span><del>- QualifiedName tagName(nullAtom, token->name(), xhtmlNamespaceURI);
</del><ins>+ auto& localName = token->name();
</ins><span class="cx"> // FIXME: This can't use HTMLConstructionSite::createElement because we
</span><span class="cx"> // have to pass the current form element. We should rework form association
</span><span class="cx"> // to occur after construction to allow better code sharing here.
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#create-an-element-for-the-token
</span><span class="cx"> Document& ownerDocument = ownerDocumentForCurrentNode();
</span><span class="cx"> bool insideTemplateElement = !ownerDocument.frame();
</span><del>- Ref<Element> element = HTMLElementFactory::createElement(tagName, ownerDocument, insideTemplateElement ? nullptr : form(), true);
-
</del><ins>+ RefPtr<Element> element = HTMLElementFactory::createKnownElement(localName, ownerDocument, insideTemplateElement ? nullptr : form(), true);
+ if (UNLIKELY(!element)) {
+
+#if ENABLE(CUSTOM_ELEMENTS)
+ auto* definitions = ownerDocumentForCurrentNode().customElementDefinitions();
+ if (customElementInterface && UNLIKELY(definitions)) {
+ if (auto* interface = definitions->findInterface(localName)) {
+ *customElementInterface = interface;
+ return nullptr;
+ }
+ }
+#else
+ UNUSED_PARAM(customElementInterface);
+#endif
+
+ element = HTMLUnknownElement::create(QualifiedName(nullAtom, localName, xhtmlNamespaceURI), ownerDocumentForCurrentNode());
+ }
+ ASSERT(element);
+
</ins><span class="cx"> // FIXME: This is a hack to connect images to pictures before the image has
</span><span class="cx"> // been inserted into the document. It can be removed once asynchronous image
</span><span class="cx"> // loading is working.
</span><del>- if (is<HTMLPictureElement>(currentNode()) && is<HTMLImageElement>(element))
- downcast<HTMLImageElement>(element.get()).setPictureElement(&downcast<HTMLPictureElement>(currentNode()));
</del><ins>+ if (is<HTMLPictureElement>(currentNode()) && is<HTMLImageElement>(*element))
+ downcast<HTMLImageElement>(*element).setPictureElement(&downcast<HTMLPictureElement>(currentNode()));
</ins><span class="cx">
</span><del>- setAttributes(element.get(), token, m_parserContentPolicy);
</del><ins>+ setAttributes(*element, token, m_parserContentPolicy);
</ins><span class="cx"> ASSERT(element->isHTMLElement());
</span><span class="cx"> return element;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+Ref<Element> HTMLConstructionSite::createHTMLElement(AtomicHTMLToken* token)
+{
+ RefPtr<Element> element = createHTMLElementOrFindCustomElementInterface(token, nullptr);
+ ASSERT(element);
+ return element.releaseNonNull();
+}
+
</ins><span class="cx"> Ref<HTMLStackItem> HTMLConstructionSite::createElementFromSavedToken(HTMLStackItem* item)
</span><span class="cx"> {
</span><span class="cx"> // NOTE: Moving from item -> token -> item copies the Attribute vector twice!
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLConstructionSiteh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLConstructionSite.h (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLConstructionSite.h 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/html/parser/HTMLConstructionSite.h 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -84,6 +84,7 @@
</span><span class="cx"> class Document;
</span><span class="cx"> class Element;
</span><span class="cx"> class HTMLFormElement;
</span><ins>+class JSCustomElementInterface;
</ins><span class="cx">
</span><span class="cx"> class HTMLConstructionSite {
</span><span class="cx"> WTF_MAKE_NONCOPYABLE(HTMLConstructionSite);
</span><span class="lines">@@ -103,6 +104,10 @@
</span><span class="cx"> void insertCommentOnDocument(AtomicHTMLToken*);
</span><span class="cx"> void insertCommentOnHTMLHtmlElement(AtomicHTMLToken*);
</span><span class="cx"> void insertHTMLElement(AtomicHTMLToken*);
</span><ins>+#if ENABLE(CUSTOM_ELEMENTS)
+ JSCustomElementInterface* insertHTMLElementOrFindCustomElementInterface(AtomicHTMLToken*);
+ void insertCustomElement(Ref<Element>&&, const AtomicString& localName, Vector<Attribute>&);
+#endif
</ins><span class="cx"> void insertSelfClosingHTMLElement(AtomicHTMLToken*);
</span><span class="cx"> void insertFormattingElement(AtomicHTMLToken*);
</span><span class="cx"> void insertHTMLHeadElement(AtomicHTMLToken*);
</span><span class="lines">@@ -194,6 +199,7 @@
</span><span class="cx">
</span><span class="cx"> void findFosterSite(HTMLConstructionSiteTask&);
</span><span class="cx">
</span><ins>+ RefPtr<Element> createHTMLElementOrFindCustomElementInterface(AtomicHTMLToken*, JSCustomElementInterface**);
</ins><span class="cx"> Ref<Element> createHTMLElement(AtomicHTMLToken*);
</span><span class="cx"> Ref<Element> createElement(AtomicHTMLToken*, const AtomicString& namespaceURI);
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLDocumentParsercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -34,6 +34,8 @@
</span><span class="cx"> #include "HTMLPreloadScanner.h"
</span><span class="cx"> #include "HTMLScriptRunner.h"
</span><span class="cx"> #include "HTMLTreeBuilder.h"
</span><ins>+#include "HTMLUnknownElement.h"
+#include "JSCustomElementInterface.h"
</ins><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><span class="lines">@@ -188,8 +190,24 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(scriptingContentIsAllowed(parserContentPolicy()));
</span><span class="cx">
</span><ins>+#if ENABLE(CUSTOM_ELEMENTS)
+ if (std::unique_ptr<CustomElementConstructionData> constructionData = m_treeBuilder->takeCustomElementConstructionData()) {
+ ASSERT(!m_treeBuilder->hasParserBlockingScriptWork());
+
+ RefPtr<Element> newElement = constructionData->interface->constructElement(constructionData->name, JSCustomElementInterface::ShouldClearException::Clear);
+ if (!newElement) {
+ // FIXME: This call to docuemnt() is wrong for elements inside a template element.
+ newElement = HTMLUnknownElement::create(QualifiedName(nullAtom, constructionData->name, xhtmlNamespaceURI), *document());
+ }
+
+ m_treeBuilder->didCreateCustomOrCallbackElement(newElement.releaseNonNull(), *constructionData);
+ return;
+ }
+#endif
+
</ins><span class="cx"> TextPosition scriptStartPosition = TextPosition::belowRangePosition();
</span><span class="cx"> if (auto scriptElement = m_treeBuilder->takeScriptToProcess(scriptStartPosition)) {
</span><ins>+ ASSERT(!m_treeBuilder->hasParserBlockingScriptWork());
</ins><span class="cx"> // We will not have a scriptRunner when parsing a DocumentFragment.
</span><span class="cx"> if (m_scriptRunner)
</span><span class="cx"> m_scriptRunner->execute(scriptElement.release(), scriptStartPosition);
</span><span class="lines">@@ -459,7 +477,7 @@
</span><span class="cx"> // The script runner will hold the script until its loaded and run. During
</span><span class="cx"> // any of this time, we want to count ourselves as "waiting for a script" and thus
</span><span class="cx"> // run the preload scanner, as well as delay completion of parsing.
</span><del>- bool treeBuilderHasBlockingScript = m_treeBuilder->hasParserBlockingScript();
</del><ins>+ bool treeBuilderHasBlockingScript = m_treeBuilder->hasParserBlockingScriptWork();
</ins><span class="cx"> bool scriptRunnerHasBlockingScript = m_scriptRunner && m_scriptRunner->hasParserBlockingScript();
</span><span class="cx"> // Since the parser is paused while a script runner has a blocking script, it should
</span><span class="cx"> // never be possible to end up with both objects holding a blocking script.
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLStackItemh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLStackItem.h (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLStackItem.h 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/html/parser/HTMLStackItem.h 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -40,6 +40,7 @@
</span><span class="cx"> public:
</span><span class="cx"> // Normal HTMLElementStack and HTMLFormattingElementList items.
</span><span class="cx"> static Ref<HTMLStackItem> create(Ref<Element>&&, AtomicHTMLToken&, const AtomicString& namespaceURI = HTMLNames::xhtmlNamespaceURI);
</span><ins>+ static Ref<HTMLStackItem> create(Ref<Element>&&, const AtomicString&, const Vector<Attribute>&);
</ins><span class="cx">
</span><span class="cx"> // Document fragment or element for parsing context.
</span><span class="cx"> static Ref<HTMLStackItem> create(Element&);
</span><span class="lines">@@ -62,6 +63,7 @@
</span><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> HTMLStackItem(Ref<Element>&&, AtomicHTMLToken&, const AtomicString& namespaceURI);
</span><ins>+ HTMLStackItem(Ref<Element>&&, const AtomicString& localName, const AtomicString& namespaceURI, const Vector<Attribute>&);
</ins><span class="cx"> explicit HTMLStackItem(Element&);
</span><span class="cx"> explicit HTMLStackItem(DocumentFragment&);
</span><span class="cx">
</span><span class="lines">@@ -89,6 +91,21 @@
</span><span class="cx"> return adoptRef(*new HTMLStackItem(WTFMove(element), token, namespaceURI));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+inline HTMLStackItem::HTMLStackItem(Ref<Element>&& element, const AtomicString& localName, const AtomicString& namespaceURI, const Vector<Attribute>& attributes)
+ : m_node(WTFMove(element))
+ , m_namespaceURI(namespaceURI)
+ , m_localName(localName)
+ , m_attributes(attributes)
+{
+ // FIXME: We should find a way to move the attributes vector in the normal code path instead of copying it.
+}
+
+inline Ref<HTMLStackItem> HTMLStackItem::create(Ref<Element>&& element, const AtomicString& localName, const Vector<Attribute>& attributes)
+{
+ auto& namespaceURI = element.get().namespaceURI();
+ return adoptRef(*new HTMLStackItem(WTFMove(element), localName, namespaceURI, attributes));
+}
+
</ins><span class="cx"> inline HTMLStackItem::HTMLStackItem(Element& element)
</span><span class="cx"> : m_node(element)
</span><span class="cx"> , m_namespaceURI(element.namespaceURI())
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLTreeBuildercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -34,6 +34,7 @@
</span><span class="cx"> #include "HTMLFormElement.h"
</span><span class="cx"> #include "HTMLOptGroupElement.h"
</span><span class="cx"> #include "HTMLParserIdioms.h"
</span><ins>+#include "JSCustomElementInterface.h"
</ins><span class="cx"> #include "LocalizedStrings.h"
</span><span class="cx"> #include "NotImplemented.h"
</span><span class="cx"> #include "XLinkNames.h"
</span><span class="lines">@@ -50,6 +51,19 @@
</span><span class="cx">
</span><span class="cx"> using namespace HTMLNames;
</span><span class="cx">
</span><ins>+#if ENABLE(CUSTOM_ELEMENTS)
+
+CustomElementConstructionData::CustomElementConstructionData(Ref<JSCustomElementInterface>&& interface, const AtomicString& name, const Vector<Attribute>& attributes)
+ : interface(WTFMove(interface))
+ , name(name)
+ , attributes(attributes) // FIXME: Avoid copying attributes.
+{ }
+
+CustomElementConstructionData::~CustomElementConstructionData()
+{ }
+
+#endif
+
</ins><span class="cx"> namespace {
</span><span class="cx">
</span><span class="cx"> inline bool isHTMLSpaceOrReplacementCharacter(UChar character)
</span><span class="lines">@@ -896,9 +910,27 @@
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><ins>+ insertGenericHTMLElement(token);
+}
+
+inline void HTMLTreeBuilder::insertGenericHTMLElement(AtomicHTMLToken& token)
+{
+#if ENABLE(CUSTOM_ELEMENTS)
+ auto* interface = m_tree.insertHTMLElementOrFindCustomElementInterface(&token);
+ if (UNLIKELY(interface))
+ m_customElementToConstruct = std::make_unique<CustomElementConstructionData>(*interface, token.name(), token.attributes());
+#else
</ins><span class="cx"> m_tree.insertHTMLElement(&token);
</span><ins>+#endif
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+#if ENABLE(CUSTOM_ELEMENTS)
+void HTMLTreeBuilder::didCreateCustomOrCallbackElement(Ref<Element>&& element, CustomElementConstructionData& data)
+{
+ m_tree.insertCustomElement(WTFMove(element), data.name, data.attributes);
+}
+#endif
+
</ins><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::processTemplateStartTag(AtomicHTMLToken& token)
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLTreeBuilderh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLTreeBuilder.h (197462 => 197463)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLTreeBuilder.h 2016-03-02 21:42:22 UTC (rev 197462)
+++ trunk/Source/WebCore/html/parser/HTMLTreeBuilder.h 2016-03-02 21:56:47 UTC (rev 197463)
</span><span class="lines">@@ -34,8 +34,20 @@
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><ins>+class JSCustomElementInterface;
</ins><span class="cx"> class HTMLDocumentParser;
</span><span class="cx">
</span><ins>+#if ENABLE(CUSTOM_ELEMENTS)
+struct CustomElementConstructionData {
+ CustomElementConstructionData(Ref<JSCustomElementInterface>&&, const AtomicString& name, const Vector<Attribute>&);
+ ~CustomElementConstructionData();
+
+ Ref<JSCustomElementInterface> interface;
+ AtomicString name;
+ Vector<Attribute> attributes;
+};
+#endif
+
</ins><span class="cx"> class HTMLTreeBuilder {
</span><span class="cx"> WTF_MAKE_FAST_ALLOCATED;
</span><span class="cx"> public:
</span><span class="lines">@@ -49,11 +61,16 @@
</span><span class="cx">
</span><span class="cx"> void constructTree(AtomicHTMLToken&);
</span><span class="cx">
</span><del>- bool hasParserBlockingScript() const;
</del><ins>+ bool hasParserBlockingScriptWork() const;
</ins><span class="cx">
</span><span class="cx"> // Must be called to take the parser-blocking script before calling the parser again.
</span><span class="cx"> RefPtr<Element> takeScriptToProcess(TextPosition& scriptStartPosition);
</span><span class="cx">
</span><ins>+#if ENABLE(CUSTOM_ELEMENTS)
+ std::unique_ptr<CustomElementConstructionData> takeCustomElementConstructionData() { return WTFMove(m_customElementToConstruct); }
+ void didCreateCustomOrCallbackElement(Ref<Element>&&, CustomElementConstructionData&);
+#endif
+
</ins><span class="cx"> // Done, close any open tags, etc.
</span><span class="cx"> void finished();
</span><span class="cx">
</span><span class="lines">@@ -165,6 +182,8 @@
</span><span class="cx">
</span><span class="cx"> void resetInsertionModeAppropriately();
</span><span class="cx">
</span><ins>+ void insertGenericHTMLElement(AtomicHTMLToken&);
+
</ins><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><span class="cx"> void processTemplateStartTag(AtomicHTMLToken&);
</span><span class="cx"> bool processTemplateEndTag(AtomicHTMLToken&);
</span><span class="lines">@@ -204,6 +223,10 @@
</span><span class="cx"> RefPtr<Element> m_scriptToProcess; // <script> tag which needs processing before resuming the parser.
</span><span class="cx"> TextPosition m_scriptToProcessStartPosition; // Starting line number of the script tag needing processing.
</span><span class="cx">
</span><ins>+#if ENABLE(CUSTOM_ELEMENTS)
+ std::unique_ptr<CustomElementConstructionData> m_customElementToConstruct;
+#endif
+
</ins><span class="cx"> bool m_shouldSkipLeadingNewline { false };
</span><span class="cx">
</span><span class="cx"> bool m_framesetOk { true };
</span><span class="lines">@@ -235,10 +258,15 @@
</span><span class="cx"> return !!m_fragmentContext.fragment();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool HTMLTreeBuilder::hasParserBlockingScript() const
</del><ins>+inline bool HTMLTreeBuilder::hasParserBlockingScriptWork() const
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!m_destroyed);
</span><del>- return !!m_scriptToProcess;
</del><ins>+#if ENABLE(CUSTOM_ELEMENTS)
+ ASSERT(!(m_scriptToProcess && m_customElementToConstruct));
+ return m_scriptToProcess || m_customElementToConstruct;
+#else
+ return m_scriptToProcess;
+#endif
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline DocumentFragment* HTMLTreeBuilder::FragmentParsingContext::fragment() const
</span></span></pre>
</div>
</div>
</body>
</html>