<!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>[177859] 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/177859">177859</a></dd>
<dt>Author</dt> <dd>darin@apple.com</dd>
<dt>Date</dt> <dd>2015-01-02 08:31:49 -0800 (Fri, 02 Jan 2015)</dd>
</dl>
<h3>Log Message</h3>
<pre>Modernize coding style of HTMLTreeBuilder
https://bugs.webkit.org/show_bug.cgi?id=140032
Reviewed by Andreas Kling.
Changes include:
- Use references rather than pointers.
- Mark data members const that are fully set up in the constructor.
- Remove many unneeded includes and forward declarations.
- Fix conditionals to be consistent and correct.
- Merge some multi-line constructs into a single line.
- Update whatwg.org URLs; not sure we should keep these, though.
- Cut down on use of WTF_MAKE_NONCOPYABLE since for many classes it's
impossible to copy anyway due to references, or harmless to copy.
- Made more things private.
- Initialize scalars in the class definition rather than each constructor.
- Use Ref/RefPtr instead of PassRefPtr.
* html/parser/HTMLDocumentParser.cpp:
(WebCore::HTMLDocumentParser::HTMLDocumentParser): Pass reference rather than pointer to
the context element.
(WebCore::HTMLDocumentParser::detach): Removed call to HTMLTreeBuilder::detach. This work
is instead done when the tree builder is destroyed.
(WebCore::HTMLDocumentParser::constructTreeFromHTMLToken): Pass reference rather than pointer.
* html/parser/HTMLTreeBuilder.cpp:
(WebCore::uninitializedPositionValue1): Marked this inline because it's trivial. It was
probably getting inlined already.
(WebCore::isCaptionColOrColgroupTag): Format on a single line.
(WebCore::isTableBodyContextTag): Ditto.
(WebCore::isNonAnchorFormattingTag): Ditto.
(WebCore::HTMLTreeBuilder::ExternalCharacterTokenBuffer::ExternalCharacterTokenBuffer):
Take reference instead of pointer.
(WebCore::HTMLTreeBuilder::ExternalCharacterTokenBuffer::takeRemaining): Use makeString helper.
(WebCore::HTMLTreeBuilder::ExternalCharacterTokenBuffer::skipLeading): Tweak formatting.
(WebCore::HTMLTreeBuilder::ExternalCharacterTokenBuffer::takeLeading): Both of the above.
(WebCore::HTMLTreeBuilder::ExternalCharacterTokenBuffer::makeString): Added.
(WebCore::HTMLTreeBuilder::isParsingTemplateContents): Moved the body of this function here,
since it's only used inside the class.
(WebCore::HTMLTreeBuilder::isParsingFragmentOrTemplateContents): Ditto.
(WebCore::HTMLTreeBuilder::HTMLTreeBuilder): Get rid of dead code that handles a null context
element. The FIXME mentions a bug that is obsolete. Also reorder the data members to be a bit
more logical and set the new m_destructionProhibited to false at the end of the constructor,
to check if we accidentally destroy the tree builder while constructing it.
(WebCore::HTMLTreeBuilder::FragmentParsingContext::FragmentParsingContext): Updated to take
a reference and to let m_fragment get initialized in the class definition.
(WebCore::HTMLTreeBuilder::FragmentParsingContext::fragment): Moved this here since it's only
used inside the class.
(WebCore::HTMLTreeBuilder::FragmentParsingContext::contextElement): Ditto.
(WebCore::HTMLTreeBuilder::FragmentParsingContext::contextElementStackItem): Ditto.
(WebCore::HTMLTreeBuilder::takeScriptToProcess): Changed return type to RefPtr instead of
PassRefPtr. Added code to handle m_scriptToProcess of null, since reading the code at the
single call site makes it clear that it's not guaranteed to be non-null! Added destruction-
related assertions since this is a public function.
(WebCore::HTMLTreeBuilder::constructTree): Updated for reference rather than pointer. Also
added destruction-related assertions since this is a public function.
(WebCore::HTMLTreeBuilder::processToken): Updated to take a reference.
(WebCore::HTMLTreeBuilder::processDoctypeToken): Ditto.
(WebCore::HTMLTreeBuilder::processFakeStartTag): Ditto. Also take an rvalue reference for
the vector of attributes that we will put into the token.
(WebCore::HTMLTreeBuilder::processFakeEndTag): Ditto.
(WebCore::HTMLTreeBuilder::processFakePEndTagIfPInButtonScope): Ditto.
(WebCore::HTMLTreeBuilder::attributesForIsindexInput): Ditto.
(WebCore::HTMLTreeBuilder::processIsindexStartTagForInBody): Ditto.
(WebCore::isLi): Ditto.
(WebCore::isDdOrDt): Ditto.
(WebCore::HTMLTreeBuilder::processCloseWhenNestedTag): Changed loop to use reference
rather than pointer for never-null stackItem. Also use auto and a for loop to make the
loop easier to read.
(WebCore::createCaseMap): Tweaked formatting.
(WebCore::adjustAttributes): Ditto.
(WebCore::HTMLTreeBuilder::processStartTagForInBody): Use reference instead of pointer.
Set insertion mode directly instead of using a setInsertionMode function.
(WebCore::HTMLTreeBuilder::processTemplateStartTag): Ditto.
(WebCore::HTMLTreeBuilder::processTemplateEndTag): Ditto.
(WebCore::HTMLTreeBuilder::processEndOfFileForInTemplateContents): Ditto.
(WebCore::HTMLTreeBuilder::processColgroupEndTagForInColumnGroup): Ditto.
(WebCore::HTMLTreeBuilder::closeTheCell): Ditto.
(WebCore::HTMLTreeBuilder::processStartTagForInTable): Ditto.
(WebCore::HTMLTreeBuilder::processStartTag): Ditto. Tweaked assertions, so that we
assert what state we are in before we fall through to each case, rather than asserting
inside each case. The per-case assertions were sort of excessive and repetitive and
even a bit hard to understand.
(WebCore::HTMLTreeBuilder::processHtmlStartTagForInBody): Ditto.
(WebCore::HTMLTreeBuilder::processBodyEndTagForInBody): Ditto.
(WebCore::HTMLTreeBuilder::processAnyOtherEndTagForInBody): Ditto.
(WebCore::HTMLTreeBuilder::callTheAdoptionAgency): Ditto.
(WebCore::HTMLTreeBuilder::resetInsertionModeAppropriately): Ditto.
(WebCore::HTMLTreeBuilder::processEndTagForInTableBody): Ditto.
(WebCore::HTMLTreeBuilder::processEndTagForInRow): Ditto.
(WebCore::HTMLTreeBuilder::processEndTagForInCell): Ditto.
(WebCore::HTMLTreeBuilder::processEndTagForInBody): Ditto.
(WebCore::HTMLTreeBuilder::processCaptionEndTagForInCaption): Ditto.
(WebCore::HTMLTreeBuilder::processTrEndTagForInRow): Ditto.
(WebCore::HTMLTreeBuilder::processTableEndTagForInTable): Ditto.
(WebCore::HTMLTreeBuilder::processEndTagForInTable): Ditto.
(WebCore::HTMLTreeBuilder::processEndTag): Ditto.
(WebCore::HTMLTreeBuilder::processComment): Ditto.
(WebCore::HTMLTreeBuilder::processCharacter): Ditto.
(WebCore::HTMLTreeBuilder::insertPhoneNumberLink): Ditto.
(WebCore::HTMLTreeBuilder::processCharacterBuffer): Ditto.
(WebCore::HTMLTreeBuilder::processCharacterBufferForInBody): Ditto.
(WebCore::HTMLTreeBuilder::processEndOfFile): Ditto.
(WebCore::HTMLTreeBuilder::defaultForInitial): Ditto.
(WebCore::HTMLTreeBuilder::defaultForBeforeHTML): Ditto.
(WebCore::HTMLTreeBuilder::defaultForBeforeHead): Ditto.
(WebCore::HTMLTreeBuilder::defaultForInHead): Ditto.
(WebCore::HTMLTreeBuilder::defaultForInHeadNoscript): Ditto.
(WebCore::HTMLTreeBuilder::defaultForAfterHead): Ditto.
(WebCore::HTMLTreeBuilder::defaultForInTableText): Ditto.
(WebCore::HTMLTreeBuilder::processStartTagForInHead): Ditto.
(WebCore::HTMLTreeBuilder::processGenericRCDATAStartTag): Ditto.
(WebCore::HTMLTreeBuilder::processGenericRawTextStartTag): Ditto.
(WebCore::HTMLTreeBuilder::processScriptStartTag): Ditto.
(WebCore::HTMLTreeBuilder::adjustedCurrentStackItem): Made this return a reference.
(WebCore::HTMLTreeBuilder::shouldProcessTokenInForeignContent): More of the same.
(WebCore::HTMLTreeBuilder::processTokenInForeignContent): Ditto.
(WebCore::HTMLTreeBuilder::finished): Changed m_isAttached assertion to !m_destroyed.
Also updated the comment.
(WebCore::HTMLTreeBuilder::parseError): Marked this empty function inline.
* html/parser/HTMLTreeBuilder.h: Removed most includes and forward declarations.
Changed the phone number functions conditional to be correct. Removed a non-helpful
FIXME about assertions we really don't need. Removed unneeded use of the inline keyword,
changed types to references rather than pointer. Removed unneeded public insertionMode
and setInsertionMode functions. Both are things that are only done inside this class and
m_insertionMode can be accessed directly instead. Added a destructor that implements
the destruction assertions. Asserted !m_destroyed at the start of all the public functions.
* html/parser/TextDocumentParser.cpp:
(WebCore::TextDocumentParser::insertFakePreElement): Use reference rather than pointer.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLDocumentParsercpp">trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLTreeBuildercpp">trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp</a></li>
<li><a href="#trunkSourceWebCorehtmlparserHTMLTreeBuilderh">trunk/Source/WebCore/html/parser/HTMLTreeBuilder.h</a></li>
<li><a href="#trunkSourceWebCorehtmlparserTextDocumentParsercpp">trunk/Source/WebCore/html/parser/TextDocumentParser.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (177858 => 177859)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2015-01-02 10:01:11 UTC (rev 177858)
+++ trunk/Source/WebCore/ChangeLog 2015-01-02 16:31:49 UTC (rev 177859)
</span><span class="lines">@@ -1,3 +1,137 @@
</span><ins>+2015-01-01 Darin Adler <darin@apple.com>
+
+ Modernize coding style of HTMLTreeBuilder
+ https://bugs.webkit.org/show_bug.cgi?id=140032
+
+ Reviewed by Andreas Kling.
+
+ Changes include:
+ - Use references rather than pointers.
+ - Mark data members const that are fully set up in the constructor.
+ - Remove many unneeded includes and forward declarations.
+ - Fix conditionals to be consistent and correct.
+ - Merge some multi-line constructs into a single line.
+ - Update whatwg.org URLs; not sure we should keep these, though.
+ - Cut down on use of WTF_MAKE_NONCOPYABLE since for many classes it's
+ impossible to copy anyway due to references, or harmless to copy.
+ - Made more things private.
+ - Initialize scalars in the class definition rather than each constructor.
+ - Use Ref/RefPtr instead of PassRefPtr.
+
+ * html/parser/HTMLDocumentParser.cpp:
+ (WebCore::HTMLDocumentParser::HTMLDocumentParser): Pass reference rather than pointer to
+ the context element.
+ (WebCore::HTMLDocumentParser::detach): Removed call to HTMLTreeBuilder::detach. This work
+ is instead done when the tree builder is destroyed.
+ (WebCore::HTMLDocumentParser::constructTreeFromHTMLToken): Pass reference rather than pointer.
+
+ * html/parser/HTMLTreeBuilder.cpp:
+ (WebCore::uninitializedPositionValue1): Marked this inline because it's trivial. It was
+ probably getting inlined already.
+ (WebCore::isCaptionColOrColgroupTag): Format on a single line.
+ (WebCore::isTableBodyContextTag): Ditto.
+ (WebCore::isNonAnchorFormattingTag): Ditto.
+ (WebCore::HTMLTreeBuilder::ExternalCharacterTokenBuffer::ExternalCharacterTokenBuffer):
+ Take reference instead of pointer.
+ (WebCore::HTMLTreeBuilder::ExternalCharacterTokenBuffer::takeRemaining): Use makeString helper.
+ (WebCore::HTMLTreeBuilder::ExternalCharacterTokenBuffer::skipLeading): Tweak formatting.
+ (WebCore::HTMLTreeBuilder::ExternalCharacterTokenBuffer::takeLeading): Both of the above.
+ (WebCore::HTMLTreeBuilder::ExternalCharacterTokenBuffer::makeString): Added.
+ (WebCore::HTMLTreeBuilder::isParsingTemplateContents): Moved the body of this function here,
+ since it's only used inside the class.
+ (WebCore::HTMLTreeBuilder::isParsingFragmentOrTemplateContents): Ditto.
+ (WebCore::HTMLTreeBuilder::HTMLTreeBuilder): Get rid of dead code that handles a null context
+ element. The FIXME mentions a bug that is obsolete. Also reorder the data members to be a bit
+ more logical and set the new m_destructionProhibited to false at the end of the constructor,
+ to check if we accidentally destroy the tree builder while constructing it.
+ (WebCore::HTMLTreeBuilder::FragmentParsingContext::FragmentParsingContext): Updated to take
+ a reference and to let m_fragment get initialized in the class definition.
+ (WebCore::HTMLTreeBuilder::FragmentParsingContext::fragment): Moved this here since it's only
+ used inside the class.
+ (WebCore::HTMLTreeBuilder::FragmentParsingContext::contextElement): Ditto.
+ (WebCore::HTMLTreeBuilder::FragmentParsingContext::contextElementStackItem): Ditto.
+ (WebCore::HTMLTreeBuilder::takeScriptToProcess): Changed return type to RefPtr instead of
+ PassRefPtr. Added code to handle m_scriptToProcess of null, since reading the code at the
+ single call site makes it clear that it's not guaranteed to be non-null! Added destruction-
+ related assertions since this is a public function.
+ (WebCore::HTMLTreeBuilder::constructTree): Updated for reference rather than pointer. Also
+ added destruction-related assertions since this is a public function.
+ (WebCore::HTMLTreeBuilder::processToken): Updated to take a reference.
+ (WebCore::HTMLTreeBuilder::processDoctypeToken): Ditto.
+ (WebCore::HTMLTreeBuilder::processFakeStartTag): Ditto. Also take an rvalue reference for
+ the vector of attributes that we will put into the token.
+ (WebCore::HTMLTreeBuilder::processFakeEndTag): Ditto.
+ (WebCore::HTMLTreeBuilder::processFakePEndTagIfPInButtonScope): Ditto.
+ (WebCore::HTMLTreeBuilder::attributesForIsindexInput): Ditto.
+ (WebCore::HTMLTreeBuilder::processIsindexStartTagForInBody): Ditto.
+ (WebCore::isLi): Ditto.
+ (WebCore::isDdOrDt): Ditto.
+ (WebCore::HTMLTreeBuilder::processCloseWhenNestedTag): Changed loop to use reference
+ rather than pointer for never-null stackItem. Also use auto and a for loop to make the
+ loop easier to read.
+ (WebCore::createCaseMap): Tweaked formatting.
+ (WebCore::adjustAttributes): Ditto.
+ (WebCore::HTMLTreeBuilder::processStartTagForInBody): Use reference instead of pointer.
+ Set insertion mode directly instead of using a setInsertionMode function.
+ (WebCore::HTMLTreeBuilder::processTemplateStartTag): Ditto.
+ (WebCore::HTMLTreeBuilder::processTemplateEndTag): Ditto.
+ (WebCore::HTMLTreeBuilder::processEndOfFileForInTemplateContents): Ditto.
+ (WebCore::HTMLTreeBuilder::processColgroupEndTagForInColumnGroup): Ditto.
+ (WebCore::HTMLTreeBuilder::closeTheCell): Ditto.
+ (WebCore::HTMLTreeBuilder::processStartTagForInTable): Ditto.
+ (WebCore::HTMLTreeBuilder::processStartTag): Ditto. Tweaked assertions, so that we
+ assert what state we are in before we fall through to each case, rather than asserting
+ inside each case. The per-case assertions were sort of excessive and repetitive and
+ even a bit hard to understand.
+ (WebCore::HTMLTreeBuilder::processHtmlStartTagForInBody): Ditto.
+ (WebCore::HTMLTreeBuilder::processBodyEndTagForInBody): Ditto.
+ (WebCore::HTMLTreeBuilder::processAnyOtherEndTagForInBody): Ditto.
+ (WebCore::HTMLTreeBuilder::callTheAdoptionAgency): Ditto.
+ (WebCore::HTMLTreeBuilder::resetInsertionModeAppropriately): Ditto.
+ (WebCore::HTMLTreeBuilder::processEndTagForInTableBody): Ditto.
+ (WebCore::HTMLTreeBuilder::processEndTagForInRow): Ditto.
+ (WebCore::HTMLTreeBuilder::processEndTagForInCell): Ditto.
+ (WebCore::HTMLTreeBuilder::processEndTagForInBody): Ditto.
+ (WebCore::HTMLTreeBuilder::processCaptionEndTagForInCaption): Ditto.
+ (WebCore::HTMLTreeBuilder::processTrEndTagForInRow): Ditto.
+ (WebCore::HTMLTreeBuilder::processTableEndTagForInTable): Ditto.
+ (WebCore::HTMLTreeBuilder::processEndTagForInTable): Ditto.
+ (WebCore::HTMLTreeBuilder::processEndTag): Ditto.
+ (WebCore::HTMLTreeBuilder::processComment): Ditto.
+ (WebCore::HTMLTreeBuilder::processCharacter): Ditto.
+ (WebCore::HTMLTreeBuilder::insertPhoneNumberLink): Ditto.
+ (WebCore::HTMLTreeBuilder::processCharacterBuffer): Ditto.
+ (WebCore::HTMLTreeBuilder::processCharacterBufferForInBody): Ditto.
+ (WebCore::HTMLTreeBuilder::processEndOfFile): Ditto.
+ (WebCore::HTMLTreeBuilder::defaultForInitial): Ditto.
+ (WebCore::HTMLTreeBuilder::defaultForBeforeHTML): Ditto.
+ (WebCore::HTMLTreeBuilder::defaultForBeforeHead): Ditto.
+ (WebCore::HTMLTreeBuilder::defaultForInHead): Ditto.
+ (WebCore::HTMLTreeBuilder::defaultForInHeadNoscript): Ditto.
+ (WebCore::HTMLTreeBuilder::defaultForAfterHead): Ditto.
+ (WebCore::HTMLTreeBuilder::defaultForInTableText): Ditto.
+ (WebCore::HTMLTreeBuilder::processStartTagForInHead): Ditto.
+ (WebCore::HTMLTreeBuilder::processGenericRCDATAStartTag): Ditto.
+ (WebCore::HTMLTreeBuilder::processGenericRawTextStartTag): Ditto.
+ (WebCore::HTMLTreeBuilder::processScriptStartTag): Ditto.
+ (WebCore::HTMLTreeBuilder::adjustedCurrentStackItem): Made this return a reference.
+ (WebCore::HTMLTreeBuilder::shouldProcessTokenInForeignContent): More of the same.
+ (WebCore::HTMLTreeBuilder::processTokenInForeignContent): Ditto.
+ (WebCore::HTMLTreeBuilder::finished): Changed m_isAttached assertion to !m_destroyed.
+ Also updated the comment.
+ (WebCore::HTMLTreeBuilder::parseError): Marked this empty function inline.
+
+ * html/parser/HTMLTreeBuilder.h: Removed most includes and forward declarations.
+ Changed the phone number functions conditional to be correct. Removed a non-helpful
+ FIXME about assertions we really don't need. Removed unneeded use of the inline keyword,
+ changed types to references rather than pointer. Removed unneeded public insertionMode
+ and setInsertionMode functions. Both are things that are only done inside this class and
+ m_insertionMode can be accessed directly instead. Added a destructor that implements
+ the destruction assertions. Asserted !m_destroyed at the start of all the public functions.
+
+ * html/parser/TextDocumentParser.cpp:
+ (WebCore::TextDocumentParser::insertFakePreElement): Use reference rather than pointer.
+
</ins><span class="cx"> 2015-01-02 Manuel Rego Casasnovas <rego@igalia.com>
</span><span class="cx">
</span><span class="cx"> [CSS Grid Layout] Remove stack from grid-auto-flow syntax
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLDocumentParsercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp (177858 => 177859)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp 2015-01-02 10:01:11 UTC (rev 177858)
+++ trunk/Source/WebCore/html/parser/HTMLDocumentParser.cpp 2015-01-02 16:31:49 UTC (rev 177859)
</span><span class="lines">@@ -92,7 +92,7 @@
</span><span class="cx"> , m_options(fragment.document())
</span><span class="cx"> , m_token(std::make_unique<HTMLToken>())
</span><span class="cx"> , m_tokenizer(std::make_unique<HTMLTokenizer>(m_options))
</span><del>- , m_treeBuilder(std::make_unique<HTMLTreeBuilder>(*this, fragment, contextElement, this->parserContentPolicy(), m_options))
</del><ins>+ , m_treeBuilder(std::make_unique<HTMLTreeBuilder>(*this, fragment, *contextElement, this->parserContentPolicy(), m_options))
</ins><span class="cx"> , m_xssAuditorDelegate(fragment.document())
</span><span class="cx"> , m_endWasDelayed(false)
</span><span class="cx"> , m_haveBackgroundParser(false)
</span><span class="lines">@@ -118,7 +118,6 @@
</span><span class="cx">
</span><span class="cx"> if (m_scriptRunner)
</span><span class="cx"> m_scriptRunner->detach();
</span><del>- m_treeBuilder->detach();
</del><span class="cx"> // FIXME: It seems wrong that we would have a preload scanner here.
</span><span class="cx"> // Yet during fast/dom/HTMLScriptElement/script-load-events.html we do.
</span><span class="cx"> m_preloadScanner = nullptr;
</span><span class="lines">@@ -349,7 +348,7 @@
</span><span class="cx"> if (rawToken.type() != HTMLToken::Character)
</span><span class="cx"> rawToken.clear();
</span><span class="cx">
</span><del>- m_treeBuilder->constructTree(&token);
</del><ins>+ m_treeBuilder->constructTree(token);
</ins><span class="cx">
</span><span class="cx"> if (!rawToken.isUninitialized()) {
</span><span class="cx"> ASSERT(rawToken.type() == HTMLToken::Character);
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLTreeBuildercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp (177858 => 177859)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp 2015-01-02 10:01:11 UTC (rev 177858)
+++ trunk/Source/WebCore/html/parser/HTMLTreeBuilder.cpp 2015-01-02 16:31:49 UTC (rev 177859)
</span><span class="lines">@@ -1,6 +1,6 @@
</span><span class="cx"> /*
</span><span class="cx"> * Copyright (C) 2010 Google, Inc. All Rights Reserved.
</span><del>- * Copyright (C) 2011 Apple Inc. All rights reserved.
</del><ins>+ * Copyright (C) 2011, 2015 Apple Inc. All rights reserved.
</ins><span class="cx"> *
</span><span class="cx"> * Redistribution and use in source and binary forms, with or without
</span><span class="cx"> * modification, are permitted provided that the following conditions
</span><span class="lines">@@ -30,23 +30,18 @@
</span><span class="cx"> #include "DocumentFragment.h"
</span><span class="cx"> #include "HTMLDocument.h"
</span><span class="cx"> #include "HTMLDocumentParser.h"
</span><del>-#include "HTMLFormControlElement.h"
</del><span class="cx"> #include "HTMLFormElement.h"
</span><span class="cx"> #include "HTMLOptGroupElement.h"
</span><del>-#include "HTMLOptionElement.h"
</del><span class="cx"> #include "HTMLParserIdioms.h"
</span><del>-#include "HTMLTableElement.h"
-#include "HTMLTemplateElement.h"
</del><span class="cx"> #include "LocalizedStrings.h"
</span><span class="cx"> #include "NotImplemented.h"
</span><span class="cx"> #include "XLinkNames.h"
</span><span class="cx"> #include "XMLNSNames.h"
</span><span class="cx"> #include "XMLNames.h"
</span><del>-#include <wtf/MainThread.h>
</del><span class="cx"> #include <wtf/NeverDestroyed.h>
</span><span class="cx"> #include <wtf/unicode/CharacterNames.h>
</span><span class="cx">
</span><del>-#if ENABLE(TELEPHONE_NUMBER_DETECTION)
</del><ins>+#if ENABLE(TELEPHONE_NUMBER_DETECTION) && PLATFORM(IOS)
</ins><span class="cx"> #include "TelephoneNumberDetector.h"
</span><span class="cx"> #endif
</span><span class="cx">
</span><span class="lines">@@ -63,7 +58,7 @@
</span><span class="cx">
</span><span class="cx"> }
</span><span class="cx">
</span><del>-static TextPosition uninitializedPositionValue1()
</del><ins>+static inline TextPosition uninitializedPositionValue1()
</ins><span class="cx"> {
</span><span class="cx"> return TextPosition(OrdinalNumber::fromOneBasedInt(-1), OrdinalNumber::first());
</span><span class="cx"> }
</span><span class="lines">@@ -90,9 +85,7 @@
</span><span class="cx">
</span><span class="cx"> static bool isCaptionColOrColgroupTag(const AtomicString& tagName)
</span><span class="cx"> {
</span><del>- return tagName == captionTag
- || tagName == colTag
- || tagName == colgroupTag;
</del><ins>+ return tagName == captionTag || tagName == colTag || tagName == colgroupTag;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static bool isTableCellContextTag(const AtomicString& tagName)
</span><span class="lines">@@ -102,9 +95,7 @@
</span><span class="cx">
</span><span class="cx"> static bool isTableBodyContextTag(const AtomicString& tagName)
</span><span class="cx"> {
</span><del>- return tagName == tbodyTag
- || tagName == tfootTag
- || tagName == theadTag;
</del><ins>+ return tagName == tbodyTag || tagName == tfootTag || tagName == theadTag;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static bool isNonAnchorNonNobrFormattingTag(const AtomicString& tagName)
</span><span class="lines">@@ -125,29 +116,27 @@
</span><span class="cx">
</span><span class="cx"> static bool isNonAnchorFormattingTag(const AtomicString& tagName)
</span><span class="cx"> {
</span><del>- return tagName == nobrTag
- || isNonAnchorNonNobrFormattingTag(tagName);
</del><ins>+ return tagName == nobrTag || isNonAnchorNonNobrFormattingTag(tagName);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-// http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#formatting
</del><ins>+// https://html.spec.whatwg.org/multipage/syntax.html#formatting
</ins><span class="cx"> static bool isFormattingTag(const AtomicString& tagName)
</span><span class="cx"> {
</span><span class="cx"> return tagName == aTag || isNonAnchorFormattingTag(tagName);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> class HTMLTreeBuilder::ExternalCharacterTokenBuffer {
</span><del>- WTF_MAKE_NONCOPYABLE(ExternalCharacterTokenBuffer);
</del><span class="cx"> public:
</span><del>- explicit ExternalCharacterTokenBuffer(AtomicHTMLToken* token)
- : m_text(token->characters(), token->charactersLength())
- , m_isAll8BitData(token->isAll8BitData())
</del><ins>+ explicit ExternalCharacterTokenBuffer(AtomicHTMLToken& token)
+ : m_text(token.characters(), token.charactersLength())
+ , m_isAll8BitData(token.isAll8BitData())
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!isEmpty());
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> explicit ExternalCharacterTokenBuffer(const String& string)
</span><span class="cx"> : m_text(string)
</span><del>- , m_isAll8BitData(m_text.length() && m_text.is8Bit())
</del><ins>+ , m_isAll8BitData(m_text.is8Bit())
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!isEmpty());
</span><span class="cx"> }
</span><span class="lines">@@ -185,11 +174,7 @@
</span><span class="cx">
</span><span class="cx"> String takeRemaining()
</span><span class="cx"> {
</span><del>- String result;
- if (m_text.is8Bit() || !isAll8BitData())
- result = m_text.toString();
- else
- result = String::make8BitFrom16BitSource(m_text.characters16(), m_text.length());
</del><ins>+ String result = makeString(m_text);
</ins><span class="cx"> m_text = StringView();
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="lines">@@ -221,8 +206,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- template<bool characterPredicate(UChar)>
- void skipLeading()
</del><ins>+ template<bool characterPredicate(UChar)> void skipLeading()
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!isEmpty());
</span><span class="cx"> while (characterPredicate(m_text[0])) {
</span><span class="lines">@@ -232,122 +216,124 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- template<bool characterPredicate(UChar)>
- String takeLeading()
</del><ins>+ template<bool characterPredicate(UChar)> String takeLeading()
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!isEmpty());
</span><span class="cx"> StringView start = m_text;
</span><span class="cx"> skipLeading<characterPredicate>();
</span><span class="cx"> if (start.length() == m_text.length())
</span><span class="cx"> return String();
</span><del>- StringView leading = start.substring(0, start.length() - m_text.length());
- if (leading.is8Bit() || !isAll8BitData())
- return leading.toString();
- return String::make8BitFrom16BitSource(leading.characters16(), leading.length());
</del><ins>+ return makeString(start.substring(0, start.length() - m_text.length()));
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+ String makeString(StringView stringView) const
+ {
+ if (stringView.is8Bit() || !isAll8BitData())
+ return stringView.toString();
+ return String::make8BitFrom16BitSource(stringView.characters16(), stringView.length());
+ }
+
</ins><span class="cx"> StringView m_text;
</span><span class="cx"> bool m_isAll8BitData;
</span><span class="cx"> };
</span><span class="cx">
</span><del>-
-HTMLTreeBuilder::HTMLTreeBuilder(HTMLDocumentParser& parser, HTMLDocument& document, ParserContentPolicy parserContentPolicy, const HTMLParserOptions& options)
- : m_framesetOk(true)
-#ifndef NDEBUG
- , m_isAttached(true)
</del><ins>+inline bool HTMLTreeBuilder::isParsingTemplateContents() const
+{
+#if ENABLE(TEMPLATE_ELEMENT)
+ return m_tree.openElements()->hasTemplateInHTMLScope();
+#else
+ return false;
</ins><span class="cx"> #endif
</span><ins>+}
+
+inline bool HTMLTreeBuilder::isParsingFragmentOrTemplateContents() const
+{
+ return isParsingFragment() || isParsingTemplateContents();
+}
+
+HTMLTreeBuilder::HTMLTreeBuilder(const HTMLDocumentParser& parser, HTMLDocument& document, ParserContentPolicy parserContentPolicy, const HTMLParserOptions& options)
+ : m_parser(parser)
+ , m_options(options)
</ins><span class="cx"> , m_tree(document, parserContentPolicy, options.maximumDOMTreeDepth)
</span><del>- , m_insertionMode(InsertionMode::Initial)
- , m_originalInsertionMode(InsertionMode::Initial)
- , m_shouldSkipLeadingNewline(false)
- , m_parser(parser)
</del><span class="cx"> , m_scriptToProcessStartPosition(uninitializedPositionValue1())
</span><del>- , m_options(options)
</del><span class="cx"> {
</span><ins>+#if !ASSERT_DISABLED
+ m_destructionProhibited = false;
+#endif
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-// FIXME: Member variables should be grouped into self-initializing structs to
-// minimize code duplication between these constructors.
-HTMLTreeBuilder::HTMLTreeBuilder(HTMLDocumentParser& parser, DocumentFragment& fragment, Element* contextElement, ParserContentPolicy parserContentPolicy, const HTMLParserOptions& options)
- : m_framesetOk(true)
-#ifndef NDEBUG
- , m_isAttached(true)
-#endif
</del><ins>+HTMLTreeBuilder::HTMLTreeBuilder(const HTMLDocumentParser& parser, DocumentFragment& fragment, Element& contextElement, ParserContentPolicy parserContentPolicy, const HTMLParserOptions& options)
+ : m_parser(parser)
+ , m_options(options)
</ins><span class="cx"> , m_fragmentContext(fragment, contextElement)
</span><span class="cx"> , m_tree(fragment, parserContentPolicy, options.maximumDOMTreeDepth)
</span><del>- , m_insertionMode(InsertionMode::Initial)
- , m_originalInsertionMode(InsertionMode::Initial)
- , m_shouldSkipLeadingNewline(false)
- , m_parser(parser)
</del><span class="cx"> , m_scriptToProcessStartPosition(uninitializedPositionValue1())
</span><del>- , m_options(options)
</del><span class="cx"> {
</span><span class="cx"> ASSERT(isMainThread());
</span><del>- // FIXME: This assertion will become invalid if <http://webkit.org/b/60316> is fixed.
- ASSERT(contextElement);
- if (contextElement) {
- // Steps 4.2-4.6 of the HTML5 Fragment Case parsing algorithm:
- // http://www.whatwg.org/specs/web-apps/current-work/multipage/the-end.html#fragment-case
- // For efficiency, we skip step 4.2 ("Let root be a new html element with no attributes")
- // and instead use the DocumentFragment as a root node.
- m_tree.openElements()->pushRootNode(HTMLStackItem::create(&fragment, HTMLStackItem::ItemForDocumentFragmentNode));
</del><span class="cx">
</span><ins>+ // https://html.spec.whatwg.org/multipage/syntax.html#parsing-html-fragments
+ // For efficiency, we skip step 5 ("Let root be a new html element with no attributes") and instead use the DocumentFragment as a root node.
+ m_tree.openElements()->pushRootNode(HTMLStackItem::create(&fragment, HTMLStackItem::ItemForDocumentFragmentNode));
+
</ins><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (contextElement->hasTagName(templateTag))
- m_templateInsertionModes.append(InsertionMode::TemplateContents);
</del><ins>+ if (contextElement.hasTagName(templateTag))
+ m_templateInsertionModes.append(InsertionMode::TemplateContents);
</ins><span class="cx"> #endif
</span><span class="cx">
</span><del>- resetInsertionModeAppropriately();
- m_tree.setForm(!contextElement || is<HTMLFormElement>(*contextElement) ? downcast<HTMLFormElement>(contextElement) : HTMLFormElement::findClosestFormAncestor(*contextElement));
- }
-}
</del><ins>+ resetInsertionModeAppropriately();
</ins><span class="cx">
</span><del>-HTMLTreeBuilder::~HTMLTreeBuilder()
-{
-}
</del><ins>+ m_tree.setForm(is<HTMLFormElement>(contextElement) ? &downcast<HTMLFormElement>(contextElement) : HTMLFormElement::findClosestFormAncestor(contextElement));
</ins><span class="cx">
</span><del>-void HTMLTreeBuilder::detach()
-{
-#ifndef NDEBUG
- // This call makes little sense in fragment mode, but for consistency
- // DocumentParser expects detach() to always be called before it's destroyed.
- m_isAttached = false;
</del><ins>+#if !ASSERT_DISABLED
+ m_destructionProhibited = false;
</ins><span class="cx"> #endif
</span><del>- // HTMLConstructionSite might be on the callstack when detach() is called
- // otherwise we'd just call m_tree.clear() here instead.
- m_tree.detach();
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> HTMLTreeBuilder::FragmentParsingContext::FragmentParsingContext()
</span><del>- : m_fragment(0)
</del><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><del>-HTMLTreeBuilder::FragmentParsingContext::FragmentParsingContext(DocumentFragment& fragment, Element* contextElement)
</del><ins>+HTMLTreeBuilder::FragmentParsingContext::FragmentParsingContext(DocumentFragment& fragment, Element& contextElement)
</ins><span class="cx"> : m_fragment(&fragment)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(!fragment.hasChildNodes());
</span><del>- m_contextElementStackItem = HTMLStackItem::create(contextElement, HTMLStackItem::ItemForContextElement);
</del><ins>+ m_contextElementStackItem = HTMLStackItem::create(&contextElement, HTMLStackItem::ItemForContextElement);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-HTMLTreeBuilder::FragmentParsingContext::~FragmentParsingContext()
</del><ins>+inline Element& HTMLTreeBuilder::FragmentParsingContext::contextElement() const
</ins><span class="cx"> {
</span><ins>+ return *contextElementStackItem().element();
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<Element> HTMLTreeBuilder::takeScriptToProcess(TextPosition& scriptStartPosition)
</del><ins>+inline HTMLStackItem& HTMLTreeBuilder::FragmentParsingContext::contextElementStackItem() const
</ins><span class="cx"> {
</span><del>- ASSERT(m_scriptToProcess);
</del><ins>+ ASSERT(m_fragment);
+ return *m_contextElementStackItem;
+}
+
+RefPtr<Element> HTMLTreeBuilder::takeScriptToProcess(TextPosition& scriptStartPosition)
+{
+ ASSERT(!m_destroyed);
+
+ if (!m_scriptToProcess)
+ return nullptr;
+
</ins><span class="cx"> // Unpause ourselves, callers may pause us again when processing the script.
</span><del>- // The HTML5 spec is written as though scripts are executed inside the tree
- // builder. We pause the parser to exit the tree builder, and then resume
- // before running scripts.
</del><ins>+ // The HTML5 spec is written as though scripts are executed inside the tree builder.
+ // We pause the parser to exit the tree builder, and then resume before running scripts.
</ins><span class="cx"> scriptStartPosition = m_scriptToProcessStartPosition;
</span><span class="cx"> m_scriptToProcessStartPosition = uninitializedPositionValue1();
</span><del>- return m_scriptToProcess.release();
</del><ins>+ return WTF::move(m_scriptToProcess);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::constructTree(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::constructTree(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><ins>+#if !ASSERT_DISABLED
+ ASSERT(!m_destroyed);
+ ASSERT(!m_destructionProhibited);
+ m_destructionProhibited = true;
+#endif
+
</ins><span class="cx"> if (shouldProcessTokenInForeignContent(token))
</span><span class="cx"> processTokenInForeignContent(token);
</span><span class="cx"> else
</span><span class="lines">@@ -355,7 +341,7 @@
</span><span class="cx">
</span><span class="cx"> if (m_parser.tokenizer()) {
</span><span class="cx"> bool inForeignContent = !m_tree.isEmpty()
</span><del>- && !adjustedCurrentStackItem()->isInHTMLNamespace()
</del><ins>+ && !adjustedCurrentStackItem().isInHTMLNamespace()
</ins><span class="cx"> && !HTMLElementStack::isHTMLIntegrationPoint(m_tree.currentStackItem())
</span><span class="cx"> && !HTMLElementStack::isMathMLTextIntegrationPoint(m_tree.currentStackItem());
</span><span class="cx">
</span><span class="lines">@@ -363,13 +349,17 @@
</span><span class="cx"> m_parser.tokenizer()->setShouldAllowCDATA(inForeignContent);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+#if !ASSERT_DISABLED
+ m_destructionProhibited = false;
+#endif
+
</ins><span class="cx"> m_tree.executeQueuedTasks();
</span><del>- // We might be detached now.
</del><ins>+ // The tree builder might have been destroyed as an indirect result of executing the queued tasks.
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processToken(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processToken(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- switch (token->type()) {
</del><ins>+ switch (token.type()) {
</ins><span class="cx"> case HTMLToken::Uninitialized:
</span><span class="cx"> ASSERT_NOT_REACHED();
</span><span class="cx"> break;
</span><span class="lines">@@ -399,12 +389,12 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processDoctypeToken(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processDoctypeToken(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::DOCTYPE);
</del><ins>+ ASSERT(token.type() == HTMLToken::DOCTYPE);
</ins><span class="cx"> if (m_insertionMode == InsertionMode::Initial) {
</span><del>- m_tree.insertDoctype(token);
- setInsertionMode(InsertionMode::BeforeHTML);
</del><ins>+ m_tree.insertDoctype(&token);
+ m_insertionMode = InsertionMode::BeforeHTML;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> if (m_insertionMode == InsertionMode::InTableText) {
</span><span class="lines">@@ -415,17 +405,17 @@
</span><span class="cx"> parseError(token);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processFakeStartTag(const QualifiedName& tagName, const Vector<Attribute>& attributes)
</del><ins>+void HTMLTreeBuilder::processFakeStartTag(const QualifiedName& tagName, Vector<Attribute>&& attributes)
</ins><span class="cx"> {
</span><span class="cx"> // FIXME: We'll need a fancier conversion than just "localName" for SVG/MathML tags.
</span><del>- AtomicHTMLToken fakeToken(HTMLToken::StartTag, tagName.localName(), attributes);
- processStartTag(&fakeToken);
</del><ins>+ AtomicHTMLToken fakeToken(HTMLToken::StartTag, tagName.localName(), WTF::move(attributes));
+ processStartTag(fakeToken);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::processFakeEndTag(const AtomicString& tagName)
</span><span class="cx"> {
</span><span class="cx"> AtomicHTMLToken fakeToken(HTMLToken::EndTag, tagName);
</span><del>- processEndTag(&fakeToken);
</del><ins>+ processEndTag(fakeToken);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::processFakeEndTag(const QualifiedName& tagName)
</span><span class="lines">@@ -446,12 +436,12 @@
</span><span class="cx"> if (!m_tree.openElements()->inButtonScope(pTag.localName()))
</span><span class="cx"> return;
</span><span class="cx"> AtomicHTMLToken endP(HTMLToken::EndTag, pTag.localName());
</span><del>- processEndTag(&endP);
</del><ins>+ processEndTag(endP);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-Vector<Attribute> HTMLTreeBuilder::attributesForIsindexInput(AtomicHTMLToken* token)
</del><ins>+Vector<Attribute> HTMLTreeBuilder::attributesForIsindexInput(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- Vector<Attribute> attributes = token->attributes();
</del><ins>+ Vector<Attribute> attributes = token.attributes();
</ins><span class="cx"> for (int i = attributes.size() - 1; i >= 0; --i) {
</span><span class="cx"> const QualifiedName& name = attributes.at(i).name();
</span><span class="cx"> if (name.matches(nameAttr) || name.matches(actionAttr) || name.matches(promptAttr))
</span><span class="lines">@@ -462,21 +452,21 @@
</span><span class="cx"> return attributes;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processIsindexStartTagForInBody(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processIsindexStartTagForInBody(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::StartTag);
- ASSERT(token->name() == isindexTag);
</del><ins>+ ASSERT(token.type() == HTMLToken::StartTag);
+ ASSERT(token.name() == isindexTag);
</ins><span class="cx"> parseError(token);
</span><span class="cx"> if (m_tree.form() && !isParsingTemplateContents())
</span><span class="cx"> return;
</span><span class="cx"> notImplemented(); // Acknowledge self-closing flag
</span><span class="cx"> processFakeStartTag(formTag);
</span><del>- Attribute* actionAttribute = token->getAttributeItem(actionAttr);
</del><ins>+ Attribute* actionAttribute = token.getAttributeItem(actionAttr);
</ins><span class="cx"> if (actionAttribute)
</span><span class="cx"> m_tree.form()->setAttribute(actionAttr, actionAttribute->value());
</span><span class="cx"> processFakeStartTag(hrTag);
</span><span class="cx"> processFakeStartTag(labelTag);
</span><del>- Attribute* promptAttribute = token->getAttributeItem(promptAttr);
</del><ins>+ Attribute* promptAttribute = token.getAttributeItem(promptAttr);
</ins><span class="cx"> if (promptAttribute)
</span><span class="cx"> processFakeCharacters(promptAttribute->value());
</span><span class="cx"> else
</span><span class="lines">@@ -490,41 +480,36 @@
</span><span class="cx">
</span><span class="cx"> namespace {
</span><span class="cx">
</span><del>-bool isLi(const HTMLStackItem* item)
</del><ins>+bool isLi(const HTMLStackItem& item)
</ins><span class="cx"> {
</span><del>- return item->hasTagName(liTag);
</del><ins>+ return item.hasTagName(liTag);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool isDdOrDt(const HTMLStackItem* item)
</del><ins>+bool isDdOrDt(const HTMLStackItem& item)
</ins><span class="cx"> {
</span><del>- return item->hasTagName(ddTag)
- || item->hasTagName(dtTag);
</del><ins>+ return item.hasTagName(ddTag) || item.hasTagName(dtTag);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> }
</span><span class="cx">
</span><del>-template <bool shouldClose(const HTMLStackItem*)>
-void HTMLTreeBuilder::processCloseWhenNestedTag(AtomicHTMLToken* token)
</del><ins>+template <bool shouldClose(const HTMLStackItem&)> void HTMLTreeBuilder::processCloseWhenNestedTag(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> m_framesetOk = false;
</span><del>- HTMLElementStack::ElementRecord* nodeRecord = m_tree.openElements()->topRecord();
- while (1) {
- RefPtr<HTMLStackItem> item = nodeRecord->stackItem();
- if (shouldClose(item.get())) {
- ASSERT(item->isElementNode());
- processFakeEndTag(item->localName());
</del><ins>+ for (auto* nodeRecord = m_tree.openElements()->topRecord(); ; nodeRecord = nodeRecord->next()) {
+ HTMLStackItem& item = *nodeRecord->stackItem();
+ if (shouldClose(item)) {
+ ASSERT(item.isElementNode());
+ processFakeEndTag(item.localName());
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><del>- if (item->isSpecialNode() && !item->hasTagName(addressTag) && !item->hasTagName(divTag) && !item->hasTagName(pTag))
</del><ins>+ if (item.isSpecialNode() && !item.hasTagName(addressTag) && !item.hasTagName(divTag) && !item.hasTagName(pTag))
</ins><span class="cx"> break;
</span><del>- nodeRecord = nodeRecord->next();
</del><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><del>-template <typename TableQualifiedName>
-static HashMap<AtomicString, QualifiedName> createCaseMap(const TableQualifiedName* const names[], unsigned length)
</del><ins>+template <typename TableQualifiedName> static HashMap<AtomicString, QualifiedName> createCaseMap(const TableQualifiedName* const names[], unsigned length)
</ins><span class="cx"> {
</span><span class="cx"> HashMap<AtomicString, QualifiedName> map;
</span><span class="cx"> for (unsigned i = 0; i < length; ++i) {
</span><span class="lines">@@ -555,8 +540,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-template<const QualifiedName* const* attributesTable(), unsigned attributesTableLength>
-static void adjustAttributes(AtomicHTMLToken& token)
</del><ins>+template<const QualifiedName* const* attributesTable(), unsigned attributesTableLength> static void adjustAttributes(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> static NeverDestroyed<HashMap<AtomicString, QualifiedName>> map = createCaseMap(attributesTable(), attributesTableLength);
</span><span class="cx"> adjustAttributes(map, token);
</span><span class="lines">@@ -600,28 +584,28 @@
</span><span class="cx"> adjustAttributes(map, token);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processStartTagForInBody(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processStartTagForInBody(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::StartTag);
- if (token->name() == htmlTag) {
</del><ins>+ ASSERT(token.type() == HTMLToken::StartTag);
+ if (token.name() == htmlTag) {
</ins><span class="cx"> processHtmlStartTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == baseTag
- || token->name() == basefontTag
- || token->name() == bgsoundTag
- || token->name() == commandTag
- || token->name() == linkTag
- || token->name() == metaTag
- || token->name() == noframesTag
- || token->name() == scriptTag
- || token->name() == styleTag
- || token->name() == titleTag) {
</del><ins>+ if (token.name() == baseTag
+ || token.name() == basefontTag
+ || token.name() == bgsoundTag
+ || token.name() == commandTag
+ || token.name() == linkTag
+ || token.name() == metaTag
+ || token.name() == noframesTag
+ || token.name() == scriptTag
+ || token.name() == styleTag
+ || token.name() == titleTag) {
</ins><span class="cx"> bool didProcess = processStartTagForInHead(token);
</span><span class="cx"> ASSERT_UNUSED(didProcess, didProcess);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == bodyTag) {
</del><ins>+ if (token.name() == bodyTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> bool fragmentOrTemplateCase = !m_tree.openElements()->secondElementIsHTMLBodyElement() || m_tree.openElements()->hasOnlyOneElement();
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><span class="lines">@@ -632,10 +616,10 @@
</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><del>- if (token->name() == framesetTag) {
</del><ins>+ if (token.name() == framesetTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> if (!m_tree.openElements()->secondElementIsHTMLBodyElement() || m_tree.openElements()->hasOnlyOneElement()) {
</span><span class="cx"> ASSERT(isParsingFragmentOrTemplateContents());
</span><span class="lines">@@ -647,78 +631,78 @@
</span><span class="cx"> m_tree.openElements()->popUntil(m_tree.openElements()->bodyElement());
</span><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);
- setInsertionMode(InsertionMode::InFrameset);
</del><ins>+ m_tree.insertHTMLElement(&token);
+ m_insertionMode = InsertionMode::InFrameset;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == addressTag
- || token->name() == articleTag
- || token->name() == asideTag
- || token->name() == blockquoteTag
- || token->name() == centerTag
- || token->name() == detailsTag
- || token->name() == dirTag
- || token->name() == divTag
- || token->name() == dlTag
- || token->name() == fieldsetTag
- || token->name() == figcaptionTag
- || token->name() == figureTag
- || token->name() == footerTag
- || token->name() == headerTag
- || token->name() == hgroupTag
- || token->name() == mainTag
- || token->name() == menuTag
- || token->name() == navTag
- || token->name() == olTag
- || token->name() == pTag
- || token->name() == sectionTag
- || token->name() == summaryTag
- || token->name() == ulTag) {
</del><ins>+ if (token.name() == addressTag
+ || token.name() == articleTag
+ || token.name() == asideTag
+ || token.name() == blockquoteTag
+ || token.name() == centerTag
+ || token.name() == detailsTag
+ || token.name() == dirTag
+ || token.name() == divTag
+ || token.name() == dlTag
+ || token.name() == fieldsetTag
+ || token.name() == figcaptionTag
+ || token.name() == figureTag
+ || token.name() == footerTag
+ || token.name() == headerTag
+ || token.name() == hgroupTag
+ || token.name() == mainTag
+ || token.name() == menuTag
+ || token.name() == navTag
+ || token.name() == olTag
+ || token.name() == pTag
+ || token.name() == sectionTag
+ || token.name() == summaryTag
+ || token.name() == ulTag) {
</ins><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><del>- if (isNumberedHeaderTag(token->name())) {
</del><ins>+ if (isNumberedHeaderTag(token.name())) {
</ins><span class="cx"> processFakePEndTagIfPInButtonScope();
</span><span class="cx"> if (m_tree.currentStackItem()->isNumberedHeaderElement()) {
</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><del>- if (token->name() == preTag || token->name() == listingTag) {
</del><ins>+ if (token.name() == preTag || token.name() == listingTag) {
</ins><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="cx"> }
</span><del>- if (token->name() == formTag) {
</del><ins>+ if (token.name() == formTag) {
</ins><span class="cx"> if (m_tree.form() && !isParsingTemplateContents()) {
</span><span class="cx"> parseError(token);
</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><del>- if (token->name() == liTag) {
</del><ins>+ if (token.name() == liTag) {
</ins><span class="cx"> processCloseWhenNestedTag<isLi>(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == ddTag || token->name() == dtTag) {
</del><ins>+ if (token.name() == ddTag || token.name() == dtTag) {
</ins><span class="cx"> processCloseWhenNestedTag<isDdOrDt>(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == plaintextTag) {
</del><ins>+ if (token.name() == plaintextTag) {
</ins><span class="cx"> processFakePEndTagIfPInButtonScope();
</span><del>- m_tree.insertHTMLElement(token);
</del><ins>+ m_tree.insertHTMLElement(&token);
</ins><span class="cx"> if (m_parser.tokenizer())
</span><span class="cx"> m_parser.tokenizer()->setState(HTMLTokenizer::PLAINTEXTState);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == buttonTag) {
</del><ins>+ if (token.name() == buttonTag) {
</ins><span class="cx"> if (m_tree.openElements()->inScope(buttonTag)) {
</span><span class="cx"> parseError(token);
</span><span class="cx"> processFakeEndTag(buttonTag);
</span><span class="lines">@@ -726,11 +710,11 @@
</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><del>- if (token->name() == aTag) {
</del><ins>+ if (token.name() == aTag) {
</ins><span class="cx"> Element* activeATag = m_tree.activeFormattingElements()->closestElementInScopeWithName(aTag.localName());
</span><span class="cx"> if (activeATag) {
</span><span class="cx"> parseError(token);
</span><span class="lines">@@ -740,121 +724,117 @@
</span><span class="cx"> m_tree.openElements()->remove(activeATag);
</span><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><del>- if (isNonAnchorNonNobrFormattingTag(token->name())) {
</del><ins>+ if (isNonAnchorNonNobrFormattingTag(token.name())) {
</ins><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><del>- if (token->name() == nobrTag) {
</del><ins>+ if (token.name() == nobrTag) {
</ins><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><span class="cx"> if (m_tree.openElements()->inScope(nobrTag)) {
</span><span class="cx"> parseError(token);
</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><del>- if (token->name() == appletTag
- || token->name() == embedTag
- || token->name() == objectTag) {
</del><ins>+ if (token.name() == appletTag || token.name() == embedTag || token.name() == objectTag) {
</ins><span class="cx"> if (!pluginContentIsAllowed(m_tree.parserContentPolicy()))
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == appletTag
- || token->name() == marqueeTag
- || token->name() == objectTag) {
</del><ins>+ if (token.name() == appletTag || token.name() == marqueeTag || token.name() == objectTag) {
</ins><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="cx"> }
</span><del>- if (token->name() == tableTag) {
</del><ins>+ if (token.name() == tableTag) {
</ins><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><del>- setInsertionMode(InsertionMode::InTable);
</del><ins>+ m_insertionMode = InsertionMode::InTable;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == imageTag) {
</del><ins>+ if (token.name() == imageTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> // Apparently we're not supposed to ask.
</span><del>- token->setName(imgTag.localName());
</del><ins>+ token.setName(imgTag.localName());
</ins><span class="cx"> // Note the fall through to the imgTag handling below!
</span><span class="cx"> }
</span><del>- if (token->name() == areaTag
- || token->name() == brTag
- || token->name() == embedTag
- || token->name() == imgTag
- || token->name() == keygenTag
- || token->name() == wbrTag) {
</del><ins>+ if (token.name() == areaTag
+ || token.name() == brTag
+ || token.name() == embedTag
+ || token.name() == imgTag
+ || token.name() == keygenTag
+ || token.name() == wbrTag) {
</ins><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><del>- if (token->name() == inputTag) {
- Attribute* typeAttribute = token->getAttributeItem(typeAttr);
</del><ins>+ if (token.name() == inputTag) {
+ Attribute* typeAttribute = token.getAttributeItem(typeAttr);
</ins><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- m_tree.insertSelfClosingHTMLElement(token);
</del><ins>+ m_tree.insertSelfClosingHTMLElement(&token);
</ins><span class="cx"> if (!typeAttribute || !equalIgnoringCase(typeAttribute->value(), "hidden"))
</span><span class="cx"> m_framesetOk = false;
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == paramTag
- || token->name() == sourceTag
- || token->name() == trackTag) {
- m_tree.insertSelfClosingHTMLElement(token);
</del><ins>+ if (token.name() == paramTag
+ || token.name() == sourceTag
+ || token.name() == trackTag) {
+ m_tree.insertSelfClosingHTMLElement(&token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == hrTag) {
</del><ins>+ if (token.name() == hrTag) {
</ins><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><del>- if (token->name() == isindexTag) {
</del><ins>+ if (token.name() == isindexTag) {
</ins><span class="cx"> processIsindexStartTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == textareaTag) {
- m_tree.insertHTMLElement(token);
</del><ins>+ if (token.name() == textareaTag) {
+ m_tree.insertHTMLElement(&token);
</ins><span class="cx"> m_shouldSkipLeadingNewline = true;
</span><span class="cx"> if (m_parser.tokenizer())
</span><span class="cx"> m_parser.tokenizer()->setState(HTMLTokenizer::RCDATAState);
</span><span class="cx"> m_originalInsertionMode = m_insertionMode;
</span><span class="cx"> m_framesetOk = false;
</span><del>- setInsertionMode(InsertionMode::Text);
</del><ins>+ m_insertionMode = InsertionMode::Text;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == xmpTag) {
</del><ins>+ if (token.name() == xmpTag) {
</ins><span class="cx"> processFakePEndTagIfPInButtonScope();
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><span class="cx"> m_framesetOk = false;
</span><span class="cx"> processGenericRawTextStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == iframeTag) {
</del><ins>+ if (token.name() == iframeTag) {
</ins><span class="cx"> m_framesetOk = false;
</span><span class="cx"> processGenericRawTextStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == noembedTag && m_options.pluginsEnabled) {
</del><ins>+ if (token.name() == noembedTag && m_options.pluginsEnabled) {
</ins><span class="cx"> processGenericRawTextStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == noscriptTag && m_options.scriptEnabled) {
</del><ins>+ if (token.name() == noscriptTag && m_options.scriptEnabled) {
</ins><span class="cx"> processGenericRawTextStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == selectTag) {
</del><ins>+ if (token.name() == selectTag) {
</ins><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">@@ -862,85 +842,86 @@
</span><span class="cx"> || m_insertionMode == InsertionMode::InTableBody
</span><span class="cx"> || m_insertionMode == InsertionMode::InRow
</span><span class="cx"> || m_insertionMode == InsertionMode::InCell)
</span><del>- setInsertionMode(InsertionMode::InSelectInTable);
</del><ins>+ m_insertionMode = InsertionMode::InSelectInTable;
</ins><span class="cx"> else
</span><del>- setInsertionMode(InsertionMode::InSelect);
</del><ins>+ m_insertionMode = InsertionMode::InSelect;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == optgroupTag || token->name() == optionTag) {
</del><ins>+ if (token.name() == optgroupTag || token.name() == optionTag) {
</ins><span class="cx"> if (is<HTMLOptionElement>(*m_tree.currentStackItem()->node())) {
</span><span class="cx"> AtomicHTMLToken endOption(HTMLToken::EndTag, optionTag.localName());
</span><del>- processEndTag(&endOption);
</del><ins>+ processEndTag(endOption);
</ins><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><del>- if (token->name() == rbTag || token->name() == rtcTag) {
</del><ins>+ if (token.name() == rbTag || token.name() == rtcTag) {
</ins><span class="cx"> if (m_tree.openElements()->inScope(rubyTag.localName())) {
</span><span class="cx"> m_tree.generateImpliedEndTags();
</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><del>- if (token->name() == rtTag || token->name() == rpTag) {
</del><ins>+ if (token.name() == rtTag || token.name() == rpTag) {
</ins><span class="cx"> if (m_tree.openElements()->inScope(rubyTag.localName())) {
</span><span class="cx"> m_tree.generateImpliedEndTagsWithExclusion(rtcTag.localName());
</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><del>- if (token->name() == MathMLNames::mathTag.localName()) {
</del><ins>+ if (token.name() == MathMLNames::mathTag.localName()) {
</ins><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- adjustMathMLAttributes(*token);
- adjustForeignAttributes(*token);
- m_tree.insertForeignElement(token, MathMLNames::mathmlNamespaceURI);
</del><ins>+ adjustMathMLAttributes(token);
+ adjustForeignAttributes(token);
+ m_tree.insertForeignElement(&token, MathMLNames::mathmlNamespaceURI);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == SVGNames::svgTag.localName()) {
</del><ins>+ if (token.name() == SVGNames::svgTag.localName()) {
</ins><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- adjustSVGAttributes(*token);
- adjustForeignAttributes(*token);
- m_tree.insertForeignElement(token, SVGNames::svgNamespaceURI);
</del><ins>+ adjustSVGAttributes(token);
+ adjustForeignAttributes(token);
+ m_tree.insertForeignElement(&token, SVGNames::svgNamespaceURI);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isCaptionColOrColgroupTag(token->name())
- || token->name() == frameTag
- || token->name() == headTag
- || isTableBodyContextTag(token->name())
- || isTableCellContextTag(token->name())
- || token->name() == trTag) {
</del><ins>+ if (isCaptionColOrColgroupTag(token.name())
+ || token.name() == frameTag
+ || token.name() == headTag
+ || isTableBodyContextTag(token.name())
+ || isTableCellContextTag(token.name())
+ || token.name() == trTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><del>- m_tree.insertHTMLElement(token);
</del><ins>+ m_tree.insertHTMLElement(&token);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>-void HTMLTreeBuilder::processTemplateStartTag(AtomicHTMLToken* token)
</del><ins>+
+void HTMLTreeBuilder::processTemplateStartTag(AtomicHTMLToken& token)
</ins><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><del>- setInsertionMode(InsertionMode::TemplateContents);
</del><ins>+ m_insertionMode = InsertionMode::TemplateContents;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool HTMLTreeBuilder::processTemplateEndTag(AtomicHTMLToken* token)
</del><ins>+bool HTMLTreeBuilder::processTemplateEndTag(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->name() == templateTag.localName());
</del><ins>+ ASSERT(token.name() == templateTag.localName());
</ins><span class="cx"> if (!m_tree.openElements()->hasTemplateInHTMLScope()) {
</span><del>- ASSERT(m_templateInsertionModes.isEmpty() || (m_templateInsertionModes.size() == 1 && m_fragmentContext.contextElement()->hasTagName(templateTag)));
</del><ins>+ ASSERT(m_templateInsertionModes.isEmpty() || (m_templateInsertionModes.size() == 1 && m_fragmentContext.contextElement().hasTagName(templateTag)));
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="lines">@@ -954,15 +935,16 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-bool HTMLTreeBuilder::processEndOfFileForInTemplateContents(AtomicHTMLToken* token)
</del><ins>+bool HTMLTreeBuilder::processEndOfFileForInTemplateContents(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> AtomicHTMLToken endTemplate(HTMLToken::EndTag, templateTag.localName());
</span><del>- if (!processTemplateEndTag(&endTemplate))
</del><ins>+ if (!processTemplateEndTag(endTemplate))
</ins><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> processEndOfFile(token);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><ins>+
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> bool HTMLTreeBuilder::processColgroupEndTagForInColumnGroup()
</span><span class="lines">@@ -978,14 +960,14 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx"> m_tree.openElements()->pop();
</span><del>- setInsertionMode(InsertionMode::InTable);
</del><ins>+ m_insertionMode = InsertionMode::InTable;
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#close-the-cell
</span><span class="cx"> void HTMLTreeBuilder::closeTheCell()
</span><span class="cx"> {
</span><del>- ASSERT(insertionMode() == InsertionMode::InCell);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InCell);
</ins><span class="cx"> if (m_tree.openElements()->inTableScope(tdTag)) {
</span><span class="cx"> ASSERT(!m_tree.openElements()->inTableScope(thTag));
</span><span class="cx"> processFakeEndTag(tdTag);
</span><span class="lines">@@ -993,45 +975,45 @@
</span><span class="cx"> }
</span><span class="cx"> ASSERT(m_tree.openElements()->inTableScope(thTag));
</span><span class="cx"> processFakeEndTag(thTag);
</span><del>- ASSERT(insertionMode() == InsertionMode::InRow);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InRow);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processStartTagForInTable(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processStartTagForInTable(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::StartTag);
- if (token->name() == captionTag) {
</del><ins>+ ASSERT(token.type() == HTMLToken::StartTag);
+ if (token.name() == captionTag) {
</ins><span class="cx"> m_tree.openElements()->popUntilTableScopeMarker();
</span><span class="cx"> m_tree.activeFormattingElements()->appendMarker();
</span><del>- m_tree.insertHTMLElement(token);
- setInsertionMode(InsertionMode::InCaption);
</del><ins>+ m_tree.insertHTMLElement(&token);
+ m_insertionMode = InsertionMode::InCaption;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == colgroupTag) {
</del><ins>+ if (token.name() == colgroupTag) {
</ins><span class="cx"> m_tree.openElements()->popUntilTableScopeMarker();
</span><del>- m_tree.insertHTMLElement(token);
- setInsertionMode(InsertionMode::InColumnGroup);
</del><ins>+ m_tree.insertHTMLElement(&token);
+ m_insertionMode = InsertionMode::InColumnGroup;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == colTag) {
</del><ins>+ if (token.name() == colTag) {
</ins><span class="cx"> processFakeStartTag(colgroupTag);
</span><del>- ASSERT(insertionMode() == InsertionMode::InColumnGroup);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InColumnGroup);
</ins><span class="cx"> processStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isTableBodyContextTag(token->name())) {
</del><ins>+ if (isTableBodyContextTag(token.name())) {
</ins><span class="cx"> m_tree.openElements()->popUntilTableScopeMarker();
</span><del>- m_tree.insertHTMLElement(token);
- setInsertionMode(InsertionMode::InTableBody);
</del><ins>+ m_tree.insertHTMLElement(&token);
+ m_insertionMode = InsertionMode::InTableBody;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isTableCellContextTag(token->name())
- || token->name() == trTag) {
</del><ins>+ if (isTableCellContextTag(token.name())
+ || token.name() == trTag) {
</ins><span class="cx"> processFakeStartTag(tbodyTag);
</span><del>- ASSERT(insertionMode() == InsertionMode::InTableBody);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InTableBody);
</ins><span class="cx"> processStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == tableTag) {
</del><ins>+ if (token.name() == tableTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> if (!processTableEndTagForInTable()) {
</span><span class="cx"> ASSERT(isParsingFragmentOrTemplateContents());
</span><span class="lines">@@ -1040,29 +1022,29 @@
</span><span class="cx"> processStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == styleTag || token->name() == scriptTag) {
</del><ins>+ if (token.name() == styleTag || token.name() == scriptTag) {
</ins><span class="cx"> processStartTagForInHead(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == inputTag) {
- Attribute* typeAttribute = token->getAttributeItem(typeAttr);
</del><ins>+ if (token.name() == inputTag) {
+ Attribute* typeAttribute = token.getAttributeItem(typeAttr);
</ins><span class="cx"> if (typeAttribute && equalIgnoringCase(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="cx"> }
</span><del>- if (token->name() == formTag) {
</del><ins>+ if (token.name() == formTag) {
</ins><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="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1072,71 +1054,70 @@
</span><span class="cx"> processStartTagForInBody(token);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processStartTag(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processStartTag(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::StartTag);
- switch (insertionMode()) {
</del><ins>+ ASSERT(token.type() == HTMLToken::StartTag);
+ switch (m_insertionMode) {
</ins><span class="cx"> case InsertionMode::Initial:
</span><del>- ASSERT(insertionMode() == InsertionMode::Initial);
</del><span class="cx"> defaultForInitial();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::BeforeHTML);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::BeforeHTML:
</span><del>- ASSERT(insertionMode() == InsertionMode::BeforeHTML);
- if (token->name() == htmlTag) {
- m_tree.insertHTMLHtmlStartTagBeforeHTML(token);
- setInsertionMode(InsertionMode::BeforeHead);
</del><ins>+ if (token.name() == htmlTag) {
+ m_tree.insertHTMLHtmlStartTagBeforeHTML(&token);
+ m_insertionMode = InsertionMode::BeforeHead;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> defaultForBeforeHTML();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::BeforeHead);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::BeforeHead:
</span><del>- ASSERT(insertionMode() == InsertionMode::BeforeHead);
- if (token->name() == htmlTag) {
</del><ins>+ if (token.name() == htmlTag) {
</ins><span class="cx"> processHtmlStartTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == headTag) {
- m_tree.insertHTMLHeadElement(token);
- setInsertionMode(InsertionMode::InHead);
</del><ins>+ if (token.name() == headTag) {
+ m_tree.insertHTMLHeadElement(&token);
+ m_insertionMode = InsertionMode::InHead;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> defaultForBeforeHead();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::InHead);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::InHead:
</span><del>- ASSERT(insertionMode() == InsertionMode::InHead);
</del><span class="cx"> if (processStartTagForInHead(token))
</span><span class="cx"> return;
</span><span class="cx"> defaultForInHead();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::AfterHead);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::AfterHead:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterHead);
- if (token->name() == htmlTag) {
</del><ins>+ if (token.name() == htmlTag) {
</ins><span class="cx"> processHtmlStartTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == bodyTag) {
</del><ins>+ if (token.name() == bodyTag) {
</ins><span class="cx"> m_framesetOk = false;
</span><del>- m_tree.insertHTMLBodyElement(token);
- setInsertionMode(InsertionMode::InBody);
</del><ins>+ m_tree.insertHTMLBodyElement(&token);
+ m_insertionMode = InsertionMode::InBody;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == framesetTag) {
- m_tree.insertHTMLElement(token);
- setInsertionMode(InsertionMode::InFrameset);
</del><ins>+ if (token.name() == framesetTag) {
+ m_tree.insertHTMLElement(&token);
+ m_insertionMode = InsertionMode::InFrameset;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == baseTag
- || token->name() == basefontTag
- || token->name() == bgsoundTag
- || token->name() == linkTag
- || token->name() == metaTag
- || token->name() == noframesTag
- || token->name() == scriptTag
- || token->name() == styleTag
</del><ins>+ if (token.name() == baseTag
+ || token.name() == basefontTag
+ || token.name() == bgsoundTag
+ || token.name() == linkTag
+ || token.name() == metaTag
+ || token.name() == noframesTag
+ || token.name() == scriptTag
+ || token.name() == styleTag
</ins><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- || token->name() == templateTag
</del><ins>+ || token.name() == templateTag
</ins><span class="cx"> #endif
</span><del>- || token->name() == titleTag) {
</del><ins>+ || token.name() == titleTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> ASSERT(m_tree.head());
</span><span class="cx"> m_tree.openElements()->pushHTMLHeadElement(m_tree.headStackItem());
</span><span class="lines">@@ -1144,26 +1125,25 @@
</span><span class="cx"> m_tree.openElements()->removeHTMLHeadElement(m_tree.head());
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == headTag) {
</del><ins>+ if (token.name() == headTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> defaultForAfterHead();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::InBody);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::InBody:
</span><del>- ASSERT(insertionMode() == InsertionMode::InBody);
</del><span class="cx"> processStartTagForInBody(token);
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::InTable);
</ins><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InTable:
</span><del>- ASSERT(insertionMode() == InsertionMode::InTable);
</del><span class="cx"> processStartTagForInTable(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InCaption:
</span><del>- ASSERT(insertionMode() == InsertionMode::InCaption);
- if (isCaptionColOrColgroupTag(token->name())
- || isTableBodyContextTag(token->name())
- || isTableCellContextTag(token->name())
- || token->name() == trTag) {
</del><ins>+ if (isCaptionColOrColgroupTag(token.name())
+ || isTableBodyContextTag(token.name())
+ || isTableCellContextTag(token.name())
+ || token.name() == trTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> if (!processCaptionEndTagForInCaption()) {
</span><span class="cx"> ASSERT(isParsingFragment());
</span><span class="lines">@@ -1175,17 +1155,16 @@
</span><span class="cx"> processStartTagForInBody(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InColumnGroup:
</span><del>- ASSERT(insertionMode() == InsertionMode::InColumnGroup);
- if (token->name() == htmlTag) {
</del><ins>+ if (token.name() == htmlTag) {
</ins><span class="cx"> processHtmlStartTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == colTag) {
- m_tree.insertSelfClosingHTMLElement(token);
</del><ins>+ if (token.name() == colTag) {
+ m_tree.insertSelfClosingHTMLElement(&token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1197,21 +1176,20 @@
</span><span class="cx"> processStartTag(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InTableBody:
</span><del>- ASSERT(insertionMode() == InsertionMode::InTableBody);
- if (token->name() == trTag) {
</del><ins>+ if (token.name() == trTag) {
</ins><span class="cx"> m_tree.openElements()->popUntilTableBodyScopeMarker(); // How is there ever anything to pop?
</span><del>- m_tree.insertHTMLElement(token);
- setInsertionMode(InsertionMode::InRow);
</del><ins>+ m_tree.insertHTMLElement(&token);
+ m_insertionMode = InsertionMode::InRow;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isTableCellContextTag(token->name())) {
</del><ins>+ if (isTableCellContextTag(token.name())) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> processFakeStartTag(trTag);
</span><del>- ASSERT(insertionMode() == InsertionMode::InRow);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InRow);
</ins><span class="cx"> processStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isCaptionColOrColgroupTag(token->name()) || isTableBodyContextTag(token->name())) {
</del><ins>+ if (isCaptionColOrColgroupTag(token.name()) || isTableBodyContextTag(token.name())) {
</ins><span class="cx"> // FIXME: This is slow.
</span><span class="cx"> if (!m_tree.openElements()->inTableScope(tbodyTag) && !m_tree.openElements()->inTableScope(theadTag) && !m_tree.openElements()->inTableScope(tfootTag)) {
</span><span class="cx"> ASSERT(isParsingFragmentOrTemplateContents());
</span><span class="lines">@@ -1227,33 +1205,31 @@
</span><span class="cx"> processStartTagForInTable(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InRow:
</span><del>- ASSERT(insertionMode() == InsertionMode::InRow);
- if (isTableCellContextTag(token->name())) {
</del><ins>+ if (isTableCellContextTag(token.name())) {
</ins><span class="cx"> m_tree.openElements()->popUntilTableRowScopeMarker();
</span><del>- m_tree.insertHTMLElement(token);
- setInsertionMode(InsertionMode::InCell);
</del><ins>+ m_tree.insertHTMLElement(&token);
+ m_insertionMode = InsertionMode::InCell;
</ins><span class="cx"> m_tree.activeFormattingElements()->appendMarker();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == trTag
- || isCaptionColOrColgroupTag(token->name())
- || isTableBodyContextTag(token->name())) {
</del><ins>+ if (token.name() == trTag
+ || isCaptionColOrColgroupTag(token.name())
+ || isTableBodyContextTag(token.name())) {
</ins><span class="cx"> if (!processTrEndTagForInRow()) {
</span><span class="cx"> ASSERT(isParsingFragmentOrTemplateContents());
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- ASSERT(insertionMode() == InsertionMode::InTableBody);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InTableBody);
</ins><span class="cx"> processStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> processStartTagForInTable(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InCell:
</span><del>- ASSERT(insertionMode() == InsertionMode::InCell);
- if (isCaptionColOrColgroupTag(token->name())
- || isTableCellContextTag(token->name())
- || token->name() == trTag
- || isTableBodyContextTag(token->name())) {
</del><ins>+ if (isCaptionColOrColgroupTag(token.name())
+ || isTableCellContextTag(token.name())
+ || token.name() == trTag
+ || isTableBodyContextTag(token.name())) {
</ins><span class="cx"> // FIXME: This could be more efficient.
</span><span class="cx"> if (!m_tree.openElements()->inTableScope(tdTag) && !m_tree.openElements()->inTableScope(thTag)) {
</span><span class="cx"> ASSERT(isParsingFragment());
</span><span class="lines">@@ -1268,31 +1244,29 @@
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::AfterBody:
</span><span class="cx"> case InsertionMode::AfterAfterBody:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterBody || insertionMode() == InsertionMode::AfterAfterBody);
- if (token->name() == htmlTag) {
</del><ins>+ if (token.name() == htmlTag) {
</ins><span class="cx"> processHtmlStartTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- setInsertionMode(InsertionMode::InBody);
</del><ins>+ m_insertionMode = InsertionMode::InBody;
</ins><span class="cx"> processStartTag(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InHeadNoscript:
</span><del>- ASSERT(insertionMode() == InsertionMode::InHeadNoscript);
- if (token->name() == htmlTag) {
</del><ins>+ if (token.name() == htmlTag) {
</ins><span class="cx"> processHtmlStartTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == basefontTag
- || token->name() == bgsoundTag
- || token->name() == linkTag
- || token->name() == metaTag
- || token->name() == noframesTag
- || token->name() == styleTag) {
</del><ins>+ if (token.name() == basefontTag
+ || token.name() == bgsoundTag
+ || token.name() == linkTag
+ || token.name() == metaTag
+ || token.name() == noframesTag
+ || token.name() == styleTag) {
</ins><span class="cx"> bool didProcess = processStartTagForInHead(token);
</span><span class="cx"> ASSERT_UNUSED(didProcess, didProcess);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == htmlTag || token->name() == noscriptTag) {
</del><ins>+ if (token.name() == htmlTag || token.name() == noscriptTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1300,25 +1274,24 @@
</span><span class="cx"> processToken(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InFrameset:
</span><del>- ASSERT(insertionMode() == InsertionMode::InFrameset);
- if (token->name() == htmlTag) {
</del><ins>+ if (token.name() == htmlTag) {
</ins><span class="cx"> processHtmlStartTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == framesetTag) {
- m_tree.insertHTMLElement(token);
</del><ins>+ if (token.name() == framesetTag) {
+ m_tree.insertHTMLElement(&token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == frameTag) {
- m_tree.insertSelfClosingHTMLElement(token);
</del><ins>+ if (token.name() == frameTag) {
+ m_tree.insertSelfClosingHTMLElement(&token);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == noframesTag) {
</del><ins>+ if (token.name() == noframesTag) {
</ins><span class="cx"> processStartTagForInHead(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1327,83 +1300,78 @@
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::AfterFrameset:
</span><span class="cx"> case InsertionMode::AfterAfterFrameset:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterFrameset || insertionMode() == InsertionMode::AfterAfterFrameset);
- if (token->name() == htmlTag) {
</del><ins>+ if (token.name() == htmlTag) {
</ins><span class="cx"> processHtmlStartTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == noframesTag) {
</del><ins>+ if (token.name() == noframesTag) {
</ins><span class="cx"> processStartTagForInHead(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> parseError(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InSelectInTable:
</span><del>- ASSERT(insertionMode() == InsertionMode::InSelectInTable);
- if (token->name() == captionTag
- || token->name() == tableTag
- || isTableBodyContextTag(token->name())
- || token->name() == trTag
- || isTableCellContextTag(token->name())) {
</del><ins>+ if (token.name() == captionTag
+ || token.name() == tableTag
+ || isTableBodyContextTag(token.name())
+ || token.name() == trTag
+ || isTableCellContextTag(token.name())) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> AtomicHTMLToken endSelect(HTMLToken::EndTag, selectTag.localName());
</span><del>- processEndTag(&endSelect);
</del><ins>+ processEndTag(endSelect);
</ins><span class="cx"> processStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::InSelect:
</span><del>- ASSERT(insertionMode() == InsertionMode::InSelect || insertionMode() == InsertionMode::InSelectInTable);
- if (token->name() == htmlTag) {
</del><ins>+ if (token.name() == htmlTag) {
</ins><span class="cx"> processHtmlStartTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == optionTag) {
</del><ins>+ if (token.name() == optionTag) {
</ins><span class="cx"> if (is<HTMLOptionElement>(*m_tree.currentStackItem()->node())) {
</span><span class="cx"> AtomicHTMLToken endOption(HTMLToken::EndTag, optionTag.localName());
</span><del>- processEndTag(&endOption);
</del><ins>+ processEndTag(endOption);
</ins><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><del>- if (token->name() == optgroupTag) {
</del><ins>+ if (token.name() == optgroupTag) {
</ins><span class="cx"> if (is<HTMLOptionElement>(*m_tree.currentStackItem()->node())) {
</span><span class="cx"> AtomicHTMLToken endOption(HTMLToken::EndTag, optionTag.localName());
</span><del>- processEndTag(&endOption);
</del><ins>+ processEndTag(endOption);
</ins><span class="cx"> }
</span><span class="cx"> if (is<HTMLOptGroupElement>(*m_tree.currentStackItem()->node())) {
</span><span class="cx"> AtomicHTMLToken endOptgroup(HTMLToken::EndTag, optgroupTag.localName());
</span><del>- processEndTag(&endOptgroup);
</del><ins>+ processEndTag(endOptgroup);
</ins><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><del>- if (token->name() == selectTag) {
</del><ins>+ if (token.name() == selectTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> AtomicHTMLToken endSelect(HTMLToken::EndTag, selectTag.localName());
</span><del>- processEndTag(&endSelect);
</del><ins>+ processEndTag(endSelect);
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == inputTag
- || token->name() == keygenTag
- || token->name() == textareaTag) {
</del><ins>+ if (token.name() == inputTag || token.name() == keygenTag || token.name() == textareaTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> if (!m_tree.openElements()->inSelectScope(selectTag)) {
</span><span class="cx"> ASSERT(isParsingFragment());
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> AtomicHTMLToken endSelect(HTMLToken::EndTag, selectTag.localName());
</span><del>- processEndTag(&endSelect);
</del><ins>+ processEndTag(endSelect);
</ins><span class="cx"> processStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == scriptTag) {
</del><ins>+ if (token.name() == scriptTag) {
</ins><span class="cx"> bool didProcess = processStartTagForInHead(token);
</span><span class="cx"> ASSERT_UNUSED(didProcess, didProcess);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1416,31 +1384,31 @@
</span><span class="cx"> case InsertionMode::Text:
</span><span class="cx"> ASSERT_NOT_REACHED();
</span><span class="cx"> break;
</span><del>- case InsertionMode::TemplateContents:
</del><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ case InsertionMode::TemplateContents:
+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (token->name() == linkTag
- || token->name() == scriptTag
- || token->name() == styleTag
- || token->name() == metaTag) {
</del><ins>+ if (token.name() == linkTag
+ || token.name() == scriptTag
+ || token.name() == styleTag
+ || token.name() == metaTag) {
</ins><span class="cx"> processStartTagForInHead(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> InsertionMode insertionMode = InsertionMode::TemplateContents;
</span><del>- if (token->name() == frameTag)
</del><ins>+ if (token.name() == frameTag)
</ins><span class="cx"> insertionMode = InsertionMode::InFrameset;
</span><del>- else if (token->name() == colTag)
</del><ins>+ else if (token.name() == colTag)
</ins><span class="cx"> insertionMode = InsertionMode::InColumnGroup;
</span><del>- else if (isCaptionColOrColgroupTag(token->name()) || isTableBodyContextTag(token->name()))
</del><ins>+ else if (isCaptionColOrColgroupTag(token.name()) || isTableBodyContextTag(token.name()))
</ins><span class="cx"> insertionMode = InsertionMode::InTable;
</span><del>- else if (token->name() == trTag)
</del><ins>+ else if (token.name() == trTag)
</ins><span class="cx"> insertionMode = InsertionMode::InTableBody;
</span><del>- else if (isTableCellContextTag(token->name()))
</del><ins>+ else if (isTableCellContextTag(token.name()))
</ins><span class="cx"> insertionMode = InsertionMode::InRow;
</span><span class="cx"> else
</span><span class="cx"> insertionMode = InsertionMode::InBody;
</span><span class="lines">@@ -1448,17 +1416,15 @@
</span><span class="cx"> ASSERT(insertionMode != InsertionMode::TemplateContents);
</span><span class="cx"> ASSERT(m_templateInsertionModes.last() == InsertionMode::TemplateContents);
</span><span class="cx"> m_templateInsertionModes.last() = insertionMode;
</span><del>- setInsertionMode(insertionMode);
</del><ins>+ m_insertionMode = insertionMode;
</ins><span class="cx">
</span><span class="cx"> processStartTag(token);
</span><del>-#else
- ASSERT_NOT_REACHED();
-#endif
</del><span class="cx"> break;
</span><ins>+#endif
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processHtmlStartTagForInBody(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processHtmlStartTagForInBody(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> parseError(token);
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><span class="lines">@@ -1467,45 +1433,43 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><del>- m_tree.insertHTMLHtmlStartTagInBody(token);
</del><ins>+ m_tree.insertHTMLHtmlStartTagInBody(&token);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool HTMLTreeBuilder::processBodyEndTagForInBody(AtomicHTMLToken* token)
</del><ins>+bool HTMLTreeBuilder::processBodyEndTagForInBody(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::EndTag);
- ASSERT(token->name() == bodyTag);
</del><ins>+ ASSERT(token.type() == HTMLToken::EndTag);
+ ASSERT(token.name() == bodyTag);
</ins><span class="cx"> if (!m_tree.openElements()->inScope(bodyTag.localName())) {
</span><span class="cx"> parseError(token);
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx"> notImplemented(); // Emit a more specific parse error based on stack contents.
</span><del>- setInsertionMode(InsertionMode::AfterBody);
</del><ins>+ m_insertionMode = InsertionMode::AfterBody;
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processAnyOtherEndTagForInBody(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processAnyOtherEndTagForInBody(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::EndTag);
- HTMLElementStack::ElementRecord* record = m_tree.openElements()->topRecord();
- while (1) {
- RefPtr<HTMLStackItem> item = record->stackItem();
- if (item->matchesHTMLTag(token->name())) {
- m_tree.generateImpliedEndTagsWithExclusion(token->name());
- if (!m_tree.currentStackItem()->matchesHTMLTag(token->name()))
</del><ins>+ ASSERT(token.type() == HTMLToken::EndTag);
+ for (auto* record = m_tree.openElements()->topRecord(); ; record = record->next()) {
+ HTMLStackItem& item = *record->stackItem();
+ if (item.matchesHTMLTag(token.name())) {
+ m_tree.generateImpliedEndTagsWithExclusion(token.name());
+ if (!m_tree.currentStackItem()->matchesHTMLTag(token.name()))
</ins><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><del>- if (item->isSpecialNode()) {
</del><ins>+ if (item.isSpecialNode()) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- record = record->next();
</del><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#parsing-main-inbody
</span><del>-void HTMLTreeBuilder::callTheAdoptionAgency(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::callTheAdoptionAgency(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> // The adoption agency algorithm is N^2. We limit the number of iterations
</span><span class="cx"> // to stop from hanging the whole browser. This limit is specified in the
</span><span class="lines">@@ -1517,7 +1481,7 @@
</span><span class="cx"> // 1, 2, 3 and 16 are covered by the for() loop.
</span><span class="cx"> for (int i = 0; i < outerIterationLimit; ++i) {
</span><span class="cx"> // 4.
</span><del>- Element* formattingElement = m_tree.activeFormattingElements()->closestElementInScopeWithName(token->name());
</del><ins>+ Element* formattingElement = m_tree.activeFormattingElements()->closestElementInScopeWithName(token.name());
</ins><span class="cx"> // 4.a
</span><span class="cx"> if (!formattingElement)
</span><span class="cx"> return processAnyOtherEndTagForInBody(token);
</span><span class="lines">@@ -1528,7 +1492,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> // 4.b
</span><del>- HTMLElementStack::ElementRecord* 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><span class="cx"> m_tree.activeFormattingElements()->remove(formattingElement);
</span><span class="lines">@@ -1538,7 +1502,7 @@
</span><span class="cx"> if (formattingElement != m_tree.currentElement())
</span><span class="cx"> parseError(token);
</span><span class="cx"> // 5.
</span><del>- HTMLElementStack::ElementRecord* 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><span class="cx"> m_tree.openElements()->popUntilPopped(formattingElement);
</span><span class="lines">@@ -1551,9 +1515,9 @@
</span><span class="cx"> // 8.
</span><span class="cx"> HTMLFormattingElementList::Bookmark bookmark = m_tree.activeFormattingElements()->bookmarkFor(formattingElement);
</span><span class="cx"> // 9.
</span><del>- HTMLElementStack::ElementRecord* node = furthestBlock;
- HTMLElementStack::ElementRecord* nextNode = node->next();
- HTMLElementStack::ElementRecord* lastNode = furthestBlock;
</del><ins>+ auto* node = furthestBlock;
+ auto* nextNode = node->next();
+ auto* lastNode = furthestBlock;
</ins><span class="cx"> // 9.1, 9.2, 9.3 and 9.11 are covered by the for() loop.
</span><span class="cx"> for (int i = 0; i < innerIterationLimit; ++i) {
</span><span class="cx"> // 9.4
</span><span class="lines">@@ -1604,9 +1568,8 @@
</span><span class="cx"> {
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#reset-the-insertion-mode-appropriately
</span><span class="cx"> bool last = false;
</span><del>- HTMLElementStack::ElementRecord* nodeRecord = m_tree.openElements()->topRecord();
- while (1) {
- RefPtr<HTMLStackItem> item = nodeRecord->stackItem();
</del><ins>+ for (auto* record = m_tree.openElements()->topRecord(); ; record = record->next()) {
+ HTMLStackItem* item = record->stackItem().get();
</ins><span class="cx"> if (item->node() == m_tree.openElements()->rootNode()) {
</span><span class="cx"> last = true;
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><span class="lines">@@ -1616,78 +1579,104 @@
</span><span class="cx"> bool shouldCreateItem = true;
</span><span class="cx"> #endif
</span><span class="cx"> if (shouldCreateItem)
</span><del>- item = m_fragmentContext.contextElementStackItem();
</del><ins>+ item = &m_fragmentContext.contextElementStackItem();
</ins><span class="cx"> }
</span><ins>+
</ins><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (item->hasTagName(templateTag))
- return setInsertionMode(m_templateInsertionModes.last());
</del><ins>+ if (item->hasTagName(templateTag)) {
+ m_insertionMode = m_templateInsertionModes.last();
+ return;
+ }
</ins><span class="cx"> #endif
</span><span class="cx"> if (item->hasTagName(selectTag)) {
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><span class="cx"> if (!last) {
</span><span class="cx"> while (item->node() != m_tree.openElements()->rootNode() && !item->hasTagName(templateTag)) {
</span><del>- nodeRecord = nodeRecord->next();
- item = nodeRecord->stackItem();
- if (is<HTMLTableElement>(*item->node()))
- return setInsertionMode(InsertionMode::InSelectInTable);
</del><ins>+ record = record->next();
+ item = record->stackItem().get();
+ if (is<HTMLTableElement>(*item->node())) {
+ m_insertionMode = InsertionMode::InSelectInTable;
+ return;
+ }
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><del>- return setInsertionMode(InsertionMode::InSelect);
</del><ins>+ m_insertionMode = InsertionMode::InSelect;
+ return;
</ins><span class="cx"> }
</span><del>- if (item->hasTagName(tdTag) || item->hasTagName(thTag))
- return setInsertionMode(InsertionMode::InCell);
- if (item->hasTagName(trTag))
- return setInsertionMode(InsertionMode::InRow);
- if (item->hasTagName(tbodyTag) || item->hasTagName(theadTag) || item->hasTagName(tfootTag))
- return setInsertionMode(InsertionMode::InTableBody);
- if (item->hasTagName(captionTag))
- return setInsertionMode(InsertionMode::InCaption);
</del><ins>+ if (item->hasTagName(tdTag) || item->hasTagName(thTag)) {
+ m_insertionMode = InsertionMode::InCell;
+ return;
+ }
+ if (item->hasTagName(trTag)) {
+ m_insertionMode = InsertionMode::InRow;
+ return;
+ }
+ if (item->hasTagName(tbodyTag) || item->hasTagName(theadTag) || item->hasTagName(tfootTag)) {
+ m_insertionMode = InsertionMode::InTableBody;
+ return;
+ }
+ if (item->hasTagName(captionTag)) {
+ m_insertionMode = InsertionMode::InCaption;
+ return;
+ }
</ins><span class="cx"> if (item->hasTagName(colgroupTag)) {
</span><del>- return setInsertionMode(InsertionMode::InColumnGroup);
</del><ins>+ m_insertionMode = InsertionMode::InColumnGroup;
+ return;
</ins><span class="cx"> }
</span><del>- if (is<HTMLTableElement>(*item->node()))
- return setInsertionMode(InsertionMode::InTable);
</del><ins>+ if (is<HTMLTableElement>(*item->node())) {
+ m_insertionMode = InsertionMode::InTable;
+ return;
+ }
</ins><span class="cx"> if (item->hasTagName(headTag)) {
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (!m_fragmentContext.fragment() || m_fragmentContext.contextElement() != item->node())
- return setInsertionMode(InsertionMode::InHead);
</del><ins>+ if (!m_fragmentContext.fragment() || &m_fragmentContext.contextElement() != item->node()) {
+ m_insertionMode = InsertionMode::InHead;
+ return;
+ }
</ins><span class="cx"> #endif
</span><del>- return setInsertionMode(InsertionMode::InBody);
</del><ins>+ m_insertionMode = InsertionMode::InBody;
+ return;
</ins><span class="cx"> }
</span><del>- if (item->hasTagName(bodyTag))
- return setInsertionMode(InsertionMode::InBody);
</del><ins>+ if (item->hasTagName(bodyTag)) {
+ m_insertionMode = InsertionMode::InBody;
+ return;
+ }
</ins><span class="cx"> if (item->hasTagName(framesetTag)) {
</span><del>- return setInsertionMode(InsertionMode::InFrameset);
</del><ins>+ m_insertionMode = InsertionMode::InFrameset;
+ return;
</ins><span class="cx"> }
</span><span class="cx"> if (item->hasTagName(htmlTag)) {
</span><del>- if (m_tree.headStackItem())
- return setInsertionMode(InsertionMode::AfterHead);
</del><ins>+ if (m_tree.headStackItem()) {
+ m_insertionMode = InsertionMode::AfterHead;
+ return;
+ }
</ins><span class="cx"> ASSERT(isParsingFragment());
</span><del>- return setInsertionMode(InsertionMode::BeforeHead);
</del><ins>+ m_insertionMode = InsertionMode::BeforeHead;
+ return;
</ins><span class="cx"> }
</span><span class="cx"> if (last) {
</span><span class="cx"> ASSERT(isParsingFragment());
</span><del>- return setInsertionMode(InsertionMode::InBody);
</del><ins>+ m_insertionMode = InsertionMode::InBody;
+ return;
</ins><span class="cx"> }
</span><del>- nodeRecord = nodeRecord->next();
</del><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processEndTagForInTableBody(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processEndTagForInTableBody(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::EndTag);
- if (isTableBodyContextTag(token->name())) {
- if (!m_tree.openElements()->inTableScope(token->name())) {
</del><ins>+ ASSERT(token.type() == HTMLToken::EndTag);
+ if (isTableBodyContextTag(token.name())) {
+ if (!m_tree.openElements()->inTableScope(token.name())) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> m_tree.openElements()->popUntilTableBodyScopeMarker();
</span><span class="cx"> m_tree.openElements()->pop();
</span><del>- setInsertionMode(InsertionMode::InTable);
</del><ins>+ m_insertionMode = InsertionMode::InTable;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == tableTag) {
</del><ins>+ if (token.name() == tableTag) {
</ins><span class="cx"> // FIXME: This is slow.
</span><span class="cx"> if (!m_tree.openElements()->inTableScope(tbodyTag) && !m_tree.openElements()->inTableScope(theadTag) && !m_tree.openElements()->inTableScope(tfootTag)) {
</span><span class="cx"> ASSERT(isParsingFragmentOrTemplateContents());
</span><span class="lines">@@ -1700,83 +1689,83 @@
</span><span class="cx"> processEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == bodyTag
- || isCaptionColOrColgroupTag(token->name())
- || token->name() == htmlTag
- || isTableCellContextTag(token->name())
- || token->name() == trTag) {
</del><ins>+ if (token.name() == bodyTag
+ || isCaptionColOrColgroupTag(token.name())
+ || token.name() == htmlTag
+ || isTableCellContextTag(token.name())
+ || token.name() == trTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> processEndTagForInTable(token);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processEndTagForInRow(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processEndTagForInRow(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::EndTag);
- if (token->name() == trTag) {
</del><ins>+ ASSERT(token.type() == HTMLToken::EndTag);
+ if (token.name() == trTag) {
</ins><span class="cx"> processTrEndTagForInRow();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == tableTag) {
</del><ins>+ if (token.name() == tableTag) {
</ins><span class="cx"> if (!processTrEndTagForInRow()) {
</span><span class="cx"> ASSERT(isParsingFragmentOrTemplateContents());
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- ASSERT(insertionMode() == InsertionMode::InTableBody);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InTableBody);
</ins><span class="cx"> processEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isTableBodyContextTag(token->name())) {
- if (!m_tree.openElements()->inTableScope(token->name())) {
</del><ins>+ if (isTableBodyContextTag(token.name())) {
+ if (!m_tree.openElements()->inTableScope(token.name())) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> processFakeEndTag(trTag);
</span><del>- ASSERT(insertionMode() == InsertionMode::InTableBody);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InTableBody);
</ins><span class="cx"> processEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == bodyTag
- || isCaptionColOrColgroupTag(token->name())
- || token->name() == htmlTag
- || isTableCellContextTag(token->name())) {
</del><ins>+ if (token.name() == bodyTag
+ || isCaptionColOrColgroupTag(token.name())
+ || token.name() == htmlTag
+ || isTableCellContextTag(token.name())) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> processEndTagForInTable(token);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processEndTagForInCell(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processEndTagForInCell(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::EndTag);
- if (isTableCellContextTag(token->name())) {
- if (!m_tree.openElements()->inTableScope(token->name())) {
</del><ins>+ ASSERT(token.type() == HTMLToken::EndTag);
+ if (isTableCellContextTag(token.name())) {
+ if (!m_tree.openElements()->inTableScope(token.name())) {
</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.currentStackItem()->matchesHTMLTag(token->name()))
</del><ins>+ if (!m_tree.currentStackItem()->matchesHTMLTag(token.name()))
</ins><span class="cx"> parseError(token);
</span><del>- m_tree.openElements()->popUntilPopped(token->name());
</del><ins>+ m_tree.openElements()->popUntilPopped(token.name());
</ins><span class="cx"> m_tree.activeFormattingElements()->clearToLastMarker();
</span><del>- setInsertionMode(InsertionMode::InRow);
</del><ins>+ m_insertionMode = InsertionMode::InRow;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == bodyTag
- || isCaptionColOrColgroupTag(token->name())
- || token->name() == htmlTag) {
</del><ins>+ if (token.name() == bodyTag
+ || isCaptionColOrColgroupTag(token.name())
+ || token.name() == htmlTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == tableTag
- || token->name() == trTag
- || isTableBodyContextTag(token->name())) {
- if (!m_tree.openElements()->inTableScope(token->name())) {
</del><ins>+ if (token.name() == tableTag
+ || token.name() == trTag
+ || isTableBodyContextTag(token.name())) {
+ if (!m_tree.openElements()->inTableScope(token.name())) {
</ins><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- ASSERT(isTableBodyContextTag(token->name()) || m_tree.openElements()->inTableScope(templateTag) || isParsingFragment());
</del><ins>+ ASSERT(isTableBodyContextTag(token.name()) || m_tree.openElements()->inTableScope(templateTag) || isParsingFragment());
</ins><span class="cx"> #else
</span><del>- ASSERT(isTableBodyContextTag(token->name()) || isParsingFragment());
</del><ins>+ ASSERT(isTableBodyContextTag(token.name()) || isParsingFragment());
</ins><span class="cx"> #endif
</span><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="lines">@@ -1788,55 +1777,55 @@
</span><span class="cx"> processEndTagForInBody(token);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processEndTagForInBody(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processEndTagForInBody(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::EndTag);
- if (token->name() == bodyTag) {
</del><ins>+ ASSERT(token.type() == HTMLToken::EndTag);
+ if (token.name() == bodyTag) {
</ins><span class="cx"> processBodyEndTagForInBody(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == htmlTag) {
</del><ins>+ if (token.name() == htmlTag) {
</ins><span class="cx"> AtomicHTMLToken endBody(HTMLToken::EndTag, bodyTag.localName());
</span><del>- if (processBodyEndTagForInBody(&endBody))
</del><ins>+ if (processBodyEndTagForInBody(endBody))
</ins><span class="cx"> processEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == addressTag
- || token->name() == articleTag
- || token->name() == asideTag
- || token->name() == blockquoteTag
- || token->name() == buttonTag
- || token->name() == centerTag
- || token->name() == detailsTag
- || token->name() == dirTag
- || token->name() == divTag
- || token->name() == dlTag
- || token->name() == fieldsetTag
- || token->name() == figcaptionTag
- || token->name() == figureTag
- || token->name() == footerTag
- || token->name() == headerTag
- || token->name() == hgroupTag
- || token->name() == listingTag
- || token->name() == mainTag
- || token->name() == menuTag
- || token->name() == navTag
- || token->name() == olTag
- || token->name() == preTag
- || token->name() == sectionTag
- || token->name() == summaryTag
- || token->name() == ulTag) {
- if (!m_tree.openElements()->inScope(token->name())) {
</del><ins>+ if (token.name() == addressTag
+ || token.name() == articleTag
+ || token.name() == asideTag
+ || token.name() == blockquoteTag
+ || token.name() == buttonTag
+ || token.name() == centerTag
+ || token.name() == detailsTag
+ || token.name() == dirTag
+ || token.name() == divTag
+ || token.name() == dlTag
+ || token.name() == fieldsetTag
+ || token.name() == figcaptionTag
+ || token.name() == figureTag
+ || token.name() == footerTag
+ || token.name() == headerTag
+ || token.name() == hgroupTag
+ || token.name() == listingTag
+ || token.name() == mainTag
+ || token.name() == menuTag
+ || token.name() == navTag
+ || token.name() == olTag
+ || token.name() == preTag
+ || token.name() == sectionTag
+ || token.name() == summaryTag
+ || token.name() == ulTag) {
+ if (!m_tree.openElements()->inScope(token.name())) {
</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.currentStackItem()->matchesHTMLTag(token->name()))
</del><ins>+ if (!m_tree.currentStackItem()->matchesHTMLTag(token.name()))
</ins><span class="cx"> parseError(token);
</span><del>- m_tree.openElements()->popUntilPopped(token->name());
</del><ins>+ m_tree.openElements()->popUntilPopped(token.name());
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == formTag) {
</del><ins>+ if (token.name() == formTag) {
</ins><span class="cx"> if (!isParsingTemplateContents()) {
</span><span class="cx"> RefPtr<Element> node = m_tree.takeForm();
</span><span class="cx"> if (!node || !m_tree.openElements()->inScope(node.get())) {
</span><span class="lines">@@ -1848,89 +1837,86 @@
</span><span class="cx"> parseError(token);
</span><span class="cx"> m_tree.openElements()->remove(node.get());
</span><span class="cx"> } else {
</span><del>- if (!m_tree.openElements()->inScope(token->name())) {
</del><ins>+ if (!m_tree.openElements()->inScope(token.name())) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> m_tree.generateImpliedEndTags();
</span><span class="cx"> if (!m_tree.currentNode()->hasTagName(formTag))
</span><span class="cx"> parseError(token);
</span><del>- m_tree.openElements()->popUntilPopped(token->name());
</del><ins>+ m_tree.openElements()->popUntilPopped(token.name());
</ins><span class="cx"> }
</span><span class="cx"> }
</span><del>- if (token->name() == pTag) {
- if (!m_tree.openElements()->inButtonScope(token->name())) {
</del><ins>+ if (token.name() == pTag) {
+ if (!m_tree.openElements()->inButtonScope(token.name())) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> processFakeStartTag(pTag);
</span><del>- ASSERT(m_tree.openElements()->inScope(token->name()));
</del><ins>+ ASSERT(m_tree.openElements()->inScope(token.name()));
</ins><span class="cx"> processEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- m_tree.generateImpliedEndTagsWithExclusion(token->name());
- if (!m_tree.currentStackItem()->matchesHTMLTag(token->name()))
</del><ins>+ m_tree.generateImpliedEndTagsWithExclusion(token.name());
+ if (!m_tree.currentStackItem()->matchesHTMLTag(token.name()))
</ins><span class="cx"> parseError(token);
</span><del>- m_tree.openElements()->popUntilPopped(token->name());
</del><ins>+ m_tree.openElements()->popUntilPopped(token.name());
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == liTag) {
- if (!m_tree.openElements()->inListItemScope(token->name())) {
</del><ins>+ if (token.name() == liTag) {
+ if (!m_tree.openElements()->inListItemScope(token.name())) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- m_tree.generateImpliedEndTagsWithExclusion(token->name());
- if (!m_tree.currentStackItem()->matchesHTMLTag(token->name()))
</del><ins>+ m_tree.generateImpliedEndTagsWithExclusion(token.name());
+ if (!m_tree.currentStackItem()->matchesHTMLTag(token.name()))
</ins><span class="cx"> parseError(token);
</span><del>- m_tree.openElements()->popUntilPopped(token->name());
</del><ins>+ m_tree.openElements()->popUntilPopped(token.name());
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == ddTag
- || token->name() == dtTag) {
- if (!m_tree.openElements()->inScope(token->name())) {
</del><ins>+ if (token.name() == ddTag || token.name() == dtTag) {
+ if (!m_tree.openElements()->inScope(token.name())) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- m_tree.generateImpliedEndTagsWithExclusion(token->name());
- if (!m_tree.currentStackItem()->matchesHTMLTag(token->name()))
</del><ins>+ m_tree.generateImpliedEndTagsWithExclusion(token.name());
+ if (!m_tree.currentStackItem()->matchesHTMLTag(token.name()))
</ins><span class="cx"> parseError(token);
</span><del>- m_tree.openElements()->popUntilPopped(token->name());
</del><ins>+ m_tree.openElements()->popUntilPopped(token.name());
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isNumberedHeaderTag(token->name())) {
</del><ins>+ if (isNumberedHeaderTag(token.name())) {
</ins><span class="cx"> if (!m_tree.openElements()->hasNumberedHeaderElementInScope()) {
</span><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.currentStackItem()->matchesHTMLTag(token->name()))
</del><ins>+ if (!m_tree.currentStackItem()->matchesHTMLTag(token.name()))
</ins><span class="cx"> parseError(token);
</span><span class="cx"> m_tree.openElements()->popUntilNumberedHeaderElementPopped();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isFormattingTag(token->name())) {
</del><ins>+ if (isFormattingTag(token.name())) {
</ins><span class="cx"> callTheAdoptionAgency(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == appletTag
- || token->name() == marqueeTag
- || token->name() == objectTag) {
- if (!m_tree.openElements()->inScope(token->name())) {
</del><ins>+ if (token.name() == appletTag || token.name() == marqueeTag || token.name() == objectTag) {
+ if (!m_tree.openElements()->inScope(token.name())) {
</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.currentStackItem()->matchesHTMLTag(token->name()))
</del><ins>+ if (!m_tree.currentStackItem()->matchesHTMLTag(token.name()))
</ins><span class="cx"> parseError(token);
</span><del>- m_tree.openElements()->popUntilPopped(token->name());
</del><ins>+ m_tree.openElements()->popUntilPopped(token.name());
</ins><span class="cx"> m_tree.activeFormattingElements()->clearToLastMarker();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == brTag) {
</del><ins>+ if (token.name() == brTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> processFakeStartTag(brTag);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -1949,7 +1935,7 @@
</span><span class="cx"> // FIXME: parse error if (!m_tree.currentStackItem()->hasTagName(captionTag))
</span><span class="cx"> m_tree.openElements()->popUntilPopped(captionTag.localName());
</span><span class="cx"> m_tree.activeFormattingElements()->clearToLastMarker();
</span><del>- setInsertionMode(InsertionMode::InTable);
</del><ins>+ m_insertionMode = InsertionMode::InTable;
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1963,7 +1949,7 @@
</span><span class="cx"> m_tree.openElements()->popUntilTableRowScopeMarker();
</span><span class="cx"> ASSERT(m_tree.currentStackItem()->hasTagName(trTag));
</span><span class="cx"> m_tree.openElements()->pop();
</span><del>- setInsertionMode(InsertionMode::InTableBody);
</del><ins>+ m_insertionMode = InsertionMode::InTableBody;
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1979,19 +1965,19 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processEndTagForInTable(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processEndTagForInTable(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::EndTag);
- if (token->name() == tableTag) {
</del><ins>+ ASSERT(token.type() == HTMLToken::EndTag);
+ if (token.name() == tableTag) {
</ins><span class="cx"> processTableEndTagForInTable();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == bodyTag
- || isCaptionColOrColgroupTag(token->name())
- || token->name() == htmlTag
- || isTableBodyContextTag(token->name())
- || isTableCellContextTag(token->name())
- || token->name() == trTag) {
</del><ins>+ if (token.name() == bodyTag
+ || isCaptionColOrColgroupTag(token.name())
+ || token.name() == htmlTag
+ || isTableBodyContextTag(token.name())
+ || isTableCellContextTag(token.name())
+ || token.name() == trTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -2001,75 +1987,75 @@
</span><span class="cx"> processEndTagForInBody(token);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processEndTag(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processEndTag(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::EndTag);
- switch (insertionMode()) {
</del><ins>+ ASSERT(token.type() == HTMLToken::EndTag);
+ switch (m_insertionMode) {
</ins><span class="cx"> case InsertionMode::Initial:
</span><del>- ASSERT(insertionMode() == InsertionMode::Initial);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::Initial);
</ins><span class="cx"> defaultForInitial();
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::BeforeHTML:
</span><del>- ASSERT(insertionMode() == InsertionMode::BeforeHTML);
- if (token->name() != headTag && token->name() != bodyTag && token->name() != htmlTag && token->name() != brTag) {
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::BeforeHTML);
+ if (token.name() != headTag && token.name() != bodyTag && token.name() != htmlTag && token.name() != brTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> defaultForBeforeHTML();
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::BeforeHead:
</span><del>- ASSERT(insertionMode() == InsertionMode::BeforeHead);
- if (token->name() != headTag && token->name() != bodyTag && token->name() != htmlTag && token->name() != brTag) {
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::BeforeHead);
+ if (token.name() != headTag && token.name() != bodyTag && token.name() != htmlTag && token.name() != brTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> defaultForBeforeHead();
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::InHead:
</span><del>- ASSERT(insertionMode() == InsertionMode::InHead);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InHead);
</ins><span class="cx"> // FIXME: This case should be broken out into processEndTagForInHead,
</span><span class="cx"> // because other end tag cases now refer to it ("process the token for using the rules of the "in head" insertion mode").
</span><span class="cx"> // but because the logic falls through to InsertionMode::AfterHead, that gets a little messy.
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><del>- if (token->name() == headTag) {
</del><ins>+ if (token.name() == headTag) {
</ins><span class="cx"> m_tree.openElements()->popHTMLHeadElement();
</span><del>- setInsertionMode(InsertionMode::AfterHead);
</del><ins>+ m_insertionMode = InsertionMode::AfterHead;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() != bodyTag && token->name() != htmlTag && token->name() != brTag) {
</del><ins>+ if (token.name() != bodyTag && token.name() != htmlTag && token.name() != brTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> defaultForInHead();
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::AfterHead:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterHead);
- if (token->name() != bodyTag && token->name() != htmlTag && token->name() != brTag) {
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::AfterHead);
+ if (token.name() != bodyTag && token.name() != htmlTag && token.name() != brTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> defaultForAfterHead();
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::InBody:
</span><del>- ASSERT(insertionMode() == InsertionMode::InBody);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InBody);
</ins><span class="cx"> processEndTagForInBody(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InTable:
</span><del>- ASSERT(insertionMode() == InsertionMode::InTable);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InTable);
</ins><span class="cx"> processEndTagForInTable(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InCaption:
</span><del>- ASSERT(insertionMode() == InsertionMode::InCaption);
- if (token->name() == captionTag) {
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InCaption);
+ if (token.name() == captionTag) {
</ins><span class="cx"> processCaptionEndTagForInCaption();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == tableTag) {
</del><ins>+ if (token.name() == tableTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> if (!processCaptionEndTagForInCaption()) {
</span><span class="cx"> ASSERT(isParsingFragment());
</span><span class="lines">@@ -2078,30 +2064,30 @@
</span><span class="cx"> processEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == bodyTag
- || token->name() == colTag
- || token->name() == colgroupTag
- || token->name() == htmlTag
- || isTableBodyContextTag(token->name())
- || isTableCellContextTag(token->name())
- || token->name() == trTag) {
</del><ins>+ if (token.name() == bodyTag
+ || token.name() == colTag
+ || token.name() == colgroupTag
+ || token.name() == htmlTag
+ || isTableBodyContextTag(token.name())
+ || isTableCellContextTag(token.name())
+ || token.name() == trTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> processEndTagForInBody(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InColumnGroup:
</span><del>- ASSERT(insertionMode() == InsertionMode::InColumnGroup);
- if (token->name() == colgroupTag) {
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InColumnGroup);
+ if (token.name() == colgroupTag) {
</ins><span class="cx"> processColgroupEndTagForInColumnGroup();
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == colTag) {
</del><ins>+ if (token.name() == colTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -2113,44 +2099,44 @@
</span><span class="cx"> processEndTag(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InRow:
</span><del>- ASSERT(insertionMode() == InsertionMode::InRow);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InRow);
</ins><span class="cx"> processEndTagForInRow(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InCell:
</span><del>- ASSERT(insertionMode() == InsertionMode::InCell);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InCell);
</ins><span class="cx"> processEndTagForInCell(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InTableBody:
</span><del>- ASSERT(insertionMode() == InsertionMode::InTableBody);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InTableBody);
</ins><span class="cx"> processEndTagForInTableBody(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::AfterBody:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterBody);
- if (token->name() == htmlTag) {
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::AfterBody);
+ if (token.name() == htmlTag) {
</ins><span class="cx"> if (isParsingFragment()) {
</span><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- setInsertionMode(InsertionMode::AfterAfterBody);
</del><ins>+ m_insertionMode = InsertionMode::AfterAfterBody;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::AfterAfterBody:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterBody || insertionMode() == InsertionMode::AfterAfterBody);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::AfterBody || m_insertionMode == InsertionMode::AfterAfterBody);
</ins><span class="cx"> parseError(token);
</span><del>- setInsertionMode(InsertionMode::InBody);
</del><ins>+ m_insertionMode = InsertionMode::InBody;
</ins><span class="cx"> processEndTag(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InHeadNoscript:
</span><del>- ASSERT(insertionMode() == InsertionMode::InHeadNoscript);
- if (token->name() == noscriptTag) {
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InHeadNoscript);
+ if (token.name() == noscriptTag) {
</ins><span class="cx"> ASSERT(m_tree.currentStackItem()->hasTagName(noscriptTag));
</span><span class="cx"> m_tree.openElements()->pop();
</span><span class="cx"> ASSERT(m_tree.currentStackItem()->hasTagName(headTag));
</span><del>- setInsertionMode(InsertionMode::InHead);
</del><ins>+ m_insertionMode = InsertionMode::InHead;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() != brTag) {
</del><ins>+ if (token.name() != brTag) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -2158,13 +2144,13 @@
</span><span class="cx"> processToken(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::Text:
</span><del>- if (token->name() == scriptTag) {
</del><ins>+ if (token.name() == scriptTag) {
</ins><span class="cx"> // Pause ourselves so that parsing stops until the script can be processed by the caller.
</span><span class="cx"> ASSERT(m_tree.currentStackItem()->hasTagName(scriptTag));
</span><span class="cx"> if (scriptingContentIsAllowed(m_tree.parserContentPolicy()))
</span><span class="cx"> m_scriptToProcess = m_tree.currentElement();
</span><span class="cx"> m_tree.openElements()->pop();
</span><del>- setInsertionMode(m_originalInsertionMode);
</del><ins>+ m_insertionMode = m_originalInsertionMode;
</ins><span class="cx">
</span><span class="cx"> if (m_parser.tokenizer()) {
</span><span class="cx"> // This token will not have been created by the tokenizer if a
</span><span class="lines">@@ -2177,11 +2163,11 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> m_tree.openElements()->pop();
</span><del>- setInsertionMode(m_originalInsertionMode);
</del><ins>+ m_insertionMode = m_originalInsertionMode;
</ins><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InFrameset:
</span><del>- ASSERT(insertionMode() == InsertionMode::InFrameset);
- if (token->name() == framesetTag) {
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InFrameset);
+ if (token.name() == framesetTag) {
</ins><span class="cx"> bool ignoreFramesetForFragmentParsing = m_tree.currentIsRootNode();
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><span class="cx"> ignoreFramesetForFragmentParsing = ignoreFramesetForFragmentParsing || m_tree.openElements()->hasTemplateInHTMLScope();
</span><span class="lines">@@ -2193,46 +2179,46 @@
</span><span class="cx"> }
</span><span class="cx"> m_tree.openElements()->pop();
</span><span class="cx"> if (!isParsingFragment() && !m_tree.currentStackItem()->hasTagName(framesetTag))
</span><del>- setInsertionMode(InsertionMode::AfterFrameset);
</del><ins>+ m_insertionMode = InsertionMode::AfterFrameset;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::AfterFrameset:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterFrameset);
- if (token->name() == htmlTag) {
- setInsertionMode(InsertionMode::AfterAfterFrameset);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::AfterFrameset);
+ if (token.name() == htmlTag) {
+ m_insertionMode = InsertionMode::AfterAfterFrameset;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::AfterAfterFrameset:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterFrameset || insertionMode() == InsertionMode::AfterAfterFrameset);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::AfterFrameset || m_insertionMode == InsertionMode::AfterAfterFrameset);
</ins><span class="cx"> parseError(token);
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InSelectInTable:
</span><del>- ASSERT(insertionMode() == InsertionMode::InSelectInTable);
- if (token->name() == captionTag
- || token->name() == tableTag
- || isTableBodyContextTag(token->name())
- || token->name() == trTag
- || isTableCellContextTag(token->name())) {
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InSelectInTable);
+ if (token.name() == captionTag
+ || token.name() == tableTag
+ || isTableBodyContextTag(token.name())
+ || token.name() == trTag
+ || isTableCellContextTag(token.name())) {
</ins><span class="cx"> parseError(token);
</span><del>- if (m_tree.openElements()->inTableScope(token->name())) {
</del><ins>+ if (m_tree.openElements()->inTableScope(token.name())) {
</ins><span class="cx"> AtomicHTMLToken endSelect(HTMLToken::EndTag, selectTag.localName());
</span><del>- processEndTag(&endSelect);
</del><ins>+ processEndTag(endSelect);
</ins><span class="cx"> processEndTag(token);
</span><span class="cx"> }
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::InSelect:
</span><del>- ASSERT(insertionMode() == InsertionMode::InSelect || insertionMode() == InsertionMode::InSelectInTable);
- if (token->name() == optgroupTag) {
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InSelect || m_insertionMode == InsertionMode::InSelectInTable);
+ if (token.name() == optgroupTag) {
</ins><span class="cx"> if (is<HTMLOptionElement>(*m_tree.currentStackItem()->node()) && m_tree.oneBelowTop() && is<HTMLOptGroupElement>(*m_tree.oneBelowTop()->node()))
</span><span class="cx"> processFakeEndTag(optionTag);
</span><span class="cx"> if (is<HTMLOptGroupElement>(*m_tree.currentStackItem()->node())) {
</span><span class="lines">@@ -2242,7 +2228,7 @@
</span><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == optionTag) {
</del><ins>+ if (token.name() == optionTag) {
</ins><span class="cx"> if (is<HTMLOptionElement>(*m_tree.currentStackItem()->node())) {
</span><span class="cx"> m_tree.openElements()->pop();
</span><span class="cx"> return;
</span><span class="lines">@@ -2250,8 +2236,8 @@
</span><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (token->name() == selectTag) {
- if (!m_tree.openElements()->inSelectScope(token->name())) {
</del><ins>+ if (token.name() == selectTag) {
+ if (!m_tree.openElements()->inSelectScope(token.name())) {
</ins><span class="cx"> ASSERT(isParsingFragment());
</span><span class="cx"> parseError(token);
</span><span class="cx"> return;
</span><span class="lines">@@ -2261,7 +2247,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -2271,31 +2257,29 @@
</span><span class="cx"> defaultForInTableText();
</span><span class="cx"> processEndTag(token);
</span><span class="cx"> break;
</span><del>- case InsertionMode::TemplateContents:
</del><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ case InsertionMode::TemplateContents:
+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateEndTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>-#else
- ASSERT_NOT_REACHED();
-#endif
</del><span class="cx"> break;
</span><ins>+#endif
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processComment(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processComment(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::Comment);
</del><ins>+ ASSERT(token.type() == HTMLToken::Comment);
</ins><span class="cx"> if (m_insertionMode == InsertionMode::Initial
</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">@@ -2303,18 +2287,19 @@
</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><del>-void HTMLTreeBuilder::processCharacter(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processCharacter(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::Character);
</del><ins>+ ASSERT(token.type() == HTMLToken::Character);
</ins><span class="cx"> ExternalCharacterTokenBuffer buffer(token);
</span><span class="cx"> processCharacterBuffer(buffer);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-// FIXME: Extract the following iOS-specific code into a separate file.
</del><span class="cx"> #if ENABLE(TELEPHONE_NUMBER_DETECTION) && PLATFORM(IOS)
</span><ins>+
+// FIXME: Extract the following iOS-specific code into a separate file.
</ins><span class="cx"> // From the string 4089961010, creates a link of the form <a href="tel:4089961010">4089961010</a> and inserts it.
</span><span class="cx"> void HTMLTreeBuilder::insertPhoneNumberLink(const String& string)
</span><span class="cx"> {
</span><span class="lines">@@ -2325,10 +2310,10 @@
</span><span class="cx"> AtomicHTMLToken aStartToken(HTMLToken::StartTag, aTagLocalName, attributes);
</span><span class="cx"> AtomicHTMLToken aEndToken(HTMLToken::EndTag, aTagLocalName);
</span><span class="cx">
</span><del>- processStartTag(&aStartToken);
</del><ins>+ processStartTag(aStartToken);
</ins><span class="cx"> m_tree.executeQueuedTasks();
</span><span class="cx"> m_tree.insertTextNode(string);
</span><del>- processEndTag(&aEndToken);
</del><ins>+ processEndTag(aEndToken);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Locates the phone numbers in the string and deals with it
</span><span class="lines">@@ -2398,6 +2383,7 @@
</span><span class="cx"> } while (currentNode);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><ins>+
</ins><span class="cx"> #endif // ENABLE(TELEPHONE_NUMBER_DETECTION) && PLATFORM(IOS)
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::processCharacterBuffer(ExternalCharacterTokenBuffer& buffer)
</span><span class="lines">@@ -2421,77 +2407,68 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- switch (insertionMode()) {
- case InsertionMode::Initial: {
- ASSERT(insertionMode() == InsertionMode::Initial);
</del><ins>+ switch (m_insertionMode) {
+ case InsertionMode::Initial:
</ins><span class="cx"> buffer.skipLeadingWhitespace();
</span><span class="cx"> if (buffer.isEmpty())
</span><span class="cx"> return;
</span><span class="cx"> defaultForInitial();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::BeforeHTML);
</ins><span class="cx"> FALLTHROUGH;
</span><del>- }
- case InsertionMode::BeforeHTML: {
- ASSERT(insertionMode() == InsertionMode::BeforeHTML);
</del><ins>+ case InsertionMode::BeforeHTML:
</ins><span class="cx"> buffer.skipLeadingWhitespace();
</span><span class="cx"> if (buffer.isEmpty())
</span><span class="cx"> return;
</span><span class="cx"> defaultForBeforeHTML();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::BeforeHead);
</ins><span class="cx"> FALLTHROUGH;
</span><del>- }
- case InsertionMode::BeforeHead: {
- ASSERT(insertionMode() == InsertionMode::BeforeHead);
</del><ins>+ case InsertionMode::BeforeHead:
</ins><span class="cx"> buffer.skipLeadingWhitespace();
</span><span class="cx"> if (buffer.isEmpty())
</span><span class="cx"> return;
</span><span class="cx"> defaultForBeforeHead();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::InHead);
</ins><span class="cx"> FALLTHROUGH;
</span><del>- }
</del><span class="cx"> case InsertionMode::InHead: {
</span><del>- ASSERT(insertionMode() == InsertionMode::InHead);
</del><span class="cx"> String leadingWhitespace = buffer.takeLeadingWhitespace();
</span><span class="cx"> if (!leadingWhitespace.isEmpty())
</span><span class="cx"> m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
</span><span class="cx"> if (buffer.isEmpty())
</span><span class="cx"> return;
</span><span class="cx"> defaultForInHead();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::AfterHead);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> }
</span><span class="cx"> case InsertionMode::AfterHead: {
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterHead);
</del><span class="cx"> String leadingWhitespace = buffer.takeLeadingWhitespace();
</span><span class="cx"> if (!leadingWhitespace.isEmpty())
</span><span class="cx"> m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
</span><span class="cx"> if (buffer.isEmpty())
</span><span class="cx"> return;
</span><span class="cx"> defaultForAfterHead();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::InBody);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> }
</span><span class="cx"> case InsertionMode::InBody:
</span><span class="cx"> case InsertionMode::InCaption:
</span><del>- case InsertionMode::TemplateContents:
- case InsertionMode::InCell: {
</del><ins>+ case InsertionMode::InCell:
</ins><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- ASSERT(insertionMode() == InsertionMode::InBody || insertionMode() == InsertionMode::InCaption || insertionMode() == InsertionMode::InCell || insertionMode() == InsertionMode::TemplateContents);
-#else
- ASSERT(insertionMode() != InsertionMode::TemplateContents);
- ASSERT(insertionMode() == InsertionMode::InBody || insertionMode() == InsertionMode::InCaption || insertionMode() == InsertionMode::InCell);
</del><ins>+ case InsertionMode::TemplateContents:
</ins><span class="cx"> #endif
</span><span class="cx"> processCharacterBufferForInBody(buffer);
</span><span class="cx"> break;
</span><del>- }
</del><span class="cx"> case InsertionMode::InTable:
</span><span class="cx"> case InsertionMode::InTableBody:
</span><del>- case InsertionMode::InRow: {
- ASSERT(insertionMode() == InsertionMode::InTable || insertionMode() == InsertionMode::InTableBody || insertionMode() == InsertionMode::InRow);
</del><ins>+ case InsertionMode::InRow:
</ins><span class="cx"> ASSERT(m_pendingTableCharacters.isEmpty());
</span><span class="cx"> if (m_tree.currentStackItem()->isElementNode()
</span><del>- && (is<HTMLTableElement>(*m_tree.currentStackItem()->node())
</del><ins>+ && (is<HTMLTableElement>(*m_tree.currentStackItem()->element())
</ins><span class="cx"> || m_tree.currentStackItem()->hasTagName(HTMLNames::tbodyTag)
</span><span class="cx"> || m_tree.currentStackItem()->hasTagName(HTMLNames::tfootTag)
</span><span class="cx"> || m_tree.currentStackItem()->hasTagName(HTMLNames::theadTag)
</span><span class="cx"> || m_tree.currentStackItem()->hasTagName(HTMLNames::trTag))) {
</span><span class="cx"> m_originalInsertionMode = m_insertionMode;
</span><del>- setInsertionMode(InsertionMode::InTableText);
</del><ins>+ m_insertionMode = InsertionMode::InTableText;
</ins><span class="cx"> // Note that we fall through to the InsertionMode::InTableText case below.
</span><span class="cx"> } else {
</span><span class="cx"> HTMLConstructionSite::RedirectToFosterParentGuard redirecter(m_tree);
</span><span class="lines">@@ -2499,13 +2476,10 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> FALLTHROUGH;
</span><del>- }
- case InsertionMode::InTableText: {
</del><ins>+ case InsertionMode::InTableText:
</ins><span class="cx"> buffer.giveRemainingTo(m_pendingTableCharacters);
</span><span class="cx"> break;
</span><del>- }
</del><span class="cx"> case InsertionMode::InColumnGroup: {
</span><del>- ASSERT(insertionMode() == InsertionMode::InColumnGroup);
</del><span class="cx"> String leadingWhitespace = buffer.takeLeadingWhitespace();
</span><span class="cx"> if (!leadingWhitespace.isEmpty())
</span><span class="cx"> m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
</span><span class="lines">@@ -2521,19 +2495,14 @@
</span><span class="cx"> goto ReprocessBuffer;
</span><span class="cx"> }
</span><span class="cx"> case InsertionMode::AfterBody:
</span><del>- case InsertionMode::AfterAfterBody: {
- ASSERT(insertionMode() == InsertionMode::AfterBody || insertionMode() == InsertionMode::AfterAfterBody);
</del><ins>+ case InsertionMode::AfterAfterBody:
</ins><span class="cx"> // FIXME: parse error
</span><del>- setInsertionMode(InsertionMode::InBody);
</del><ins>+ m_insertionMode = InsertionMode::InBody;
</ins><span class="cx"> goto ReprocessBuffer;
</span><del>- }
- case InsertionMode::Text: {
- ASSERT(insertionMode() == InsertionMode::Text);
</del><ins>+ case InsertionMode::Text:
</ins><span class="cx"> m_tree.insertTextNode(buffer.takeRemaining());
</span><span class="cx"> break;
</span><del>- }
</del><span class="cx"> case InsertionMode::InHeadNoscript: {
</span><del>- ASSERT(insertionMode() == InsertionMode::InHeadNoscript);
</del><span class="cx"> String leadingWhitespace = buffer.takeLeadingWhitespace();
</span><span class="cx"> if (!leadingWhitespace.isEmpty())
</span><span class="cx"> m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
</span><span class="lines">@@ -2544,7 +2513,6 @@
</span><span class="cx"> }
</span><span class="cx"> case InsertionMode::InFrameset:
</span><span class="cx"> case InsertionMode::AfterFrameset: {
</span><del>- ASSERT(insertionMode() == InsertionMode::InFrameset || insertionMode() == InsertionMode::AfterFrameset || insertionMode() == InsertionMode::AfterAfterFrameset);
</del><span class="cx"> String leadingWhitespace = buffer.takeRemainingWhitespace();
</span><span class="cx"> if (!leadingWhitespace.isEmpty())
</span><span class="cx"> m_tree.insertTextNode(leadingWhitespace, AllWhitespace);
</span><span class="lines">@@ -2553,11 +2521,9 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case InsertionMode::InSelectInTable:
</span><del>- case InsertionMode::InSelect: {
- ASSERT(insertionMode() == InsertionMode::InSelect || insertionMode() == InsertionMode::InSelectInTable);
</del><ins>+ case InsertionMode::InSelect:
</ins><span class="cx"> m_tree.insertTextNode(buffer.takeRemaining());
</span><span class="cx"> break;
</span><del>- }
</del><span class="cx"> case InsertionMode::AfterAfterFrameset: {
</span><span class="cx"> String leadingWhitespace = buffer.takeRemainingWhitespace();
</span><span class="cx"> if (!leadingWhitespace.isEmpty()) {
</span><span class="lines">@@ -2583,64 +2549,55 @@
</span><span class="cx"> #else
</span><span class="cx"> m_tree.insertTextNode(characters);
</span><span class="cx"> #endif
</span><del>-
</del><span class="cx"> if (m_framesetOk && !isAllWhitespaceOrReplacementCharacters(characters))
</span><span class="cx"> m_framesetOk = false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processEndOfFile(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processEndOfFile(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::EndOfFile);
- switch (insertionMode()) {
</del><ins>+ ASSERT(token.type() == HTMLToken::EndOfFile);
+ switch (m_insertionMode) {
</ins><span class="cx"> case InsertionMode::Initial:
</span><del>- ASSERT(insertionMode() == InsertionMode::Initial);
</del><span class="cx"> defaultForInitial();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::BeforeHTML);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::BeforeHTML:
</span><del>- ASSERT(insertionMode() == InsertionMode::BeforeHTML);
</del><span class="cx"> defaultForBeforeHTML();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::BeforeHead);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::BeforeHead:
</span><del>- ASSERT(insertionMode() == InsertionMode::BeforeHead);
</del><span class="cx"> defaultForBeforeHead();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::InHead);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::InHead:
</span><del>- ASSERT(insertionMode() == InsertionMode::InHead);
</del><span class="cx"> defaultForInHead();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::AfterHead);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::AfterHead:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterHead);
</del><span class="cx"> defaultForAfterHead();
</span><ins>+ ASSERT(m_insertionMode == InsertionMode::InBody);
</ins><span class="cx"> FALLTHROUGH;
</span><span class="cx"> case InsertionMode::InBody:
</span><span class="cx"> case InsertionMode::InCell:
</span><span class="cx"> case InsertionMode::InCaption:
</span><span class="cx"> case InsertionMode::InRow:
</span><del>-#if ENABLE(TEMPLATE_ELEMENT)
- ASSERT(insertionMode() == InsertionMode::InBody || insertionMode() == InsertionMode::InCell || insertionMode() == InsertionMode::InCaption || insertionMode() == InsertionMode::InRow || insertionMode() == InsertionMode::TemplateContents);
-#else
- ASSERT(insertionMode() != InsertionMode::TemplateContents);
- ASSERT(insertionMode() == InsertionMode::InBody || insertionMode() == InsertionMode::InCell || insertionMode() == InsertionMode::InCaption || insertionMode() == InsertionMode::InRow);
-#endif
</del><span class="cx"> notImplemented(); // Emit parse error based on what elements are still open.
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (!m_templateInsertionModes.isEmpty())
</del><ins>+ if (!m_templateInsertionModes.isEmpty()) {
</ins><span class="cx"> if (processEndOfFileForInTemplateContents(token))
</span><span class="cx"> return;
</span><ins>+ }
</ins><span class="cx"> #endif
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::AfterBody:
</span><span class="cx"> case InsertionMode::AfterAfterBody:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterBody || insertionMode() == InsertionMode::AfterAfterBody);
</del><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InHeadNoscript:
</span><del>- ASSERT(insertionMode() == InsertionMode::InHeadNoscript);
</del><span class="cx"> defaultForInHeadNoscript();
</span><span class="cx"> processEndOfFile(token);
</span><span class="cx"> return;
</span><span class="cx"> case InsertionMode::AfterFrameset:
</span><span class="cx"> case InsertionMode::AfterAfterFrameset:
</span><del>- ASSERT(insertionMode() == InsertionMode::AfterFrameset || insertionMode() == InsertionMode::AfterAfterFrameset);
</del><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InColumnGroup:
</span><span class="cx"> if (m_tree.currentIsRootNode()) {
</span><span class="lines">@@ -2659,14 +2616,14 @@
</span><span class="cx"> case InsertionMode::InTableBody:
</span><span class="cx"> case InsertionMode::InSelectInTable:
</span><span class="cx"> case InsertionMode::InSelect:
</span><del>- ASSERT(insertionMode() == InsertionMode::InSelect || insertionMode() == InsertionMode::InSelectInTable || insertionMode() == InsertionMode::InTable || insertionMode() == InsertionMode::InFrameset || insertionMode() == InsertionMode::InTableBody || insertionMode() == InsertionMode::InColumnGroup);
</del><ins>+ ASSERT(m_insertionMode == InsertionMode::InSelect || m_insertionMode == InsertionMode::InSelectInTable || m_insertionMode == InsertionMode::InTable || m_insertionMode == InsertionMode::InFrameset || m_insertionMode == InsertionMode::InTableBody || m_insertionMode == InsertionMode::InColumnGroup);
</ins><span class="cx"> if (m_tree.currentNode() != m_tree.openElements()->rootNode())
</span><span class="cx"> parseError(token);
</span><del>-
</del><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (!m_templateInsertionModes.isEmpty())
</del><ins>+ if (!m_templateInsertionModes.isEmpty()) {
</ins><span class="cx"> if (processEndOfFileForInTemplateContents(token))
</span><span class="cx"> return;
</span><ins>+ }
</ins><span class="cx"> #endif
</span><span class="cx"> break;
</span><span class="cx"> case InsertionMode::InTableText:
</span><span class="lines">@@ -2679,16 +2636,14 @@
</span><span class="cx"> notImplemented(); // mark the script element as "already started".
</span><span class="cx"> m_tree.openElements()->pop();
</span><span class="cx"> ASSERT(m_originalInsertionMode != InsertionMode::Text);
</span><del>- setInsertionMode(m_originalInsertionMode);
</del><ins>+ m_insertionMode = m_originalInsertionMode;
</ins><span class="cx"> processEndOfFile(token);
</span><span class="cx"> return;
</span><del>- case InsertionMode::TemplateContents:
</del><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><ins>+ case InsertionMode::TemplateContents:
</ins><span class="cx"> if (processEndOfFileForInTemplateContents(token))
</span><span class="cx"> return;
</span><span class="cx"> break;
</span><del>-#else
- ASSERT_NOT_REACHED();
</del><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx"> ASSERT(m_tree.currentNode());
</span><span class="lines">@@ -2700,38 +2655,38 @@
</span><span class="cx"> notImplemented();
</span><span class="cx"> m_tree.setDefaultCompatibilityMode();
</span><span class="cx"> // FIXME: parse error
</span><del>- setInsertionMode(InsertionMode::BeforeHTML);
</del><ins>+ m_insertionMode = InsertionMode::BeforeHTML;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::defaultForBeforeHTML()
</span><span class="cx"> {
</span><span class="cx"> AtomicHTMLToken startHTML(HTMLToken::StartTag, htmlTag.localName());
</span><span class="cx"> m_tree.insertHTMLHtmlStartTagBeforeHTML(&startHTML);
</span><del>- setInsertionMode(InsertionMode::BeforeHead);
</del><ins>+ m_insertionMode = InsertionMode::BeforeHead;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::defaultForBeforeHead()
</span><span class="cx"> {
</span><span class="cx"> AtomicHTMLToken startHead(HTMLToken::StartTag, headTag.localName());
</span><del>- processStartTag(&startHead);
</del><ins>+ processStartTag(startHead);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::defaultForInHead()
</span><span class="cx"> {
</span><span class="cx"> AtomicHTMLToken endHead(HTMLToken::EndTag, headTag.localName());
</span><del>- processEndTag(&endHead);
</del><ins>+ processEndTag(endHead);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::defaultForInHeadNoscript()
</span><span class="cx"> {
</span><span class="cx"> AtomicHTMLToken endNoscript(HTMLToken::EndTag, noscriptTag.localName());
</span><del>- processEndTag(&endNoscript);
</del><ins>+ processEndTag(endNoscript);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::defaultForAfterHead()
</span><span class="cx"> {
</span><span class="cx"> AtomicHTMLToken startBody(HTMLToken::StartTag, bodyTag.localName());
</span><del>- processStartTag(&startBody);
</del><ins>+ processStartTag(startBody);
</ins><span class="cx"> m_framesetOk = true;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2745,90 +2700,90 @@
</span><span class="cx"> m_tree.reconstructTheActiveFormattingElements();
</span><span class="cx"> m_tree.insertTextNode(characters, NotAllWhitespace);
</span><span class="cx"> m_framesetOk = false;
</span><del>- setInsertionMode(m_originalInsertionMode);
</del><ins>+ m_insertionMode = m_originalInsertionMode;
</ins><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx"> m_tree.insertTextNode(characters);
</span><del>- setInsertionMode(m_originalInsertionMode);
</del><ins>+ m_insertionMode = m_originalInsertionMode;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-bool HTMLTreeBuilder::processStartTagForInHead(AtomicHTMLToken* token)
</del><ins>+bool HTMLTreeBuilder::processStartTagForInHead(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::StartTag);
- if (token->name() == htmlTag) {
</del><ins>+ ASSERT(token.type() == HTMLToken::StartTag);
+ if (token.name() == htmlTag) {
</ins><span class="cx"> processHtmlStartTagForInBody(token);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- if (token->name() == baseTag
- || token->name() == basefontTag
- || token->name() == bgsoundTag
- || token->name() == commandTag
- || token->name() == linkTag
- || token->name() == metaTag) {
- m_tree.insertSelfClosingHTMLElement(token);
</del><ins>+ if (token.name() == baseTag
+ || token.name() == basefontTag
+ || token.name() == bgsoundTag
+ || token.name() == commandTag
+ || token.name() == linkTag
+ || token.name() == metaTag) {
+ 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><del>- if (token->name() == titleTag) {
</del><ins>+ if (token.name() == titleTag) {
</ins><span class="cx"> processGenericRCDATAStartTag(token);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- if (token->name() == noscriptTag) {
</del><ins>+ if (token.name() == noscriptTag) {
</ins><span class="cx"> if (m_options.scriptEnabled) {
</span><span class="cx"> processGenericRawTextStartTag(token);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- m_tree.insertHTMLElement(token);
- setInsertionMode(InsertionMode::InHeadNoscript);
</del><ins>+ m_tree.insertHTMLElement(&token);
+ m_insertionMode = InsertionMode::InHeadNoscript;
</ins><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- if (token->name() == noframesTag || token->name() == styleTag) {
</del><ins>+ if (token.name() == noframesTag || token.name() == styleTag) {
</ins><span class="cx"> processGenericRawTextStartTag(token);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><del>- if (token->name() == scriptTag) {
</del><ins>+ if (token.name() == scriptTag) {
</ins><span class="cx"> processScriptStartTag(token);
</span><del>- if (m_options.usePreHTML5ParserQuirks && token->selfClosing())
</del><ins>+ if (m_options.usePreHTML5ParserQuirks && token.selfClosing())
</ins><span class="cx"> processFakeEndTag(scriptTag);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- if (token->name() == templateTag) {
</del><ins>+ if (token.name() == templateTag) {
</ins><span class="cx"> processTemplateStartTag(token);
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><del>- if (token->name() == headTag) {
</del><ins>+ if (token.name() == headTag) {
</ins><span class="cx"> parseError(token);
</span><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>-void HTMLTreeBuilder::processGenericRCDATAStartTag(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processGenericRCDATAStartTag(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::StartTag);
- m_tree.insertHTMLElement(token);
</del><ins>+ ASSERT(token.type() == HTMLToken::StartTag);
+ m_tree.insertHTMLElement(&token);
</ins><span class="cx"> if (m_parser.tokenizer())
</span><span class="cx"> m_parser.tokenizer()->setState(HTMLTokenizer::RCDATAState);
</span><span class="cx"> m_originalInsertionMode = m_insertionMode;
</span><del>- setInsertionMode(InsertionMode::Text);
</del><ins>+ m_insertionMode = InsertionMode::Text;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processGenericRawTextStartTag(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processGenericRawTextStartTag(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::StartTag);
- m_tree.insertHTMLElement(token);
</del><ins>+ ASSERT(token.type() == HTMLToken::StartTag);
+ m_tree.insertHTMLElement(&token);
</ins><span class="cx"> if (m_parser.tokenizer())
</span><span class="cx"> m_parser.tokenizer()->setState(HTMLTokenizer::RAWTEXTState);
</span><span class="cx"> m_originalInsertionMode = m_insertionMode;
</span><del>- setInsertionMode(InsertionMode::Text);
</del><ins>+ m_insertionMode = InsertionMode::Text;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processScriptStartTag(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processScriptStartTag(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- ASSERT(token->type() == HTMLToken::StartTag);
- m_tree.insertScriptElement(token);
</del><ins>+ ASSERT(token.type() == HTMLToken::StartTag);
+ m_tree.insertScriptElement(&token);
</ins><span class="cx"> if (m_parser.tokenizer())
</span><span class="cx"> m_parser.tokenizer()->setState(HTMLTokenizer::ScriptDataState);
</span><span class="cx"> m_originalInsertionMode = m_insertionMode;
</span><span class="lines">@@ -2837,55 +2792,55 @@
</span><span class="cx">
</span><span class="cx"> m_scriptToProcessStartPosition = position;
</span><span class="cx">
</span><del>- setInsertionMode(InsertionMode::Text);
</del><ins>+ m_insertionMode = InsertionMode::Text;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/#adjusted-current-node
</span><del>-HTMLStackItem* HTMLTreeBuilder::adjustedCurrentStackItem() const
</del><ins>+HTMLStackItem& HTMLTreeBuilder::adjustedCurrentStackItem() const
</ins><span class="cx"> {
</span><span class="cx"> ASSERT(!m_tree.isEmpty());
</span><span class="cx"> if (isParsingFragment() && m_tree.openElements()->hasOnlyOneElement())
</span><span class="cx"> return m_fragmentContext.contextElementStackItem();
</span><span class="cx">
</span><del>- return m_tree.currentStackItem();
</del><ins>+ return *m_tree.currentStackItem();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#tree-construction
</span><del>-bool HTMLTreeBuilder::shouldProcessTokenInForeignContent(AtomicHTMLToken* token)
</del><ins>+bool HTMLTreeBuilder::shouldProcessTokenInForeignContent(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><span class="cx"> if (m_tree.isEmpty())
</span><span class="cx"> return false;
</span><del>- HTMLStackItem* adjustedCurrentNode = adjustedCurrentStackItem();
- if (adjustedCurrentNode->isInHTMLNamespace())
</del><ins>+ HTMLStackItem& adjustedCurrentNode = adjustedCurrentStackItem();
+ if (adjustedCurrentNode.isInHTMLNamespace())
</ins><span class="cx"> return false;
</span><del>- if (HTMLElementStack::isMathMLTextIntegrationPoint(adjustedCurrentNode)) {
- if (token->type() == HTMLToken::StartTag
- && token->name() != MathMLNames::mglyphTag
- && token->name() != MathMLNames::malignmarkTag)
</del><ins>+ if (HTMLElementStack::isMathMLTextIntegrationPoint(&adjustedCurrentNode)) {
+ if (token.type() == HTMLToken::StartTag
+ && token.name() != MathMLNames::mglyphTag
+ && token.name() != MathMLNames::malignmarkTag)
</ins><span class="cx"> return false;
</span><del>- if (token->type() == HTMLToken::Character)
</del><ins>+ if (token.type() == HTMLToken::Character)
</ins><span class="cx"> return false;
</span><span class="cx"> }
</span><del>- if (adjustedCurrentNode->hasTagName(MathMLNames::annotation_xmlTag)
- && token->type() == HTMLToken::StartTag
- && token->name() == SVGNames::svgTag)
</del><ins>+ if (adjustedCurrentNode.hasTagName(MathMLNames::annotation_xmlTag)
+ && token.type() == HTMLToken::StartTag
+ && token.name() == SVGNames::svgTag)
</ins><span class="cx"> return false;
</span><del>- if (HTMLElementStack::isHTMLIntegrationPoint(adjustedCurrentNode)) {
- if (token->type() == HTMLToken::StartTag)
</del><ins>+ if (HTMLElementStack::isHTMLIntegrationPoint(&adjustedCurrentNode)) {
+ if (token.type() == HTMLToken::StartTag)
</ins><span class="cx"> return false;
</span><del>- if (token->type() == HTMLToken::Character)
</del><ins>+ if (token.type() == HTMLToken::Character)
</ins><span class="cx"> return false;
</span><span class="cx"> }
</span><del>- if (token->type() == HTMLToken::EndOfFile)
</del><ins>+ if (token.type() == HTMLToken::EndOfFile)
</ins><span class="cx"> return false;
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::processTokenInForeignContent(AtomicHTMLToken* token)
</del><ins>+void HTMLTreeBuilder::processTokenInForeignContent(AtomicHTMLToken& token)
</ins><span class="cx"> {
</span><del>- HTMLStackItem* adjustedCurrentNode = adjustedCurrentStackItem();
</del><ins>+ HTMLStackItem& adjustedCurrentNode = adjustedCurrentStackItem();
</ins><span class="cx">
</span><del>- switch (token->type()) {
</del><ins>+ switch (token.type()) {
</ins><span class="cx"> case HTMLToken::Uninitialized:
</span><span class="cx"> ASSERT_NOT_REACHED();
</span><span class="cx"> break;
</span><span class="lines">@@ -2893,67 +2848,67 @@
</span><span class="cx"> parseError(token);
</span><span class="cx"> break;
</span><span class="cx"> case HTMLToken::StartTag: {
</span><del>- if (token->name() == bTag
- || token->name() == bigTag
- || token->name() == blockquoteTag
- || token->name() == bodyTag
- || token->name() == brTag
- || token->name() == centerTag
- || token->name() == codeTag
- || token->name() == ddTag
- || token->name() == divTag
- || token->name() == dlTag
- || token->name() == dtTag
- || token->name() == emTag
- || token->name() == embedTag
- || isNumberedHeaderTag(token->name())
- || token->name() == headTag
- || token->name() == hrTag
- || token->name() == iTag
- || token->name() == imgTag
- || token->name() == liTag
- || token->name() == listingTag
- || token->name() == menuTag
- || token->name() == metaTag
- || token->name() == nobrTag
- || token->name() == olTag
- || token->name() == pTag
- || token->name() == preTag
- || token->name() == rubyTag
- || token->name() == sTag
- || token->name() == smallTag
- || token->name() == spanTag
- || token->name() == strongTag
- || token->name() == strikeTag
- || token->name() == subTag
- || token->name() == supTag
- || token->name() == tableTag
- || token->name() == ttTag
- || token->name() == uTag
- || token->name() == ulTag
- || token->name() == varTag
- || (token->name() == fontTag && (token->getAttributeItem(colorAttr) || token->getAttributeItem(faceAttr) || token->getAttributeItem(sizeAttr)))) {
</del><ins>+ if (token.name() == bTag
+ || token.name() == bigTag
+ || token.name() == blockquoteTag
+ || token.name() == bodyTag
+ || token.name() == brTag
+ || token.name() == centerTag
+ || token.name() == codeTag
+ || token.name() == ddTag
+ || token.name() == divTag
+ || token.name() == dlTag
+ || token.name() == dtTag
+ || token.name() == emTag
+ || token.name() == embedTag
+ || isNumberedHeaderTag(token.name())
+ || token.name() == headTag
+ || token.name() == hrTag
+ || token.name() == iTag
+ || token.name() == imgTag
+ || token.name() == liTag
+ || token.name() == listingTag
+ || token.name() == menuTag
+ || token.name() == metaTag
+ || token.name() == nobrTag
+ || token.name() == olTag
+ || token.name() == pTag
+ || token.name() == preTag
+ || token.name() == rubyTag
+ || token.name() == sTag
+ || token.name() == smallTag
+ || token.name() == spanTag
+ || token.name() == strongTag
+ || token.name() == strikeTag
+ || token.name() == subTag
+ || token.name() == supTag
+ || token.name() == tableTag
+ || token.name() == ttTag
+ || token.name() == uTag
+ || token.name() == ulTag
+ || token.name() == varTag
+ || (token.name() == fontTag && (token.getAttributeItem(colorAttr) || token.getAttributeItem(faceAttr) || token.getAttributeItem(sizeAttr)))) {
</ins><span class="cx"> parseError(token);
</span><span class="cx"> m_tree.openElements()->popUntilForeignContentScopeMarker();
</span><span class="cx"> processStartTag(token);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- const AtomicString& currentNamespace = adjustedCurrentNode->namespaceURI();
</del><ins>+ const AtomicString& currentNamespace = adjustedCurrentNode.namespaceURI();
</ins><span class="cx"> if (currentNamespace == MathMLNames::mathmlNamespaceURI)
</span><del>- adjustMathMLAttributes(*token);
</del><ins>+ adjustMathMLAttributes(token);
</ins><span class="cx"> if (currentNamespace == SVGNames::svgNamespaceURI) {
</span><del>- adjustSVGTagNameCase(*token);
- adjustSVGAttributes(*token);
</del><ins>+ adjustSVGTagNameCase(token);
+ adjustSVGAttributes(token);
</ins><span class="cx"> }
</span><del>- adjustForeignAttributes(*token);
- m_tree.insertForeignElement(token, currentNamespace);
</del><ins>+ adjustForeignAttributes(token);
+ m_tree.insertForeignElement(&token, currentNamespace);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case HTMLToken::EndTag: {
</span><del>- if (adjustedCurrentNode->namespaceURI() == SVGNames::svgNamespaceURI)
- adjustSVGTagNameCase(*token);
</del><ins>+ if (adjustedCurrentNode.namespaceURI() == SVGNames::svgNamespaceURI)
+ adjustSVGTagNameCase(token);
</ins><span class="cx">
</span><del>- if (token->name() == SVGNames::scriptTag && m_tree.currentStackItem()->hasTagName(SVGNames::scriptTag)) {
</del><ins>+ if (token.name() == SVGNames::scriptTag && m_tree.currentStackItem()->hasTagName(SVGNames::scriptTag)) {
</ins><span class="cx"> if (scriptingContentIsAllowed(m_tree.parserContentPolicy()))
</span><span class="cx"> m_scriptToProcess = m_tree.currentElement();
</span><span class="cx"> m_tree.openElements()->pop();
</span><span class="lines">@@ -2961,11 +2916,11 @@
</span><span class="cx"> }
</span><span class="cx"> if (!m_tree.currentStackItem()->isInHTMLNamespace()) {
</span><span class="cx"> // FIXME: This code just wants an Element* iterator, instead of an ElementRecord*
</span><del>- HTMLElementStack::ElementRecord* nodeRecord = m_tree.openElements()->topRecord();
- if (!nodeRecord->stackItem()->hasLocalName(token->name()))
</del><ins>+ auto* nodeRecord = m_tree.openElements()->topRecord();
+ if (!nodeRecord->stackItem()->hasLocalName(token.name()))
</ins><span class="cx"> parseError(token);
</span><span class="cx"> while (1) {
</span><del>- if (nodeRecord->stackItem()->hasLocalName(token->name())) {
</del><ins>+ if (nodeRecord->stackItem()->hasLocalName(token.name())) {
</ins><span class="cx"> m_tree.openElements()->popUntilPopped(nodeRecord->element());
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -2980,10 +2935,10 @@
</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><del>- String characters = String(token->characters(), token->charactersLength());
</del><ins>+ String characters = String(token.characters(), token.charactersLength());
</ins><span class="cx"> m_tree.insertTextNode(characters);
</span><span class="cx"> if (m_framesetOk && !isAllWhitespaceOrReplacementCharacters(characters))
</span><span class="cx"> m_framesetOk = false;
</span><span class="lines">@@ -2997,6 +2952,8 @@
</span><span class="cx">
</span><span class="cx"> void HTMLTreeBuilder::finished()
</span><span class="cx"> {
</span><ins>+ ASSERT(!m_destroyed);
+
</ins><span class="cx"> if (isParsingFragment())
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="lines">@@ -3004,12 +2961,11 @@
</span><span class="cx"> ASSERT(m_templateInsertionModes.isEmpty());
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- ASSERT(m_isAttached);
- // Warning, this may detach the parser. Do not do anything else after this.
</del><span class="cx"> m_tree.finishedParsing();
</span><ins>+ // The tree builder might have been destroyed as an indirect result of finishing the parsing.
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void HTMLTreeBuilder::parseError(AtomicHTMLToken*)
</del><ins>+inline void HTMLTreeBuilder::parseError(AtomicHTMLToken&)
</ins><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserHTMLTreeBuilderh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/HTMLTreeBuilder.h (177858 => 177859)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/HTMLTreeBuilder.h 2015-01-02 10:01:11 UTC (rev 177858)
+++ trunk/Source/WebCore/html/parser/HTMLTreeBuilder.h 2015-01-02 16:31:49 UTC (rev 177859)
</span><span class="lines">@@ -1,6 +1,6 @@
</span><span class="cx"> /*
</span><span class="cx"> * Copyright (C) 2010 Google, Inc. All Rights Reserved.
</span><del>- * Copyright (C) 2011 Apple Inc. All rights reserved.
</del><ins>+ * Copyright (C) 2011, 2015 Apple Inc. All rights reserved.
</ins><span class="cx"> *
</span><span class="cx"> * Redistribution and use in source and binary forms, with or without
</span><span class="cx"> * modification, are permitted provided that the following conditions
</span><span class="lines">@@ -27,64 +27,37 @@
</span><span class="cx"> #ifndef HTMLTreeBuilder_h
</span><span class="cx"> #define HTMLTreeBuilder_h
</span><span class="cx">
</span><del>-#include "FragmentScriptingPermission.h"
</del><span class="cx"> #include "HTMLConstructionSite.h"
</span><del>-#include "HTMLElementStack.h"
-#include "HTMLFormattingElementList.h"
</del><span class="cx"> #include "HTMLParserOptions.h"
</span><del>-#include "HTMLStackItem.h"
-#include "HTMLTokenizer.h"
-#include <wtf/Noncopyable.h>
-#include <wtf/PassRefPtr.h>
-#include <wtf/RefPtr.h>
-#include <wtf/Vector.h>
-#include <wtf/text/StringBuilder.h>
-#include <wtf/text/TextPosition.h>
</del><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><del>-class AtomicHTMLToken;
-class Document;
-class DocumentFragment;
-class Element;
-class Frame;
-class HTMLToken;
-class HTMLDocument;
-class Node;
</del><span class="cx"> class HTMLDocumentParser;
</span><span class="cx">
</span><span class="cx"> class HTMLTreeBuilder {
</span><del>- WTF_MAKE_NONCOPYABLE(HTMLTreeBuilder); WTF_MAKE_FAST_ALLOCATED;
</del><ins>+ WTF_MAKE_FAST_ALLOCATED;
</ins><span class="cx"> public:
</span><del>- HTMLTreeBuilder(HTMLDocumentParser&, HTMLDocument&, ParserContentPolicy, const HTMLParserOptions&);
- HTMLTreeBuilder(HTMLDocumentParser&, DocumentFragment&, Element* contextElement, ParserContentPolicy, const HTMLParserOptions&);
</del><ins>+ HTMLTreeBuilder(const HTMLDocumentParser&, HTMLDocument&, ParserContentPolicy, const HTMLParserOptions&);
+ HTMLTreeBuilder(const HTMLDocumentParser&, DocumentFragment&, Element& contextElement, ParserContentPolicy, const HTMLParserOptions&);
+ void setShouldSkipLeadingNewline(bool);
+
</ins><span class="cx"> ~HTMLTreeBuilder();
</span><span class="cx">
</span><del>- const HTMLElementStack* openElements() const { return m_tree.openElements(); }
</del><ins>+ bool isParsingFragment() const;
</ins><span class="cx">
</span><del>- bool isParsingFragment() const { return !!m_fragmentContext.fragment(); }
-#if ENABLE(TEMPLATE_ELEMENT)
- bool isParsingTemplateContents() const { return m_tree.openElements()->hasTemplateInHTMLScope(); }
-#else
- bool isParsingTemplateContents() const { return false; }
-#endif
- bool isParsingFragmentOrTemplateContents() const { return isParsingFragment() || isParsingTemplateContents(); }
</del><ins>+ void constructTree(AtomicHTMLToken&);
</ins><span class="cx">
</span><del>- void detach();
</del><ins>+ bool hasParserBlockingScript() const;
</ins><span class="cx">
</span><del>- void constructTree(AtomicHTMLToken*);
-
- bool hasParserBlockingScript() const { return !!m_scriptToProcess; }
</del><span class="cx"> // Must be called to take the parser-blocking script before calling the parser again.
</span><del>- PassRefPtr<Element> takeScriptToProcess(TextPosition& scriptStartPosition);
</del><ins>+ RefPtr<Element> takeScriptToProcess(TextPosition& scriptStartPosition);
</ins><span class="cx">
</span><span class="cx"> // Done, close any open tags, etc.
</span><span class="cx"> void finished();
</span><span class="cx">
</span><del>- void setShouldSkipLeadingNewline(bool shouldSkip) { m_shouldSkipLeadingNewline = shouldSkip; }
-
</del><span class="cx"> private:
</span><span class="cx"> class ExternalCharacterTokenBuffer;
</span><ins>+
</ins><span class="cx"> // Represents HTML5 "insertion mode"
</span><span class="cx"> // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#insertion-mode
</span><span class="cx"> enum class InsertionMode {
</span><span class="lines">@@ -94,7 +67,9 @@
</span><span class="cx"> InHead,
</span><span class="cx"> InHeadNoscript,
</span><span class="cx"> AfterHead,
</span><ins>+#if ENABLE(TEMPLATE_ELEMENT)
</ins><span class="cx"> TemplateContents,
</span><ins>+#endif
</ins><span class="cx"> InBody,
</span><span class="cx"> Text,
</span><span class="cx"> InTable,
</span><span class="lines">@@ -113,52 +88,54 @@
</span><span class="cx"> AfterAfterFrameset,
</span><span class="cx"> };
</span><span class="cx">
</span><del>-#if ENABLE(TELEPHONE_NUMBER_DETECTION)
</del><ins>+ bool isParsingTemplateContents() const;
+ bool isParsingFragmentOrTemplateContents() const;
+
+#if ENABLE(TELEPHONE_NUMBER_DETECTION) && PLATFORM(IOS)
</ins><span class="cx"> void insertPhoneNumberLink(const String&);
</span><span class="cx"> void linkifyPhoneNumbers(const String&);
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- void processToken(AtomicHTMLToken*);
</del><ins>+ void processToken(AtomicHTMLToken&);
</ins><span class="cx">
</span><del>- void processDoctypeToken(AtomicHTMLToken*);
- void processStartTag(AtomicHTMLToken*);
- void processEndTag(AtomicHTMLToken*);
- void processComment(AtomicHTMLToken*);
- void processCharacter(AtomicHTMLToken*);
- void processEndOfFile(AtomicHTMLToken*);
</del><ins>+ void processDoctypeToken(AtomicHTMLToken&);
+ void processStartTag(AtomicHTMLToken&);
+ void processEndTag(AtomicHTMLToken&);
+ void processComment(AtomicHTMLToken&);
+ void processCharacter(AtomicHTMLToken&);
+ void processEndOfFile(AtomicHTMLToken&);
</ins><span class="cx">
</span><del>- bool processStartTagForInHead(AtomicHTMLToken*);
- void processStartTagForInBody(AtomicHTMLToken*);
- void processStartTagForInTable(AtomicHTMLToken*);
- void processEndTagForInBody(AtomicHTMLToken*);
- void processEndTagForInTable(AtomicHTMLToken*);
- void processEndTagForInTableBody(AtomicHTMLToken*);
- void processEndTagForInRow(AtomicHTMLToken*);
- void processEndTagForInCell(AtomicHTMLToken*);
</del><ins>+ bool processStartTagForInHead(AtomicHTMLToken&);
+ void processStartTagForInBody(AtomicHTMLToken&);
+ void processStartTagForInTable(AtomicHTMLToken&);
+ void processEndTagForInBody(AtomicHTMLToken&);
+ void processEndTagForInTable(AtomicHTMLToken&);
+ void processEndTagForInTableBody(AtomicHTMLToken&);
+ void processEndTagForInRow(AtomicHTMLToken&);
+ void processEndTagForInCell(AtomicHTMLToken&);
</ins><span class="cx">
</span><del>- void processIsindexStartTagForInBody(AtomicHTMLToken*);
- void processHtmlStartTagForInBody(AtomicHTMLToken*);
- bool processBodyEndTagForInBody(AtomicHTMLToken*);
</del><ins>+ void processIsindexStartTagForInBody(AtomicHTMLToken&);
+ void processHtmlStartTagForInBody(AtomicHTMLToken&);
+ bool processBodyEndTagForInBody(AtomicHTMLToken&);
</ins><span class="cx"> bool processTableEndTagForInTable();
</span><span class="cx"> bool processCaptionEndTagForInCaption();
</span><span class="cx"> bool processColgroupEndTagForInColumnGroup();
</span><span class="cx"> bool processTrEndTagForInRow();
</span><del>- // FIXME: This function should be inlined into its one call site or it
- // needs to assert which tokens it can be called with.
- void processAnyOtherEndTagForInBody(AtomicHTMLToken*);
</del><span class="cx">
</span><ins>+ void processAnyOtherEndTagForInBody(AtomicHTMLToken&);
+
</ins><span class="cx"> void processCharacterBuffer(ExternalCharacterTokenBuffer&);
</span><span class="cx"> inline void processCharacterBufferForInBody(ExternalCharacterTokenBuffer&);
</span><span class="cx">
</span><del>- void processFakeStartTag(const QualifiedName&, const Vector<Attribute>& attributes = Vector<Attribute>());
</del><ins>+ void processFakeStartTag(const QualifiedName&, Vector<Attribute>&& attributes = Vector<Attribute>());
</ins><span class="cx"> void processFakeEndTag(const QualifiedName&);
</span><span class="cx"> void processFakeEndTag(const AtomicString&);
</span><span class="cx"> void processFakeCharacters(const String&);
</span><span class="cx"> void processFakePEndTagIfPInButtonScope();
</span><span class="cx">
</span><del>- void processGenericRCDATAStartTag(AtomicHTMLToken*);
- void processGenericRawTextStartTag(AtomicHTMLToken*);
- void processScriptStartTag(AtomicHTMLToken*);
</del><ins>+ void processGenericRCDATAStartTag(AtomicHTMLToken&);
+ void processGenericRawTextStartTag(AtomicHTMLToken&);
+ void processScriptStartTag(AtomicHTMLToken&);
</ins><span class="cx">
</span><span class="cx"> // Default processing for the different insertion modes.
</span><span class="cx"> void defaultForInitial();
</span><span class="lines">@@ -169,81 +146,104 @@
</span><span class="cx"> void defaultForAfterHead();
</span><span class="cx"> void defaultForInTableText();
</span><span class="cx">
</span><del>- inline bool shouldProcessTokenInForeignContent(AtomicHTMLToken*);
- void processTokenInForeignContent(AtomicHTMLToken*);
</del><ins>+ bool shouldProcessTokenInForeignContent(AtomicHTMLToken&);
+ void processTokenInForeignContent(AtomicHTMLToken&);
</ins><span class="cx">
</span><del>- inline HTMLStackItem* adjustedCurrentStackItem() const;
</del><ins>+ HTMLStackItem& adjustedCurrentStackItem() const;
</ins><span class="cx">
</span><del>- Vector<Attribute> attributesForIsindexInput(AtomicHTMLToken*);
</del><ins>+ Vector<Attribute> attributesForIsindexInput(AtomicHTMLToken&);
</ins><span class="cx">
</span><del>- void callTheAdoptionAgency(AtomicHTMLToken*);
</del><ins>+ void callTheAdoptionAgency(AtomicHTMLToken&);
</ins><span class="cx">
</span><span class="cx"> void closeTheCell();
</span><span class="cx">
</span><del>- template <bool shouldClose(const HTMLStackItem*)>
- void processCloseWhenNestedTag(AtomicHTMLToken*);
</del><ins>+ template <bool shouldClose(const HTMLStackItem&)> void processCloseWhenNestedTag(AtomicHTMLToken&);
</ins><span class="cx">
</span><del>- void parseError(AtomicHTMLToken*);
</del><ins>+ void parseError(AtomicHTMLToken&);
</ins><span class="cx">
</span><del>- InsertionMode insertionMode() const { return m_insertionMode; }
- void setInsertionMode(InsertionMode mode) { m_insertionMode = mode; }
-
</del><span class="cx"> void resetInsertionModeAppropriately();
</span><span class="cx">
</span><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- void processTemplateStartTag(AtomicHTMLToken*);
- bool processTemplateEndTag(AtomicHTMLToken*);
- bool processEndOfFileForInTemplateContents(AtomicHTMLToken*);
</del><ins>+ void processTemplateStartTag(AtomicHTMLToken&);
+ bool processTemplateEndTag(AtomicHTMLToken&);
+ bool processEndOfFileForInTemplateContents(AtomicHTMLToken&);
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> class FragmentParsingContext {
</span><del>- WTF_MAKE_NONCOPYABLE(FragmentParsingContext);
</del><span class="cx"> public:
</span><span class="cx"> FragmentParsingContext();
</span><del>- FragmentParsingContext(DocumentFragment&, Element* contextElement);
- ~FragmentParsingContext();
</del><ins>+ FragmentParsingContext(DocumentFragment&, Element& contextElement);
</ins><span class="cx">
</span><del>- DocumentFragment* fragment() const { return m_fragment; }
- Element* contextElement() const { ASSERT(m_fragment); return m_contextElementStackItem->element(); }
- HTMLStackItem* contextElementStackItem() const { ASSERT(m_fragment); return m_contextElementStackItem.get(); }
</del><ins>+ DocumentFragment* fragment() const;
+ Element& contextElement() const;
+ HTMLStackItem& contextElementStackItem() const;
</ins><span class="cx">
</span><span class="cx"> private:
</span><del>- DocumentFragment* m_fragment;
</del><ins>+ DocumentFragment* m_fragment { nullptr };
</ins><span class="cx"> RefPtr<HTMLStackItem> m_contextElementStackItem;
</span><span class="cx"> };
</span><span class="cx">
</span><del>- bool m_framesetOk;
-#ifndef NDEBUG
- bool m_isAttached;
-#endif
- FragmentParsingContext m_fragmentContext;
</del><ins>+ const HTMLDocumentParser& m_parser;
+ const HTMLParserOptions m_options;
+ const FragmentParsingContext m_fragmentContext;
+
</ins><span class="cx"> HTMLConstructionSite m_tree;
</span><span class="cx">
</span><del>- // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#insertion-mode
- InsertionMode m_insertionMode;
-
- // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#original-insertion-mode
- InsertionMode m_originalInsertionMode;
-
</del><ins>+ // https://html.spec.whatwg.org/multipage/syntax.html#the-insertion-mode
+ InsertionMode m_insertionMode { InsertionMode::Initial };
+ InsertionMode m_originalInsertionMode { InsertionMode::Initial };
</ins><span class="cx"> #if ENABLE(TEMPLATE_ELEMENT)
</span><del>- Vector<InsertionMode> m_templateInsertionModes;
</del><ins>+ Vector<InsertionMode, 1> m_templateInsertionModes;
</ins><span class="cx"> #endif
</span><span class="cx">
</span><del>- // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#pending-table-character-tokens
</del><ins>+ // https://html.spec.whatwg.org/multipage/syntax.html#concept-pending-table-char-tokens
</ins><span class="cx"> StringBuilder m_pendingTableCharacters;
</span><span class="cx">
</span><del>- bool m_shouldSkipLeadingNewline;
-
- // We access parser because HTML5 spec requires that we be able to change the state of the tokenizer
- // from within parser actions. We also need it to track the current position.
- HTMLDocumentParser& m_parser;
-
</del><span class="cx"> RefPtr<Element> m_scriptToProcess; // <script> tag which needs processing before resuming the parser.
</span><span class="cx"> TextPosition m_scriptToProcessStartPosition; // Starting line number of the script tag needing processing.
</span><span class="cx">
</span><del>- HTMLParserOptions m_options;
</del><ins>+ bool m_shouldSkipLeadingNewline { false };
+
+ bool m_framesetOk { true };
+
+#if !ASSERT_DISABLED
+ bool m_destroyed { false };
+ bool m_destructionProhibited { true };
+#endif
</ins><span class="cx"> };
</span><span class="cx">
</span><ins>+inline HTMLTreeBuilder::~HTMLTreeBuilder()
+{
+#if !ASSERT_DISABLED
+ ASSERT(!m_destroyed);
+ ASSERT(!m_destructionProhibited);
+ m_destroyed = true;
+#endif
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+inline void HTMLTreeBuilder::setShouldSkipLeadingNewline(bool shouldSkip)
+{
+ ASSERT(!m_destroyed);
+ m_shouldSkipLeadingNewline = shouldSkip;
+}
+
+inline bool HTMLTreeBuilder::isParsingFragment() const
+{
+ ASSERT(!m_destroyed);
+ return !!m_fragmentContext.fragment();
+}
+
+inline bool HTMLTreeBuilder::hasParserBlockingScript() const
+{
+ ASSERT(!m_destroyed);
+ return !!m_scriptToProcess;
+}
+
+inline DocumentFragment* HTMLTreeBuilder::FragmentParsingContext::fragment() const
+{
+ return m_fragment;
+}
+
+}
+
</ins><span class="cx"> #endif
</span></span></pre></div>
<a id="trunkSourceWebCorehtmlparserTextDocumentParsercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/html/parser/TextDocumentParser.cpp (177858 => 177859)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/html/parser/TextDocumentParser.cpp 2015-01-02 10:01:11 UTC (rev 177858)
+++ trunk/Source/WebCore/html/parser/TextDocumentParser.cpp 2015-01-02 16:31:49 UTC (rev 177859)
</span><span class="lines">@@ -59,7 +59,7 @@
</span><span class="cx"> Vector<Attribute> attributes;
</span><span class="cx"> attributes.append(Attribute(styleAttr, "word-wrap: break-word; white-space: pre-wrap;"));
</span><span class="cx"> AtomicHTMLToken fakePre(HTMLToken::StartTag, preTag.localName(), attributes);
</span><del>- treeBuilder()->constructTree(&fakePre);
</del><ins>+ treeBuilder()->constructTree(fakePre);
</ins><span class="cx">
</span><span class="cx"> // Normally we would skip the first \n after a <pre> element, but we don't
</span><span class="cx"> // want to skip the first \n for text documents!
</span></span></pre>
</div>
</div>
</body>
</html>