2010-07-02 Adam Barth <abarth@webkit.org>
[WebKit-https.git] / WebCore / html / HTMLTreeBuilder.h
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 #ifndef HTMLTreeBuilder_h
27 #define HTMLTreeBuilder_h
28
29 #include "Element.h"
30 #include "FragmentScriptingPermission.h"
31 #include "HTMLElementStack.h"
32 #include "HTMLFormattingElementList.h"
33 #include "HTMLTokenizer.h"
34 #include <wtf/Noncopyable.h>
35 #include <wtf/OwnPtr.h>
36 #include <wtf/PassOwnPtr.h>
37 #include <wtf/PassRefPtr.h>
38 #include <wtf/RefPtr.h>
39 #include <wtf/unicode/Unicode.h>
40
41 namespace WebCore {
42
43 class AtomicHTMLToken;
44 class Document;
45 class DocumentFragment;
46 class Frame;
47 class HTMLToken;
48 class HTMLDocument;
49 class LegacyHTMLTreeBuilder;
50 class Node;
51
52 class HTMLTreeBuilder : public Noncopyable {
53 public:
54     // FIXME: Replace constructors with create() functions returning PassOwnPtrs
55     HTMLTreeBuilder(HTMLTokenizer*, HTMLDocument*, bool reportErrors);
56     HTMLTreeBuilder(HTMLTokenizer*, DocumentFragment*, FragmentScriptingPermission);
57     ~HTMLTreeBuilder();
58
59     void setPaused(bool paused) { m_isPaused = paused; }
60     bool isPaused() const { return m_isPaused; }
61
62     // The token really should be passed as a const& since it's never modified.
63     void constructTreeFromToken(HTMLToken&);
64     // Must be called when parser is paused before calling the parser again.
65     PassRefPtr<Element> takeScriptToProcess(int& scriptStartLine);
66
67     // Done, close any open tags, etc.
68     void finished();
69
70     static HTMLTokenizer::State adjustedLexerState(HTMLTokenizer::State, const AtomicString& tagName, Frame*);
71
72     // FIXME: This is a dirty, rotten hack to keep HTMLFormControlElement happy
73     // until we stop using the legacy parser. DO NOT CALL THIS METHOD.
74     LegacyHTMLTreeBuilder* legacyTreeBuilder() const { return m_legacyTreeBuilder.get(); }
75
76 private:
77     // Represents HTML5 "insertion mode"
78     // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#insertion-mode
79     enum InsertionMode {
80         InitialMode,
81         BeforeHTMLMode,
82         BeforeHeadMode,
83         InHeadMode,
84         InHeadNoscriptMode,
85         AfterHeadMode,
86         InBodyMode,
87         TextMode,
88         InTableMode,
89         InTableTextMode,
90         InCaptionMode,
91         InColumnGroupMode,
92         InTableBodyMode,
93         InRowMode,
94         InCellMode,
95         InSelectMode,
96         InSelectInTableMode,
97         InForeignContentMode,
98         AfterBodyMode,
99         InFramesetMode,
100         AfterFramesetMode,
101         AfterAfterBodyMode,
102         AfterAfterFramesetMode,
103     };
104
105     void passTokenToLegacyParser(HTMLToken&);
106
107     // Specialized functions for processing the different types of tokens.
108     void processToken(AtomicHTMLToken&);
109     void processDoctypeToken(AtomicHTMLToken&);
110     void processStartTag(AtomicHTMLToken&);
111     void processEndTag(AtomicHTMLToken&);
112     void processComment(AtomicHTMLToken&);
113     void processCharacter(AtomicHTMLToken&);
114     void processEndOfFile(AtomicHTMLToken&);
115
116     // Default processing for the different insertion modes.
117     void processDefaultForInitialMode(AtomicHTMLToken&);
118     void processDefaultForBeforeHTMLMode(AtomicHTMLToken&);
119     void processDefaultForBeforeHeadMode(AtomicHTMLToken&);
120     void processDefaultForInHeadMode(AtomicHTMLToken&);
121     void processDefaultForInHeadNoscriptMode(AtomicHTMLToken&);
122     void processDefaultForAfterHeadMode(AtomicHTMLToken&);
123
124     bool processStartTagForInHead(AtomicHTMLToken&);
125
126     bool processBodyEndTagForInBody(AtomicHTMLToken&);
127
128     template<typename ChildType>
129     PassRefPtr<ChildType> attach(Node* parent, PassRefPtr<ChildType> prpChild)
130     {
131         RefPtr<ChildType> child = prpChild;
132         parent->parserAddChild(child);
133         // It's slightly unfortunate that we need to hold a reference to child
134         // here to call attach().  We should investigate whether we can rely on
135         // |parent| to hold a ref at this point.  In the common case (at least
136         // for elements), however, we'll get to use this ref in the stack of
137         // open elements.
138         child->attach();
139         return child.release();
140     };
141
142     void insertDoctype(AtomicHTMLToken&);
143     void insertComment(AtomicHTMLToken&);
144     void insertCommentOnDocument(AtomicHTMLToken&);
145     void insertCommentOnHTMLHtmlElement(AtomicHTMLToken&);
146     void insertHTMLHtmlElement(AtomicHTMLToken&);
147     void insertHTMLHeadElement(AtomicHTMLToken&);
148     void insertHTMLBodyElement(AtomicHTMLToken&);
149     void insertElement(AtomicHTMLToken&);
150     void insertSelfClosingElement(AtomicHTMLToken&);
151     void insertFormattingElement(AtomicHTMLToken&);
152     void insertGenericRCDATAElement(AtomicHTMLToken&);
153     void insertGenericRawTextElement(AtomicHTMLToken&);
154     void insertScriptElement(AtomicHTMLToken&);
155     void insertTextNode(AtomicHTMLToken&);
156
157     void insertHTMLStartTagBeforeHTML(AtomicHTMLToken&);
158     void insertHTMLStartTagInBody(AtomicHTMLToken&);
159
160     PassRefPtr<Element> createElement(AtomicHTMLToken&);
161     PassRefPtr<Element> createElementAndAttachToCurrent(AtomicHTMLToken&);
162
163     void mergeAttributesFromTokenIntoElement(AtomicHTMLToken&, Element*);
164
165     bool indexOfFirstUnopenFormattingElement(unsigned& firstUnopenElementIndex) const;
166     void reconstructTheActiveFormattingElements();
167     void clearActiveFormatingElementsUpToLastMarker() { }
168
169     void generateImpliedEndTags();
170     void generateImpliedEndTagsWithExclusion(const AtomicString& tagName);
171
172     Element* currentElement() { return m_openElements.top(); }
173
174     RefPtr<Element> m_headElement;
175     RefPtr<Element> m_formElement;
176     HTMLElementStack m_openElements;
177     HTMLFormattingElementList m_activeFormattingElements;
178     bool m_framesetOk;
179
180     // FIXME: Implement error reporting.
181     void parseError(AtomicHTMLToken&) { }
182
183     void handleScriptStartTag();
184     void handleScriptEndTag(Element*, int scriptStartLine);
185
186     void setInsertionMode(InsertionMode value) { m_insertionMode = value; }
187     InsertionMode insertionMode() const { return m_insertionMode; }
188
189     static bool isScriptingFlagEnabled(Frame* frame);
190
191     Document* m_document; // This is only used by the m_legacyParser for now.
192     bool m_reportErrors;
193     bool m_isPaused;
194
195     InsertionMode m_insertionMode;
196     InsertionMode m_originalInsertionMode;
197
198     // HTML5 spec requires that we be able to change the state of the tokenizer
199     // from within parser actions.
200     HTMLTokenizer* m_tokenizer;
201
202     // We're re-using logic from the old LegacyHTMLTreeBuilder while this class is being written.
203     OwnPtr<LegacyHTMLTreeBuilder> m_legacyTreeBuilder;
204
205     // These members are intentionally duplicated as the first set is a hack
206     // on top of the legacy parser which will eventually be removed.
207     RefPtr<Element> m_lastScriptElement; // FIXME: Hack for <script> support on top of the old parser.
208     int m_lastScriptElementStartLine; // FIXME: Hack for <script> support on top of the old parser.
209
210     RefPtr<Element> m_scriptToProcess; // <script> tag which needs processing before resuming the parser.
211     int m_scriptToProcessStartLine; // Starting line number of the script tag needing processing.
212
213     // FIXME: FragmentScriptingPermission is a HACK for platform/Pasteboard.
214     // FragmentScriptingNotAllowed causes the Parser to remove children
215     // from <script> tags (so javascript doesn't show up in pastes).
216     FragmentScriptingPermission m_fragmentScriptingPermission;
217     bool m_isParsingFragment;
218 };
219
220 }
221
222 #endif