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, 2013 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 "bindings/core/v8/ExceptionStatePlaceholder.h"
28 #include "core/dom/Node.h"
29 #include "core/html/CollectionType.h"
30 #include "wtf/OwnPtr.h"
31 #include "wtf/Vector.h"
32
33 namespace blink {
34
35 class ClassCollection;
36 class ExceptionState;
37 class FloatPoint;
38 class HTMLCollection;
39 template <typename NodeType> class StaticNodeTypeList;
40 typedef StaticNodeTypeList<Element> StaticElementList;
41 class TagCollection;
42
43 enum DynamicRestyleFlags {
44 ChildrenOrSiblingsAffectedByFocus = 1 << 0,
45 ChildrenOrSiblingsAffectedByHover = 1 << 1,
46 ChildrenOrSiblingsAffectedByActive = 1 << 2,
47 ChildrenOrSiblingsAffectedByDrag = 1 << 3,
48 ChildrenAffectedByFirstChildRules = 1 << 4,
49 ChildrenAffectedByLastChildRules = 1 << 5,
50 ChildrenAffectedByDirectAdjacentRules = 1 << 6,
51 ChildrenAffectedByIndirectAdjacentRules = 1 << 7,
52 ChildrenAffectedByForwardPositionalRules = 1 << 8,
53 ChildrenAffectedByBackwardPositionalRules = 1 << 9,
54
55 NumberOfDynamicRestyleFlags = 10,
56 };
57
58 // This constant controls how much buffer is initially allocated
59 // for a Node Vector that is used to store child Nodes of a given Node.
60 // FIXME: Optimize the value.
61 const int initialNodeVectorSize = 11;
62 typedef WillBeHeapVector<RefPtrWillBeMember<Node>, initialNodeVectorSize> NodeVector;
63
64 class ContainerNode : public Node {
65 public:
66 virtual ~ContainerNode();
67
firstChild()68 Node* firstChild() const { return m_firstChild; }
lastChild()69 Node* lastChild() const { return m_lastChild; }
hasChildren()70 bool hasChildren() const { return m_firstChild; }
71
hasOneChild()72 bool hasOneChild() const { return m_firstChild && !m_firstChild->nextSibling(); }
hasOneTextChild()73 bool hasOneTextChild() const { return hasOneChild() && m_firstChild->isTextNode(); }
74 bool hasChildCount(unsigned) const;
75
76 PassRefPtrWillBeRawPtr<HTMLCollection> children();
77
78 unsigned countChildren() const;
79
80 PassRefPtrWillBeRawPtr<Element> querySelector(const AtomicString& selectors, ExceptionState&);
81 PassRefPtrWillBeRawPtr<StaticElementList> querySelectorAll(const AtomicString& selectors, ExceptionState&);
82
83 PassRefPtrWillBeRawPtr<Node> insertBefore(PassRefPtrWillBeRawPtr<Node> newChild, Node* refChild, ExceptionState& = ASSERT_NO_EXCEPTION);
84 PassRefPtrWillBeRawPtr<Node> replaceChild(PassRefPtrWillBeRawPtr<Node> newChild, PassRefPtrWillBeRawPtr<Node> oldChild, ExceptionState& = ASSERT_NO_EXCEPTION);
85 PassRefPtrWillBeRawPtr<Node> removeChild(PassRefPtrWillBeRawPtr<Node> child, ExceptionState& = ASSERT_NO_EXCEPTION);
86 PassRefPtrWillBeRawPtr<Node> appendChild(PassRefPtrWillBeRawPtr<Node> newChild, ExceptionState& = ASSERT_NO_EXCEPTION);
87
88 Element* getElementById(const AtomicString& id) const;
89 PassRefPtrWillBeRawPtr<TagCollection> getElementsByTagName(const AtomicString&);
90 PassRefPtrWillBeRawPtr<TagCollection> getElementsByTagNameNS(const AtomicString& namespaceURI, const AtomicString& localName);
91 PassRefPtrWillBeRawPtr<NameNodeList> getElementsByName(const AtomicString& elementName);
92 PassRefPtrWillBeRawPtr<ClassCollection> getElementsByClassName(const AtomicString& classNames);
93 PassRefPtrWillBeRawPtr<RadioNodeList> radioNodeList(const AtomicString&, bool onlyMatchImgElements = false);
94
95 // These methods are only used during parsing.
96 // They don't send DOM mutation events or handle reparenting.
97 void parserAppendChild(PassRefPtrWillBeRawPtr<Node>);
98 void parserRemoveChild(Node&);
99 void parserInsertBefore(PassRefPtrWillBeRawPtr<Node> newChild, Node& refChild);
100 void parserTakeAllChildrenFrom(ContainerNode&);
101
102 void removeChildren();
103
104 void cloneChildNodes(ContainerNode* clone);
105
106 virtual void attach(const AttachContext& = AttachContext()) OVERRIDE;
107 virtual void detach(const AttachContext& = AttachContext()) OVERRIDE;
108 virtual LayoutRect boundingBox() const OVERRIDE FINAL;
109 virtual void setFocus(bool) OVERRIDE;
110 void focusStateChanged();
111 virtual void setActive(bool = true) OVERRIDE;
112 virtual void setHovered(bool = true) OVERRIDE;
113
childrenOrSiblingsAffectedByFocus()114 bool childrenOrSiblingsAffectedByFocus() const { return hasRestyleFlag(ChildrenOrSiblingsAffectedByFocus); }
setChildrenOrSiblingsAffectedByFocus()115 void setChildrenOrSiblingsAffectedByFocus() { setRestyleFlag(ChildrenOrSiblingsAffectedByFocus); }
116
childrenOrSiblingsAffectedByHover()117 bool childrenOrSiblingsAffectedByHover() const { return hasRestyleFlag(ChildrenOrSiblingsAffectedByHover); }
setChildrenOrSiblingsAffectedByHover()118 void setChildrenOrSiblingsAffectedByHover() { setRestyleFlag(ChildrenOrSiblingsAffectedByHover); }
119
childrenOrSiblingsAffectedByActive()120 bool childrenOrSiblingsAffectedByActive() const { return hasRestyleFlag(ChildrenOrSiblingsAffectedByActive); }
setChildrenOrSiblingsAffectedByActive()121 void setChildrenOrSiblingsAffectedByActive() { setRestyleFlag(ChildrenOrSiblingsAffectedByActive); }
122
childrenOrSiblingsAffectedByDrag()123 bool childrenOrSiblingsAffectedByDrag() const { return hasRestyleFlag(ChildrenOrSiblingsAffectedByDrag); }
setChildrenOrSiblingsAffectedByDrag()124 void setChildrenOrSiblingsAffectedByDrag() { setRestyleFlag(ChildrenOrSiblingsAffectedByDrag); }
125
childrenAffectedByPositionalRules()126 bool childrenAffectedByPositionalRules() const { return hasRestyleFlag(ChildrenAffectedByForwardPositionalRules) || hasRestyleFlag(ChildrenAffectedByBackwardPositionalRules); }
127
childrenAffectedByFirstChildRules()128 bool childrenAffectedByFirstChildRules() const { return hasRestyleFlag(ChildrenAffectedByFirstChildRules); }
setChildrenAffectedByFirstChildRules()129 void setChildrenAffectedByFirstChildRules() { setRestyleFlag(ChildrenAffectedByFirstChildRules); }
130
childrenAffectedByLastChildRules()131 bool childrenAffectedByLastChildRules() const { return hasRestyleFlag(ChildrenAffectedByLastChildRules); }
setChildrenAffectedByLastChildRules()132 void setChildrenAffectedByLastChildRules() { setRestyleFlag(ChildrenAffectedByLastChildRules); }
133
childrenAffectedByDirectAdjacentRules()134 bool childrenAffectedByDirectAdjacentRules() const { return hasRestyleFlag(ChildrenAffectedByDirectAdjacentRules); }
setChildrenAffectedByDirectAdjacentRules()135 void setChildrenAffectedByDirectAdjacentRules() { setRestyleFlag(ChildrenAffectedByDirectAdjacentRules); }
136
childrenAffectedByIndirectAdjacentRules()137 bool childrenAffectedByIndirectAdjacentRules() const { return hasRestyleFlag(ChildrenAffectedByIndirectAdjacentRules); }
setChildrenAffectedByIndirectAdjacentRules()138 void setChildrenAffectedByIndirectAdjacentRules() { setRestyleFlag(ChildrenAffectedByIndirectAdjacentRules); }
139
childrenAffectedByForwardPositionalRules()140 bool childrenAffectedByForwardPositionalRules() const { return hasRestyleFlag(ChildrenAffectedByForwardPositionalRules); }
setChildrenAffectedByForwardPositionalRules()141 void setChildrenAffectedByForwardPositionalRules() { setRestyleFlag(ChildrenAffectedByForwardPositionalRules); }
142
childrenAffectedByBackwardPositionalRules()143 bool childrenAffectedByBackwardPositionalRules() const { return hasRestyleFlag(ChildrenAffectedByBackwardPositionalRules); }
setChildrenAffectedByBackwardPositionalRules()144 void setChildrenAffectedByBackwardPositionalRules() { setRestyleFlag(ChildrenAffectedByBackwardPositionalRules); }
145
146 // FIXME: These methods should all be renamed to something better than "check",
147 // since it's not clear that they alter the style bits of siblings and children.
148 void checkForChildrenAdjacentRuleChanges();
149 enum SiblingCheckType { FinishedParsingChildren, SiblingElementInserted, SiblingElementRemoved };
150 void checkForSiblingStyleChanges(SiblingCheckType, Node* nodeBeforeChange, Node* nodeAfterChange);
151 void recalcChildStyle(StyleRecalcChange);
152
childrenSupportStyleSharing()153 bool childrenSupportStyleSharing() const { return !hasRestyleFlags(); }
154
155 // -----------------------------------------------------------------------------
156 // Notification of document structure changes (see core/dom/Node.h for more notification methods)
157
158 enum ChildrenChangeType { ElementInserted, NonElementInserted, ElementRemoved, NonElementRemoved, AllChildrenRemoved, TextChanged };
159 enum ChildrenChangeSource { ChildrenChangeSourceAPI, ChildrenChangeSourceParser };
160 struct ChildrenChange {
161 STACK_ALLOCATED();
162 public:
forInsertionChildrenChange163 static ChildrenChange forInsertion(Node& node, ChildrenChangeSource byParser)
164 {
165 ChildrenChange change = {
166 node.isElementNode() ? ElementInserted : NonElementInserted,
167 node.previousSibling(),
168 node.nextSibling(),
169 byParser
170 };
171 return change;
172 }
173
forRemovalChildrenChange174 static ChildrenChange forRemoval(Node& node, Node* previousSibling, Node* nextSibling, ChildrenChangeSource byParser)
175 {
176 ChildrenChange change = {
177 node.isElementNode() ? ElementRemoved : NonElementRemoved,
178 previousSibling,
179 nextSibling,
180 byParser
181 };
182 return change;
183 }
184
isChildInsertionChildrenChange185 bool isChildInsertion() const { return type == ElementInserted || type == NonElementInserted; }
isChildRemovalChildrenChange186 bool isChildRemoval() const { return type == ElementRemoved || type == NonElementRemoved; }
isChildElementChangeChildrenChange187 bool isChildElementChange() const { return type == ElementInserted || type == ElementRemoved; }
188
189 ChildrenChangeType type;
190 RawPtrWillBeMember<Node> siblingBeforeChange;
191 RawPtrWillBeMember<Node> siblingAfterChange;
192 ChildrenChangeSource byParser;
193 };
194
195 // Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
196 // node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
197 virtual void childrenChanged(const ChildrenChange&);
198
199 void disconnectDescendantFrames();
200
201 virtual void trace(Visitor*) OVERRIDE;
202
203 protected:
204 ContainerNode(TreeScope*, ConstructionType = CreateContainer);
205
206 void invalidateNodeListCachesInAncestors(const QualifiedName* attrName = 0, Element* attributeOwnerElement = 0);
207
208 #if !ENABLE(OILPAN)
209 void removeDetachedChildren();
210 #endif
211
setFirstChild(Node * child)212 void setFirstChild(Node* child) { m_firstChild = child; }
setLastChild(Node * child)213 void setLastChild(Node* child) { m_lastChild = child; }
214
215 // Utility functions for NodeListsNodeData API.
216 template <typename Collection> PassRefPtrWillBeRawPtr<Collection> ensureCachedCollection(CollectionType);
217 template <typename Collection> PassRefPtrWillBeRawPtr<Collection> ensureCachedCollection(CollectionType, const AtomicString& name);
218 template <typename Collection> PassRefPtrWillBeRawPtr<Collection> ensureCachedCollection(CollectionType, const AtomicString& namespaceURI, const AtomicString& localName);
219 template <typename Collection> Collection* cachedCollection(CollectionType);
220
221 private:
222 bool isContainerNode() const WTF_DELETED_FUNCTION; // This will catch anyone doing an unnecessary check.
223 bool isTextNode() const WTF_DELETED_FUNCTION; // This will catch anyone doing an unnecessary check.
224
225 NodeListsNodeData& ensureNodeLists();
226 void removeBetween(Node* previousChild, Node* nextChild, Node& oldChild);
227 void insertBeforeCommon(Node& nextChild, Node& oldChild);
228 void appendChildCommon(Node& child);
229 void updateTreeAfterInsertion(Node& child);
230 void willRemoveChildren();
231 void willRemoveChild(Node& child);
232 void removeDetachedChildrenInContainer(ContainerNode&);
233 void addChildNodesToDeletionQueue(Node*&, Node*&, ContainerNode&);
234
235 void notifyNodeInserted(Node&, ChildrenChangeSource = ChildrenChangeSourceAPI);
236 void notifyNodeInsertedInternal(Node&, NodeVector& postInsertionNotificationTargets);
237 void notifyNodeRemoved(Node&);
238
hasRestyleFlag(DynamicRestyleFlags mask)239 bool hasRestyleFlag(DynamicRestyleFlags mask) const { return hasRareData() && hasRestyleFlagInternal(mask); }
hasRestyleFlags()240 bool hasRestyleFlags() const { return hasRareData() && hasRestyleFlagsInternal(); }
241 void setRestyleFlag(DynamicRestyleFlags);
242 bool hasRestyleFlagInternal(DynamicRestyleFlags) const;
243 bool hasRestyleFlagsInternal() const;
244
245 inline bool checkAcceptChildGuaranteedNodeTypes(const Node& newChild, ExceptionState&) const;
246 inline bool checkAcceptChild(const Node* newChild, const Node* oldChild, ExceptionState&) const;
247 inline bool containsConsideringHostElements(const Node&) const;
248 inline bool isChildTypeAllowed(const Node& child) const;
249
250 void attachChildren(const AttachContext& = AttachContext());
251 void detachChildren(const AttachContext& = AttachContext());
252
253 bool getUpperLeftCorner(FloatPoint&) const;
254 bool getLowerRightCorner(FloatPoint&) const;
255
256 RawPtrWillBeMember<Node> m_firstChild;
257 RawPtrWillBeMember<Node> m_lastChild;
258 };
259
260 #if ENABLE(ASSERT)
261 bool childAttachedAllowedWhenAttachingChildren(ContainerNode*);
262 #endif
263
264 DEFINE_NODE_TYPE_CASTS(ContainerNode, isContainerNode());
265
hasChildCount(unsigned count)266 inline bool ContainerNode::hasChildCount(unsigned count) const
267 {
268 Node* child = m_firstChild;
269 while (count && child) {
270 child = child->nextSibling();
271 --count;
272 }
273 return !count && !child;
274 }
275
ContainerNode(TreeScope * treeScope,ConstructionType type)276 inline ContainerNode::ContainerNode(TreeScope* treeScope, ConstructionType type)
277 : Node(treeScope, type)
278 , m_firstChild(nullptr)
279 , m_lastChild(nullptr)
280 {
281 }
282
attachChildren(const AttachContext & context)283 inline void ContainerNode::attachChildren(const AttachContext& context)
284 {
285 AttachContext childrenContext(context);
286 childrenContext.resolvedStyle = 0;
287
288 for (Node* child = firstChild(); child; child = child->nextSibling()) {
289 ASSERT(child->needsAttach() || childAttachedAllowedWhenAttachingChildren(this));
290 if (child->needsAttach())
291 child->attach(childrenContext);
292 }
293 }
294
detachChildren(const AttachContext & context)295 inline void ContainerNode::detachChildren(const AttachContext& context)
296 {
297 AttachContext childrenContext(context);
298 childrenContext.resolvedStyle = 0;
299
300 for (Node* child = firstChild(); child; child = child->nextSibling())
301 child->detach(childrenContext);
302 }
303
countChildren()304 inline unsigned Node::countChildren() const
305 {
306 if (!isContainerNode())
307 return 0;
308 return toContainerNode(this)->countChildren();
309 }
310
firstChild()311 inline Node* Node::firstChild() const
312 {
313 if (!isContainerNode())
314 return 0;
315 return toContainerNode(this)->firstChild();
316 }
317
lastChild()318 inline Node* Node::lastChild() const
319 {
320 if (!isContainerNode())
321 return 0;
322 return toContainerNode(this)->lastChild();
323 }
324
parentElementOrShadowRoot()325 inline ContainerNode* Node::parentElementOrShadowRoot() const
326 {
327 ContainerNode* parent = parentNode();
328 return parent && (parent->isElementNode() || parent->isShadowRoot()) ? parent : 0;
329 }
330
parentElementOrDocumentFragment()331 inline ContainerNode* Node::parentElementOrDocumentFragment() const
332 {
333 ContainerNode* parent = parentNode();
334 return parent && (parent->isElementNode() || parent->isDocumentFragment()) ? parent : 0;
335 }
336
isTreeScope()337 inline bool Node::isTreeScope() const
338 {
339 return &treeScope().rootNode() == this;
340 }
341
getChildNodes(ContainerNode & node,NodeVector & nodes)342 inline void getChildNodes(ContainerNode& node, NodeVector& nodes)
343 {
344 ASSERT(!nodes.size());
345 for (Node* child = node.firstChild(); child; child = child->nextSibling())
346 nodes.append(child);
347 }
348
349 } // namespace blink
350
351 #endif // ContainerNode_h
352