2010-07-12 Eric Seidel <eric@webkit.org>
[WebKit-https.git] / WebCore / html / HTMLElementStack.cpp
index 0b4b1a3..d1a1752 100644 (file)
 #include "HTMLElementStack.h"
 
 #include "Element.h"
+#include "HTMLNames.h"
 #include <wtf/PassOwnPtr.h>
 
+#if ENABLE(SVG)
+#include "SVGNames.h"
+#endif
+
 namespace WebCore {
 
-class HTMLElementStack::ElementRecord : public Noncopyable {
-public:
-    ElementRecord(PassRefPtr<Element> element, PassOwnPtr<ElementRecord> next)
-        : m_element(element)
-        , m_next(next)
-    {
-    }
+using namespace HTMLNames;
+
+namespace {
+
+inline bool isScopeMarker(Element* element)
+{
+    return element->hasTagName(appletTag)
+        || element->hasTagName(buttonTag)
+        || element->hasTagName(captionTag)
+#if ENABLE(SVG_FOREIGN_OBJECT)
+        || element->hasTagName(SVGNames::foreignObjectTag)
+#endif
+        || element->hasTagName(htmlTag)
+        || element->hasTagName(marqueeTag)
+        || element->hasTagName(objectTag)
+        || element->hasTagName(tableTag)
+        || element->hasTagName(tdTag)
+        || element->hasTagName(thTag);
+}
+
+inline bool isListItemScopeMarker(Element* element)
+{
+    return isScopeMarker(element)
+        || element->hasTagName(olTag)
+        || element->hasTagName(ulTag);
+}
 
-    Element* element() const { return m_element.get(); }
-    ElementRecord* next() const { return m_next.get(); }
-    PassOwnPtr<ElementRecord> releaseNext() { return m_next.release(); }
-    void setNext(PassOwnPtr<ElementRecord> next) { m_next = next; }
+inline bool isTableScopeMarker(Element* element)
+{
+    return element->hasTagName(tableTag)
+        || element->hasTagName(htmlTag);
+}
+
+inline bool isTableBodyScopeMarker(Element* element)
+{
+    return element->hasTagName(tbodyTag)
+        || element->hasTagName(tfootTag)
+        || element->hasTagName(theadTag)
+        || element->hasTagName(htmlTag);
+}
+
+inline bool isTableRowScopeMarker(Element* element)
+{
+    return element->hasTagName(trTag)
+        || element->hasTagName(htmlTag);
+}
 
-private:
-    RefPtr<Element> m_element;
-    OwnPtr<ElementRecord> m_next;
-};
+}
+
+HTMLElementStack::ElementRecord::ElementRecord(PassRefPtr<Element> element, PassOwnPtr<ElementRecord> next)
+    : m_element(element)
+    , m_next(next)
+{
+    ASSERT(m_element);
+}
+
+HTMLElementStack::ElementRecord::~ElementRecord()
+{
+}
+
+void HTMLElementStack::ElementRecord::replaceElement(PassRefPtr<Element> element)
+{
+    ASSERT(element);
+    // FIXME: Should this call finishParsingChildren?
+    m_element = element;
+}
+
+bool HTMLElementStack::ElementRecord::isAbove(ElementRecord* other) const
+{
+    for (ElementRecord* below = next(); below; below = below->next()) {
+        if (below == other)
+            return true;
+    }
+    return false;
+}
 
 HTMLElementStack::HTMLElementStack()
     : m_htmlElement(0)
@@ -67,14 +130,76 @@ void HTMLElementStack::popHTMLHeadElement()
     popCommon();
 }
 
+void HTMLElementStack::popHTMLBodyElement()
+{
+    ASSERT(top() == m_bodyElement);
+    m_bodyElement = 0;
+    popCommon();
+}
+
 void HTMLElementStack::pop()
 {
     ASSERT(!top()->hasTagName(HTMLNames::headTag));
     popCommon();
 }
 
+void HTMLElementStack::popUntilElementWithNamespace(const AtomicString& namespaceURI)
+{
+    while (top()->namespaceURI() != namespaceURI)
+        pop();
+}
+
+void HTMLElementStack::popUntil(const AtomicString& tagName)
+{
+    while (!top()->hasLocalName(tagName)) {
+        // pop() will ASSERT at <body> if callers fail to check that there is an
+        // element with localName |tagName| on the stack of open elements.
+        pop();
+    }
+}
+
+void HTMLElementStack::popUntilPopped(const AtomicString& tagName)
+{
+    popUntil(tagName);
+    pop();
+}
+
+void HTMLElementStack::popUntil(Element* element)
+{
+    while (top() != element)
+        pop();
+}
+
+void HTMLElementStack::popUntilPopped(Element* element)
+{
+    popUntil(element);
+    pop();
+}
+
+void HTMLElementStack::popUntilTableScopeMarker()
+{
+    // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#clear-the-stack-back-to-a-table-context
+    while (!isTableScopeMarker(top()))
+        pop();
+}
+
+void HTMLElementStack::popUntilTableBodyScopeMarker()
+{
+    // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#clear-the-stack-back-to-a-table-body-context
+    while (!isTableBodyScopeMarker(top()))
+        pop();
+}
+
+void HTMLElementStack::popUntilTableRowScopeMarker()
+{
+    // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#clear-the-stack-back-to-a-table-row-context
+    while (!isTableRowScopeMarker(top()))
+        pop();
+}
+
 void HTMLElementStack::pushHTMLHtmlElement(PassRefPtr<Element> element)
 {
+    ASSERT(!m_top); // <html> should always be the bottom of the stack.
     ASSERT(element->hasTagName(HTMLNames::htmlTag));
     ASSERT(!m_htmlElement);
     m_htmlElement = element.get();
@@ -106,11 +231,56 @@ void HTMLElementStack::push(PassRefPtr<Element> element)
     pushCommon(element);
 }
 
+void HTMLElementStack::insertAbove(PassRefPtr<Element> element, ElementRecord* recordBelow)
+{
+    ASSERT(element);
+    ASSERT(recordBelow);
+    ASSERT(m_top);
+    ASSERT(!element->hasTagName(HTMLNames::htmlTag));
+    ASSERT(!element->hasTagName(HTMLNames::headTag));
+    ASSERT(!element->hasTagName(HTMLNames::bodyTag));
+    ASSERT(m_htmlElement);
+    if (recordBelow == m_top) {
+        push(element);
+        return;
+    }
+
+    for (ElementRecord* recordAbove = m_top.get(); recordAbove; recordAbove = recordAbove->next()) {
+        if (recordAbove->next() != recordBelow)
+            continue;
+
+        recordAbove->setNext(new ElementRecord(element, recordAbove->releaseNext()));
+        recordAbove->next()->element()->beginParsingChildren();
+        return;
+    }
+    ASSERT_NOT_REACHED();
+}
+
+HTMLElementStack::ElementRecord* HTMLElementStack::topRecord() const
+{
+    ASSERT(m_top);
+    return m_top.get();
+}
+
 Element* HTMLElementStack::top() const
 {
+    ASSERT(m_top->element());
     return m_top->element();
 }
 
+Element* HTMLElementStack::oneBelowTop() const
+{
+    // We should never be calling this if it could be 0.
+    ASSERT(m_top);
+    ASSERT(m_top->next());
+    return m_top->next()->element();
+}
+
+Element* HTMLElementStack::bottom() const
+{
+    return htmlElement();
+}
+
 void HTMLElementStack::removeHTMLHeadElement(Element* element)
 {
     ASSERT(m_headElement == element);
@@ -119,7 +289,7 @@ void HTMLElementStack::removeHTMLHeadElement(Element* element)
         return;
     }
     m_headElement = 0;
-    removeNonFirstCommon(element);
+    removeNonTopCommon(element);
 }
 
 void HTMLElementStack::remove(Element* element)
@@ -129,47 +299,118 @@ void HTMLElementStack::remove(Element* element)
         pop();
         return;
     }
-    removeNonFirstCommon(element);
+    removeNonTopCommon(element);
 }
 
-bool HTMLElementStack::contains(Element* element) const
+HTMLElementStack::ElementRecord* HTMLElementStack::find(Element* element) const
 {
     for (ElementRecord* pos = m_top.get(); pos; pos = pos->next()) {
         if (pos->element() == element)
+            return pos;
+    }
+    return 0;
+}
+
+HTMLElementStack::ElementRecord* HTMLElementStack::topmost(const AtomicString& tagName) const
+{
+    for (ElementRecord* pos = m_top.get(); pos; pos = pos->next()) {
+        if (pos->element()->hasLocalName(tagName))
+            return pos;
+    }
+    return 0;
+}
+
+bool HTMLElementStack::contains(Element* element) const
+{
+    return !!find(element);
+}
+
+template <bool isMarker(Element*)>
+bool inScopeCommon(HTMLElementStack::ElementRecord* top, const AtomicString& targetTag)
+{
+    for (HTMLElementStack::ElementRecord* pos = top; pos; pos = pos->next()) {
+        Element* element = pos->element();
+        if (element->hasLocalName(targetTag))
             return true;
+        if (isMarker(element))
+            return false;
     }
+    ASSERT_NOT_REACHED(); // <html> is always on the stack and is a scope marker.
     return false;
 }
 
-bool HTMLElementStack::inScope(const AtomicString& name) const
+bool HTMLElementStack::hasOnlyHTMLElementsInScope() const
+{
+    for (ElementRecord* record = m_top.get(); record; record = record->next()) {
+        Element* element = record->element();
+        if (element->namespaceURI() != xhtmlNamespaceURI)
+            return false;
+        if (isScopeMarker(element))
+            return true;
+    }
+    ASSERT_NOT_REACHED(); // <html> is always on the stack and is a scope marker.
+    return true;
+}
+
+bool HTMLElementStack::inScope(Element* targetElement) const
 {
-    // FIXME: This algorithm is wrong.
     for (ElementRecord* pos = m_top.get(); pos; pos = pos->next()) {
-        if (pos->element()->tagQName() == name)
+        Element* element = pos->element();
+        if (element == targetElement)
             return true;
+        if (isScopeMarker(element))
+            return false;
     }
+    ASSERT_NOT_REACHED(); // <html> is always on the stack and is a scope marker.
     return false;
 }
 
-bool HTMLElementStack::inScope(Element* element) const
+bool HTMLElementStack::inScope(const AtomicString& targetTag) const
+{
+    return inScopeCommon<isScopeMarker>(m_top.get(), targetTag);
+}
+
+bool HTMLElementStack::inScope(const QualifiedName& tagName) const
+{
+    // FIXME: Is localName() right for non-html elements?
+    return inScope(tagName.localName());
+}
+
+bool HTMLElementStack::inListItemScope(const AtomicString& targetTag) const
 {
-    // FIXME: This algorithm is wrong.
-    return contains(element);
+    return inScopeCommon<isListItemScopeMarker>(m_top.get(), targetTag);
 }
 
-Element* HTMLElementStack::htmlElement()
+bool HTMLElementStack::inListItemScope(const QualifiedName& tagName) const
+{
+    // FIXME: Is localName() right for non-html elements?
+    return inListItemScope(tagName.localName());
+}
+
+bool HTMLElementStack::inTableScope(const AtomicString& targetTag) const
+{
+    return inScopeCommon<isTableScopeMarker>(m_top.get(), targetTag);
+}
+
+bool HTMLElementStack::inTableScope(const QualifiedName& tagName) const
+{
+    // FIXME: Is localName() right for non-html elements?
+    return inTableScope(tagName.localName());
+}
+
+Element* HTMLElementStack::htmlElement() const
 {
     ASSERT(m_htmlElement);
     return m_htmlElement;
 }
 
-Element* HTMLElementStack::headElement()
+Element* HTMLElementStack::headElement() const
 {
     ASSERT(m_headElement);
     return m_headElement;
 }
 
-Element* HTMLElementStack::bodyElement()
+Element* HTMLElementStack::bodyElement() const
 {
     ASSERT(m_bodyElement);
     return m_bodyElement;
@@ -177,6 +418,7 @@ Element* HTMLElementStack::bodyElement()
 
 void HTMLElementStack::pushCommon(PassRefPtr<Element> element)
 {
+    ASSERT(m_htmlElement);
     m_top.set(new ElementRecord(element, m_top.release()));
     top()->beginParsingChildren();
 }
@@ -184,18 +426,18 @@ void HTMLElementStack::pushCommon(PassRefPtr<Element> element)
 void HTMLElementStack::popCommon()
 {
     ASSERT(!top()->hasTagName(HTMLNames::htmlTag));
-    ASSERT(!top()->hasTagName(HTMLNames::bodyTag));
+    ASSERT(!top()->hasTagName(HTMLNames::headTag) || !m_headElement);
+    ASSERT(!top()->hasTagName(HTMLNames::bodyTag) || !m_bodyElement);
     top()->finishParsingChildren();
     m_top = m_top->releaseNext();
 }
 
-void HTMLElementStack::removeNonFirstCommon(Element* element)
+void HTMLElementStack::removeNonTopCommon(Element* element)
 {
     ASSERT(!element->hasTagName(HTMLNames::htmlTag));
     ASSERT(!element->hasTagName(HTMLNames::bodyTag));
-    ElementRecord* pos = m_top.get();
-    ASSERT(pos->element() != element);
-    while (pos->next()) {
+    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?
@@ -207,4 +449,14 @@ void HTMLElementStack::removeNonFirstCommon(Element* element)
     ASSERT_NOT_REACHED();
 }
 
+#ifndef NDEBUG
+
+void HTMLElementStack::show()
+{
+    for (ElementRecord* record = m_top.get(); record; record = record->next())
+        record->element()->showNode();
+}
+
+#endif
+
 }