Move innerHTML and outerHTML to Element

Source/core/html/parser/HTMLTreeBuilder.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 357 matching lines @@
 }
 
 void HTMLTreeBuilder::constructTree(AtomicHTMLToken* token)
 {
     if (shouldProcessTokenInForeignContent(token))
         processTokenInForeignContent(token);
     else
         processToken(token);
 
     if (m_parser->tokenizer()) {
-        bool inForeignContent = !m_tree.isEmpty()
-            && !m_tree.currentStackItem()->isInHTMLNamespace()
-            && !HTMLElementStack::isHTMLIntegrationPoint(m_tree.currentStackItem())
-            && !HTMLElementStack::isMathMLTextIntegrationPoint(m_tree.currentStackItem());
+        bool inForeignContent = false;
+
+        if (!m_tree.isEmpty()) {
+            RefPtr<HTMLStackItem> contextNodeRef;

[abarth-chromium, 2013/10/29 04:04:42]

contextNodeRef  <-- What does the "Ref" in this name mean?  Perhaps just
contextNode?

Why do we even need this variable?

+            HTMLStackItem* adjustedCurrentNode = adjustedCurrentStackItem(contextNodeRef);
+            inForeignContent = !adjustedCurrentNode->isInHTMLNamespace()
+                && !HTMLElementStack::isHTMLIntegrationPoint(adjustedCurrentNode)
+                && !HTMLElementStack::isMathMLTextIntegrationPoint(adjustedCurrentNode);
+        }
 
         m_parser->tokenizer()->setForceNullCharacterReplacement(m_insertionMode == TextMode || inForeignContent);
         m_parser->tokenizer()->setShouldAllowCDATA(inForeignContent);
     }
 
     m_tree.executeQueuedTasks();
     // We might be detached now.
 }
 
 void HTMLTreeBuilder::processToken(AtomicHTMLToken* token)
@@ skipping 596 matching lines @@
     if (m_tree.currentIsRootNode() || m_tree.currentNode()->hasTagName(templateTag)) {
         ASSERT(isParsingFragmentOrTemplateContents());
         // FIXME: parse error
         return false;
     }
     m_tree.openElements()->pop();
     setInsertionMode(InTableMode);
     return true;
 }
 
+// http://www.whatwg.org/specs/web-apps/current-work/#adjusted-current-node
+HTMLStackItem* HTMLTreeBuilder::adjustedCurrentStackItem(RefPtr<HTMLStackItem>& contextStackItem) const

[abarth-chromium, 2013/10/29 04:04:42]

Why not just return a PassRefPtr<HTMLStackItem>.  Then you don't need this crazy
parameter.

[davve, 2013/10/29 09:15:38]

Just me showing my inexperience with the RefPtr-family. (re-reads
http://www.webkit.org/coding/RefPtr.html ). Thanks for the sanity check, the
function now returns a PassRefPtr<HTMLStackItem>.

+{
+    ASSERT(!m_tree.isEmpty());
+    if (isParsingFragment() && m_tree.openElements()->hasOnlyOneElement()) {
+        contextStackItem = HTMLStackItem::create(m_fragmentContext.contextElement(), HTMLStackItem::ItemForContextElement);
+        return contextStackItem.get();
+    }
+
+    return m_tree.currentStackItem();
+}
+
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#close-the-cell
 void HTMLTreeBuilder::closeTheCell()
 {
     ASSERT(insertionMode() == InCellMode);
     if (m_tree.openElements()->inTableScope(tdTag)) {
         ASSERT(!m_tree.openElements()->inTableScope(thTag));
         processFakeEndTag(tdTag);
         return;
     }
     ASSERT(m_tree.openElements()->inTableScope(thTag));
@@ skipping 1660 matching lines @@
     m_scriptToProcessStartPosition = position;
 
     setInsertionMode(TextMode);
 }
 
 // http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#tree-construction
 bool HTMLTreeBuilder::shouldProcessTokenInForeignContent(AtomicHTMLToken* token)
 {
     if (m_tree.isEmpty())
         return false;
-    HTMLStackItem* item = m_tree.currentStackItem();
-    if (item->isInHTMLNamespace())
+    RefPtr<HTMLStackItem> contextNodeRef;
+    HTMLStackItem* adjustedCurrentNode = adjustedCurrentStackItem(contextNodeRef);
+
+    if (adjustedCurrentNode->isInHTMLNamespace())
         return false;
-    if (HTMLElementStack::isMathMLTextIntegrationPoint(item)) {
+    if (HTMLElementStack::isMathMLTextIntegrationPoint(adjustedCurrentNode)) {
         if (token->type() == HTMLToken::StartTag
             && token->name() != MathMLNames::mglyphTag
             && token->name() != MathMLNames::malignmarkTag)
             return false;
         if (token->type() == HTMLToken::Character)
             return false;
     }
-    if (item->hasTagName(MathMLNames::annotation_xmlTag)
+    if (adjustedCurrentNode->hasTagName(MathMLNames::annotation_xmlTag)
         && token->type() == HTMLToken::StartTag
         && token->name() == SVGNames::svgTag)
         return false;
-    if (HTMLElementStack::isHTMLIntegrationPoint(item)) {
+    if (HTMLElementStack::isHTMLIntegrationPoint(adjustedCurrentNode)) {
         if (token->type() == HTMLToken::StartTag)
             return false;
         if (token->type() == HTMLToken::Character)
             return false;
     }
     if (token->type() == HTMLToken::EndOfFile)
         return false;
     return true;
 }
 
 void HTMLTreeBuilder::processTokenInForeignContent(AtomicHTMLToken* token)
 {
+    RefPtr<HTMLStackItem> contextNodeRef;
+    HTMLStackItem* adjustedCurrentNode = adjustedCurrentStackItem(contextNodeRef);
+
     switch (token->type()) {
     case HTMLToken::Uninitialized:
         ASSERT_NOT_REACHED();
         break;
     case HTMLToken::DOCTYPE:
         parseError(token);
         break;
     case HTMLToken::StartTag: {
         if (token->name() == bTag
             || token->name() == bigTag
@@ skipping 33 matching lines @@
             || token->name() == ttTag
             || token->name() == uTag
             || token->name() == ulTag
             || token->name() == varTag
             || (token->name() == fontTag && (token->getAttributeItem(colorAttr) || token->getAttributeItem(faceAttr) || token->getAttributeItem(sizeAttr)))) {
             parseError(token);
             m_tree.openElements()->popUntilForeignContentScopeMarker();
             processStartTag(token);
             return;
         }
-        const AtomicString& currentNamespace = m_tree.currentStackItem()->namespaceURI();
+        const AtomicString& currentNamespace = adjustedCurrentNode->namespaceURI();
         if (currentNamespace == MathMLNames::mathmlNamespaceURI)
             adjustMathMLAttributes(token);
         if (currentNamespace == SVGNames::svgNamespaceURI) {
             adjustSVGTagNameCase(token);
             adjustSVGAttributes(token);
         }
         adjustForeignAttributes(token);
         m_tree.insertForeignElement(token, currentNamespace);
         break;
     }
     case HTMLToken::EndTag: {
-        if (m_tree.currentStackItem()->namespaceURI() == SVGNames::svgNamespaceURI)
+        if (adjustedCurrentNode->namespaceURI() == SVGNames::svgNamespaceURI)
             adjustSVGTagNameCase(token);
 
         if (token->name() == SVGNames::scriptTag && m_tree.currentStackItem()->hasTagName(SVGNames::scriptTag)) {
             if (scriptingContentIsAllowed(m_tree.parserContentPolicy()))
                 m_scriptToProcess = m_tree.currentElement();
             m_tree.openElements()->pop();
             return;
         }
         if (!m_tree.currentStackItem()->isInHTMLNamespace()) {
             // FIXME: This code just wants an Element* iterator, instead of an ElementRecord*
@@ skipping 40 matching lines @@
     ASSERT(m_isAttached);
     // Warning, this may detach the parser. Do not do anything else after this.
     m_tree.finishedParsing();
 }
 
 void HTMLTreeBuilder::parseError(AtomicHTMLToken*)
 {
 }
 
 } // namespace WebCore