Apply FINAL to the Node hierarchy.
[WebKit.git] / Source / WebCore / dom / ContainerNode.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011 Apple Inc. All rights reserved.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public License
18  * along with this library; see the file COPYING.LIB.  If not, write to
19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  *
22  */
23
24 #ifndef ContainerNode_h
25 #define ContainerNode_h
26
27 #include "ExceptionCodePlaceholder.h"
28 #include "Node.h"
29
30 #include <wtf/OwnPtr.h>
31 #include <wtf/Vector.h>
32
33 namespace WebCore {
34
35 class FloatPoint;
36     
37 typedef void (*NodeCallback)(Node*, unsigned);
38
39 namespace Private { 
40     template<class GenericNode, class GenericNodeContainer>
41     void addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer*);
42 };
43
44 class NoEventDispatchAssertion {
45 public:
46     NoEventDispatchAssertion()
47     {
48 #ifndef NDEBUG
49         if (!isMainThread())
50             return;
51         s_count++;
52 #endif
53     }
54
55     ~NoEventDispatchAssertion()
56     {
57 #ifndef NDEBUG
58         if (!isMainThread())
59             return;
60         ASSERT(s_count);
61         s_count--;
62 #endif
63     }
64
65 #ifndef NDEBUG
66     static bool isEventDispatchForbidden()
67     {
68         if (!isMainThread())
69             return false;
70         return s_count;
71     }
72 #endif
73
74 private:
75 #ifndef NDEBUG
76     static unsigned s_count;
77 #endif
78 };
79
80 class ContainerNode : public Node {
81     friend class PostAttachCallbackDisabler;
82 public:
83     virtual ~ContainerNode();
84
85     Node* firstChild() const { return m_firstChild; }
86     Node* lastChild() const { return m_lastChild; }
87     bool hasChildNodes() const { return m_firstChild; }
88
89     unsigned childNodeCount() const;
90     Node* childNode(unsigned index) const;
91
92     bool insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& = ASSERT_NO_EXCEPTION, AttachBehavior = AttachNow);
93     bool replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& = ASSERT_NO_EXCEPTION, AttachBehavior = AttachNow);
94     bool removeChild(Node* child, ExceptionCode& = ASSERT_NO_EXCEPTION);
95     bool appendChild(PassRefPtr<Node> newChild, ExceptionCode& = ASSERT_NO_EXCEPTION, AttachBehavior = AttachNow);
96
97     // These methods are only used during parsing.
98     // They don't send DOM mutation events or handle reparenting.
99     // However, arbitrary code may be run by beforeload handlers.
100     void parserAppendChild(PassRefPtr<Node>);
101     void parserRemoveChild(Node*);
102     void parserInsertBefore(PassRefPtr<Node> newChild, Node* refChild);
103
104     void removeChildren();
105     void takeAllChildrenFrom(ContainerNode*);
106
107     void cloneChildNodes(ContainerNode* clone);
108
109     virtual void attach() OVERRIDE;
110     virtual void detach() OVERRIDE;
111     virtual LayoutRect boundingBox() const OVERRIDE;
112     virtual void setFocus(bool) OVERRIDE;
113     virtual void setActive(bool active = true, bool pause = false) OVERRIDE;
114     virtual void setHovered(bool = true) OVERRIDE;
115     virtual void scheduleSetNeedsStyleRecalc(StyleChangeType = FullStyleChange) OVERRIDE FINAL;
116
117     // -----------------------------------------------------------------------------
118     // Notification of document structure changes (see Node.h for more notification methods)
119
120     // Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
121     // node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
122     virtual void childrenChanged(bool createdByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
123
124     void attachChildren();
125     void attachChildrenLazily();
126     void detachChildren();
127     void detachChildrenIfNeeded();
128
129     void disconnectDescendantFrames();
130
131     virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const { return true; }
132
133 protected:
134     ContainerNode(Document*, ConstructionType = CreateContainer);
135
136     static void queuePostAttachCallback(NodeCallback, Node*, unsigned = 0);
137     static bool postAttachCallbacksAreSuspended();
138
139     template<class GenericNode, class GenericNodeContainer>
140     friend void appendChildToContainer(GenericNode* child, GenericNodeContainer*);
141
142     template<class GenericNode, class GenericNodeContainer>
143     friend void Private::addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer*);
144
145     void removeDetachedChildren();
146     void setFirstChild(Node* child) { m_firstChild = child; }
147     void setLastChild(Node* child) { m_lastChild = child; }
148
149 private:
150     void removeBetween(Node* previousChild, Node* nextChild, Node* oldChild);
151     void insertBeforeCommon(Node* nextChild, Node* oldChild);
152
153     static void dispatchPostAttachCallbacks();
154     void suspendPostAttachCallbacks();
155     void resumePostAttachCallbacks();
156
157     bool getUpperLeftCorner(FloatPoint&) const;
158     bool getLowerRightCorner(FloatPoint&) const;
159
160     Node* m_firstChild;
161     Node* m_lastChild;
162 };
163
164 #ifndef NDEBUG
165 bool childAttachedAllowedWhenAttachingChildren(ContainerNode*);
166 #endif
167
168 inline ContainerNode* toContainerNode(Node* node)
169 {
170     ASSERT_WITH_SECURITY_IMPLICATION(!node || node->isContainerNode());
171     return static_cast<ContainerNode*>(node);
172 }
173
174 inline const ContainerNode* toContainerNode(const Node* node)
175 {
176     ASSERT_WITH_SECURITY_IMPLICATION(!node || node->isContainerNode());
177     return static_cast<const ContainerNode*>(node);
178 }
179
180 // This will catch anyone doing an unnecessary cast.
181 void toContainerNode(const ContainerNode*);
182
183 inline ContainerNode::ContainerNode(Document* document, ConstructionType type)
184     : Node(document, type)
185     , m_firstChild(0)
186     , m_lastChild(0)
187 {
188 }
189
190 inline void ContainerNode::attachChildren()
191 {
192     for (Node* child = firstChild(); child; child = child->nextSibling()) {
193         ASSERT(!child->attached() || childAttachedAllowedWhenAttachingChildren(this));
194         if (!child->attached())
195             child->attach();
196     }
197 }
198
199 inline void ContainerNode::attachChildrenLazily()
200 {
201     for (Node* child = firstChild(); child; child = child->nextSibling())
202         if (!child->attached())
203             child->lazyAttach();
204 }
205
206 inline void ContainerNode::detachChildrenIfNeeded()
207 {
208     for (Node* child = firstChild(); child; child = child->nextSibling()) {
209         if (child->attached())
210             child->detach();
211     }
212 }
213
214 inline void ContainerNode::detachChildren()
215 {
216     for (Node* child = firstChild(); child; child = child->nextSibling())
217         child->detach();
218 }
219
220 inline unsigned Node::childNodeCount() const
221 {
222     if (!isContainerNode())
223         return 0;
224     return toContainerNode(this)->childNodeCount();
225 }
226
227 inline Node* Node::childNode(unsigned index) const
228 {
229     if (!isContainerNode())
230         return 0;
231     return toContainerNode(this)->childNode(index);
232 }
233
234 inline Node* Node::firstChild() const
235 {
236     if (!isContainerNode())
237         return 0;
238     return toContainerNode(this)->firstChild();
239 }
240
241 inline Node* Node::lastChild() const
242 {
243     if (!isContainerNode())
244         return 0;
245     return toContainerNode(this)->lastChild();
246 }
247
248 inline Node* Node::highestAncestor() const
249 {
250     Node* node = const_cast<Node*>(this);
251     Node* highest = node;
252     for (; node; node = node->parentNode())
253         highest = node;
254     return highest;
255 }
256
257 inline bool Node::needsShadowTreeWalker() const
258 {
259     if (getFlag(NeedsShadowTreeWalkerFlag))
260         return true;
261     ContainerNode* parent = parentOrShadowHostNode();
262     return parent && parent->getFlag(NeedsShadowTreeWalkerFlag);
263 }
264
265 // This constant controls how much buffer is initially allocated
266 // for a Node Vector that is used to store child Nodes of a given Node.
267 // FIXME: Optimize the value.
268 const int initialNodeVectorSize = 11;
269 typedef Vector<RefPtr<Node>, initialNodeVectorSize> NodeVector;
270
271 inline void getChildNodes(Node* node, NodeVector& nodes)
272 {
273     ASSERT(!nodes.size());
274     for (Node* child = node->firstChild(); child; child = child->nextSibling())
275         nodes.append(child);
276 }
277
278 class ChildNodesLazySnapshot {
279     WTF_MAKE_NONCOPYABLE(ChildNodesLazySnapshot);
280     WTF_MAKE_FAST_ALLOCATED;
281 public:
282     explicit ChildNodesLazySnapshot(Node* parentNode)
283         : m_currentNode(parentNode->firstChild())
284         , m_currentIndex(0)
285     {
286         m_nextSnapshot = latestSnapshot;
287         latestSnapshot = this;
288     }
289
290     ~ChildNodesLazySnapshot()
291     {
292         latestSnapshot = m_nextSnapshot;
293     }
294
295     // Returns 0 if there is no next Node.
296     PassRefPtr<Node> nextNode()
297     {
298         if (LIKELY(!hasSnapshot())) {
299             RefPtr<Node> node = m_currentNode;
300             if (node)
301                 m_currentNode = node->nextSibling();
302             return node.release();
303         }
304         Vector<RefPtr<Node> >& nodeVector = *m_childNodes;
305         if (m_currentIndex >= nodeVector.size())
306             return 0;
307         return nodeVector[m_currentIndex++];
308     }
309
310     void takeSnapshot()
311     {
312         if (hasSnapshot())
313             return;
314         m_childNodes = adoptPtr(new Vector<RefPtr<Node> >());
315         Node* node = m_currentNode.get();
316         while (node) {
317             m_childNodes->append(node);
318             node = node->nextSibling();
319         }
320     }
321
322     ChildNodesLazySnapshot* nextSnapshot() { return m_nextSnapshot; }
323     bool hasSnapshot() { return !!m_childNodes.get(); }
324
325     static void takeChildNodesLazySnapshot()
326     {
327         ChildNodesLazySnapshot* snapshot = latestSnapshot;
328         while (snapshot && !snapshot->hasSnapshot()) {
329             snapshot->takeSnapshot();
330             snapshot = snapshot->nextSnapshot();
331         }
332     }
333
334 private:
335     static ChildNodesLazySnapshot* latestSnapshot;
336
337     RefPtr<Node> m_currentNode;
338     unsigned m_currentIndex;
339     OwnPtr<Vector<RefPtr<Node> > > m_childNodes; // Lazily instantiated.
340     ChildNodesLazySnapshot* m_nextSnapshot;
341 };
342
343 class PostAttachCallbackDisabler {
344 public:
345     PostAttachCallbackDisabler(ContainerNode* node)
346         : m_node(node)
347     {
348         ASSERT(m_node);
349         m_node->suspendPostAttachCallbacks();
350     }
351
352     ~PostAttachCallbackDisabler()
353     {
354         m_node->resumePostAttachCallbacks();
355     }
356
357 private:
358     ContainerNode* m_node;
359 };
360
361 } // namespace WebCore
362
363 #endif // ContainerNode_h