Introduce isHTMLHtmlElement and toHTMLHtmlElement

Source/core/html/parser/HTMLElementStack.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 13 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
 #include "config.h"
 #include "core/html/parser/HTMLElementStack.h"
 
 #include "HTMLNames.h"
 #include "MathMLNames.h"
 #include "SVGNames.h"
 #include "core/dom/Element.h"
+#include "core/html/HTMLHtmlElement.h"
 #include "core/html/HTMLOptGroupElement.h"
 #include "core/html/HTMLTableElement.h"
 #include <wtf/PassOwnPtr.h>
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 
 namespace {
 
 inline bool isRootNode(HTMLStackItem* item)
 {
     return item->isDocumentFragmentNode()
-        || item->hasTagName(htmlTag);
+        || isHTMLHtmlElement(item->node());
 }
 
 inline bool isScopeMarker(HTMLStackItem* item)
 {
     return item->hasTagName(appletTag)
         || item->hasTagName(captionTag)
         || item->hasTagName(marqueeTag)
         || item->hasTagName(objectTag)
         || isHTMLTableElement(item->node())
         || item->hasTagName(tdTag)
@@ skipping 243 matching lines @@
 }
     
 void HTMLElementStack::pushRootNode(PassRefPtr<HTMLStackItem> rootItem)
 {
     ASSERT(rootItem->isDocumentFragmentNode());
     pushRootNodeCommon(rootItem);
 }
 
 void HTMLElementStack::pushHTMLHtmlElement(PassRefPtr<HTMLStackItem> item)
 {
-    ASSERT(item->hasTagName(HTMLNames::htmlTag));
+    ASSERT(isHTMLHtmlElement(item->node()));
     pushRootNodeCommon(item);
 }
     
 void HTMLElementStack::pushRootNodeCommon(PassRefPtr<HTMLStackItem> rootItem)
 {
     ASSERT(!m_top);
     ASSERT(!m_rootNode);
     m_rootNode = rootItem->node();
     pushCommon(rootItem);
 }
 
 void HTMLElementStack::pushHTMLHeadElement(PassRefPtr<HTMLStackItem> item)
 {
     ASSERT(item->hasTagName(HTMLNames::headTag));
     ASSERT(!m_headElement);
     m_headElement = item->element();
     pushCommon(item);
 }
 
 void HTMLElementStack::pushHTMLBodyElement(PassRefPtr<HTMLStackItem> item)
 {
     ASSERT(item->hasTagName(HTMLNames::bodyTag));
     ASSERT(!m_bodyElement);
     m_bodyElement = item->element();
     pushCommon(item);
 }
 
 void HTMLElementStack::push(PassRefPtr<HTMLStackItem> item)
 {
-    ASSERT(!item->hasTagName(HTMLNames::htmlTag));
+    ASSERT(!isHTMLHtmlElement(item->node()));
     ASSERT(!item->hasTagName(HTMLNames::headTag));
     ASSERT(!item->hasTagName(HTMLNames::bodyTag));
     ASSERT(m_rootNode);
     pushCommon(item);
 }
 
 void HTMLElementStack::insertAbove(PassRefPtr<HTMLStackItem> item, ElementRecord* recordBelow)
 {
     ASSERT(item);
     ASSERT(recordBelow);
     ASSERT(m_top);
-    ASSERT(!item->hasTagName(HTMLNames::htmlTag));
+    ASSERT(!isHTMLHtmlElement(item->node()));
     ASSERT(!item->hasTagName(HTMLNames::headTag));
     ASSERT(!item->hasTagName(HTMLNames::bodyTag));
     ASSERT(m_rootNode);
     if (recordBelow == m_top) {
         push(item);
         return;
     }
 
     for (ElementRecord* recordAbove = m_top.get(); recordAbove; recordAbove = recordAbove->next()) {
         if (recordAbove->next() != recordBelow)
@@ skipping 194 matching lines @@
 void HTMLElementStack::pushCommon(PassRefPtr<HTMLStackItem> item)
 {
     ASSERT(m_rootNode);
 
     m_stackDepth++;
     m_top = adoptPtr(new ElementRecord(item, m_top.release()));
 }
 
 void HTMLElementStack::popCommon()
 {
-    ASSERT(!topStackItem()->hasTagName(HTMLNames::htmlTag));
+    ASSERT(!isHTMLHtmlElement(topStackItem()->node()));
     ASSERT(!topStackItem()->hasTagName(HTMLNames::headTag) || !m_headElement);
     ASSERT(!topStackItem()->hasTagName(HTMLNames::bodyTag) || !m_bodyElement);
     top()->finishParsingChildren();
     m_top = m_top->releaseNext();
 
     m_stackDepth--;
 }
 
 void HTMLElementStack::removeNonTopCommon(Element* element)
 {
-    ASSERT(!element->hasTagName(HTMLNames::htmlTag));
+    ASSERT(!isHTMLHtmlElement(element));
     ASSERT(!element->hasTagName(HTMLNames::bodyTag));
     ASSERT(top() != element);
     for (ElementRecord* pos = m_top.get(); pos; pos = pos->next()) {
         if (pos->next()->element() == element) {
             // FIXME: Is it OK to call finishParsingChildren()
             // when the children aren't actually finished?
             element->finishParsingChildren();
             pos->setNext(pos->next()->releaseNext());
             m_stackDepth--;
             return;
@@ skipping 19 matching lines @@
 
 void HTMLElementStack::show()
 {
     for (ElementRecord* record = m_top.get(); record; record = record->next())
         record->element()->showNode();
 }
 
 #endif
 
 }