Unreviewed buildfix after r62196 and r62214.
[WebKit-https.git] / WebCore / html / HTMLElementStack.cpp
1 /*
2  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL GOOGLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "HTMLElementStack.h"
28
29 #include "Element.h"
30 #include "HTMLNames.h"
31 #include <wtf/PassOwnPtr.h>
32
33 #if ENABLE(SVG)
34 #include "SVGNames.h"
35 #endif
36
37 namespace WebCore {
38
39 using namespace HTMLNames;
40
41 class HTMLElementStack::ElementRecord : public Noncopyable {
42 public:
43     ElementRecord(PassRefPtr<Element> element, PassOwnPtr<ElementRecord> next)
44         : m_element(element)
45         , m_next(next)
46     {
47     }
48
49     Element* element() const { return m_element.get(); }
50     ElementRecord* next() const { return m_next.get(); }
51     PassOwnPtr<ElementRecord> releaseNext() { return m_next.release(); }
52     void setNext(PassOwnPtr<ElementRecord> next) { m_next = next; }
53
54 private:
55     RefPtr<Element> m_element;
56     OwnPtr<ElementRecord> m_next;
57 };
58
59 HTMLElementStack::HTMLElementStack()
60     : m_htmlElement(0)
61     , m_headElement(0)
62     , m_bodyElement(0)
63 {
64 }
65
66 HTMLElementStack::~HTMLElementStack()
67 {
68 }
69
70 void HTMLElementStack::popHTMLHeadElement()
71 {
72     ASSERT(top() == m_headElement);
73     m_headElement = 0;
74     popCommon();
75 }
76
77 void HTMLElementStack::pop()
78 {
79     ASSERT(!top()->hasTagName(HTMLNames::headTag));
80     popCommon();
81 }
82
83 void HTMLElementStack::popUntil(const AtomicString& tagName)
84 {
85     while (!top()->hasLocalName(tagName)) {
86         // pop() will ASSERT at <body> if callers fail to check that there is an
87         // element with localName |tagName| on the stack of open elements.
88         pop();
89     }
90 }
91
92 void HTMLElementStack::pushHTMLHtmlElement(PassRefPtr<Element> element)
93 {
94     ASSERT(element->hasTagName(HTMLNames::htmlTag));
95     ASSERT(!m_htmlElement);
96     m_htmlElement = element.get();
97     pushCommon(element);
98 }
99
100 void HTMLElementStack::pushHTMLHeadElement(PassRefPtr<Element> element)
101 {
102     ASSERT(element->hasTagName(HTMLNames::headTag));
103     ASSERT(!m_headElement);
104     m_headElement = element.get();
105     pushCommon(element);
106 }
107
108 void HTMLElementStack::pushHTMLBodyElement(PassRefPtr<Element> element)
109 {
110     ASSERT(element->hasTagName(HTMLNames::bodyTag));
111     ASSERT(!m_bodyElement);
112     m_bodyElement = element.get();
113     pushCommon(element);
114 }
115
116 void HTMLElementStack::push(PassRefPtr<Element> element)
117 {
118     ASSERT(!element->hasTagName(HTMLNames::htmlTag));
119     ASSERT(!element->hasTagName(HTMLNames::headTag));
120     ASSERT(!element->hasTagName(HTMLNames::bodyTag));
121     ASSERT(m_htmlElement);
122     pushCommon(element);
123 }
124
125 Element* HTMLElementStack::top() const
126 {
127     return m_top->element();
128 }
129
130 void HTMLElementStack::removeHTMLHeadElement(Element* element)
131 {
132     ASSERT(m_headElement == element);
133     if (m_top->element() == element) {
134         popHTMLHeadElement();
135         return;
136     }
137     m_headElement = 0;
138     removeNonFirstCommon(element);
139 }
140
141 void HTMLElementStack::remove(Element* element)
142 {
143     ASSERT(!element->hasTagName(HTMLNames::headTag));
144     if (m_top->element() == element) {
145         pop();
146         return;
147     }
148     removeNonFirstCommon(element);
149 }
150
151 bool HTMLElementStack::contains(Element* element) const
152 {
153     for (ElementRecord* pos = m_top.get(); pos; pos = pos->next()) {
154         if (pos->element() == element)
155             return true;
156     }
157     return false;
158 }
159
160 namespace {
161
162 inline bool isScopeMarker(const Element* element)
163 {
164     return element->hasTagName(appletTag)
165         || element->hasTagName(captionTag)
166         || element->hasTagName(appletTag)
167         || element->hasTagName(htmlTag)
168         || element->hasTagName(tableTag)
169         || element->hasTagName(tdTag)
170         || element->hasTagName(thTag)
171         || element->hasTagName(buttonTag)
172         || element->hasTagName(marqueeTag)
173         || element->hasTagName(objectTag)
174 #if ENABLE(SVG_FOREIGN_OBJECT)
175         || element->hasTagName(SVGNames::foreignObjectTag)
176 #endif
177         ;
178 }
179
180 inline bool isListItemScopeMarker(const Element* element)
181 {
182     return isScopeMarker(element)
183         || element->hasTagName(olTag)
184         || element->hasTagName(ulTag);
185 }
186 inline bool isTableScopeMarker(const Element* element)
187 {
188     return element->hasTagName(htmlTag)
189         || element->hasTagName(tableTag);
190 }
191
192 }
193
194 template <bool isMarker(const Element*)>
195 bool inScopeCommon(HTMLElementStack::ElementRecord* top, const AtomicString& targetTag)
196 {
197     for (HTMLElementStack::ElementRecord* pos = top; pos; pos = pos->next()) {
198         Element* element = pos->element();
199         if (element->hasLocalName(targetTag))
200             return true;
201         if (isMarker(element))
202             return false;
203     }
204     ASSERT_NOT_REACHED(); // <html> is always on the stack and is a scope marker.
205     return false;
206 }
207
208 bool HTMLElementStack::inScope(Element* targetElement) const
209 {
210     for (ElementRecord* pos = m_top.get(); pos; pos = pos->next()) {
211         Element* element = pos->element();
212         if (element == targetElement)
213             return true;
214         if (isScopeMarker(element))
215             return false;
216     }
217     ASSERT_NOT_REACHED(); // <html> is always on the stack and is a scope marker.
218     return false;
219 }
220
221 bool HTMLElementStack::inScope(const AtomicString& targetTag) const
222 {
223     return inScopeCommon<isScopeMarker>(m_top.get(), targetTag);
224 }
225
226 bool HTMLElementStack::inListItemScope(const AtomicString& targetTag) const
227 {
228     return inScopeCommon<isListItemScopeMarker>(m_top.get(), targetTag);
229 }
230
231 bool HTMLElementStack::inTableScope(const AtomicString& targetTag) const
232 {
233     return inScopeCommon<isTableScopeMarker>(m_top.get(), targetTag);
234 }
235
236 Element* HTMLElementStack::htmlElement()
237 {
238     ASSERT(m_htmlElement);
239     return m_htmlElement;
240 }
241
242 Element* HTMLElementStack::headElement()
243 {
244     ASSERT(m_headElement);
245     return m_headElement;
246 }
247
248 Element* HTMLElementStack::bodyElement()
249 {
250     ASSERT(m_bodyElement);
251     return m_bodyElement;
252 }
253
254 void HTMLElementStack::pushCommon(PassRefPtr<Element> element)
255 {
256     m_top.set(new ElementRecord(element, m_top.release()));
257     top()->beginParsingChildren();
258 }
259
260 void HTMLElementStack::popCommon()
261 {
262     ASSERT(!top()->hasTagName(HTMLNames::htmlTag));
263     ASSERT(!top()->hasTagName(HTMLNames::bodyTag));
264     top()->finishParsingChildren();
265     m_top = m_top->releaseNext();
266 }
267
268 void HTMLElementStack::removeNonFirstCommon(Element* element)
269 {
270     ASSERT(!element->hasTagName(HTMLNames::htmlTag));
271     ASSERT(!element->hasTagName(HTMLNames::bodyTag));
272     ElementRecord* pos = m_top.get();
273     ASSERT(pos->element() != element);
274     while (pos->next()) {
275         if (pos->next()->element() == element) {
276             // FIXME: Is it OK to call finishParsingChildren()
277             // when the children aren't actually finished?
278             element->finishParsingChildren();
279             pos->setNext(pos->next()->releaseNext());
280             return;
281         }
282     }
283     ASSERT_NOT_REACHED();
284 }
285
286 }