src/third_party/WebKit/Source/core/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, 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
  68     Node* firstChild() const { return m_firstChild; }
  69     Node* lastChild() const { return m_lastChild; }
  70     bool hasChildren() const { return m_firstChild; }
  71
  72     bool hasOneChild() const { return m_firstChild && !m_firstChild->nextSibling(); }
  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
 114     bool childrenOrSiblingsAffectedByFocus() const { return hasRestyleFlag(ChildrenOrSiblingsAffectedByFocus); }
 115     void setChildrenOrSiblingsAffectedByFocus() { setRestyleFlag(ChildrenOrSiblingsAffectedByFocus); }
 116
 117     bool childrenOrSiblingsAffectedByHover() const { return hasRestyleFlag(ChildrenOrSiblingsAffectedByHover); }
 118     void setChildrenOrSiblingsAffectedByHover() { setRestyleFlag(ChildrenOrSiblingsAffectedByHover); }
 119
 120     bool childrenOrSiblingsAffectedByActive() const { return hasRestyleFlag(ChildrenOrSiblingsAffectedByActive); }
 121     void setChildrenOrSiblingsAffectedByActive() { setRestyleFlag(ChildrenOrSiblingsAffectedByActive); }
 122
 123     bool childrenOrSiblingsAffectedByDrag() const { return hasRestyleFlag(ChildrenOrSiblingsAffectedByDrag); }
 124     void setChildrenOrSiblingsAffectedByDrag() { setRestyleFlag(ChildrenOrSiblingsAffectedByDrag); }
 125
 126     bool childrenAffectedByPositionalRules() const { return hasRestyleFlag(ChildrenAffectedByForwardPositionalRules) || hasRestyleFlag(ChildrenAffectedByBackwardPositionalRules); }
 127
 128     bool childrenAffectedByFirstChildRules() const { return hasRestyleFlag(ChildrenAffectedByFirstChildRules); }
 129     void setChildrenAffectedByFirstChildRules() { setRestyleFlag(ChildrenAffectedByFirstChildRules); }
 130
 131     bool childrenAffectedByLastChildRules() const { return hasRestyleFlag(ChildrenAffectedByLastChildRules); }
 132     void setChildrenAffectedByLastChildRules() { setRestyleFlag(ChildrenAffectedByLastChildRules); }
 133
 134     bool childrenAffectedByDirectAdjacentRules() const { return hasRestyleFlag(ChildrenAffectedByDirectAdjacentRules); }
 135     void setChildrenAffectedByDirectAdjacentRules() { setRestyleFlag(ChildrenAffectedByDirectAdjacentRules); }
 136
 137     bool childrenAffectedByIndirectAdjacentRules() const { return hasRestyleFlag(ChildrenAffectedByIndirectAdjacentRules); }
 138     void setChildrenAffectedByIndirectAdjacentRules() { setRestyleFlag(ChildrenAffectedByIndirectAdjacentRules); }
 139
 140     bool childrenAffectedByForwardPositionalRules() const { return hasRestyleFlag(ChildrenAffectedByForwardPositionalRules); }
 141     void setChildrenAffectedByForwardPositionalRules() { setRestyleFlag(ChildrenAffectedByForwardPositionalRules); }
 142
 143     bool childrenAffectedByBackwardPositionalRules() const { return hasRestyleFlag(ChildrenAffectedByBackwardPositionalRules); }
 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
 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:
 163         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
 174         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
 185         bool isChildInsertion() const { return type == ElementInserted || type == NonElementInserted; }
 186         bool isChildRemoval() const { return type == ElementRemoved || type == NonElementRemoved; }
 187         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
 212     void setFirstChild(Node* child) { m_firstChild = 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
 239     bool hasRestyleFlag(DynamicRestyleFlags mask) const { return hasRareData() && hasRestyleFlagInternal(mask); }
 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
 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
 276 inline ContainerNode::ContainerNode(TreeScope* treeScope, ConstructionType type)
 277     : Node(treeScope, type)
 278     , m_firstChild(nullptr)
 279     , m_lastChild(nullptr)
 280 {
 281 }
 282
 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
 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
 304 inline unsigned Node::countChildren() const
 305 {
 306     if (!isContainerNode())
 307         return 0;
 308     return toContainerNode(this)->countChildren();
 309 }
 310
 311 inline Node* Node::firstChild() const
 312 {
 313     if (!isContainerNode())
 314         return 0;
 315     return toContainerNode(this)->firstChild();
 316 }
 317
 318 inline Node* Node::lastChild() const
 319 {
 320     if (!isContainerNode())
 321         return 0;
 322     return toContainerNode(this)->lastChild();
 323 }
 324
 325 inline ContainerNode* Node::parentElementOrShadowRoot() const
 326 {
 327     ContainerNode* parent = parentNode();
 328     return parent && (parent->isElementNode() || parent->isShadowRoot()) ? parent : 0;
 329 }
 330
 331 inline ContainerNode* Node::parentElementOrDocumentFragment() const
 332 {
 333     ContainerNode* parent = parentNode();
 334     return parent && (parent->isElementNode() || parent->isDocumentFragment()) ? parent : 0;
 335 }
 336
 337 inline bool Node::isTreeScope() const
 338 {
 339     return &treeScope().rootNode() == this;
 340 }
 341
 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