<!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>[200340] trunk/Source/WebCore</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/200340">200340</a></dd>
<dt>Author</dt> <dd>cdumez@apple.com</dd>
<dt>Date</dt> <dd>2016-05-02 15:18:05 -0700 (Mon, 02 May 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Modernize HTMLConstructionSite
https://bugs.webkit.org/show_bug.cgi?id=157279
Reviewed by Alex Christensen.
Modernize HTMLConstructionSite: Use less raw pointers, more auto, more
range loops and more nullptr.
* dom/ScriptElement.h:
* html/parser/HTMLConstructionSite.cpp:
(WebCore::setAttributes):
(WebCore::shouldUseLengthLimit):
(WebCore::executeReparentTask):
(WebCore::HTMLConstructionSite::attachLater):
(WebCore::HTMLConstructionSite::executeQueuedTasks):
(WebCore::HTMLConstructionSite::HTMLConstructionSite):
(WebCore::HTMLConstructionSite::takeForm):
(WebCore::HTMLConstructionSite::dispatchDocumentElementAvailableIfNeeded):
(WebCore::HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML):
(WebCore::HTMLConstructionSite::mergeAttributesFromTokenIntoElement):
(WebCore::HTMLConstructionSite::insertHTMLHtmlStartTagInBody):
(WebCore::HTMLConstructionSite::insertHTMLBodyStartTagInBody):
(WebCore::HTMLConstructionSite::setDefaultCompatibilityMode):
(WebCore::HTMLConstructionSite::setCompatibilityMode):
(WebCore::HTMLConstructionSite::finishedParsing):
(WebCore::HTMLConstructionSite::insertDoctype):
(WebCore::HTMLConstructionSite::insertComment):
(WebCore::HTMLConstructionSite::insertCommentOnDocument):
(WebCore::HTMLConstructionSite::insertCommentOnHTMLHtmlElement):
(WebCore::HTMLConstructionSite::insertHTMLHeadElement):
(WebCore::HTMLConstructionSite::insertHTMLBodyElement):
(WebCore::HTMLConstructionSite::insertHTMLFormElement):
(WebCore::HTMLConstructionSite::insertHTMLElement):
(WebCore::HTMLConstructionSite::insertHTMLElementOrFindCustomElementInterface):
(WebCore::HTMLConstructionSite::insertCustomElement):
(WebCore::HTMLConstructionSite::insertSelfClosingHTMLElement):
(WebCore::HTMLConstructionSite::insertFormattingElement):
(WebCore::HTMLConstructionSite::insertScriptElement):
(WebCore::HTMLConstructionSite::insertForeignElement):
(WebCore::HTMLConstructionSite::insertTextNode):
(WebCore::HTMLConstructionSite::reparent):
(WebCore::HTMLConstructionSite::insertAlreadyParsedChild):
(WebCore::HTMLConstructionSite::takeAllChildren):
(WebCore::HTMLConstructionSite::createElement):
(WebCore::HTMLConstructionSite::createHTMLElementOrFindCustomElementInterface):
(WebCore::HTMLConstructionSite::createHTMLElement):
(WebCore::HTMLConstructionSite::createElementFromSavedToken):
(WebCore::HTMLConstructionSite::indexOfFirstUnopenFormattingElement):
(WebCore::HTMLConstructionSite::reconstructTheActiveFormattingElements):
(WebCore::HTMLConstructionSite::findFosterSite):
(WebCore::HTMLConstructionSite::shouldFosterParent):
(WebCore::HTMLConstructionSite::fosterParent):
(WebCore::HTMLConstructionSite::~HTMLConstructionSite): Deleted.
(WebCore::HTMLConstructionSite::setForm): Deleted.
(WebCore::HTMLConstructionSite::setCompatibilityModeFromDoctype): Deleted.
(WebCore::HTMLConstructionSite::ownerDocumentForCurrentNode): Deleted.
(WebCore::HTMLConstructionSite::generateImpliedEndTagsWithExclusion): Deleted.
* html/parser/HTMLConstructionSite.h:
(WebCore::HTMLConstructionSite::inQuirksMode):
(WebCore::HTMLConstructionSite::isTelephoneNumberParsingEnabled):
(WebCore::HTMLConstructionSite::RedirectToFosterParentGuard::RedirectToFosterParentGuard):
* html/parser/HTMLElementStack.cpp:
(WebCore::HTMLNames::isRootNode):
(WebCore::HTMLElementStack::ElementRecord::ElementRecord):
(WebCore::HTMLElementStack::ElementRecord::replaceElement):
(WebCore::HTMLElementStack::ElementRecord::isAbove):
(WebCore::HTMLElementStack::popAll):
(WebCore::HTMLElementStack::popUntil):
(WebCore::HTMLElementStack::popUntilPopped):
(WebCore::HTMLElementStack::pushRootNode):
(WebCore::HTMLElementStack::pushHTMLHtmlElement):
(WebCore::HTMLElementStack::pushRootNodeCommon):
(WebCore::HTMLElementStack::pushHTMLHeadElement):
(WebCore::HTMLElementStack::pushHTMLBodyElement):
(WebCore::HTMLElementStack::push):
(WebCore::HTMLElementStack::insertAbove):
(WebCore::HTMLElementStack::removeHTMLHeadElement):
(WebCore::HTMLElementStack::remove):
(WebCore::HTMLElementStack::contains):
(WebCore::inScopeCommon):
(WebCore::HTMLElementStack::hasNumberedHeaderElementInScope):
(WebCore::HTMLElementStack::inScope):
(WebCore::HTMLElementStack::pushCommon):
(WebCore::HTMLElementStack::popCommon):
(WebCore::HTMLElementStack::removeNonTopCommon):
(WebCore::HTMLElementStack::show):
(WebCore::HTMLElementStack::hasOnlyOneElement): Deleted.
(WebCore::HTMLElementStack::secondElementIsHTMLBodyElement): Deleted.
(WebCore::HTMLElementStack::pop): Deleted.
(WebCore::HTMLElementStack::popUntilTableScopeMarker): Deleted.
(WebCore::HTMLElementStack::oneBelowTop): Deleted.
* html/parser/HTMLElementStack.h:
(WebCore::HTMLElementStack::ElementRecord::stackItem):
(WebCore::HTMLElementStack::ElementRecord::setNext): Deleted.
(WebCore::HTMLElementStack::popUntilPopped): Deleted.
* html/parser/HTMLFormattingElementList.cpp:
(WebCore::HTMLFormattingElementList::contains):
(WebCore::HTMLFormattingElementList::swapTo):
(WebCore::HTMLFormattingElementList::append):
(WebCore::HTMLFormattingElementList::remove):
(WebCore::HTMLFormattingElementList::tryToEnsureNoahsArkConditionQuickly):
(WebCore::HTMLFormattingElementList::ensureNoahsArkCondition):
* html/parser/HTMLFormattingElementList.h:
(WebCore::HTMLFormattingElementList::Entry::Entry):
(WebCore::HTMLFormattingElementList::Entry::replaceElement):
(WebCore::HTMLFormattingElementList::Bookmark::Bookmark):
(WebCore::HTMLFormattingElementList::Bookmark::moveToAfter):
(WebCore::HTMLFormattingElementList::Bookmark::mark):
(WebCore::HTMLFormattingElementList::first):
(WebCore::HTMLFormattingElementList::Entry::isMarker): Deleted.
(WebCore::HTMLFormattingElementList::Entry::stackItem): Deleted.
(WebCore::HTMLFormattingElementList::Entry::operator!=): Deleted.
* html/parser/HTMLTreeBuilder.cpp:
(WebCore::HTMLTreeBuilder::processDoctypeToken):
(WebCore::HTMLTreeBuilder::processCloseWhenNestedTag):
(WebCore::HTMLTreeBuilder::processStartTagForInBody):
(WebCore::HTMLTreeBuilder::insertGenericHTMLElement):
(WebCore::HTMLTreeBuilder::processTemplateStartTag):
(WebCore::HTMLTreeBuilder::processStartTagForInTable):
(WebCore::HTMLTreeBuilder::processStartTag):
(WebCore::HTMLTreeBuilder::processHtmlStartTagForInBody):
(WebCore::HTMLTreeBuilder::processAnyOtherEndTagForInBody):
(WebCore::HTMLTreeBuilder::callTheAdoptionAgency):
(WebCore::HTMLTreeBuilder::processEndTagForInBody):
(WebCore::HTMLTreeBuilder::processComment):
(WebCore::HTMLTreeBuilder::defaultForBeforeHTML):
(WebCore::HTMLTreeBuilder::processStartTagForInHead):
(WebCore::HTMLTreeBuilder::processGenericRCDATAStartTag):
(WebCore::HTMLTreeBuilder::processGenericRawTextStartTag):
(WebCore::HTMLTreeBuilder::processScriptStartTag):
(WebCore::HTMLTreeBuilder::processTokenInForeignContent):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCoredomScriptElementh">trunk/Source/WebCore/dom/ScriptElement.h</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="#trunkSourceWebCorehtmlparserHTMLElementStackcpp">trunk/Source/WebCore/html/parser/HTMLElementStack.cpp</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLElementStackh">trunk/Source/WebCore/html/parser/HTMLElementStack.h</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLFormattingElementListcpp">trunk/Source/WebCore/html/parser/HTMLFormattingElementList.cpp</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLFormattingElementListh">trunk/Source/WebCore/html/parser/HTMLFormattingElementList.h</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLTreeBuildercpp">trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (200339 => 200340)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2016-05-02 21:42:07 UTC (rev 200339)
+++ trunk/Source/WebCore/ChangeLog 2016-05-02 22:18:05 UTC (rev 200340)
</span><span class="lines">@@ -1,3 +1,137 @@
</span><ins>+2016-05-02 Chris Dumez <cdumez@apple.com>
+
+ Modernize HTMLConstructionSite
+ https://bugs.webkit.org/show_bug.cgi?id=157279
+
+ Reviewed by Alex Christensen.
+
+ Modernize HTMLConstructionSite: Use less raw pointers, more auto, more
+ range loops and more nullptr.
+
+ * dom/ScriptElement.h:
+ * html/parser/HTMLConstructionSite.cpp:
+ (WebCore::setAttributes):
+ (WebCore::shouldUseLengthLimit):
+ (WebCore::executeReparentTask):
+ (WebCore::HTMLConstructionSite::attachLater):
+ (WebCore::HTMLConstructionSite::executeQueuedTasks):
+ (WebCore::HTMLConstructionSite::HTMLConstructionSite):
+ (WebCore::HTMLConstructionSite::takeForm):
+ (WebCore::HTMLConstructionSite::dispatchDocumentElementAvailableIfNeeded):
+ (WebCore::HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML):
+ (WebCore::HTMLConstructionSite::mergeAttributesFromTokenIntoElement):
+ (WebCore::HTMLConstructionSite::insertHTMLHtmlStartTagInBody):
+ (WebCore::HTMLConstructionSite::insertHTMLBodyStartTagInBody):
+ (WebCore::HTMLConstructionSite::setDefaultCompatibilityMode):
+ (WebCore::HTMLConstructionSite::setCompatibilityMode):
+ (WebCore::HTMLConstructionSite::finishedParsing):
+ (WebCore::HTMLConstructionSite::insertDoctype):
+ (WebCore::HTMLConstructionSite::insertComment):
+ (WebCore::HTMLConstructionSite::insertCommentOnDocument):
+ (WebCore::HTMLConstructionSite::insertCommentOnHTMLHtmlElement):
+ (WebCore::HTMLConstructionSite::insertHTMLHeadElement):
+ (WebCore::HTMLConstructionSite::insertHTMLBodyElement):
+ (WebCore::HTMLConstructionSite::insertHTMLFormElement):
+ (WebCore::HTMLConstructionSite::insertHTMLElement):
+ (WebCore::HTMLConstructionSite::insertHTMLElementOrFindCustomElementInterface):
+ (WebCore::HTMLConstructionSite::insertCustomElement):
+ (WebCore::HTMLConstructionSite::insertSelfClosingHTMLElement):
+ (WebCore::HTMLConstructionSite::insertFormattingElement):
+ (WebCore::HTMLConstructionSite::insertScriptElement):
+ (WebCore::HTMLConstructionSite::insertForeignElement):
+ (WebCore::HTMLConstructionSite::insertTextNode):
+ (WebCore::HTMLConstructionSite::reparent):
+ (WebCore::HTMLConstructionSite::insertAlreadyParsedChild):
+ (WebCore::HTMLConstructionSite::takeAllChildren):
+ (WebCore::HTMLConstructionSite::createElement):
+ (WebCore::HTMLConstructionSite::createHTMLElementOrFindCustomElementInterface):
+ (WebCore::HTMLConstructionSite::createHTMLElement):
+ (WebCore::HTMLConstructionSite::createElementFromSavedToken):
+ (WebCore::HTMLConstructionSite::indexOfFirstUnopenFormattingElement):
+ (WebCore::HTMLConstructionSite::reconstructTheActiveFormattingElements):
+ (WebCore::HTMLConstructionSite::findFosterSite):
+ (WebCore::HTMLConstructionSite::shouldFosterParent):
+ (WebCore::HTMLConstructionSite::fosterParent):
+ (WebCore::HTMLConstructionSite::~HTMLConstructionSite): Deleted.
+ (WebCore::HTMLConstructionSite::setForm): Deleted.
+ (WebCore::HTMLConstructionSite::setCompatibilityModeFromDoctype): Deleted.
+ (WebCore::HTMLConstructionSite::ownerDocumentForCurrentNode): Deleted.
+ (WebCore::HTMLConstructionSite::generateImpliedEndTagsWithExclusion): Deleted.
+ * html/parser/HTMLConstructionSite.h:
+ (WebCore::HTMLConstructionSite::inQuirksMode):
+ (WebCore::HTMLConstructionSite::isTelephoneNumberParsingEnabled):
+ (WebCore::HTMLConstructionSite::RedirectToFosterParentGuard::RedirectToFosterParentGuard):
+ * html/parser/HTMLElementStack.cpp:
+ (WebCore::HTMLNames::isRootNode):
+ (WebCore::HTMLElementStack::ElementRecord::ElementRecord):
+ (WebCore::HTMLElementStack::ElementRecord::replaceElement):
+ (WebCore::HTMLElementStack::ElementRecord::isAbove):
+ (WebCore::HTMLElementStack::popAll):
+ (WebCore::HTMLElementStack::popUntil):
+ (WebCore::HTMLElementStack::popUntilPopped):
+ (WebCore::HTMLElementStack::pushRootNode):
+ (WebCore::HTMLElementStack::pushHTMLHtmlElement):
+ (WebCore::HTMLElementStack::pushRootNodeCommon):
+ (WebCore::HTMLElementStack::pushHTMLHeadElement):
+ (WebCore::HTMLElementStack::pushHTMLBodyElement):
+ (WebCore::HTMLElementStack::push):
+ (WebCore::HTMLElementStack::insertAbove):
+ (WebCore::HTMLElementStack::removeHTMLHeadElement):
+ (WebCore::HTMLElementStack::remove):
+ (WebCore::HTMLElementStack::contains):
+ (WebCore::inScopeCommon):
+ (WebCore::HTMLElementStack::hasNumberedHeaderElementInScope):
+ (WebCore::HTMLElementStack::inScope):
+ (WebCore::HTMLElementStack::pushCommon):
+ (WebCore::HTMLElementStack::popCommon):
+ (WebCore::HTMLElementStack::removeNonTopCommon):
+ (WebCore::HTMLElementStack::show):
+ (WebCore::HTMLElementStack::hasOnlyOneElement): Deleted.
+ (WebCore::HTMLElementStack::secondElementIsHTMLBodyElement): Deleted.
+ (WebCore::HTMLElementStack::pop): Deleted.
+ (WebCore::HTMLElementStack::popUntilTableScopeMarker): Deleted.
+ (WebCore::HTMLElementStack::oneBelowTop): Deleted.
+ * html/parser/HTMLElementStack.h:
+ (WebCore::HTMLElementStack::ElementRecord::stackItem):
+ (WebCore::HTMLElementStack::ElementRecord::setNext): Deleted.
+ (WebCore::HTMLElementStack::popUntilPopped): Deleted.
+ * html/parser/HTMLFormattingElementList.cpp:
+ (WebCore::HTMLFormattingElementList::contains):
+ (WebCore::HTMLFormattingElementList::swapTo):
+ (WebCore::HTMLFormattingElementList::append):
+ (WebCore::HTMLFormattingElementList::remove):
+ (WebCore::HTMLFormattingElementList::tryToEnsureNoahsArkConditionQuickly):
+ (WebCore::HTMLFormattingElementList::ensureNoahsArkCondition):
+ * html/parser/HTMLFormattingElementList.h:
+ (WebCore::HTMLFormattingElementList::Entry::Entry):
+ (WebCore::HTMLFormattingElementList::Entry::replaceElement):
+ (WebCore::HTMLFormattingElementList::Bookmark::Bookmark):
+ (WebCore::HTMLFormattingElementList::Bookmark::moveToAfter):
+ (WebCore::HTMLFormattingElementList::Bookmark::mark):
+ (WebCore::HTMLFormattingElementList::first):
+ (WebCore::HTMLFormattingElementList::Entry::isMarker): Deleted.
+ (WebCore::HTMLFormattingElementList::Entry::stackItem): Deleted.
+ (WebCore::HTMLFormattingElementList::Entry::operator!=): Deleted.
+ * html/parser/HTMLTreeBuilder.cpp:
+ (WebCore::HTMLTreeBuilder::processDoctypeToken):
+ (WebCore::HTMLTreeBuilder::processCloseWhenNestedTag):
+ (WebCore::HTMLTreeBuilder::processStartTagForInBody):
+ (WebCore::HTMLTreeBuilder::insertGenericHTMLElement):
+ (WebCore::HTMLTreeBuilder::processTemplateStartTag):
+ (WebCore::HTMLTreeBuilder::processStartTagForInTable):
+ (WebCore::HTMLTreeBuilder::processStartTag):
+ (WebCore::HTMLTreeBuilder::processHtmlStartTagForInBody):
+ (WebCore::HTMLTreeBuilder::processAnyOtherEndTagForInBody):
+ (WebCore::HTMLTreeBuilder::callTheAdoptionAgency):
+ (WebCore::HTMLTreeBuilder::processEndTagForInBody):
+ (WebCore::HTMLTreeBuilder::processComment):
+ (WebCore::HTMLTreeBuilder::defaultForBeforeHTML):
+ (WebCore::HTMLTreeBuilder::processStartTagForInHead):
+ (WebCore::HTMLTreeBuilder::processGenericRCDATAStartTag):
+ (WebCore::HTMLTreeBuilder::processGenericRawTextStartTag):
+ (WebCore::HTMLTreeBuilder::processScriptStartTag):
+ (WebCore::HTMLTreeBuilder::processTokenInForeignContent):
+
</ins><span class="cx"> 2016-05-02 Per Arne Vollan <peavo@outlook.com>
</span><span class="cx">
</span><span class="cx"> Remove unneeded casts once we upgrade to a version of Visual Studio that is not broken
</span></span></pre></div>
<a id="trunkSourceWebCoredomScriptElementh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/dom/ScriptElement.h (200339 => 200340)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/dom/ScriptElement.h 2016-05-02 21:42:07 UTC (rev 200339)
+++ trunk/Source/WebCore/dom/ScriptElement.h 2016-05-02 22:18:05 UTC (rev 200340)
</span><span class="lines">@@ -112,6 +112,7 @@
</span><span class="cx"> String m_fallbackCharacterEncoding;
</span><span class="cx"> };
</span><span class="cx">
</span><ins>+// FIXME: replace with downcast<ScriptElement>.
</ins><span class="cx"> ScriptElement* toScriptElementIfPossible(Element*);
</span><span class="cx">
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLConstructionSitecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLConstructionSite.cpp (200339 => 200340)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLConstructionSite.cpp 2016-05-02 21:42:07 UTC (rev 200339)
+++ trunk/Source/WebCore/html/parser/HTMLConstructionSite.cpp 2016-05-02 22:18:05 UTC (rev 200340)
</span><span class="lines">@@ -60,9 +60,9 @@
</span><span class="cx"> element.parserSetAttributes(attributes);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static inline void setAttributes(Element& element, AtomicHTMLToken* token, ParserContentPolicy parserContentPolicy)
</del><ins>+static inline void setAttributes(Element& element, AtomicHTMLToken& token, ParserContentPolicy parserContentPolicy)
</ins><span class="cx"> {
</span><del>- setAttributes(element, token->attributes(), parserContentPolicy);
</del><ins>+ setAttributes(element, token.attributes(), parserContentPolicy);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static bool hasImpliedEndTag(const HTMLStackItem& item)
</span><span class="lines">@@ -79,11 +79,9 @@
</span><span class="cx"> || item.hasTagName(rtcTag);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static bool shouldUseLengthLimit(const ContainerNode* node)
</del><ins>+static bool shouldUseLengthLimit(const ContainerNode& node)
</ins><span class="cx"> {
</span><del>- return !node->hasTagName(scriptTag)
- && !node->hasTagName(styleTag)
- && !node->hasTagName(SVGNames::scriptTag);
</del><ins>+ return !node.hasTagName(scriptTag) && !node.hasTagName(styleTag) && !node.hasTagName(SVGNames::scriptTag);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static inline bool causesFosterParenting(const HTMLStackItem& item)
</span><span class="lines">@@ -130,7 +128,7 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(task.operation == HTMLConstructionSiteTask::Reparent);
</span><span class="cx">
</span><del>- if (ContainerNode* parent = task.child->parentNode())
</del><ins>+ if (auto* parent = task.child->parentNode())
</ins><span class="cx"> parent->parserRemoveChild(*task.child);
</span><span class="cx">
</span><span class="cx"> task.parent->parserAppendChild(*task.child);
</span><span class="lines">@@ -172,79 +170,72 @@
</span><span class="cx"> ASSERT_NOT_REACHED();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::attachLater(ContainerNode* parent, PassRefPtr<Node> prpChild, bool selfClosing)
</del><ins>+void HTMLConstructionSite::attachLater(ContainerNode& parent, Ref<Node>&& child, bool selfClosing)
</ins><span class="cx"> {
</span><del>- ASSERT(scriptingContentIsAllowed(m_parserContentPolicy) || !is<Element>(*prpChild) || !toScriptElementIfPossible(downcast<Element>(prpChild.get())));
- ASSERT(pluginContentIsAllowed(m_parserContentPolicy) || !prpChild->isPluginElement());
</del><ins>+ ASSERT(scriptingContentIsAllowed(m_parserContentPolicy) || !is<Element>(child.get()) || !toScriptElementIfPossible(downcast<Element>(child.ptr())));
+ ASSERT(pluginContentIsAllowed(m_parserContentPolicy) || !child->isPluginElement());
</ins><span class="cx">
</span><del>- HTMLConstructionSiteTask task(HTMLConstructionSiteTask::Insert);
- task.parent = parent;
- task.child = prpChild;
- task.selfClosing = selfClosing;
-
</del><span class="cx"> if (shouldFosterParent()) {
</span><del>- fosterParent(task.child);
</del><ins>+ fosterParent(WTFMove(child));
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ HTMLConstructionSiteTask task(HTMLConstructionSiteTask::Insert);
+ task.parent = &parent;
+ task.child = WTFMove(child);
+ task.selfClosing = selfClosing;
+
</ins><span class="cx"> // Add as a sibling of the parent if we have reached the maximum depth allowed.
</span><span class="cx"> if (m_openElements.stackDepth() > m_maximumDOMTreeDepth && task.parent->parentNode())
</span><span class="cx"> task.parent = task.parent->parentNode();
</span><span class="cx">
</span><span class="cx"> ASSERT(task.parent);
</span><del>- m_taskQueue.append(task);
</del><ins>+ m_taskQueue.append(WTFMove(task));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::executeQueuedTasks()
</span><span class="cx"> {
</span><del>- const size_t size = m_taskQueue.size();
- if (!size)
</del><ins>+ if (m_taskQueue.isEmpty())
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> // Copy the task queue into a local variable in case executeTask
</span><span class="cx"> // re-enters the parser.
</span><span class="cx"> TaskQueue queue = WTFMove(m_taskQueue);
</span><span class="cx">
</span><del>- for (size_t i = 0; i < size; ++i)
- executeTask(queue[i]);
</del><ins>+ for (auto& task : queue)
+ executeTask(task);
</ins><span class="cx">
</span><span class="cx"> // We might be detached now.
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> HTMLConstructionSite::HTMLConstructionSite(Document& document, ParserContentPolicy parserContentPolicy, unsigned maximumDOMTreeDepth)
</span><del>- : m_document(&document)
- , m_attachmentRoot(&document)
</del><ins>+ : m_document(document)
+ , m_attachmentRoot(document)
</ins><span class="cx"> , m_parserContentPolicy(parserContentPolicy)
</span><span class="cx"> , m_isParsingFragment(false)
</span><span class="cx"> , m_redirectAttachToFosterParent(false)
</span><span class="cx"> , m_maximumDOMTreeDepth(maximumDOMTreeDepth)
</span><span class="cx"> , m_inQuirksMode(document.inQuirksMode())
</span><span class="cx"> {
</span><del>- ASSERT(m_document->isHTMLDocument() || m_document->isXHTMLDocument());
</del><ins>+ ASSERT(m_document.isHTMLDocument() || m_document.isXHTMLDocument());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> HTMLConstructionSite::HTMLConstructionSite(DocumentFragment& fragment, ParserContentPolicy parserContentPolicy, unsigned maximumDOMTreeDepth)
</span><del>- : m_document(&fragment.document())
- , m_attachmentRoot(&fragment)
</del><ins>+ : m_document(fragment.document())
+ , m_attachmentRoot(fragment)
</ins><span class="cx"> , m_parserContentPolicy(parserContentPolicy)
</span><span class="cx"> , m_isParsingFragment(true)
</span><span class="cx"> , m_redirectAttachToFosterParent(false)
</span><span class="cx"> , m_maximumDOMTreeDepth(maximumDOMTreeDepth)
</span><span class="cx"> , m_inQuirksMode(fragment.document().inQuirksMode())
</span><span class="cx"> {
</span><del>- ASSERT(m_document->isHTMLDocument() || m_document->isXHTMLDocument());
</del><ins>+ ASSERT(m_document.isHTMLDocument() || m_document.isXHTMLDocument());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> HTMLConstructionSite::~HTMLConstructionSite()
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::detach()
-{
- m_document = 0;
- m_attachmentRoot = 0;
-}
-
</del><span class="cx"> void HTMLConstructionSite::setForm(HTMLFormElement* form)
</span><span class="cx"> {
</span><span class="cx"> // This method should only be needed for HTMLTreeBuilder in the fragment case.
</span><span class="lines">@@ -252,61 +243,63 @@
</span><span class="cx"> m_form = form;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<HTMLFormElement> HTMLConstructionSite::takeForm()
</del><ins>+RefPtr<HTMLFormElement> HTMLConstructionSite::takeForm()
</ins><span class="cx"> {
</span><del>- return m_form.release();
</del><ins>+ return WTFMove(m_form);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::dispatchDocumentElementAvailableIfNeeded()
</span><span class="cx"> {
</span><del>- ASSERT(m_document);
- if (m_document->frame() && !m_isParsingFragment)
- m_document->frame()->injectUserScripts(InjectAtDocumentStart);
</del><ins>+ if (m_isParsingFragment)
+ return;
+
+ if (auto* frame = m_document.frame())
+ frame->injectUserScripts(InjectAtDocumentStart);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertHTMLHtmlStartTagBeforeHTML(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- Ref<HTMLHtmlElement> element = HTMLHtmlElement::create(*m_document);
- setAttributes(element.get(), token, m_parserContentPolicy);
- attachLater(m_attachmentRoot, element.ptr());
- m_openElements.pushHTMLHtmlElement(HTMLStackItem::create(element.copyRef(), *token));
</del><ins>+ auto element = HTMLHtmlElement::create(m_document);
+ setAttributes(element, token, m_parserContentPolicy);
+ attachLater(m_attachmentRoot, element.copyRef());
+ m_openElements.pushHTMLHtmlElement(HTMLStackItem::create(element.copyRef(), token));
</ins><span class="cx">
</span><span class="cx"> executeQueuedTasks();
</span><span class="cx"> element->insertedByParser();
</span><span class="cx"> dispatchDocumentElementAvailableIfNeeded();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::mergeAttributesFromTokenIntoElement(AtomicHTMLToken* token, Element* element)
</del><ins>+void HTMLConstructionSite::mergeAttributesFromTokenIntoElement(AtomicHTMLToken& token, Element& element)
</ins><span class="cx"> {
</span><del>- if (token->attributes().isEmpty())
</del><ins>+ if (token.attributes().isEmpty())
</ins><span class="cx"> return;
</span><span class="cx">
</span><del>- for (auto& tokenAttribute : token->attributes()) {
- if (!element->elementData() || !element->findAttributeByName(tokenAttribute.name()))
- element->setAttribute(tokenAttribute.name(), tokenAttribute.value());
</del><ins>+ for (auto& tokenAttribute : token.attributes()) {
+ if (!element.elementData() || !element.findAttributeByName(tokenAttribute.name()))
+ element.setAttribute(tokenAttribute.name(), tokenAttribute.value());
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertHTMLHtmlStartTagInBody(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertHTMLHtmlStartTagInBody(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> // Fragments do not have a root HTML element, so any additional HTML elements
</span><span class="cx"> // encountered during fragment parsing should be ignored.
</span><span class="cx"> if (m_isParsingFragment)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- mergeAttributesFromTokenIntoElement(token, &m_openElements.htmlElement());
</del><ins>+ mergeAttributesFromTokenIntoElement(token, m_openElements.htmlElement());
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertHTMLBodyStartTagInBody(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertHTMLBodyStartTagInBody(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- mergeAttributesFromTokenIntoElement(token, &m_openElements.bodyElement());
</del><ins>+ mergeAttributesFromTokenIntoElement(token, m_openElements.bodyElement());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::setDefaultCompatibilityMode()
</span><span class="cx"> {
</span><span class="cx"> if (m_isParsingFragment)
</span><span class="cx"> return;
</span><del>- if (m_document->isSrcdocDocument())
</del><ins>+ if (m_document.isSrcdocDocument())
</ins><span class="cx"> return;
</span><span class="cx"> setCompatibilityMode(DocumentCompatibilityMode::QuirksMode);
</span><span class="cx"> }
</span><span class="lines">@@ -314,7 +307,7 @@
</span><span class="cx"> void HTMLConstructionSite::setCompatibilityMode(DocumentCompatibilityMode mode)
</span><span class="cx"> {
</span><span class="cx"> m_inQuirksMode = (mode == DocumentCompatibilityMode::QuirksMode);
</span><del>- m_document->setCompatibilityMode(mode);
</del><ins>+ m_document.setCompatibilityMode(mode);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::setCompatibilityModeFromDoctype(const String& name, const String& publicId, const String& systemId)
</span><span class="lines">@@ -407,18 +400,17 @@
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::finishedParsing()
</span><span class="cx"> {
</span><del>- m_document->finishedParsing();
</del><ins>+ m_document.finishedParsing();
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertDoctype(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertDoctype(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::DOCTYPE);
</del><ins>+ ASSERT(token.type() == HTMLToken::DOCTYPE);
</ins><span class="cx">
</span><del>- String publicId = token->publicIdentifier();
- String systemId = token->systemIdentifier();
</del><ins>+ String publicId = token.publicIdentifier();
+ String systemId = token.systemIdentifier();
</ins><span class="cx">
</span><del>- RefPtr<DocumentType> doctype = DocumentType::create(*m_document, token->name(), publicId, systemId);
- attachLater(m_attachmentRoot, doctype.release());
</del><ins>+ attachLater(m_attachmentRoot, DocumentType::create(m_document, token.name(), publicId, systemId));
</ins><span class="cx">
</span><span class="cx"> // DOCTYPE nodes are only processed when parsing fragments w/o contextElements, which
</span><span class="cx"> // never occurs. However, if we ever chose to support such, this code is subtly wrong,
</span><span class="lines">@@ -429,106 +421,107 @@
</span><span class="cx"> if (m_isParsingFragment)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- if (token->forceQuirks())
</del><ins>+ if (token.forceQuirks())
</ins><span class="cx"> setCompatibilityMode(DocumentCompatibilityMode::QuirksMode);
</span><span class="cx"> else
</span><del>- setCompatibilityModeFromDoctype(token->name(), publicId, systemId);
</del><ins>+ setCompatibilityModeFromDoctype(token.name(), publicId, systemId);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertComment(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertComment(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::Comment);
- attachLater(&currentNode(), Comment::create(ownerDocumentForCurrentNode(), token->comment()));
</del><ins>+ ASSERT(token.type() == HTMLToken::Comment);
+ attachLater(currentNode(), Comment::create(ownerDocumentForCurrentNode(), token.comment()));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertCommentOnDocument(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertCommentOnDocument(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::Comment);
- attachLater(m_attachmentRoot, Comment::create(*m_document, token->comment()));
</del><ins>+ ASSERT(token.type() == HTMLToken::Comment);
+ attachLater(m_attachmentRoot, Comment::create(m_document, token.comment()));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertCommentOnHTMLHtmlElement(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertCommentOnHTMLHtmlElement(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::Comment);
</del><ins>+ ASSERT(token.type() == HTMLToken::Comment);
</ins><span class="cx"> ContainerNode& parent = m_openElements.rootNode();
</span><del>- attachLater(&parent, Comment::create(parent.document(), token->comment()));
</del><ins>+ attachLater(parent, Comment::create(parent.document(), token.comment()));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertHTMLHeadElement(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertHTMLHeadElement(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!shouldFosterParent());
</span><del>- m_head = HTMLStackItem::create(createHTMLElement(token), *token);
- attachLater(&currentNode(), &m_head->element());
- m_openElements.pushHTMLHeadElement(m_head);
</del><ins>+ m_head = HTMLStackItem::create(createHTMLElement(token), token);
+ attachLater(currentNode(), m_head->element());
+ m_openElements.pushHTMLHeadElement(*m_head);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertHTMLBodyElement(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertHTMLBodyElement(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!shouldFosterParent());
</span><del>- RefPtr<Element> body = createHTMLElement(token);
- attachLater(&currentNode(), body.get());
- m_openElements.pushHTMLBodyElement(HTMLStackItem::create(body.releaseNonNull(), *token));
</del><ins>+ auto body = createHTMLElement(token);
+ attachLater(currentNode(), body.copyRef());
+ m_openElements.pushHTMLBodyElement(HTMLStackItem::create(WTFMove(body), token));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertHTMLFormElement(AtomicHTMLToken* token, bool isDemoted)
</del><ins>+void HTMLConstructionSite::insertHTMLFormElement(AtomicHTMLToken& token, bool isDemoted)
</ins><span class="cx"> {
</span><del>- RefPtr<Element> element = createHTMLElement(token);
- ASSERT(is<HTMLFormElement>(*element));
- m_form = static_pointer_cast<HTMLFormElement>(element.release());
</del><ins>+ auto element = createHTMLElement(token);
+ m_form = &downcast<HTMLFormElement>(element.get());
</ins><span class="cx"> m_form->setDemoted(isDemoted);
</span><del>- attachLater(&currentNode(), m_form);
- m_openElements.push(HTMLStackItem::create(*m_form, *token));
</del><ins>+ attachLater(currentNode(), *m_form);
+ m_openElements.push(HTMLStackItem::create(*m_form, token));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertHTMLElement(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertHTMLElement(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- RefPtr<Element> element = createHTMLElement(token);
- attachLater(&currentNode(), element);
- m_openElements.push(HTMLStackItem::create(element.releaseNonNull(), *token));
</del><ins>+ auto element = createHTMLElement(token);
+ attachLater(currentNode(), element.copyRef());
+ m_openElements.push(HTMLStackItem::create(WTFMove(element), token));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if ENABLE(CUSTOM_ELEMENTS)
</span><del>-JSCustomElementInterface* HTMLConstructionSite::insertHTMLElementOrFindCustomElementInterface(AtomicHTMLToken* token)
</del><ins>+
+JSCustomElementInterface* HTMLConstructionSite::insertHTMLElementOrFindCustomElementInterface(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> JSCustomElementInterface* interface = nullptr;
</span><span class="cx"> RefPtr<Element> element = createHTMLElementOrFindCustomElementInterface(token, &interface);
</span><span class="cx"> if (UNLIKELY(interface))
</span><span class="cx"> return interface;
</span><del>- attachLater(&currentNode(), element);
- m_openElements.push(HTMLStackItem::create(element.releaseNonNull(), *token));
</del><ins>+ attachLater(currentNode(), *element);
+ m_openElements.push(HTMLStackItem::create(element.releaseNonNull(), token));
</ins><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::insertCustomElement(Ref<Element>&& element, const AtomicString& localName, Vector<Attribute>& attributes)
</span><span class="cx"> {
</span><del>- setAttributes(element.get(), attributes, m_parserContentPolicy);
- attachLater(&currentNode(), element.ptr());
</del><ins>+ setAttributes(element, attributes, m_parserContentPolicy);
+ attachLater(currentNode(), element.copyRef());
</ins><span class="cx"> m_openElements.push(HTMLStackItem::create(WTFMove(element), localName, attributes));
</span><span class="cx"> }
</span><ins>+
</ins><span class="cx"> #endif
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertSelfClosingHTMLElement(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertSelfClosingHTMLElement(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::StartTag);
</del><ins>+ ASSERT(token.type() == HTMLToken::StartTag);
</ins><span class="cx"> // Normally HTMLElementStack is responsible for calling finishParsingChildren,
</span><span class="cx"> // but self-closing elements are never in the element stack so the stack
</span><span class="cx"> // doesn't get a chance to tell them that we're done parsing their children.
</span><del>- attachLater(&currentNode(), createHTMLElement(token), true);
</del><ins>+ attachLater(currentNode(), createHTMLElement(token), true);
</ins><span class="cx"> // FIXME: Do we want to acknowledge the token's self-closing flag?
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#acknowledge-self-closing-flag
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertFormattingElement(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertFormattingElement(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#the-stack-of-open-elements
</span><span class="cx"> // Possible active formatting elements include:
</span><span class="cx"> // a, b, big, code, em, font, i, nobr, s, small, strike, strong, tt, and u.
</span><del>- ASSERT(isFormattingTag(token->name()));
</del><ins>+ ASSERT(isFormattingTag(token.name()));
</ins><span class="cx"> insertHTMLElement(token);
</span><del>- m_activeFormattingElements.append(&currentStackItem());
</del><ins>+ m_activeFormattingElements.append(currentStackItem());
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertScriptElement(AtomicHTMLToken* token)
</del><ins>+void HTMLConstructionSite::insertScriptElement(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/multipage/scripting-1.html#already-started
</span><span class="cx"> // http://html5.org/specs/dom-parsing.html#dom-range-createcontextualfragment
</span><span class="lines">@@ -537,23 +530,23 @@
</span><span class="cx"> // those flags or effects thereof.
</span><span class="cx"> const bool parserInserted = m_parserContentPolicy != AllowScriptingContentAndDoNotMarkAlreadyStarted;
</span><span class="cx"> const bool alreadyStarted = m_isParsingFragment && parserInserted;
</span><del>- Ref<HTMLScriptElement> element = HTMLScriptElement::create(scriptTag, ownerDocumentForCurrentNode(), parserInserted, alreadyStarted);
- setAttributes(element.get(), token, m_parserContentPolicy);
</del><ins>+ auto element = HTMLScriptElement::create(scriptTag, ownerDocumentForCurrentNode(), parserInserted, alreadyStarted);
+ setAttributes(element, token, m_parserContentPolicy);
</ins><span class="cx"> if (scriptingContentIsAllowed(m_parserContentPolicy))
</span><del>- attachLater(&currentNode(), element.ptr());
- m_openElements.push(HTMLStackItem::create(WTFMove(element), *token));
</del><ins>+ attachLater(currentNode(), element.copyRef());
+ m_openElements.push(HTMLStackItem::create(WTFMove(element), token));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::insertForeignElement(AtomicHTMLToken* token, const AtomicString& namespaceURI)
</del><ins>+void HTMLConstructionSite::insertForeignElement(AtomicHTMLToken& token, const AtomicString& namespaceURI)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::StartTag);
</del><ins>+ ASSERT(token.type() == HTMLToken::StartTag);
</ins><span class="cx"> notImplemented(); // parseError when xmlns or xmlns:xlink are wrong.
</span><span class="cx">
</span><del>- RefPtr<Element> element = createElement(token, namespaceURI);
- if (scriptingContentIsAllowed(m_parserContentPolicy) || !toScriptElementIfPossible(element.get()))
- attachLater(&currentNode(), element, token->selfClosing());
- if (!token->selfClosing())
- m_openElements.push(HTMLStackItem::create(element.releaseNonNull(), *token, namespaceURI));
</del><ins>+ auto element = createElement(token, namespaceURI);
+ if (scriptingContentIsAllowed(m_parserContentPolicy) || !toScriptElementIfPossible(element.ptr()))
+ attachLater(currentNode(), element.copyRef(), token.selfClosing());
+ if (!token.selfClosing())
+ m_openElements.push(HTMLStackItem::create(WTFMove(element), token, namespaceURI));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::insertTextNode(const String& characters, WhitespaceMode whitespaceMode)
</span><span class="lines">@@ -569,11 +562,10 @@
</span><span class="cx">
</span><span class="cx"> // Strings composed entirely of whitespace are likely to be repeated.
</span><span class="cx"> // Turn them into AtomicString so we share a single string for each.
</span><del>- bool shouldUseAtomicString = whitespaceMode == AllWhitespace
- || (whitespaceMode == WhitespaceUnknown && isAllWhitespace(characters));
</del><ins>+ bool shouldUseAtomicString = whitespaceMode == AllWhitespace || (whitespaceMode == WhitespaceUnknown && isAllWhitespace(characters));
</ins><span class="cx">
</span><span class="cx"> unsigned currentPosition = 0;
</span><del>- unsigned lengthLimit = shouldUseLengthLimit(task.parent.get()) ? Text::defaultLengthLimit : std::numeric_limits<unsigned>::max();
</del><ins>+ unsigned lengthLimit = shouldUseLengthLimit(*task.parent) ? Text::defaultLengthLimit : std::numeric_limits<unsigned>::max();
</ins><span class="cx">
</span><span class="cx"> // FIXME: Splitting text nodes into smaller chunks contradicts HTML5 spec, but is currently necessary
</span><span class="cx"> // for performance, see <https://bugs.webkit.org/show_bug.cgi?id=55898>.
</span><span class="lines">@@ -582,12 +574,11 @@
</span><span class="cx"> if (is<Text>(previousChild)) {
</span><span class="cx"> // FIXME: We're only supposed to append to this text node if it
</span><span class="cx"> // was the last text node inserted by the parser.
</span><del>- Text& textNode = downcast<Text>(*previousChild);
- currentPosition = textNode.parserAppendData(characters, 0, lengthLimit);
</del><ins>+ currentPosition = downcast<Text>(*previousChild).parserAppendData(characters, 0, lengthLimit);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> while (currentPosition < characters.length()) {
</span><del>- Ref<Text> textNode = Text::createWithLengthLimit(task.parent->document(), shouldUseAtomicString ? AtomicString(characters).string() : characters, currentPosition, lengthLimit);
</del><ins>+ auto textNode = Text::createWithLengthLimit(task.parent->document(), shouldUseAtomicString ? AtomicString(characters).string() : characters, currentPosition, lengthLimit);
</ins><span class="cx"> // If we have a whole string of unbreakable characters the above could lead to an infinite loop. Exceeding the length limit is the lesser evil.
</span><span class="cx"> if (!textNode->length()) {
</span><span class="cx"> String substring = characters.substring(currentPosition);
</span><span class="lines">@@ -607,7 +598,7 @@
</span><span class="cx"> HTMLConstructionSiteTask task(HTMLConstructionSiteTask::Reparent);
</span><span class="cx"> task.parent = &newParent.node();
</span><span class="cx"> task.child = &child.element();
</span><del>- m_taskQueue.append(task);
</del><ins>+ m_taskQueue.append(WTFMove(task));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::reparent(HTMLElementStack::ElementRecord& newParent, HTMLStackItem& child)
</span><span class="lines">@@ -615,20 +606,20 @@
</span><span class="cx"> HTMLConstructionSiteTask task(HTMLConstructionSiteTask::Reparent);
</span><span class="cx"> task.parent = &newParent.node();
</span><span class="cx"> task.child = &child.element();
</span><del>- m_taskQueue.append(task);
</del><ins>+ m_taskQueue.append(WTFMove(task));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::insertAlreadyParsedChild(HTMLStackItem& newParent, HTMLElementStack::ElementRecord& child)
</span><span class="cx"> {
</span><span class="cx"> if (causesFosterParenting(newParent)) {
</span><del>- fosterParent(&child.element());
</del><ins>+ fosterParent(child.element());
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> HTMLConstructionSiteTask task(HTMLConstructionSiteTask::InsertAlreadyParsedChild);
</span><span class="cx"> task.parent = &newParent.node();
</span><span class="cx"> task.child = &child.element();
</span><del>- m_taskQueue.append(task);
</del><ins>+ m_taskQueue.append(WTFMove(task));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::takeAllChildren(HTMLStackItem& newParent, HTMLElementStack::ElementRecord& oldParent)
</span><span class="lines">@@ -636,14 +627,14 @@
</span><span class="cx"> HTMLConstructionSiteTask task(HTMLConstructionSiteTask::TakeAllChildren);
</span><span class="cx"> task.parent = &newParent.node();
</span><span class="cx"> task.child = &oldParent.node();
</span><del>- m_taskQueue.append(task);
</del><ins>+ m_taskQueue.append(WTFMove(task));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-Ref<Element> HTMLConstructionSite::createElement(AtomicHTMLToken* token, const AtomicString& namespaceURI)
</del><ins>+Ref<Element> HTMLConstructionSite::createElement(AtomicHTMLToken& token, const AtomicString& namespaceURI)
</ins><span class="cx"> {
</span><del>- QualifiedName tagName(nullAtom, token->name(), namespaceURI);
- Ref<Element> element = ownerDocumentForCurrentNode().createElement(tagName, true);
- setAttributes(element.get(), token, m_parserContentPolicy);
</del><ins>+ QualifiedName tagName(nullAtom, token.name(), namespaceURI);
+ auto element = ownerDocumentForCurrentNode().createElement(tagName, true);
+ setAttributes(element, token, m_parserContentPolicy);
</ins><span class="cx"> return element;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -655,9 +646,9 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RefPtr<Element> HTMLConstructionSite::createHTMLElementOrFindCustomElementInterface(
</span><del>- AtomicHTMLToken* token, JSCustomElementInterface** customElementInterface)
</del><ins>+ AtomicHTMLToken& token, JSCustomElementInterface** customElementInterface)
</ins><span class="cx"> {
</span><del>- auto& localName = token->name();
</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="lines">@@ -703,53 +694,53 @@
</span><span class="cx"> return element;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-Ref<Element> HTMLConstructionSite::createHTMLElement(AtomicHTMLToken* token)
</del><ins>+Ref<Element> HTMLConstructionSite::createHTMLElement(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<Element> element = createHTMLElementOrFindCustomElementInterface(token, nullptr);
</span><span class="cx"> ASSERT(element);
</span><span class="cx"> return element.releaseNonNull();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-Ref<HTMLStackItem> HTMLConstructionSite::createElementFromSavedToken(HTMLStackItem* item)
</del><ins>+Ref<HTMLStackItem> HTMLConstructionSite::createElementFromSavedToken(HTMLStackItem& item)
</ins><span class="cx"> {
</span><span class="cx"> // NOTE: Moving from item -> token -> item copies the Attribute vector twice!
</span><del>- AtomicHTMLToken fakeToken(HTMLToken::StartTag, item->localName(), Vector<Attribute>(item->attributes()));
- ASSERT(item->namespaceURI() == HTMLNames::xhtmlNamespaceURI);
- ASSERT(isFormattingTag(item->localName()));
- return HTMLStackItem::create(createHTMLElement(&fakeToken), fakeToken, item->namespaceURI());
</del><ins>+ AtomicHTMLToken fakeToken(HTMLToken::StartTag, item.localName(), Vector<Attribute>(item.attributes()));
+ ASSERT(item.namespaceURI() == HTMLNames::xhtmlNamespaceURI);
+ ASSERT(isFormattingTag(item.localName()));
+ return HTMLStackItem::create(createHTMLElement(fakeToken), fakeToken, item.namespaceURI());
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool HTMLConstructionSite::indexOfFirstUnopenFormattingElement(unsigned& firstUnopenElementIndex) const
</del><ins>+Optional<unsigned> HTMLConstructionSite::indexOfFirstUnopenFormattingElement() const
</ins><span class="cx"> {
</span><span class="cx"> if (m_activeFormattingElements.isEmpty())
</span><del>- return false;
</del><ins>+ return Nullopt;
</ins><span class="cx"> unsigned index = m_activeFormattingElements.size();
</span><span class="cx"> do {
</span><span class="cx"> --index;
</span><del>- const HTMLFormattingElementList::Entry& entry = m_activeFormattingElements.at(index);
- if (entry.isMarker() || m_openElements.contains(&entry.element())) {
- firstUnopenElementIndex = index + 1;
- return firstUnopenElementIndex < m_activeFormattingElements.size();
</del><ins>+ const auto& entry = m_activeFormattingElements.at(index);
+ if (entry.isMarker() || m_openElements.contains(entry.element())) {
+ unsigned firstUnopenElementIndex = index + 1;
+ return firstUnopenElementIndex < m_activeFormattingElements.size() ? firstUnopenElementIndex : Optional<unsigned>(Nullopt);
</ins><span class="cx"> }
</span><span class="cx"> } while (index);
</span><del>- firstUnopenElementIndex = index;
- return true;
</del><ins>+
+ return index;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLConstructionSite::reconstructTheActiveFormattingElements()
</span><span class="cx"> {
</span><del>- unsigned firstUnopenElementIndex;
- if (!indexOfFirstUnopenFormattingElement(firstUnopenElementIndex))
</del><ins>+ Optional<unsigned> firstUnopenElementIndex = indexOfFirstUnopenFormattingElement();
+ if (!firstUnopenElementIndex)
</ins><span class="cx"> return;
</span><span class="cx">
</span><del>- unsigned unopenEntryIndex = firstUnopenElementIndex;
- ASSERT(unopenEntryIndex < m_activeFormattingElements.size());
- for (; unopenEntryIndex < m_activeFormattingElements.size(); ++unopenEntryIndex) {
- HTMLFormattingElementList::Entry& unopenedEntry = m_activeFormattingElements.at(unopenEntryIndex);
- RefPtr<HTMLStackItem> reconstructed = createElementFromSavedToken(unopenedEntry.stackItem());
- attachLater(&currentNode(), &reconstructed->node());
- m_openElements.push(reconstructed);
- unopenedEntry.replaceElement(reconstructed.release());
</del><ins>+ ASSERT(firstUnopenElementIndex.value() < m_activeFormattingElements.size());
+ for (unsigned unopenEntryIndex = firstUnopenElementIndex.value(); unopenEntryIndex < m_activeFormattingElements.size(); ++unopenEntryIndex) {
+ auto& unopenedEntry = m_activeFormattingElements.at(unopenEntryIndex);
+ ASSERT(unopenedEntry.stackItem());
+ auto reconstructed = createElementFromSavedToken(*unopenedEntry.stackItem());
+ attachLater(currentNode(), reconstructed->node());
+ m_openElements.push(reconstructed.copyRef());
+ unopenedEntry.replaceElement(WTFMove(reconstructed));
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -765,24 +756,18 @@
</span><span class="cx"> m_openElements.pop();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool HTMLConstructionSite::inQuirksMode()
-{
- return m_inQuirksMode;
-}
-
</del><span class="cx"> void HTMLConstructionSite::findFosterSite(HTMLConstructionSiteTask& task)
</span><span class="cx"> {
</span><span class="cx"> // When a node is to be foster parented, the last template element with no table element is below it in the stack of open elements is the foster parent element (NOT the template's parent!)
</span><del>- HTMLElementStack::ElementRecord* lastTemplateElement = m_openElements.topmost(templateTag.localName());
</del><ins>+ auto* lastTemplateElement = m_openElements.topmost(templateTag.localName());
</ins><span class="cx"> if (lastTemplateElement && !m_openElements.inTableScope(tableTag)) {
</span><span class="cx"> task.parent = &lastTemplateElement->element();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- HTMLElementStack::ElementRecord* lastTableElementRecord = m_openElements.topmost(tableTag.localName());
- if (lastTableElementRecord) {
- Element& lastTableElement = lastTableElementRecord->element();
- ContainerNode* parent = lastTableElement.parentNode();
</del><ins>+ if (auto* lastTableElementRecord = m_openElements.topmost(tableTag.localName())) {
+ auto& lastTableElement = lastTableElementRecord->element();
+ auto* parent = lastTableElement.parentNode();
</ins><span class="cx"> // When parsing HTML fragments, we skip step 4.2 ("Let root be a new html element with no attributes") for efficiency,
</span><span class="cx"> // and instead use the DocumentFragment as a root node. So we must treat the root node (DocumentFragment) as if it is a html element here.
</span><span class="cx"> bool parentCanBeFosterParent = parent && (parent->isElementNode() || (m_isParsingFragment && parent == &m_openElements.rootNode()));
</span><span class="lines">@@ -801,18 +786,17 @@
</span><span class="cx">
</span><span class="cx"> bool HTMLConstructionSite::shouldFosterParent() const
</span><span class="cx"> {
</span><del>- return m_redirectAttachToFosterParent
- && causesFosterParenting(currentStackItem());
</del><ins>+ return m_redirectAttachToFosterParent && causesFosterParenting(currentStackItem());
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLConstructionSite::fosterParent(PassRefPtr<Node> node)
</del><ins>+void HTMLConstructionSite::fosterParent(Ref<Node>&& node)
</ins><span class="cx"> {
</span><span class="cx"> HTMLConstructionSiteTask task(HTMLConstructionSiteTask::Insert);
</span><span class="cx"> findFosterSite(task);
</span><del>- task.child = node;
</del><ins>+ task.child = WTFMove(node);
</ins><span class="cx"> ASSERT(task.parent);
</span><span class="cx">
</span><del>- m_taskQueue.append(task);
</del><ins>+ m_taskQueue.append(WTFMove(task));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLConstructionSiteh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLConstructionSite.h (200339 => 200340)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLConstructionSite.h 2016-05-02 21:42:07 UTC (rev 200339)
+++ trunk/Source/WebCore/html/parser/HTMLConstructionSite.h 2016-05-02 22:18:05 UTC (rev 200340)
</span><span class="lines">@@ -31,8 +31,8 @@
</span><span class="cx"> #include "HTMLElementStack.h"
</span><span class="cx"> #include "HTMLFormattingElementList.h"
</span><span class="cx"> #include <wtf/Noncopyable.h>
</span><del>-#include <wtf/PassRefPtr.h>
</del><span class="cx"> #include <wtf/RefPtr.h>
</span><ins>+#include <wtf/TemporaryChange.h>
</ins><span class="cx"> #include <wtf/Vector.h>
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="lines">@@ -93,33 +93,32 @@
</span><span class="cx"> HTMLConstructionSite(DocumentFragment&, ParserContentPolicy, unsigned maximumDOMTreeDepth);
</span><span class="cx"> ~HTMLConstructionSite();
</span><span class="cx">
</span><del>- void detach();
</del><span class="cx"> void executeQueuedTasks();
</span><span class="cx">
</span><span class="cx"> void setDefaultCompatibilityMode();
</span><span class="cx"> void finishedParsing();
</span><span class="cx">
</span><del>- void insertDoctype(AtomicHTMLToken*);
- void insertComment(AtomicHTMLToken*);
- void insertCommentOnDocument(AtomicHTMLToken*);
- void insertCommentOnHTMLHtmlElement(AtomicHTMLToken*);
- void insertHTMLElement(AtomicHTMLToken*);
</del><ins>+ void insertDoctype(AtomicHTMLToken&);
+ void insertComment(AtomicHTMLToken&);
+ void insertCommentOnDocument(AtomicHTMLToken&);
+ void insertCommentOnHTMLHtmlElement(AtomicHTMLToken&);
+ void insertHTMLElement(AtomicHTMLToken&);
</ins><span class="cx"> #if ENABLE(CUSTOM_ELEMENTS)
</span><del>- JSCustomElementInterface* insertHTMLElementOrFindCustomElementInterface(AtomicHTMLToken*);
</del><ins>+ JSCustomElementInterface* insertHTMLElementOrFindCustomElementInterface(AtomicHTMLToken&);
</ins><span class="cx"> void insertCustomElement(Ref<Element>&&, const AtomicString& localName, Vector<Attribute>&);
</span><span class="cx"> #endif
</span><del>- void insertSelfClosingHTMLElement(AtomicHTMLToken*);
- void insertFormattingElement(AtomicHTMLToken*);
- void insertHTMLHeadElement(AtomicHTMLToken*);
- void insertHTMLBodyElement(AtomicHTMLToken*);
- void insertHTMLFormElement(AtomicHTMLToken*, bool isDemoted = false);
- void insertScriptElement(AtomicHTMLToken*);
</del><ins>+ void insertSelfClosingHTMLElement(AtomicHTMLToken&);
+ void insertFormattingElement(AtomicHTMLToken&);
+ void insertHTMLHeadElement(AtomicHTMLToken&);
+ void insertHTMLBodyElement(AtomicHTMLToken&);
+ void insertHTMLFormElement(AtomicHTMLToken&, bool isDemoted = false);
+ void insertScriptElement(AtomicHTMLToken&);
</ins><span class="cx"> void insertTextNode(const String&, WhitespaceMode = WhitespaceUnknown);
</span><del>- void insertForeignElement(AtomicHTMLToken*, const AtomicString& namespaceURI);
</del><ins>+ void insertForeignElement(AtomicHTMLToken&, const AtomicString& namespaceURI);
</ins><span class="cx">
</span><del>- void insertHTMLHtmlStartTagBeforeHTML(AtomicHTMLToken*);
- void insertHTMLHtmlStartTagInBody(AtomicHTMLToken*);
- void insertHTMLBodyStartTagInBody(AtomicHTMLToken*);
</del><ins>+ void insertHTMLHtmlStartTagBeforeHTML(AtomicHTMLToken&);
+ void insertHTMLHtmlStartTagInBody(AtomicHTMLToken&);
+ void insertHTMLBodyStartTagInBody(AtomicHTMLToken&);
</ins><span class="cx">
</span><span class="cx"> void reparent(HTMLElementStack::ElementRecord& newParent, HTMLElementStack::ElementRecord& child);
</span><span class="cx"> void reparent(HTMLElementStack::ElementRecord& newParent, HTMLStackItem& child);
</span><span class="lines">@@ -129,18 +128,18 @@
</span><span class="cx"> void insertAlreadyParsedChild(HTMLStackItem& newParent, HTMLElementStack::ElementRecord& child);
</span><span class="cx"> void takeAllChildren(HTMLStackItem& newParent, HTMLElementStack::ElementRecord& oldParent);
</span><span class="cx">
</span><del>- Ref<HTMLStackItem> createElementFromSavedToken(HTMLStackItem*);
</del><ins>+ Ref<HTMLStackItem> createElementFromSavedToken(HTMLStackItem&);
</ins><span class="cx">
</span><span class="cx"> bool shouldFosterParent() const;
</span><del>- void fosterParent(PassRefPtr<Node>);
</del><ins>+ void fosterParent(Ref<Node>&&);
</ins><span class="cx">
</span><del>- bool indexOfFirstUnopenFormattingElement(unsigned& firstUnopenElementIndex) const;
</del><ins>+ Optional<unsigned> indexOfFirstUnopenFormattingElement() const;
</ins><span class="cx"> void reconstructTheActiveFormattingElements();
</span><span class="cx">
</span><span class="cx"> void generateImpliedEndTags();
</span><span class="cx"> void generateImpliedEndTagsWithExclusion(const AtomicString& tagName);
</span><span class="cx">
</span><del>- bool inQuirksMode();
</del><ins>+ bool inQuirksMode() { return m_inQuirksMode; }
</ins><span class="cx">
</span><span class="cx"> bool isEmpty() const { return !m_openElements.stackDepth(); }
</span><span class="cx"> Element& currentElement() const { return m_openElements.top(); }
</span><span class="lines">@@ -157,32 +156,23 @@
</span><span class="cx">
</span><span class="cx"> void setForm(HTMLFormElement*);
</span><span class="cx"> HTMLFormElement* form() const { return m_form.get(); }
</span><del>- PassRefPtr<HTMLFormElement> takeForm();
</del><ins>+ RefPtr<HTMLFormElement> takeForm();
</ins><span class="cx">
</span><span class="cx"> ParserContentPolicy parserContentPolicy() { return m_parserContentPolicy; }
</span><span class="cx">
</span><span class="cx"> #if ENABLE(TELEPHONE_NUMBER_DETECTION)
</span><del>- bool isTelephoneNumberParsingEnabled() { return m_document->isTelephoneNumberParsingEnabled(); }
</del><ins>+ bool isTelephoneNumberParsingEnabled() { return m_document.isTelephoneNumberParsingEnabled(); }
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> class RedirectToFosterParentGuard {
</span><span class="cx"> WTF_MAKE_NONCOPYABLE(RedirectToFosterParentGuard);
</span><span class="cx"> public:
</span><del>- RedirectToFosterParentGuard(HTMLConstructionSite& tree)
- : m_tree(tree)
- , m_wasRedirectingBefore(tree.m_redirectAttachToFosterParent)
- {
- m_tree.m_redirectAttachToFosterParent = true;
- }
</del><ins>+ explicit RedirectToFosterParentGuard(HTMLConstructionSite& tree)
+ : m_redirectAttachToFosterParentChange(tree.m_redirectAttachToFosterParent, true)
+ { }
</ins><span class="cx">
</span><del>- ~RedirectToFosterParentGuard()
- {
- m_tree.m_redirectAttachToFosterParent = m_wasRedirectingBefore;
- }
-
</del><span class="cx"> private:
</span><del>- HTMLConstructionSite& m_tree;
- bool m_wasRedirectingBefore;
</del><ins>+ TemporaryChange<bool> m_redirectAttachToFosterParentChange;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> static bool isFormattingTag(const AtomicString&);
</span><span class="lines">@@ -195,23 +185,23 @@
</span><span class="cx"> void setCompatibilityMode(DocumentCompatibilityMode);
</span><span class="cx"> void setCompatibilityModeFromDoctype(const String& name, const String& publicId, const String& systemId);
</span><span class="cx">
</span><del>- void attachLater(ContainerNode* parent, PassRefPtr<Node> child, bool selfClosing = false);
</del><ins>+ void attachLater(ContainerNode& parent, Ref<Node>&& child, bool selfClosing = false);
</ins><span class="cx">
</span><span class="cx"> void findFosterSite(HTMLConstructionSiteTask&);
</span><span class="cx">
</span><del>- RefPtr<Element> createHTMLElementOrFindCustomElementInterface(AtomicHTMLToken*, JSCustomElementInterface**);
- Ref<Element> createHTMLElement(AtomicHTMLToken*);
- Ref<Element> createElement(AtomicHTMLToken*, const AtomicString& namespaceURI);
</del><ins>+ RefPtr<Element> createHTMLElementOrFindCustomElementInterface(AtomicHTMLToken&, JSCustomElementInterface**);
+ Ref<Element> createHTMLElement(AtomicHTMLToken&);
+ Ref<Element> createElement(AtomicHTMLToken&, const AtomicString& namespaceURI);
</ins><span class="cx">
</span><del>- void mergeAttributesFromTokenIntoElement(AtomicHTMLToken*, Element*);
</del><ins>+ void mergeAttributesFromTokenIntoElement(AtomicHTMLToken&, Element&);
</ins><span class="cx"> void dispatchDocumentElementAvailableIfNeeded();
</span><span class="cx">
</span><del>- Document* m_document;
</del><ins>+ Document& m_document;
</ins><span class="cx">
</span><span class="cx"> // This is the root ContainerNode to which the parser attaches all newly
</span><span class="cx"> // constructed nodes. It points to a DocumentFragment when parsing fragments
</span><span class="cx"> // and a Document in all other cases.
</span><del>- ContainerNode* m_attachmentRoot;
</del><ins>+ ContainerNode& m_attachmentRoot;
</ins><span class="cx">
</span><span class="cx"> RefPtr<HTMLStackItem> m_head;
</span><span class="cx"> RefPtr<HTMLFormElement> m_form;
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLElementStackcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLElementStack.cpp (200339 => 200340)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLElementStack.cpp 2016-05-02 21:42:07 UTC (rev 200339)
+++ trunk/Source/WebCore/html/parser/HTMLElementStack.cpp 2016-05-02 22:18:05 UTC (rev 200340)
</span><span class="lines">@@ -40,8 +40,7 @@
</span><span class="cx">
</span><span class="cx"> inline bool isRootNode(HTMLStackItem& item)
</span><span class="cx"> {
</span><del>- return item.isDocumentFragment()
- || item.hasTagName(htmlTag);
</del><ins>+ return item.isDocumentFragment() || item.hasTagName(htmlTag);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline bool isScopeMarker(HTMLStackItem& item)
</span><span class="lines">@@ -116,42 +115,32 @@
</span><span class="cx">
</span><span class="cx"> }
</span><span class="cx">
</span><del>-HTMLElementStack::ElementRecord::ElementRecord(PassRefPtr<HTMLStackItem> item, std::unique_ptr<ElementRecord> next)
- : m_item(item)
</del><ins>+HTMLElementStack::ElementRecord::ElementRecord(Ref<HTMLStackItem>&& item, std::unique_ptr<ElementRecord> next)
+ : m_item(WTFMove(item))
</ins><span class="cx"> , m_next(WTFMove(next))
</span><span class="cx"> {
</span><del>- ASSERT(m_item);
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> HTMLElementStack::ElementRecord::~ElementRecord()
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::ElementRecord::replaceElement(PassRefPtr<HTMLStackItem> item)
</del><ins>+void HTMLElementStack::ElementRecord::replaceElement(Ref<HTMLStackItem>&& item)
</ins><span class="cx"> {
</span><del>- ASSERT(item);
- ASSERT(!m_item || m_item->isElement());
</del><ins>+ ASSERT(m_item->isElement());
</ins><span class="cx"> // FIXME: Should this call finishParsingChildren?
</span><del>- m_item = item;
</del><ins>+ m_item = WTFMove(item);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool HTMLElementStack::ElementRecord::isAbove(ElementRecord* other) const
</del><ins>+bool HTMLElementStack::ElementRecord::isAbove(ElementRecord& other) const
</ins><span class="cx"> {
</span><del>- for (ElementRecord* below = next(); below; below = below->next()) {
- if (below == other)
</del><ins>+ for (auto* below = next(); below; below = below->next()) {
+ if (below == &other)
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-HTMLElementStack::HTMLElementStack()
- : m_rootNode(0)
- , m_headElement(0)
- , m_bodyElement(0)
- , m_stackDepth(0)
-{
-}
-
</del><span class="cx"> HTMLElementStack::~HTMLElementStack()
</span><span class="cx"> {
</span><span class="cx"> }
</span><span class="lines">@@ -189,9 +178,9 @@
</span><span class="cx">
</span><span class="cx"> void HTMLElementStack::popAll()
</span><span class="cx"> {
</span><del>- m_rootNode = 0;
- m_headElement = 0;
- m_bodyElement = 0;
</del><ins>+ m_rootNode = nullptr;
+ m_headElement = nullptr;
+ m_bodyElement = nullptr;
</ins><span class="cx"> m_stackDepth = 0;
</span><span class="cx"> while (m_top) {
</span><span class="cx"> topNode().finishParsingChildren();
</span><span class="lines">@@ -226,13 +215,13 @@
</span><span class="cx"> pop();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::popUntil(Element* element)
</del><ins>+void HTMLElementStack::popUntil(Element& element)
</ins><span class="cx"> {
</span><del>- while (&top() != element)
</del><ins>+ while (&top() != &element)
</ins><span class="cx"> pop();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::popUntilPopped(Element* element)
</del><ins>+void HTMLElementStack::popUntilPopped(Element& element)
</ins><span class="cx"> {
</span><span class="cx"> popUntil(element);
</span><span class="cx"> pop();
</span><span class="lines">@@ -292,78 +281,76 @@
</span><span class="cx"> pop();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::pushRootNode(PassRefPtr<HTMLStackItem> rootItem)
</del><ins>+void HTMLElementStack::pushRootNode(Ref<HTMLStackItem>&& rootItem)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(rootItem->isDocumentFragment());
</span><del>- pushRootNodeCommon(rootItem);
</del><ins>+ pushRootNodeCommon(WTFMove(rootItem));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::pushHTMLHtmlElement(PassRefPtr<HTMLStackItem> item)
</del><ins>+void HTMLElementStack::pushHTMLHtmlElement(Ref<HTMLStackItem>&& item)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(item->hasTagName(HTMLNames::htmlTag));
</span><del>- pushRootNodeCommon(item);
</del><ins>+ pushRootNodeCommon(WTFMove(item));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::pushRootNodeCommon(PassRefPtr<HTMLStackItem> rootItem)
</del><ins>+void HTMLElementStack::pushRootNodeCommon(Ref<HTMLStackItem>&& rootItem)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!m_top);
</span><span class="cx"> ASSERT(!m_rootNode);
</span><span class="cx"> m_rootNode = &rootItem->node();
</span><del>- pushCommon(rootItem);
</del><ins>+ pushCommon(WTFMove(rootItem));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::pushHTMLHeadElement(PassRefPtr<HTMLStackItem> item)
</del><ins>+void HTMLElementStack::pushHTMLHeadElement(Ref<HTMLStackItem>&& item)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(item->hasTagName(HTMLNames::headTag));
</span><span class="cx"> ASSERT(!m_headElement);
</span><span class="cx"> m_headElement = &item->element();
</span><del>- pushCommon(item);
</del><ins>+ pushCommon(WTFMove(item));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::pushHTMLBodyElement(PassRefPtr<HTMLStackItem> item)
</del><ins>+void HTMLElementStack::pushHTMLBodyElement(Ref<HTMLStackItem>&& item)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(item->hasTagName(HTMLNames::bodyTag));
</span><span class="cx"> ASSERT(!m_bodyElement);
</span><span class="cx"> m_bodyElement = &item->element();
</span><del>- pushCommon(item);
</del><ins>+ pushCommon(WTFMove(item));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::push(PassRefPtr<HTMLStackItem> item)
</del><ins>+void HTMLElementStack::push(Ref<HTMLStackItem>&& item)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!item->hasTagName(HTMLNames::htmlTag));
</span><span class="cx"> ASSERT(!item->hasTagName(HTMLNames::headTag));
</span><span class="cx"> ASSERT(!item->hasTagName(HTMLNames::bodyTag));
</span><span class="cx"> ASSERT(m_rootNode);
</span><del>- pushCommon(item);
</del><ins>+ pushCommon(WTFMove(item));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::insertAbove(PassRefPtr<HTMLStackItem> item, ElementRecord* recordBelow)
</del><ins>+void HTMLElementStack::insertAbove(Ref<HTMLStackItem>&& item, ElementRecord& recordBelow)
</ins><span class="cx"> {
</span><del>- ASSERT(item);
- ASSERT(recordBelow);
</del><span class="cx"> ASSERT(m_top);
</span><span class="cx"> ASSERT(!item->hasTagName(HTMLNames::htmlTag));
</span><span class="cx"> ASSERT(!item->hasTagName(HTMLNames::headTag));
</span><span class="cx"> ASSERT(!item->hasTagName(HTMLNames::bodyTag));
</span><span class="cx"> ASSERT(m_rootNode);
</span><del>- if (recordBelow == m_top.get()) {
- push(item);
</del><ins>+ if (&recordBelow == m_top.get()) {
+ push(item.copyRef());
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- for (ElementRecord* recordAbove = m_top.get(); recordAbove; recordAbove = recordAbove->next()) {
- if (recordAbove->next() != recordBelow)
</del><ins>+ for (auto* recordAbove = m_top.get(); recordAbove; recordAbove = recordAbove->next()) {
+ if (recordAbove->next() != &recordBelow)
</ins><span class="cx"> continue;
</span><span class="cx">
</span><del>- m_stackDepth++;
- recordAbove->setNext(std::make_unique<ElementRecord>(item, recordAbove->releaseNext()));
</del><ins>+ ++m_stackDepth;
+ recordAbove->setNext(std::make_unique<ElementRecord>(WTFMove(item), recordAbove->releaseNext()));
</ins><span class="cx"> recordAbove->next()->element().beginParsingChildren();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> ASSERT_NOT_REACHED();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-HTMLElementStack::ElementRecord& HTMLElementStack::topRecord() const
</del><ins>+auto HTMLElementStack::topRecord() const -> ElementRecord&
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(m_top);
</span><span class="cx"> return *m_top;
</span><span class="lines">@@ -379,10 +366,10 @@
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::removeHTMLHeadElement(Element* element)
</del><ins>+void HTMLElementStack::removeHTMLHeadElement(Element& element)
</ins><span class="cx"> {
</span><del>- ASSERT(m_headElement == element);
- if (&m_top->element() == element) {
</del><ins>+ ASSERT(m_headElement == &element);
+ if (&m_top->element() == &element) {
</ins><span class="cx"> popHTMLHeadElement();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -390,35 +377,35 @@
</span><span class="cx"> removeNonTopCommon(element);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::remove(Element* element)
</del><ins>+void HTMLElementStack::remove(Element& element)
</ins><span class="cx"> {
</span><del>- ASSERT(!element->hasTagName(HTMLNames::headTag));
- if (&m_top->element() == element) {
</del><ins>+ ASSERT(!element.hasTagName(HTMLNames::headTag));
+ if (&m_top->element() == &element) {
</ins><span class="cx"> pop();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> removeNonTopCommon(element);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-HTMLElementStack::ElementRecord* HTMLElementStack::find(Element* element) const
</del><ins>+auto HTMLElementStack::find(Element& element) const -> ElementRecord*
</ins><span class="cx"> {
</span><del>- for (ElementRecord* record = m_top.get(); record; record = record->next()) {
- if (&record->node() == element)
</del><ins>+ for (auto* record = m_top.get(); record; record = record->next()) {
+ if (&record->node() == &element)
</ins><span class="cx"> return record;
</span><span class="cx"> }
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-HTMLElementStack::ElementRecord* HTMLElementStack::topmost(const AtomicString& tagName) const
</del><ins>+auto HTMLElementStack::topmost(const AtomicString& tagName) const -> ElementRecord*
</ins><span class="cx"> {
</span><del>- for (ElementRecord* record = m_top.get(); record; record = record->next()) {
</del><ins>+ for (auto* record = m_top.get(); record; record = record->next()) {
</ins><span class="cx"> if (record->stackItem().matchesHTMLTag(tagName))
</span><span class="cx"> return record;
</span><span class="cx"> }
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool HTMLElementStack::contains(Element* element) const
</del><ins>+bool HTMLElementStack::contains(Element& element) const
</ins><span class="cx"> {
</span><span class="cx"> return !!find(element);
</span><span class="cx"> }
</span><span class="lines">@@ -431,7 +418,7 @@
</span><span class="cx"> template <bool isMarker(HTMLStackItem&)> bool inScopeCommon(HTMLElementStack::ElementRecord* top, const AtomicString& targetTag)
</span><span class="cx"> {
</span><span class="cx"> for (auto* record = top; record; record = record->next()) {
</span><del>- HTMLStackItem& item = record->stackItem();
</del><ins>+ auto& item = record->stackItem();
</ins><span class="cx"> if (item.matchesHTMLTag(targetTag))
</span><span class="cx"> return true;
</span><span class="cx"> if (isMarker(item))
</span><span class="lines">@@ -443,8 +430,8 @@
</span><span class="cx">
</span><span class="cx"> bool HTMLElementStack::hasNumberedHeaderElementInScope() const
</span><span class="cx"> {
</span><del>- for (ElementRecord* record = m_top.get(); record; record = record->next()) {
- HTMLStackItem& item = record->stackItem();
</del><ins>+ for (auto* record = m_top.get(); record; record = record->next()) {
+ auto& item = record->stackItem();
</ins><span class="cx"> if (isNumberedHeaderElement(item))
</span><span class="cx"> return true;
</span><span class="cx"> if (isScopeMarker(item))
</span><span class="lines">@@ -454,11 +441,11 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool HTMLElementStack::inScope(Element* targetElement) const
</del><ins>+bool HTMLElementStack::inScope(Element& targetElement) const
</ins><span class="cx"> {
</span><del>- for (ElementRecord* record = m_top.get(); record; record = record->next()) {
- HTMLStackItem& item = record->stackItem();
- if (&item.node() == targetElement)
</del><ins>+ for (auto* record = m_top.get(); record; record = record->next()) {
+ auto& item = record->stackItem();
+ if (&item.node() == &targetElement)
</ins><span class="cx"> return true;
</span><span class="cx"> if (isScopeMarker(item))
</span><span class="cx"> return false;
</span><span class="lines">@@ -545,12 +532,12 @@
</span><span class="cx"> return *m_rootNode;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::pushCommon(PassRefPtr<HTMLStackItem> item)
</del><ins>+void HTMLElementStack::pushCommon(Ref<HTMLStackItem>&& item)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(m_rootNode);
</span><span class="cx">
</span><del>- m_stackDepth++;
- m_top = std::make_unique<ElementRecord>(item, WTFMove(m_top));
</del><ins>+ ++m_stackDepth;
+ m_top = std::make_unique<ElementRecord>(WTFMove(item), WTFMove(m_top));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLElementStack::popCommon()
</span><span class="lines">@@ -562,32 +549,32 @@
</span><span class="cx"> top().finishParsingChildren();
</span><span class="cx"> m_top = m_top->releaseNext();
</span><span class="cx">
</span><del>- m_stackDepth--;
</del><ins>+ --m_stackDepth;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLElementStack::removeNonTopCommon(Element* element)
</del><ins>+void HTMLElementStack::removeNonTopCommon(Element& element)
</ins><span class="cx"> {
</span><del>- ASSERT(!element->hasTagName(HTMLNames::htmlTag));
- ASSERT(!element->hasTagName(HTMLNames::bodyTag));
- ASSERT(&top() != element);
- for (ElementRecord* record = m_top.get(); record; record = record->next()) {
- if (&record->next()->element() == element) {
</del><ins>+ ASSERT(!element.hasTagName(HTMLNames::htmlTag));
+ ASSERT(!element.hasTagName(HTMLNames::bodyTag));
+ ASSERT(&top() != &element);
+ for (auto* record = m_top.get(); record; record = record->next()) {
+ if (&record->next()->element() == &element) {
</ins><span class="cx"> // FIXME: Is it OK to call finishParsingChildren()
</span><span class="cx"> // when the children aren't actually finished?
</span><del>- element->finishParsingChildren();
</del><ins>+ element.finishParsingChildren();
</ins><span class="cx"> record->setNext(record->next()->releaseNext());
</span><del>- m_stackDepth--;
</del><ins>+ --m_stackDepth;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> ASSERT_NOT_REACHED();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-HTMLElementStack::ElementRecord* HTMLElementStack::furthestBlockForFormattingElement(Element* formattingElement) const
</del><ins>+auto HTMLElementStack::furthestBlockForFormattingElement(Element& formattingElement) const -> ElementRecord*
</ins><span class="cx"> {
</span><span class="cx"> ElementRecord* furthestBlock = nullptr;
</span><del>- for (ElementRecord* record = m_top.get(); record; record = record->next()) {
- if (&record->element() == formattingElement)
</del><ins>+ for (auto* record = m_top.get(); record; record = record->next()) {
+ if (&record->element() == &formattingElement)
</ins><span class="cx"> return furthestBlock;
</span><span class="cx"> if (isSpecialNode(record->stackItem()))
</span><span class="cx"> furthestBlock = record;
</span><span class="lines">@@ -600,7 +587,7 @@
</span><span class="cx">
</span><span class="cx"> void HTMLElementStack::show()
</span><span class="cx"> {
</span><del>- for (ElementRecord* record = m_top.get(); record; record = record->next())
</del><ins>+ for (auto* record = m_top.get(); record; record = record->next())
</ins><span class="cx"> record->element().showNode();
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLElementStackh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLElementStack.h (200339 => 200340)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLElementStack.h 2016-05-02 21:42:07 UTC (rev 200339)
+++ trunk/Source/WebCore/html/parser/HTMLElementStack.h 2016-05-02 22:18:05 UTC (rev 200340)
</span><span class="lines">@@ -44,23 +44,25 @@
</span><span class="cx"> class HTMLElementStack {
</span><span class="cx"> WTF_MAKE_NONCOPYABLE(HTMLElementStack); WTF_MAKE_FAST_ALLOCATED;
</span><span class="cx"> public:
</span><del>- HTMLElementStack();
</del><ins>+ HTMLElementStack() = default;
</ins><span class="cx"> ~HTMLElementStack();
</span><span class="cx">
</span><span class="cx"> class ElementRecord {
</span><span class="cx"> WTF_MAKE_NONCOPYABLE(ElementRecord); WTF_MAKE_FAST_ALLOCATED;
</span><span class="cx"> public:
</span><del>- ElementRecord(PassRefPtr<HTMLStackItem>, std::unique_ptr<ElementRecord>);
</del><ins>+ ElementRecord(Ref<HTMLStackItem>&&, std::unique_ptr<ElementRecord>);
</ins><span class="cx"> ~ElementRecord();
</span><span class="cx">
</span><span class="cx"> Element& element() const { return m_item->element(); }
</span><span class="cx"> ContainerNode& node() const { return m_item->node(); }
</span><span class="cx"> const AtomicString& namespaceURI() const { return m_item->namespaceURI(); }
</span><del>- HTMLStackItem& stackItem() const { return *m_item; }
- void replaceElement(PassRefPtr<HTMLStackItem>);
</del><ins>+ HTMLStackItem& stackItem() { return m_item.get(); }
+ const HTMLStackItem& stackItem() const { return m_item.get(); }
</ins><span class="cx">
</span><del>- bool isAbove(ElementRecord*) const;
</del><ins>+ void replaceElement(Ref<HTMLStackItem>&&);
</ins><span class="cx">
</span><ins>+ bool isAbove(ElementRecord&) const;
+
</ins><span class="cx"> ElementRecord* next() const { return m_next.get(); }
</span><span class="cx">
</span><span class="cx"> private:
</span><span class="lines">@@ -69,7 +71,7 @@
</span><span class="cx"> std::unique_ptr<ElementRecord> releaseNext() { return WTFMove(m_next); }
</span><span class="cx"> void setNext(std::unique_ptr<ElementRecord> next) { m_next = WTFMove(next); }
</span><span class="cx">
</span><del>- RefPtr<HTMLStackItem> m_item;
</del><ins>+ Ref<HTMLStackItem> m_item;
</ins><span class="cx"> std::unique_ptr<ElementRecord> m_next;
</span><span class="cx"> };
</span><span class="cx">
</span><span class="lines">@@ -94,25 +96,25 @@
</span><span class="cx">
</span><span class="cx"> HTMLStackItem* oneBelowTop() const;
</span><span class="cx"> ElementRecord& topRecord() const;
</span><del>- ElementRecord* find(Element*) const;
- ElementRecord* furthestBlockForFormattingElement(Element*) const;
</del><ins>+ ElementRecord* find(Element&) const;
+ ElementRecord* furthestBlockForFormattingElement(Element&) const;
</ins><span class="cx"> ElementRecord* topmost(const AtomicString& tagName) const;
</span><span class="cx">
</span><del>- void insertAbove(PassRefPtr<HTMLStackItem>, ElementRecord*);
</del><ins>+ void insertAbove(Ref<HTMLStackItem>&&, ElementRecord&);
</ins><span class="cx">
</span><del>- void push(PassRefPtr<HTMLStackItem>);
- void pushRootNode(PassRefPtr<HTMLStackItem>);
- void pushHTMLHtmlElement(PassRefPtr<HTMLStackItem>);
- void pushHTMLHeadElement(PassRefPtr<HTMLStackItem>);
- void pushHTMLBodyElement(PassRefPtr<HTMLStackItem>);
</del><ins>+ void push(Ref<HTMLStackItem>&&);
+ void pushRootNode(Ref<HTMLStackItem>&&);
+ void pushHTMLHtmlElement(Ref<HTMLStackItem>&&);
+ void pushHTMLHeadElement(Ref<HTMLStackItem>&&);
+ void pushHTMLBodyElement(Ref<HTMLStackItem>&&);
</ins><span class="cx">
</span><span class="cx"> void pop();
</span><span class="cx"> void popUntil(const AtomicString& tagName);
</span><del>- void popUntil(Element*);
</del><ins>+ void popUntil(Element&);
</ins><span class="cx"> void popUntilPopped(const AtomicString& tagName);
</span><span class="cx"> void popUntilPopped(const QualifiedName& tagName) { popUntilPopped(tagName.localName()); }
</span><span class="cx">
</span><del>- void popUntilPopped(Element*);
</del><ins>+ void popUntilPopped(Element&);
</ins><span class="cx"> void popUntilNumberedHeaderElementPopped();
</span><span class="cx"> void popUntilTableScopeMarker(); // "clear the stack back to a table context" in the spec.
</span><span class="cx"> void popUntilTableBodyScopeMarker(); // "clear the stack back to a table body context" in the spec.
</span><span class="lines">@@ -125,13 +127,13 @@
</span><span class="cx"> static bool isMathMLTextIntegrationPoint(HTMLStackItem&);
</span><span class="cx"> static bool isHTMLIntegrationPoint(HTMLStackItem&);
</span><span class="cx">
</span><del>- void remove(Element*);
- void removeHTMLHeadElement(Element*);
</del><ins>+ void remove(Element&);
+ void removeHTMLHeadElement(Element&);
</ins><span class="cx">
</span><del>- bool contains(Element*) const;
</del><ins>+ bool contains(Element&) const;
</ins><span class="cx"> bool contains(const AtomicString& tagName) const;
</span><span class="cx">
</span><del>- bool inScope(Element*) const;
</del><ins>+ bool inScope(Element&) const;
</ins><span class="cx"> bool inScope(const AtomicString& tagName) const;
</span><span class="cx"> bool inScope(const QualifiedName&) const;
</span><span class="cx"> bool inListItemScope(const AtomicString& tagName) const;
</span><span class="lines">@@ -159,10 +161,10 @@
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- void pushCommon(PassRefPtr<HTMLStackItem>);
- void pushRootNodeCommon(PassRefPtr<HTMLStackItem>);
</del><ins>+ void pushCommon(Ref<HTMLStackItem>&&);
+ void pushRootNodeCommon(Ref<HTMLStackItem>&&);
</ins><span class="cx"> void popCommon();
</span><del>- void removeNonTopCommon(Element*);
</del><ins>+ void removeNonTopCommon(Element&);
</ins><span class="cx">
</span><span class="cx"> std::unique_ptr<ElementRecord> m_top;
</span><span class="cx">
</span><span class="lines">@@ -171,10 +173,10 @@
</span><span class="cx"> // FIXME: We don't currently require type-specific information about
</span><span class="cx"> // these elements so we haven't yet bothered to plumb the types all the
</span><span class="cx"> // way down through createElement, etc.
</span><del>- ContainerNode* m_rootNode;
- Element* m_headElement;
- Element* m_bodyElement;
- unsigned m_stackDepth;
</del><ins>+ ContainerNode* m_rootNode { nullptr };
+ Element* m_headElement { nullptr };
+ Element* m_bodyElement { nullptr };
+ unsigned m_stackDepth { 0 };
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } // namespace WebCore
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLFormattingElementListcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLFormattingElementList.cpp (200339 => 200340)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLFormattingElementList.cpp 2016-05-02 21:42:07 UTC (rev 200339)
+++ trunk/Source/WebCore/html/parser/HTMLFormattingElementList.cpp 2016-05-02 22:18:05 UTC (rev 200340)
</span><span class="lines">@@ -57,52 +57,52 @@
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool HTMLFormattingElementList::contains(Element* element)
</del><ins>+bool HTMLFormattingElementList::contains(Element& element)
</ins><span class="cx"> {
</span><span class="cx"> return !!find(element);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-HTMLFormattingElementList::Entry* HTMLFormattingElementList::find(Element* element)
</del><ins>+auto HTMLFormattingElementList::find(Element& element) -> Entry*
</ins><span class="cx"> {
</span><del>- size_t index = m_entries.reverseFind(element);
</del><ins>+ size_t index = m_entries.reverseFind(&element);
</ins><span class="cx"> if (index != notFound) {
</span><span class="cx"> // This is somewhat of a hack, and is why this method can't be const.
</span><span class="cx"> return &m_entries[index];
</span><span class="cx"> }
</span><del>- return 0;
</del><ins>+ return nullptr;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-HTMLFormattingElementList::Bookmark HTMLFormattingElementList::bookmarkFor(Element* element)
</del><ins>+auto HTMLFormattingElementList::bookmarkFor(Element& element) -> Bookmark
</ins><span class="cx"> {
</span><del>- size_t index = m_entries.reverseFind(element);
</del><ins>+ size_t index = m_entries.reverseFind(&element);
</ins><span class="cx"> ASSERT(index != notFound);
</span><del>- return Bookmark(&at(index));
</del><ins>+ return Bookmark(at(index));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLFormattingElementList::swapTo(Element* oldElement, PassRefPtr<HTMLStackItem> newItem, const Bookmark& bookmark)
</del><ins>+void HTMLFormattingElementList::swapTo(Element& oldElement, Ref<HTMLStackItem>&& newItem, const Bookmark& bookmark)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(contains(oldElement));
</span><del>- ASSERT(!contains(&newItem->element()));
</del><ins>+ ASSERT(!contains(newItem->element()));
</ins><span class="cx"> if (!bookmark.hasBeenMoved()) {
</span><del>- ASSERT(&bookmark.mark()->element() == oldElement);
- bookmark.mark()->replaceElement(newItem);
</del><ins>+ ASSERT(&bookmark.mark().element() == &oldElement);
+ bookmark.mark().replaceElement(newItem.copyRef());
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- size_t index = bookmark.mark() - first();
</del><ins>+ size_t index = &bookmark.mark() - &first();
</ins><span class="cx"> ASSERT_WITH_SECURITY_IMPLICATION(index < size());
</span><del>- m_entries.insert(index + 1, newItem);
</del><ins>+ m_entries.insert(index + 1, WTFMove(newItem));
</ins><span class="cx"> remove(oldElement);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLFormattingElementList::append(PassRefPtr<HTMLStackItem> item)
</del><ins>+void HTMLFormattingElementList::append(Ref<HTMLStackItem>&& item)
</ins><span class="cx"> {
</span><del>- ensureNoahsArkCondition(item.get());
- m_entries.append(item);
</del><ins>+ ensureNoahsArkCondition(item);
+ m_entries.append(WTFMove(item));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLFormattingElementList::remove(Element* element)
</del><ins>+void HTMLFormattingElementList::remove(Element& element)
</ins><span class="cx"> {
</span><del>- size_t index = m_entries.reverseFind(element);
</del><ins>+ size_t index = m_entries.reverseFind(&element);
</ins><span class="cx"> if (index != notFound)
</span><span class="cx"> m_entries.remove(index);
</span><span class="cx"> }
</span><span class="lines">@@ -123,7 +123,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLFormattingElementList::tryToEnsureNoahsArkConditionQuickly(HTMLStackItem* newItem, Vector<HTMLStackItem*>& remainingCandidates)
</del><ins>+void HTMLFormattingElementList::tryToEnsureNoahsArkConditionQuickly(HTMLStackItem& newItem, Vector<HTMLStackItem*>& remainingCandidates)
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(remainingCandidates.isEmpty());
</span><span class="cx">
</span><span class="lines">@@ -134,7 +134,7 @@
</span><span class="cx"> // of a quickly ensuring the condition.
</span><span class="cx"> Vector<HTMLStackItem*, 10> candidates;
</span><span class="cx">
</span><del>- size_t newItemAttributeCount = newItem->attributes().size();
</del><ins>+ size_t newItemAttributeCount = newItem.attributes().size();
</ins><span class="cx">
</span><span class="cx"> for (size_t i = m_entries.size(); i; ) {
</span><span class="cx"> --i;
</span><span class="lines">@@ -144,7 +144,7 @@
</span><span class="cx">
</span><span class="cx"> // Quickly reject obviously non-matching candidates.
</span><span class="cx"> HTMLStackItem* candidate = entry.stackItem();
</span><del>- if (newItem->localName() != candidate->localName() || newItem->namespaceURI() != candidate->namespaceURI())
</del><ins>+ if (newItem.localName() != candidate->localName() || newItem.namespaceURI() != candidate->namespaceURI())
</ins><span class="cx"> continue;
</span><span class="cx"> if (candidate->attributes().size() != newItemAttributeCount)
</span><span class="cx"> continue;
</span><span class="lines">@@ -158,7 +158,7 @@
</span><span class="cx"> remainingCandidates.appendVector(candidates);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLFormattingElementList::ensureNoahsArkCondition(HTMLStackItem* newItem)
</del><ins>+void HTMLFormattingElementList::ensureNoahsArkCondition(HTMLStackItem& newItem)
</ins><span class="cx"> {
</span><span class="cx"> Vector<HTMLStackItem*> candidates;
</span><span class="cx"> tryToEnsureNoahsArkConditionQuickly(newItem, candidates);
</span><span class="lines">@@ -170,15 +170,15 @@
</span><span class="cx"> Vector<HTMLStackItem*> remainingCandidates;
</span><span class="cx"> remainingCandidates.reserveInitialCapacity(candidates.size());
</span><span class="cx">
</span><del>- for (auto& attribute : newItem->attributes()) {
</del><ins>+ for (auto& attribute : newItem.attributes()) {
</ins><span class="cx"> for (auto& candidate : candidates) {
</span><span class="cx"> // These properties should already have been checked by tryToEnsureNoahsArkConditionQuickly.
</span><del>- ASSERT(newItem->attributes().size() == candidate->attributes().size());
- ASSERT(newItem->localName() == candidate->localName() && newItem->namespaceURI() == candidate->namespaceURI());
</del><ins>+ ASSERT(newItem.attributes().size() == candidate->attributes().size());
+ ASSERT(newItem.localName() == candidate->localName() && newItem.namespaceURI() == candidate->namespaceURI());
</ins><span class="cx">
</span><del>- const Attribute* candidateAttribute = candidate->findAttribute(attribute.name());
</del><ins>+ auto* candidateAttribute = candidate->findAttribute(attribute.name());
</ins><span class="cx"> if (candidateAttribute && candidateAttribute->value() == attribute.value())
</span><del>- remainingCandidates.append(candidate);
</del><ins>+ remainingCandidates.uncheckedAppend(candidate);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (remainingCandidates.size() < kNoahsArkCapacity)
</span><span class="lines">@@ -192,7 +192,7 @@
</span><span class="cx"> // however, that we wil spin the loop more than once because of how the
</span><span class="cx"> // formatting element list gets permuted.
</span><span class="cx"> for (size_t i = kNoahsArkCapacity - 1; i < candidates.size(); ++i)
</span><del>- remove(&candidates[i]->element());
</del><ins>+ remove(candidates[i]->element());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if ENABLE(TREE_DEBUGGING)
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLFormattingElementListh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLFormattingElementList.h (200339 => 200340)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLFormattingElementList.h 2016-05-02 21:42:07 UTC (rev 200339)
+++ trunk/Source/WebCore/html/parser/HTMLFormattingElementList.h 2016-05-02 22:18:05 UTC (rev 200340)
</span><span class="lines">@@ -48,16 +48,14 @@
</span><span class="cx"> class Entry {
</span><span class="cx"> public:
</span><span class="cx"> // Inline because they're hot and Vector<T> uses them.
</span><del>- explicit Entry(PassRefPtr<HTMLStackItem> item)
- : m_item(item)
</del><ins>+ explicit Entry(Ref<HTMLStackItem>&& item)
+ : m_item(WTFMove(item))
</ins><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx"> enum MarkerEntryType { MarkerEntry };
</span><span class="cx"> Entry(MarkerEntryType)
</span><del>- : m_item(0)
</del><span class="cx"> {
</span><span class="cx"> }
</span><del>- ~Entry() {}
</del><span class="cx">
</span><span class="cx"> bool isMarker() const { return !m_item; }
</span><span class="cx">
</span><span class="lines">@@ -69,7 +67,7 @@
</span><span class="cx"> ASSERT(m_item);
</span><span class="cx"> return m_item->element();
</span><span class="cx"> }
</span><del>- void replaceElement(PassRefPtr<HTMLStackItem> item) { m_item = item; }
</del><ins>+ void replaceElement(Ref<HTMLStackItem>&& item) { m_item = WTFMove(item); }
</ins><span class="cx">
</span><span class="cx"> // Needed for use with Vector. These are super-hot and must be inline.
</span><span class="cx"> bool operator==(Element* element) const { return !m_item ? !element : &m_item->element() == element; }
</span><span class="lines">@@ -81,20 +79,20 @@
</span><span class="cx">
</span><span class="cx"> class Bookmark {
</span><span class="cx"> public:
</span><del>- Bookmark(Entry* entry)
</del><ins>+ explicit Bookmark(Entry& entry)
</ins><span class="cx"> : m_hasBeenMoved(false)
</span><del>- , m_mark(entry)
</del><ins>+ , m_mark(&entry)
</ins><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void moveToAfter(Entry* before)
</del><ins>+ void moveToAfter(Entry& before)
</ins><span class="cx"> {
</span><span class="cx"> m_hasBeenMoved = true;
</span><del>- m_mark = before;
</del><ins>+ m_mark = &before;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool hasBeenMoved() const { return m_hasBeenMoved; }
</span><del>- Entry* mark() const { return m_mark; }
</del><ins>+ Entry& mark() const { ASSERT(m_mark); return *m_mark; }
</ins><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> bool m_hasBeenMoved;
</span><span class="lines">@@ -106,13 +104,13 @@
</span><span class="cx">
</span><span class="cx"> Element* closestElementInScopeWithName(const AtomicString&);
</span><span class="cx">
</span><del>- Entry* find(Element*);
- bool contains(Element*);
- void append(PassRefPtr<HTMLStackItem>);
- void remove(Element*);
</del><ins>+ Entry* find(Element&);
+ bool contains(Element&);
+ void append(Ref<HTMLStackItem>&&);
+ void remove(Element&);
</ins><span class="cx">
</span><del>- Bookmark bookmarkFor(Element*);
- void swapTo(Element* oldElement, PassRefPtr<HTMLStackItem> newItem, const Bookmark&);
</del><ins>+ Bookmark bookmarkFor(Element&);
+ void swapTo(Element& oldElement, Ref<HTMLStackItem>&& newItem, const Bookmark&);
</ins><span class="cx">
</span><span class="cx"> void appendMarker();
</span><span class="cx"> // clearToLastMarker also clears the marker (per the HTML5 spec).
</span><span class="lines">@@ -126,12 +124,12 @@
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- Entry* first() { return &at(0); }
</del><ins>+ Entry& first() { return at(0); }
</ins><span class="cx">
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#list-of-active-formatting-elements
</span><span class="cx"> // These functions enforce the "Noah's Ark" condition, which removes redundant mis-nested elements.
</span><del>- void tryToEnsureNoahsArkConditionQuickly(HTMLStackItem*, Vector<HTMLStackItem*>& remainingCandiates);
- void ensureNoahsArkCondition(HTMLStackItem*);
</del><ins>+ void tryToEnsureNoahsArkConditionQuickly(HTMLStackItem&, Vector<HTMLStackItem*>& remainingCandidates);
+ void ensureNoahsArkCondition(HTMLStackItem&);
</ins><span class="cx">
</span><span class="cx"> Vector<Entry> m_entries;
</span><span class="cx"> };
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLTreeBuildercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp (200339 => 200340)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp 2016-05-02 21:42:07 UTC (rev 200339)
+++ trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp 2016-05-02 22:18:05 UTC (rev 200340)
</span><span class="lines">@@ -400,7 +400,7 @@
</span><span class="cx"> {
</span><span class="cx"> ASSERT(token.type() == HTMLToken::DOCTYPE);
</span><span class="cx"> if (m_insertionMode == InsertionMode::Initial) {
</span><del>- m_tree.insertDoctype(&token);
</del><ins>+ m_tree.insertDoctype(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::BeforeHTML;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -510,7 +510,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> processFakePEndTagIfPInButtonScope();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> template <typename TableQualifiedName> static HashMap<AtomicString, QualifiedName> createCaseMap(const TableQualifiedName* const names[], unsigned length)
</span><span class="lines">@@ -618,7 +618,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> m_framesetOk = false;
</span><del>- m_tree.insertHTMLBodyStartTagInBody(&token);
</del><ins>+ m_tree.insertHTMLBodyStartTagInBody(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == framesetTag) {
</span><span class="lines">@@ -630,10 +630,10 @@
</span><span class="cx"> if (!m_framesetOk)
</span><span class="cx"> return;
</span><span class="cx"> m_tree.openElements().bodyElement().remove(ASSERT_NO_EXCEPTION);
</span><del>- m_tree.openElements().popUntil(&m_tree.openElements().bodyElement());
</del><ins>+ m_tree.openElements().popUntil(m_tree.openElements().bodyElement());
</ins><span class="cx"> m_tree.openElements().popHTMLBodyElement();
</span><span class="cx"> ASSERT(&m_tree.openElements().top() == &m_tree.openElements().htmlElement());
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::InFrameset;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -661,7 +661,7 @@
</span><span class="cx"> || token.name() == summaryTag
</span><span class="cx"> || token.name() == ulTag) {
</span><span class="cx"> processFakePEndTagIfPInButtonScope();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (isNumberedHeaderTag(token.name())) {
</span><span class="lines">@@ -670,12 +670,12 @@
</span><span class="cx"> parseError(token);
</span><span class="cx"> m_tree.openElements().pop();
</span><span class="cx"> }
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == preTag || token.name() == listingTag) {
</span><span class="cx"> processFakePEndTagIfPInButtonScope();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_shouldSkipLeadingNewline = true;
</span><span class="cx"> m_framesetOk = false;
</span><span class="cx"> return;
</span><span class="lines">@@ -686,7 +686,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> processFakePEndTagIfPInButtonScope();
</span><del>- m_tree.insertHTMLFormElement(&token);
</del><ins>+ m_tree.insertHTMLFormElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == liTag) {
</span><span class="lines">@@ -699,7 +699,7 @@
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == plaintextTag) {
</span><span class="cx"> processFakePEndTagIfPInButtonScope();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_parser.tokenizer().setPLAINTEXTState();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -711,7 +711,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_framesetOk = false;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -720,17 +720,17 @@
</span><span class="cx"> if (activeATag) {
</span><span class="cx"> parseError(token);
</span><span class="cx"> processFakeEndTag(aTag);
</span><del>- m_tree.activeFormattingElements().remove(activeATag);
- if (m_tree.openElements().contains(activeATag))
- m_tree.openElements().remove(activeATag);
</del><ins>+ m_tree.activeFormattingElements().remove(*activeATag);
+ if (m_tree.openElements().contains(*activeATag))
+ m_tree.openElements().remove(*activeATag);
</ins><span class="cx"> }
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- m_tree.insertFormattingElement(&token);
</del><ins>+ m_tree.insertFormattingElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (isNonAnchorNonNobrFormattingTag(token.name())) {
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- m_tree.insertFormattingElement(&token);
</del><ins>+ m_tree.insertFormattingElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == nobrTag) {
</span><span class="lines">@@ -740,7 +740,7 @@
</span><span class="cx"> processFakeEndTag(nobrTag);
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><span class="cx"> }
</span><del>- m_tree.insertFormattingElement(&token);
</del><ins>+ m_tree.insertFormattingElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == appletTag || token.name() == embedTag || token.name() == objectTag) {
</span><span class="lines">@@ -749,7 +749,7 @@
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == appletTag || token.name() == marqueeTag || token.name() == objectTag) {
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_tree.activeFormattingElements().appendMarker();
</span><span class="cx"> m_framesetOk = false;
</span><span class="cx"> return;
</span><span class="lines">@@ -757,7 +757,7 @@
</span><span class="cx"> if (token.name() == tableTag) {
</span><span class="cx"> if (!m_tree.inQuirksMode() && m_tree.openElements().inButtonScope(pTag))
</span><span class="cx"> processFakeEndTag(pTag);
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_framesetOk = false;
</span><span class="cx"> m_insertionMode = InsertionMode::InTable;
</span><span class="cx"> return;
</span><span class="lines">@@ -775,25 +775,25 @@
</span><span class="cx"> || token.name() == keygenTag
</span><span class="cx"> || token.name() == wbrTag) {
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- m_tree.insertSelfClosingHTMLElement(&token);
</del><ins>+ m_tree.insertSelfClosingHTMLElement(token);
</ins><span class="cx"> m_framesetOk = false;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == inputTag) {
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- m_tree.insertSelfClosingHTMLElement(&token);
</del><ins>+ m_tree.insertSelfClosingHTMLElement(token);
</ins><span class="cx"> Attribute* typeAttribute = findAttribute(token.attributes(), typeAttr);
</span><span class="cx"> if (!typeAttribute || !equalLettersIgnoringASCIICase(typeAttribute->value(), "hidden"))
</span><span class="cx"> m_framesetOk = false;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == paramTag || token.name() == sourceTag || token.name() == trackTag) {
</span><del>- m_tree.insertSelfClosingHTMLElement(&token);
</del><ins>+ m_tree.insertSelfClosingHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == hrTag) {
</span><span class="cx"> processFakePEndTagIfPInButtonScope();
</span><del>- m_tree.insertSelfClosingHTMLElement(&token);
</del><ins>+ m_tree.insertSelfClosingHTMLElement(token);
</ins><span class="cx"> m_framesetOk = false;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -802,7 +802,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == textareaTag) {
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_shouldSkipLeadingNewline = true;
</span><span class="cx"> m_parser.tokenizer().setRCDATAState();
</span><span class="cx"> m_originalInsertionMode = m_insertionMode;
</span><span class="lines">@@ -832,7 +832,7 @@
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == selectTag) {
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_framesetOk = false;
</span><span class="cx"> if (m_insertionMode == InsertionMode::InTable
</span><span class="cx"> || m_insertionMode == InsertionMode::InCaption
</span><span class="lines">@@ -851,7 +851,7 @@
</span><span class="cx"> processEndTag(endOption);
</span><span class="cx"> }
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == rbTag || token.name() == rtcTag) {
</span><span class="lines">@@ -860,7 +860,7 @@
</span><span class="cx"> if (!m_tree.currentStackItem().hasTagName(rubyTag))
</span><span class="cx"> parseError(token);
</span><span class="cx"> }
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == rtTag || token.name() == rpTag) {
</span><span class="lines">@@ -869,21 +869,21 @@
</span><span class="cx"> if (!m_tree.currentStackItem().hasTagName(rubyTag) && !m_tree.currentStackItem().hasTagName(rtcTag))
</span><span class="cx"> parseError(token);
</span><span class="cx"> }
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == MathMLNames::mathTag.localName()) {
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><span class="cx"> adjustMathMLAttributes(token);
</span><span class="cx"> adjustForeignAttributes(token);
</span><del>- m_tree.insertForeignElement(&token, MathMLNames::mathmlNamespaceURI);
</del><ins>+ m_tree.insertForeignElement(token, MathMLNames::mathmlNamespaceURI);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == SVGNames::svgTag.localName()) {
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><span class="cx"> adjustSVGAttributes(token);
</span><span class="cx"> adjustForeignAttributes(token);
</span><del>- m_tree.insertForeignElement(&token, SVGNames::svgNamespaceURI);
</del><ins>+ m_tree.insertForeignElement(token, SVGNames::svgNamespaceURI);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (isCaptionColOrColgroupTag(token.name())
</span><span class="lines">@@ -907,11 +907,11 @@
</span><span class="cx"> inline void HTMLTreeBuilder::insertGenericHTMLElement(AtomicHTMLToken& token)
</span><span class="cx"> {
</span><span class="cx"> #if ENABLE(CUSTOM_ELEMENTS)
</span><del>- auto* interface = m_tree.insertHTMLElementOrFindCustomElementInterface(&token);
</del><ins>+ auto* interface = m_tree.insertHTMLElementOrFindCustomElementInterface(token);
</ins><span class="cx"> if (UNLIKELY(interface))
</span><span class="cx"> m_customElementToConstruct = std::make_unique<CustomElementConstructionData>(*interface, token.name(), token.attributes());
</span><span class="cx"> #else
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -925,7 +925,7 @@
</span><span class="cx"> void HTMLTreeBuilder::processTemplateStartTag(AtomicHTMLToken& token)
</span><span class="cx"> {
</span><span class="cx"> m_tree.activeFormattingElements().appendMarker();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_templateInsertionModes.append(InsertionMode::TemplateContents);
</span><span class="cx"> m_insertionMode = InsertionMode::TemplateContents;
</span><span class="cx"> }
</span><span class="lines">@@ -992,13 +992,13 @@
</span><span class="cx"> if (token.name() == captionTag) {
</span><span class="cx"> m_tree.openElements().popUntilTableScopeMarker();
</span><span class="cx"> m_tree.activeFormattingElements().appendMarker();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::InCaption;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == colgroupTag) {
</span><span class="cx"> m_tree.openElements().popUntilTableScopeMarker();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::InColumnGroup;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1010,7 +1010,7 @@
</span><span class="cx"> }
</span><span class="cx"> if (isTableBodyContextTag(token.name())) {
</span><span class="cx"> m_tree.openElements().popUntilTableScopeMarker();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::InTableBody;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1037,7 +1037,7 @@
</span><span class="cx"> Attribute* typeAttribute = findAttribute(token.attributes(), typeAttr);
</span><span class="cx"> if (typeAttribute && equalLettersIgnoringASCIICase(typeAttribute->value(), "hidden")) {
</span><span class="cx"> parseError(token);
</span><del>- m_tree.insertSelfClosingHTMLElement(&token);
</del><ins>+ m_tree.insertSelfClosingHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> // Fall through to "anything else" case.
</span><span class="lines">@@ -1046,7 +1046,7 @@
</span><span class="cx"> parseError(token);
</span><span class="cx"> if (m_tree.form() && !isParsingTemplateContents())
</span><span class="cx"> return;
</span><del>- m_tree.insertHTMLFormElement(&token, true);
</del><ins>+ m_tree.insertHTMLFormElement(token, true);
</ins><span class="cx"> m_tree.openElements().pop();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1069,7 +1069,7 @@
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::BeforeHTML:
</span><span class="cx"> if (token.name() == htmlTag) {
</span><del>- m_tree.insertHTMLHtmlStartTagBeforeHTML(&token);
</del><ins>+ m_tree.insertHTMLHtmlStartTagBeforeHTML(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::BeforeHead;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1082,7 +1082,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == headTag) {
</span><del>- m_tree.insertHTMLHeadElement(&token);
</del><ins>+ m_tree.insertHTMLHeadElement(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::InHead;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1102,12 +1102,12 @@
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == bodyTag) {
</span><span class="cx"> m_framesetOk = false;
</span><del>- m_tree.insertHTMLBodyElement(&token);
</del><ins>+ m_tree.insertHTMLBodyElement(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::InBody;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == framesetTag) {
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::InFrameset;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1122,9 +1122,10 @@
</span><span class="cx"> || token.name() == templateTag
</span><span class="cx"> || token.name() == titleTag) {
</span><span class="cx"> parseError(token);
</span><del>- m_tree.openElements().pushHTMLHeadElement(m_tree.headStackItem());
</del><ins>+ ASSERT(m_tree.headStackItem());
+ m_tree.openElements().pushHTMLHeadElement(*m_tree.headStackItem());
</ins><span class="cx"> processStartTagForInHead(token);
</span><del>- m_tree.openElements().removeHTMLHeadElement(&m_tree.head());
</del><ins>+ m_tree.openElements().removeHTMLHeadElement(m_tree.head());
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == headTag) {
</span><span class="lines">@@ -1161,7 +1162,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == colTag) {
</span><del>- m_tree.insertSelfClosingHTMLElement(&token);
</del><ins>+ m_tree.insertSelfClosingHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == templateTag) {
</span><span class="lines">@@ -1177,7 +1178,7 @@
</span><span class="cx"> case InsertionMode::InTableBody:
</span><span class="cx"> if (token.name() == trTag) {
</span><span class="cx"> m_tree.openElements().popUntilTableBodyScopeMarker(); // How is there ever anything to pop?
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::InRow;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1206,7 +1207,7 @@
</span><span class="cx"> case InsertionMode::InRow:
</span><span class="cx"> if (isTableCellContextTag(token.name())) {
</span><span class="cx"> m_tree.openElements().popUntilTableRowScopeMarker();
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::InCell;
</span><span class="cx"> m_tree.activeFormattingElements().appendMarker();
</span><span class="cx"> return;
</span><span class="lines">@@ -1278,11 +1279,11 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == framesetTag) {
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == frameTag) {
</span><del>- m_tree.insertSelfClosingHTMLElement(&token);
</del><ins>+ m_tree.insertSelfClosingHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == noframesTag) {
</span><span class="lines">@@ -1326,7 +1327,7 @@
</span><span class="cx"> AtomicHTMLToken endOption(HTMLToken::EndTag, optionTag.localName());
</span><span class="cx"> processEndTag(endOption);
</span><span class="cx"> }
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == optgroupTag) {
</span><span class="lines">@@ -1338,7 +1339,7 @@
</span><span class="cx"> AtomicHTMLToken endOptgroup(HTMLToken::EndTag, optgroupTag.localName());
</span><span class="cx"> processEndTag(endOptgroup);
</span><span class="cx"> }
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == selectTag) {
</span><span class="lines">@@ -1418,7 +1419,7 @@
</span><span class="cx"> ASSERT(isParsingTemplateContents());
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- m_tree.insertHTMLHtmlStartTagInBody(&token);
</del><ins>+ m_tree.insertHTMLHtmlStartTagInBody(token);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool HTMLTreeBuilder::processBodyEndTagForInBody(AtomicHTMLToken& token)
</span><span class="lines">@@ -1443,7 +1444,7 @@
</span><span class="cx"> m_tree.generateImpliedEndTagsWithExclusion(token.name());
</span><span class="cx"> if (!m_tree.currentStackItem().matchesHTMLTag(token.name()))
</span><span class="cx"> parseError(token);
</span><del>- m_tree.openElements().popUntilPopped(&item.element());
</del><ins>+ m_tree.openElements().popUntilPopped(item.element());
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (isSpecialNode(item)) {
</span><span class="lines">@@ -1471,34 +1472,34 @@
</span><span class="cx"> if (!formattingElement)
</span><span class="cx"> return processAnyOtherEndTagForInBody(token);
</span><span class="cx"> // 4.c
</span><del>- if ((m_tree.openElements().contains(formattingElement)) && !m_tree.openElements().inScope(formattingElement)) {
</del><ins>+ if ((m_tree.openElements().contains(*formattingElement)) && !m_tree.openElements().inScope(*formattingElement)) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> notImplemented(); // Check the stack of open elements for a more specific parse error.
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> // 4.b
</span><del>- auto* formattingElementRecord = m_tree.openElements().find(formattingElement);
</del><ins>+ auto* formattingElementRecord = m_tree.openElements().find(*formattingElement);
</ins><span class="cx"> if (!formattingElementRecord) {
</span><span class="cx"> parseError(token);
</span><del>- m_tree.activeFormattingElements().remove(formattingElement);
</del><ins>+ m_tree.activeFormattingElements().remove(*formattingElement);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> // 4.d
</span><span class="cx"> if (formattingElement != &m_tree.currentElement())
</span><span class="cx"> parseError(token);
</span><span class="cx"> // 5.
</span><del>- auto* furthestBlock = m_tree.openElements().furthestBlockForFormattingElement(formattingElement);
</del><ins>+ auto* furthestBlock = m_tree.openElements().furthestBlockForFormattingElement(*formattingElement);
</ins><span class="cx"> // 6.
</span><span class="cx"> if (!furthestBlock) {
</span><del>- m_tree.openElements().popUntilPopped(formattingElement);
- m_tree.activeFormattingElements().remove(formattingElement);
</del><ins>+ m_tree.openElements().popUntilPopped(*formattingElement);
+ m_tree.activeFormattingElements().remove(*formattingElement);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> // 7.
</span><del>- ASSERT(furthestBlock->isAbove(formattingElementRecord));
</del><ins>+ ASSERT(furthestBlock->isAbove(*formattingElementRecord));
</ins><span class="cx"> Ref<HTMLStackItem> commonAncestor = formattingElementRecord->next()->stackItem();
</span><span class="cx"> // 8.
</span><del>- HTMLFormattingElementList::Bookmark bookmark = m_tree.activeFormattingElements().bookmarkFor(formattingElement);
</del><ins>+ HTMLFormattingElementList::Bookmark bookmark = m_tree.activeFormattingElements().bookmarkFor(*formattingElement);
</ins><span class="cx"> // 9.
</span><span class="cx"> auto* node = furthestBlock;
</span><span class="cx"> auto* nextNode = node->next();
</span><span class="lines">@@ -1510,8 +1511,8 @@
</span><span class="cx"> ASSERT(node);
</span><span class="cx"> nextNode = node->next(); // Save node->next() for the next iteration in case node is deleted in 9.5.
</span><span class="cx"> // 9.5
</span><del>- if (!m_tree.activeFormattingElements().contains(&node->element())) {
- m_tree.openElements().remove(&node->element());
</del><ins>+ if (!m_tree.activeFormattingElements().contains(node->element())) {
+ m_tree.openElements().remove(node->element());
</ins><span class="cx"> node = 0;
</span><span class="cx"> continue;
</span><span class="cx"> }
</span><span class="lines">@@ -1519,15 +1520,15 @@
</span><span class="cx"> if (node == formattingElementRecord)
</span><span class="cx"> break;
</span><span class="cx"> // 9.7
</span><del>- RefPtr<HTMLStackItem> newItem = m_tree.createElementFromSavedToken(&node->stackItem());
</del><ins>+ auto newItem = m_tree.createElementFromSavedToken(node->stackItem());
</ins><span class="cx">
</span><del>- HTMLFormattingElementList::Entry* nodeEntry = m_tree.activeFormattingElements().find(&node->element());
</del><ins>+ HTMLFormattingElementList::Entry* nodeEntry = m_tree.activeFormattingElements().find(node->element());
</ins><span class="cx"> nodeEntry->replaceElement(newItem.copyRef());
</span><del>- node->replaceElement(newItem.release());
</del><ins>+ node->replaceElement(WTFMove(newItem));
</ins><span class="cx">
</span><span class="cx"> // 9.8
</span><span class="cx"> if (lastNode == furthestBlock)
</span><del>- bookmark.moveToAfter(nodeEntry);
</del><ins>+ bookmark.moveToAfter(*nodeEntry);
</ins><span class="cx"> // 9.9
</span><span class="cx"> m_tree.reparent(*node, *lastNode);
</span><span class="cx"> // 9.10
</span><span class="lines">@@ -1536,16 +1537,16 @@
</span><span class="cx"> // 10.
</span><span class="cx"> m_tree.insertAlreadyParsedChild(commonAncestor.get(), *lastNode);
</span><span class="cx"> // 11.
</span><del>- RefPtr<HTMLStackItem> newItem = m_tree.createElementFromSavedToken(&formattingElementRecord->stackItem());
</del><ins>+ auto newItem = m_tree.createElementFromSavedToken(formattingElementRecord->stackItem());
</ins><span class="cx"> // 12.
</span><del>- m_tree.takeAllChildren(*newItem, *furthestBlock);
</del><ins>+ m_tree.takeAllChildren(newItem, *furthestBlock);
</ins><span class="cx"> // 13.
</span><del>- m_tree.reparent(*furthestBlock, *newItem);
</del><ins>+ m_tree.reparent(*furthestBlock, newItem);
</ins><span class="cx"> // 14.
</span><del>- m_tree.activeFormattingElements().swapTo(formattingElement, newItem, bookmark);
</del><ins>+ m_tree.activeFormattingElements().swapTo(*formattingElement, newItem.copyRef(), bookmark);
</ins><span class="cx"> // 15.
</span><del>- m_tree.openElements().remove(formattingElement);
- m_tree.openElements().insertAbove(newItem, furthestBlock);
</del><ins>+ m_tree.openElements().remove(*formattingElement);
+ m_tree.openElements().insertAbove(WTFMove(newItem), *furthestBlock);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1798,15 +1799,15 @@
</span><span class="cx"> }
</span><span class="cx"> if (token.name() == formTag) {
</span><span class="cx"> if (!isParsingTemplateContents()) {
</span><del>- RefPtr<Element> node = m_tree.takeForm();
- if (!node || !m_tree.openElements().inScope(node.get())) {
</del><ins>+ RefPtr<Element> formElement = m_tree.takeForm();
+ if (!formElement || !m_tree.openElements().inScope(*formElement)) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> m_tree.generateImpliedEndTags();
</span><del>- if (&m_tree.currentNode() != node.get())
</del><ins>+ if (&m_tree.currentNode() != formElement.get())
</ins><span class="cx"> parseError(token);
</span><del>- m_tree.openElements().remove(node.get());
</del><ins>+ m_tree.openElements().remove(*formElement);
</ins><span class="cx"> } else {
</span><span class="cx"> if (!m_tree.openElements().inScope(token.name())) {
</span><span class="cx"> parseError(token);
</span><span class="lines">@@ -2213,11 +2214,11 @@
</span><span class="cx"> || m_insertionMode == InsertionMode::BeforeHTML
</span><span class="cx"> || m_insertionMode == InsertionMode::AfterAfterBody
</span><span class="cx"> || m_insertionMode == InsertionMode::AfterAfterFrameset) {
</span><del>- m_tree.insertCommentOnDocument(&token);
</del><ins>+ m_tree.insertCommentOnDocument(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (m_insertionMode == InsertionMode::AfterBody) {
</span><del>- m_tree.insertCommentOnHTMLHtmlElement(&token);
</del><ins>+ m_tree.insertCommentOnHTMLHtmlElement(token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (m_insertionMode == InsertionMode::InTableText) {
</span><span class="lines">@@ -2225,7 +2226,7 @@
</span><span class="cx"> processComment(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- m_tree.insertComment(&token);
</del><ins>+ m_tree.insertComment(token);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::processCharacter(AtomicHTMLToken& token)
</span><span class="lines">@@ -2583,7 +2584,7 @@
</span><span class="cx"> void HTMLTreeBuilder::defaultForBeforeHTML()
</span><span class="cx"> {
</span><span class="cx"> AtomicHTMLToken startHTML(HTMLToken::StartTag, htmlTag.localName());
</span><del>- m_tree.insertHTMLHtmlStartTagBeforeHTML(&startHTML);
</del><ins>+ m_tree.insertHTMLHtmlStartTagBeforeHTML(startHTML);
</ins><span class="cx"> m_insertionMode = InsertionMode::BeforeHead;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2642,7 +2643,7 @@
</span><span class="cx"> || token.name() == commandTag
</span><span class="cx"> || token.name() == linkTag
</span><span class="cx"> || token.name() == metaTag) {
</span><del>- m_tree.insertSelfClosingHTMLElement(&token);
</del><ins>+ m_tree.insertSelfClosingHTMLElement(token);
</ins><span class="cx"> // Note: The custom processing for the <meta> tag is done in HTMLMetaElement::process().
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -2655,7 +2656,7 @@
</span><span class="cx"> processGenericRawTextStartTag(token);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_insertionMode = InsertionMode::InHeadNoscript;
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="lines">@@ -2684,7 +2685,7 @@
</span><span class="cx"> void HTMLTreeBuilder::processGenericRCDATAStartTag(AtomicHTMLToken& token)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(token.type() == HTMLToken::StartTag);
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_parser.tokenizer().setRCDATAState();
</span><span class="cx"> m_originalInsertionMode = m_insertionMode;
</span><span class="cx"> m_insertionMode = InsertionMode::Text;
</span><span class="lines">@@ -2693,7 +2694,7 @@
</span><span class="cx"> void HTMLTreeBuilder::processGenericRawTextStartTag(AtomicHTMLToken& token)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(token.type() == HTMLToken::StartTag);
</span><del>- m_tree.insertHTMLElement(&token);
</del><ins>+ m_tree.insertHTMLElement(token);
</ins><span class="cx"> m_parser.tokenizer().setRAWTEXTState();
</span><span class="cx"> m_originalInsertionMode = m_insertionMode;
</span><span class="cx"> m_insertionMode = InsertionMode::Text;
</span><span class="lines">@@ -2702,7 +2703,7 @@
</span><span class="cx"> void HTMLTreeBuilder::processScriptStartTag(AtomicHTMLToken& token)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(token.type() == HTMLToken::StartTag);
</span><del>- m_tree.insertScriptElement(&token);
</del><ins>+ m_tree.insertScriptElement(token);
</ins><span class="cx"> m_parser.tokenizer().setScriptDataState();
</span><span class="cx"> m_originalInsertionMode = m_insertionMode;
</span><span class="cx">
</span><span class="lines">@@ -2824,7 +2825,7 @@
</span><span class="cx"> adjustSVGAttributes(token);
</span><span class="cx"> }
</span><span class="cx"> adjustForeignAttributes(token);
</span><del>- m_tree.insertForeignElement(&token, currentNamespace);
</del><ins>+ m_tree.insertForeignElement(token, currentNamespace);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case HTMLToken::EndTag: {
</span><span class="lines">@@ -2844,7 +2845,7 @@
</span><span class="cx"> parseError(token);
</span><span class="cx"> while (1) {
</span><span class="cx"> if (nodeRecord->stackItem().localName() == token.name()) {
</span><del>- m_tree.openElements().popUntilPopped(&nodeRecord->element());
</del><ins>+ m_tree.openElements().popUntilPopped(nodeRecord->element());
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> nodeRecord = nodeRecord->next();
</span><span class="lines">@@ -2858,7 +2859,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case HTMLToken::Comment:
</span><del>- m_tree.insertComment(&token);
</del><ins>+ m_tree.insertComment(token);
</ins><span class="cx"> return;
</span><span class="cx"> case HTMLToken::Character: {
</span><span class="cx"> String characters = String(token.characters(), token.charactersLength());
</span></span></pre>
</div>
</div>
</body>
</html>