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 HTMLConstructionSite_h 28 #define HTMLConstructionSite_h 29 30 #include "core/dom/ParserContentPolicy.h" 31 #include "core/html/parser/HTMLElementStack.h" 32 #include "core/html/parser/HTMLFormattingElementList.h" 33 #include "wtf/Noncopyable.h" 34 #include "wtf/PassRefPtr.h" 35 #include "wtf/RefPtr.h" 36 #include "wtf/Vector.h" 37 38 namespace WebCore { 39 40 struct HTMLConstructionSiteTask { 41 enum Operation { 42 Insert, 43 InsertAlreadyParsedChild, 44 Reparent, 45 TakeAllChildren, 46 }; 47 48 explicit HTMLConstructionSiteTask(Operation op) 49 : operation(op) 50 , selfClosing(false) 51 { 52 } 53 54 ContainerNode* oldParent() 55 { 56 // It's sort of ugly, but we store the |oldParent| in the |child| field 57 // of the task so that we don't bloat the HTMLConstructionSiteTask 58 // object in the common case of the Insert operation. 59 return toContainerNode(child.get()); 60 } 61 62 Operation operation; 63 RefPtr<ContainerNode> parent; 64 RefPtr<Node> nextChild; 65 RefPtr<Node> child; 66 bool selfClosing; 67 }; 68 69 } // namespace WebCore 70 71 namespace WTF { 72 template<> struct VectorTraits<WebCore::HTMLConstructionSiteTask> : SimpleClassVectorTraits { }; 73 } // namespace WTF 74 75 namespace WebCore { 76 77 enum WhitespaceMode { 78 AllWhitespace, 79 NotAllWhitespace, 80 WhitespaceUnknown 81 }; 82 83 class AtomicHTMLToken; 84 class Document; 85 class Element; 86 class HTMLFormElement; 87 88 class HTMLConstructionSite { 89 WTF_MAKE_NONCOPYABLE(HTMLConstructionSite); 90 public: 91 HTMLConstructionSite(Document*, ParserContentPolicy); 92 HTMLConstructionSite(DocumentFragment*, ParserContentPolicy); 93 ~HTMLConstructionSite(); 94 95 void detach(); 96 void executeQueuedTasks(); 97 98 void setDefaultCompatibilityMode(); 99 void finishedParsing(); 100 101 void insertDoctype(AtomicHTMLToken*); 102 void insertComment(AtomicHTMLToken*); 103 void insertCommentOnDocument(AtomicHTMLToken*); 104 void insertCommentOnHTMLHtmlElement(AtomicHTMLToken*); 105 void insertHTMLElement(AtomicHTMLToken*); 106 void insertSelfClosingHTMLElement(AtomicHTMLToken*); 107 void insertFormattingElement(AtomicHTMLToken*); 108 void insertHTMLHeadElement(AtomicHTMLToken*); 109 void insertHTMLBodyElement(AtomicHTMLToken*); 110 void insertHTMLFormElement(AtomicHTMLToken*, bool isDemoted = false); 111 void insertScriptElement(AtomicHTMLToken*); 112 void insertTextNode(const String&, WhitespaceMode = WhitespaceUnknown); 113 void insertForeignElement(AtomicHTMLToken*, const AtomicString& namespaceURI); 114 115 void insertHTMLHtmlStartTagBeforeHTML(AtomicHTMLToken*); 116 void insertHTMLHtmlStartTagInBody(AtomicHTMLToken*); 117 void insertHTMLBodyStartTagInBody(AtomicHTMLToken*); 118 119 void reparent(HTMLElementStack::ElementRecord* newParent, HTMLElementStack::ElementRecord* child); 120 void reparent(HTMLElementStack::ElementRecord* newParent, HTMLStackItem* child); 121 // insertAlreadyParsedChild assumes that |child| has already been parsed (i.e., we're just 122 // moving it around in the tree rather than parsing it for the first time). That means 123 // this function doesn't call beginParsingChildren / finishParsingChildren. 124 void insertAlreadyParsedChild(HTMLStackItem* newParent, HTMLElementStack::ElementRecord* child); 125 void takeAllChildren(HTMLStackItem* newParent, HTMLElementStack::ElementRecord* oldParent); 126 127 PassRefPtr<HTMLStackItem> createElementFromSavedToken(HTMLStackItem*); 128 129 bool shouldFosterParent() const; 130 void fosterParent(PassRefPtr<Node>); 131 132 bool indexOfFirstUnopenFormattingElement(unsigned& firstUnopenElementIndex) const; 133 void reconstructTheActiveFormattingElements(); 134 135 void generateImpliedEndTags(); 136 void generateImpliedEndTagsWithExclusion(const AtomicString& tagName); 137 138 bool inQuirksMode(); 139 140 bool isEmpty() const { return !m_openElements.stackDepth(); } 141 HTMLElementStack::ElementRecord* currentElementRecord() const { return m_openElements.topRecord(); } 142 Element* currentElement() const { return m_openElements.top(); } 143 ContainerNode* currentNode() const { return m_openElements.topNode(); } 144 HTMLStackItem* currentStackItem() const { return m_openElements.topStackItem(); } 145 HTMLStackItem* oneBelowTop() const { return m_openElements.oneBelowTop(); } 146 Document* ownerDocumentForCurrentNode(); 147 HTMLElementStack* openElements() const { return &m_openElements; } 148 HTMLFormattingElementList* activeFormattingElements() const { return &m_activeFormattingElements; } 149 bool currentIsRootNode() { return m_openElements.topNode() == m_openElements.rootNode(); } 150 151 Element* head() const { return m_head->element(); } 152 HTMLStackItem* headStackItem() const { return m_head.get(); } 153 154 void setForm(HTMLFormElement*); 155 HTMLFormElement* form() const { return m_form.get(); } 156 PassRefPtr<HTMLFormElement> takeForm(); 157 158 ParserContentPolicy parserContentPolicy() { return m_parserContentPolicy; } 159 160 class RedirectToFosterParentGuard { 161 WTF_MAKE_NONCOPYABLE(RedirectToFosterParentGuard); 162 public: 163 RedirectToFosterParentGuard(HTMLConstructionSite& tree) 164 : m_tree(tree) 165 , m_wasRedirectingBefore(tree.m_redirectAttachToFosterParent) 166 { 167 m_tree.m_redirectAttachToFosterParent = true; 168 } 169 170 ~RedirectToFosterParentGuard() 171 { 172 m_tree.m_redirectAttachToFosterParent = m_wasRedirectingBefore; 173 } 174 175 private: 176 HTMLConstructionSite& m_tree; 177 bool m_wasRedirectingBefore; 178 }; 179 180 private: 181 // In the common case, this queue will have only one task because most 182 // tokens produce only one DOM mutation. 183 typedef Vector<HTMLConstructionSiteTask, 1> TaskQueue; 184 185 void setCompatibilityMode(Document::CompatibilityMode); 186 void setCompatibilityModeFromDoctype(const String& name, const String& publicId, const String& systemId); 187 188 void attachLater(ContainerNode* parent, PassRefPtr<Node> child, bool selfClosing = false); 189 190 void findFosterSite(HTMLConstructionSiteTask&); 191 192 PassRefPtr<Element> createHTMLElement(AtomicHTMLToken*); 193 PassRefPtr<Element> createElement(AtomicHTMLToken*, const AtomicString& namespaceURI); 194 195 void mergeAttributesFromTokenIntoElement(AtomicHTMLToken*, Element*); 196 void dispatchDocumentElementAvailableIfNeeded(); 197 198 Document* m_document; 199 200 // This is the root ContainerNode to which the parser attaches all newly 201 // constructed nodes. It points to a DocumentFragment when parsing fragments 202 // and a Document in all other cases. 203 ContainerNode* m_attachmentRoot; 204 205 RefPtr<HTMLStackItem> m_head; 206 RefPtr<HTMLFormElement> m_form; 207 mutable HTMLElementStack m_openElements; 208 mutable HTMLFormattingElementList m_activeFormattingElements; 209 210 TaskQueue m_taskQueue; 211 212 ParserContentPolicy m_parserContentPolicy; 213 bool m_isParsingFragment; 214 215 // http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#parsing-main-intable 216 // In the "in table" insertion mode, we sometimes get into a state where 217 // "whenever a node would be inserted into the current node, it must instead 218 // be foster parented." This flag tracks whether we're in that state. 219 bool m_redirectAttachToFosterParent; 220 221 bool m_inQuirksMode; 222 }; 223 224 } // namespace WebCore 225 226 #endif 227