1/*
2 * Copyright (C) 2010 Google, Inc. All Rights Reserved.
3 * Copyright (C) 2011 Apple Inc. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY
15 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL GOOGLE INC. OR
18 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 */
26
27#ifndef HTMLElementStack_h
28#define HTMLElementStack_h
29
30#include "Element.h"
31#include "HTMLNames.h"
32#include <wtf/Forward.h>
33#include <wtf/Noncopyable.h>
34#include <wtf/OwnPtr.h>
35#include <wtf/PassOwnPtr.h>
36#include <wtf/RefPtr.h>
37
38namespace WebCore {
39
40class ContainerNode;
41class DocumentFragment;
42class Element;
43class QualifiedName;
44
45// NOTE: The HTML5 spec uses a backwards (grows downward) stack.  We're using
46// more standard (grows upwards) stack terminology here.
47class HTMLElementStack {
48    WTF_MAKE_NONCOPYABLE(HTMLElementStack); WTF_MAKE_FAST_ALLOCATED;
49public:
50    HTMLElementStack();
51    ~HTMLElementStack();
52
53    class ElementRecord {
54        WTF_MAKE_NONCOPYABLE(ElementRecord);
55    public:
56        ~ElementRecord(); // Public for ~PassOwnPtr()
57
58        Element* element() const { return toElement(m_node.get()); }
59        ContainerNode* node() const { return m_node.get(); }
60        void replaceElement(PassRefPtr<Element>);
61
62        bool isAbove(ElementRecord*) const;
63
64        ElementRecord* next() const { return m_next.get(); }
65
66    private:
67        friend class HTMLElementStack;
68
69        ElementRecord(PassRefPtr<ContainerNode>, PassOwnPtr<ElementRecord>);
70
71        PassOwnPtr<ElementRecord> releaseNext() { return m_next.release(); }
72        void setNext(PassOwnPtr<ElementRecord> next) { m_next = next; }
73
74        RefPtr<ContainerNode> m_node;
75        OwnPtr<ElementRecord> m_next;
76    };
77
78    // Inlining this function is a (small) performance win on the parsing
79    // benchmark.
80    Element* top() const
81    {
82        ASSERT(m_top->element());
83        return m_top->element();
84    }
85
86    ContainerNode* topNode() const
87    {
88        ASSERT(m_top->node());
89        return m_top->node();
90    }
91
92    Element* oneBelowTop() const;
93    ElementRecord* topRecord() const;
94    Element* bottom() const;
95    ElementRecord* find(Element*) const;
96    ElementRecord* topmost(const AtomicString& tagName) const;
97
98    void insertAbove(PassRefPtr<Element>, ElementRecord*);
99
100    void push(PassRefPtr<Element>);
101    void pushRootNode(PassRefPtr<ContainerNode>);
102    void pushHTMLHtmlElement(PassRefPtr<Element>);
103    void pushHTMLHeadElement(PassRefPtr<Element>);
104    void pushHTMLBodyElement(PassRefPtr<Element>);
105
106    void pop();
107    void popUntil(const AtomicString& tagName);
108    void popUntil(Element*);
109    void popUntilPopped(const AtomicString& tagName);
110    void popUntilPopped(Element*);
111    void popUntilNumberedHeaderElementPopped();
112    void popUntilTableScopeMarker(); // "clear the stack back to a table context" in the spec.
113    void popUntilTableBodyScopeMarker(); // "clear the stack back to a table body context" in the spec.
114    void popUntilTableRowScopeMarker(); // "clear the stack back to a table row context" in the spec.
115    void popUntilForeignContentScopeMarker();
116    void popHTMLHeadElement();
117    void popHTMLBodyElement();
118    void popAll();
119
120    void remove(Element*);
121    void removeHTMLHeadElement(Element*);
122
123    bool contains(Element*) const;
124    bool contains(const AtomicString& tagName) const;
125
126    bool inScope(Element*) const;
127    bool inScope(const AtomicString& tagName) const;
128    bool inScope(const QualifiedName&) const;
129    bool inListItemScope(const AtomicString& tagName) const;
130    bool inListItemScope(const QualifiedName&) const;
131    bool inTableScope(const AtomicString& tagName) const;
132    bool inTableScope(const QualifiedName&) const;
133    bool inButtonScope(const AtomicString& tagName) const;
134    bool inButtonScope(const QualifiedName&) const;
135    bool inSelectScope(const AtomicString& tagName) const;
136    bool inSelectScope(const QualifiedName&) const;
137
138    bool hasOnlyHTMLElementsInScope() const;
139    bool hasNumberedHeaderElementInScope() const;
140
141    bool hasOnlyOneElement() const;
142    bool secondElementIsHTMLBodyElement() const;
143
144    Element* htmlElement() const;
145    Element* headElement() const;
146    Element* bodyElement() const;
147
148    ContainerNode* rootNode() const;
149
150#ifndef NDEBUG
151    void show();
152#endif
153
154private:
155    void pushCommon(PassRefPtr<ContainerNode>);
156    void pushRootNodeCommon(PassRefPtr<ContainerNode>);
157    void popCommon();
158    void removeNonTopCommon(Element*);
159
160    OwnPtr<ElementRecord> m_top;
161
162    // We remember the root node, <head> and <body> as they are pushed. Their
163    // ElementRecords keep them alive. The root node is never popped.
164    // FIXME: We don't currently require type-specific information about
165    // these elements so we haven't yet bothered to plumb the types all the
166    // way down through createElement, etc.
167    ContainerNode* m_rootNode;
168    Element* m_headElement;
169    Element* m_bodyElement;
170};
171
172inline bool isInHTMLNamespace(Node* node)
173{
174    // A DocumentFragment takes the place of the document element when parsing
175    // fragments and should be considered in the HTML namespace.
176    return node->namespaceURI() == HTMLNames::xhtmlNamespaceURI
177        || node->nodeType() == Node::DOCUMENT_FRAGMENT_NODE;
178}
179
180
181} // namespace WebCore
182
183#endif // HTMLElementStack_h
184