Remove dead Node::isBlockFlowOrBlockTable
[WebKit-https.git] / Source / WebCore / dom / Node.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, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
6  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #ifndef Node_h
26 #define Node_h
27
28 #include "EditingBoundary.h"
29 #include "EventTarget.h"
30 #include "FractionalLayoutRect.h"
31 #include "KURLHash.h"
32 #include "LayoutTypes.h"
33 #include "MutationObserver.h"
34 #include "RenderStyleConstants.h"
35 #include "ScriptWrappable.h"
36 #include "TreeShared.h"
37 #include <wtf/Forward.h>
38 #include <wtf/ListHashSet.h>
39 #include <wtf/text/AtomicString.h>
40
41 #if USE(JSC)
42 namespace JSC {
43     class JSGlobalData;
44     class SlotVisitor;
45 }
46 #endif
47
48 // This needs to be here because Document.h also depends on it.
49 #define DUMP_NODE_STATISTICS 0
50
51 namespace WebCore {
52
53 class Attribute;
54 class ClassNodeList;
55 class ContainerNode;
56 class DOMSettableTokenList;
57 class Document;
58 class DynamicSubtreeNodeList;
59 class Element;
60 class Event;
61 class EventContext;
62 class EventDispatchMediator;
63 class EventListener;
64 class FloatPoint;
65 class Frame;
66 class HTMLInputElement;
67 class IntRect;
68 class KeyboardEvent;
69 class NSResolver;
70 class NamedNodeMap;
71 class NameNodeList;
72 class NodeList;
73 class NodeListsNodeData;
74 class NodeRareData;
75 class NodeRenderingContext;
76 class PlatformKeyboardEvent;
77 class PlatformMouseEvent;
78 class PlatformWheelEvent;
79 class QualifiedName;
80 class RadioNodeList;
81 class RegisteredEventListener;
82 class RenderArena;
83 class RenderBox;
84 class RenderBoxModelObject;
85 class RenderObject;
86 class RenderStyle;
87 class ShadowRoot;
88 class TagNodeList;
89 class TreeScope;
90
91 #if ENABLE(GESTURE_EVENTS)
92 class PlatformGestureEvent;
93 #endif
94
95 #if ENABLE(MICRODATA)
96 class HTMLPropertiesCollection;
97 class PropertyNodeList;
98 #endif
99
100 typedef int ExceptionCode;
101
102 const int nodeStyleChangeShift = 20;
103
104 // SyntheticStyleChange means that we need to go through the entire style change logic even though
105 // no style property has actually changed. It is used to restructure the tree when, for instance,
106 // RenderLayers are created or destroyed due to animation changes.
107 enum StyleChangeType { 
108     NoStyleChange = 0, 
109     InlineStyleChange = 1 << nodeStyleChangeShift, 
110     FullStyleChange = 2 << nodeStyleChangeShift, 
111     SyntheticStyleChange = 3 << nodeStyleChangeShift
112 };
113
114 class Node : public EventTarget, public ScriptWrappable, public TreeShared<Node, ContainerNode> {
115     friend class Document;
116     friend class TreeScope;
117     friend class TreeScopeAdopter;
118
119 public:
120     enum NodeType {
121         ELEMENT_NODE = 1,
122         ATTRIBUTE_NODE = 2,
123         TEXT_NODE = 3,
124         CDATA_SECTION_NODE = 4,
125         ENTITY_REFERENCE_NODE = 5,
126         ENTITY_NODE = 6,
127         PROCESSING_INSTRUCTION_NODE = 7,
128         COMMENT_NODE = 8,
129         DOCUMENT_NODE = 9,
130         DOCUMENT_TYPE_NODE = 10,
131         DOCUMENT_FRAGMENT_NODE = 11,
132         NOTATION_NODE = 12,
133         XPATH_NAMESPACE_NODE = 13,
134     };
135     enum DocumentPosition {
136         DOCUMENT_POSITION_EQUIVALENT = 0x00,
137         DOCUMENT_POSITION_DISCONNECTED = 0x01,
138         DOCUMENT_POSITION_PRECEDING = 0x02,
139         DOCUMENT_POSITION_FOLLOWING = 0x04,
140         DOCUMENT_POSITION_CONTAINS = 0x08,
141         DOCUMENT_POSITION_CONTAINED_BY = 0x10,
142         DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20,
143     };
144
145     static bool isSupported(const String& feature, const String& version);
146
147     static void startIgnoringLeaks();
148     static void stopIgnoringLeaks();
149
150     static void dumpStatistics();
151
152     enum StyleChange { NoChange, NoInherit, Inherit, Detach, Force };    
153     static StyleChange diff(const RenderStyle*, const RenderStyle*, Document*);
154
155     virtual ~Node();
156
157     // DOM methods & attributes for Node
158
159     bool hasTagName(const QualifiedName&) const;
160     bool hasLocalName(const AtomicString&) const;
161     virtual String nodeName() const = 0;
162     virtual String nodeValue() const;
163     virtual void setNodeValue(const String&, ExceptionCode&);
164     virtual NodeType nodeType() const = 0;
165     ContainerNode* parentNode() const;
166     Element* parentElement() const;
167     Node* previousSibling() const { return m_previous; }
168     Node* nextSibling() const { return m_next; }
169     PassRefPtr<NodeList> childNodes();
170     Node* firstChild() const;
171     Node* lastChild() const;
172     bool hasAttributes() const;
173     NamedNodeMap* attributes() const;
174
175     virtual KURL baseURI() const;
176     
177     void getSubresourceURLs(ListHashSet<KURL>&) const;
178
179     // These should all actually return a node, but this is only important for language bindings,
180     // which will already know and hold a ref on the right node to return. Returning bool allows
181     // these methods to be more efficient since they don't need to return a ref
182     bool insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode&, bool shouldLazyAttach = false);
183     bool replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode&, bool shouldLazyAttach = false);
184     bool removeChild(Node* child, ExceptionCode&);
185     bool appendChild(PassRefPtr<Node> newChild, ExceptionCode&, bool shouldLazyAttach = false);
186
187     void remove(ExceptionCode&);
188     bool hasChildNodes() const { return firstChild(); }
189     virtual PassRefPtr<Node> cloneNode(bool deep) = 0;
190     const AtomicString& localName() const { return virtualLocalName(); }
191     const AtomicString& namespaceURI() const { return virtualNamespaceURI(); }
192     const AtomicString& prefix() const { return virtualPrefix(); }
193     virtual void setPrefix(const AtomicString&, ExceptionCode&);
194     void normalize();
195
196     bool isSameNode(Node* other) const { return this == other; }
197     bool isEqualNode(Node*) const;
198     bool isDefaultNamespace(const AtomicString& namespaceURI) const;
199     String lookupPrefix(const AtomicString& namespaceURI) const;
200     String lookupNamespaceURI(const String& prefix) const;
201     String lookupNamespacePrefix(const AtomicString& namespaceURI, const Element* originalElement) const;
202     
203     String textContent(bool convertBRsToNewlines = false) const;
204     void setTextContent(const String&, ExceptionCode&);
205     
206     Node* lastDescendant() const;
207     Node* firstDescendant() const;
208
209     virtual bool isActiveNode() const { return false; }
210     
211     // Other methods (not part of DOM)
212
213     bool isElementNode() const { return getFlag(IsElementFlag); }
214     bool isContainerNode() const { return getFlag(IsContainerFlag); }
215     bool isTextNode() const { return getFlag(IsTextFlag); }
216     bool isHTMLElement() const { return getFlag(IsHTMLFlag); }
217     bool isSVGElement() const { return getFlag(IsSVGFlag); }
218
219     virtual bool isMediaControlElement() const { return false; }
220     virtual bool isMediaControls() const { return false; }
221     bool isStyledElement() const { return getFlag(IsStyledElementFlag); }
222     virtual bool isAttributeNode() const { return false; }
223     virtual bool isCharacterDataNode() const { return false; }
224     virtual bool isFrameOwnerElement() const { return false; }
225     virtual bool isPluginElement() const { return false; }
226     bool isDocumentNode() const;
227     bool isShadowRoot() const { return getFlag(IsShadowRootFlag); }
228     bool inNamedFlow() const { return getFlag(InNamedFlowFlag); }
229     bool hasAttrList() const { return getFlag(HasAttrListFlag); }
230     bool hasCustomCallbacks() const { return getFlag(HasCustomCallbacksFlag); }
231
232     // If this node is in a shadow tree, returns its shadow host. Otherwise, returns 0.
233     Element* shadowHost() const;
234     // If this node is in a shadow tree, returns its shadow host. Otherwise, returns this.
235     // Deprecated. Should use shadowHost() and check the return value.
236     Node* shadowAncestorNode() const;
237     ShadowRoot* shadowRoot() const;
238     ShadowRoot* youngestShadowRoot() const;
239
240     // Returns 0, a child of ShadowRoot, or a legacy shadow root.
241     Node* nonBoundaryShadowTreeRootNode();
242     bool isInShadowTree() const;
243     // Node's parent, shadow tree host.
244     ContainerNode* parentOrHostNode() const;
245     Element* parentOrHostElement() const;
246     void setParentOrHostNode(ContainerNode*);
247     Node* highestAncestor() const;
248
249     // Use when it's guaranteed to that shadowHost is 0.
250     ContainerNode* parentNodeGuaranteedHostFree() const;
251     // Returns the parent node, but 0 if the parent node is a ShadowRoot.
252     ContainerNode* nonShadowBoundaryParentNode() const;
253
254     bool selfOrAncestorHasDirAutoAttribute() const { return getFlag(SelfOrAncestorHasDirAutoFlag); }
255     void setSelfOrAncestorHasDirAutoAttribute(bool flag) { setFlag(flag, SelfOrAncestorHasDirAutoFlag); }
256
257     // Returns the enclosing event parent node (or self) that, when clicked, would trigger a navigation.
258     Node* enclosingLinkEventParentOrSelf();
259
260     bool isBlockFlow() const;
261
262     // These low-level calls give the caller responsibility for maintaining the integrity of the tree.
263     void setPreviousSibling(Node* previous) { m_previous = previous; }
264     void setNextSibling(Node* next) { m_next = next; }
265
266     virtual bool canContainRangeEndPoint() const { return false; }
267
268     // FIXME: These two functions belong in editing -- "atomic node" is an editing concept.
269     Node* previousNodeConsideringAtomicNodes() const;
270     Node* nextNodeConsideringAtomicNodes() const;
271     
272     // Returns the next leaf node or 0 if there are no more.
273     // Delivers leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
274     // Uses an editing-specific concept of what a leaf node is, and should probably be moved
275     // out of the Node class into an editing-specific source file.
276     Node* nextLeafNode() const;
277
278     // Returns the previous leaf node or 0 if there are no more.
279     // Delivers leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
280     // Uses an editing-specific concept of what a leaf node is, and should probably be moved
281     // out of the Node class into an editing-specific source file.
282     Node* previousLeafNode() const;
283
284     // enclosingBlockFlowElement() is deprecated. Use enclosingBlock instead.
285     Element* enclosingBlockFlowElement() const;
286
287     bool isRootEditableElement() const;
288     Element* rootEditableElement() const;
289     Element* rootEditableElement(EditableType) const;
290
291     bool inSameContainingBlockFlowElement(Node*);
292
293     // Called by the parser when this element's close tag is reached,
294     // signaling that all child tags have been parsed and added.
295     // This is needed for <applet> and <object> elements, which can't lay themselves out
296     // until they know all of their nested <param>s. [Radar 3603191, 4040848].
297     // Also used for script elements and some SVG elements for similar purposes,
298     // but making parsing a special case in this respect should be avoided if possible.
299     virtual void finishParsingChildren() { }
300     virtual void beginParsingChildren() { }
301
302     // Called on the focused node right before dispatching an unload event.
303     virtual void aboutToUnload() { }
304
305     // For <link> and <style> elements.
306     virtual bool sheetLoaded() { return true; }
307     virtual void notifyLoadedSheetAndAllCriticalSubresources(bool /* error loading subresource */) { }
308     virtual void startLoadingDynamicSheet() { ASSERT_NOT_REACHED(); }
309
310     bool attributeStyleDirty() const { return getFlag(AttributeStyleDirtyFlag); }
311     bool hasName() const { return getFlag(HasNameFlag); }
312     bool hasID() const;
313     bool hasClass() const;
314
315     bool active() const { return getFlag(IsActiveFlag); }
316     bool inActiveChain() const { return getFlag(InActiveChainFlag); }
317     bool hovered() const { return getFlag(IsHoveredFlag); }
318     bool focused() const { return hasRareData() ? rareDataFocused() : false; }
319     bool attached() const { return getFlag(IsAttachedFlag); }
320     void setAttached() { setFlag(IsAttachedFlag); }
321     bool needsStyleRecalc() const { return styleChangeType() != NoStyleChange; }
322     StyleChangeType styleChangeType() const { return static_cast<StyleChangeType>(m_nodeFlags & StyleChangeMask); }
323     bool childNeedsStyleRecalc() const { return getFlag(ChildNeedsStyleRecalcFlag); }
324     bool isLink() const { return getFlag(IsLinkFlag); }
325
326     void setAttributeStyleDirty() { setFlag(AttributeStyleDirtyFlag); }
327     void clearAttributeStyleDirty() { clearFlag(AttributeStyleDirtyFlag); }
328
329     void setHasName(bool f) { setFlag(f, HasNameFlag); }
330     void setChildNeedsStyleRecalc() { setFlag(ChildNeedsStyleRecalcFlag); }
331     void clearChildNeedsStyleRecalc() { clearFlag(ChildNeedsStyleRecalcFlag); }
332
333     void setInActiveChain() { setFlag(InActiveChainFlag); }
334     void clearInActiveChain() { clearFlag(InActiveChainFlag); }
335
336     void setNeedsStyleRecalc(StyleChangeType changeType = FullStyleChange);
337     void clearNeedsStyleRecalc() { m_nodeFlags &= ~StyleChangeMask; }
338     virtual void scheduleSetNeedsStyleRecalc(StyleChangeType changeType = FullStyleChange) { setNeedsStyleRecalc(changeType); }
339
340     void setIsLink(bool f) { setFlag(f, IsLinkFlag); }
341     void setIsLink() { setFlag(IsLinkFlag); }
342     void clearIsLink() { clearFlag(IsLinkFlag); }
343
344     void setInNamedFlow() { setFlag(InNamedFlowFlag); }
345     void clearInNamedFlow() { clearFlag(InNamedFlowFlag); }
346
347     void setHasAttrList() { setFlag(HasAttrListFlag); }
348     void clearHasAttrList() { clearFlag(HasAttrListFlag); }
349
350     bool hasScopedHTMLStyleChild() const { return getFlag(HasScopedHTMLStyleChildFlag); }
351     void setHasScopedHTMLStyleChild(bool flag) { setFlag(flag, HasScopedHTMLStyleChildFlag); }
352
353     bool hasEventTargetData() const { return getFlag(HasEventTargetDataFlag); }
354     void setHasEventTargetData(bool flag) { setFlag(flag, HasEventTargetDataFlag); }
355
356     enum ShouldSetAttached {
357         SetAttached,
358         DoNotSetAttached
359     };
360     void lazyAttach(ShouldSetAttached = SetAttached);
361     void lazyReattach(ShouldSetAttached = SetAttached);
362
363     virtual void setFocus(bool = true);
364     virtual void setActive(bool f = true, bool /*pause*/ = false) { setFlag(f, IsActiveFlag); }
365     virtual void setHovered(bool f = true) { setFlag(f, IsHoveredFlag); }
366
367     virtual short tabIndex() const;
368
369     // Whether this kind of node can receive focus by default. Most nodes are
370     // not focusable but some elements, such as form controls and links, are.
371     virtual bool supportsFocus() const;
372     // Whether the node can actually be focused.
373     virtual bool isFocusable() const;
374     virtual bool isKeyboardFocusable(KeyboardEvent*) const;
375     virtual bool isMouseFocusable() const;
376     virtual Node* focusDelegate();
377
378     bool isContentEditable();
379     bool isContentRichlyEditable();
380
381     void inspect();
382
383     bool rendererIsEditable(EditableType editableType = ContentIsEditable) const
384     {
385         switch (editableType) {
386         case ContentIsEditable:
387             return rendererIsEditable(Editable);
388         case HasEditableAXRole:
389             return isEditableToAccessibility(Editable);
390         }
391         ASSERT_NOT_REACHED();
392         return false;
393     }
394
395     bool rendererIsRichlyEditable(EditableType editableType = ContentIsEditable) const
396     {
397         switch (editableType) {
398         case ContentIsEditable:
399             return rendererIsEditable(RichlyEditable);
400         case HasEditableAXRole:
401             return isEditableToAccessibility(RichlyEditable);
402         }
403         ASSERT_NOT_REACHED();
404         return false;
405     }
406
407     virtual bool shouldUseInputMethod();
408     virtual LayoutRect boundingBox() const;
409     IntRect pixelSnappedBoundingBox() const { return pixelSnappedIntRect(boundingBox()); }
410     LayoutRect renderRect(bool* isReplaced);
411     IntRect pixelSnappedRenderRect(bool* isReplaced) { return pixelSnappedIntRect(renderRect(isReplaced)); }
412
413     // Returns true if the node has a non-empty bounding box in layout.
414     // This does not 100% guarantee the user can see it, but is pretty close.
415     // Note: This method only works properly after layout has occurred.
416     bool hasNonEmptyBoundingBox() const;
417
418     unsigned nodeIndex() const;
419
420     // Returns the DOM ownerDocument attribute. This method never returns NULL, except in the case 
421     // of (1) a Document node or (2) a DocumentType node that is not used with any Document yet. 
422     Document* ownerDocument() const;
423
424     // Returns the document associated with this node. This method never returns NULL, except in the case 
425     // of a DocumentType node that is not used with any Document yet. A Document node returns itself.
426     Document* document() const
427     {
428         ASSERT(this);
429         // FIXME: below ASSERT is useful, but prevents the use of document() in the constructor or destructor
430         // due to the virtual function call to nodeType().
431         ASSERT(documentInternal() || (nodeType() == DOCUMENT_TYPE_NODE && !inDocument()));
432         return documentInternal();
433     }
434
435     TreeScope* treeScope() const;
436
437     // Returns true if this node is associated with a document and is in its associated document's
438     // node tree, false otherwise.
439     bool inDocument() const 
440     { 
441         ASSERT(m_document || !getFlag(InDocumentFlag));
442         return getFlag(InDocumentFlag);
443     }
444
445     bool isReadOnlyNode() const { return nodeType() == ENTITY_REFERENCE_NODE; }
446     virtual bool childTypeAllowed(NodeType) const { return false; }
447     unsigned childNodeCount() const;
448     Node* childNode(unsigned index) const;
449
450     // Does a pre-order traversal of the tree to find the next node after this one.
451     // This uses the same order that tags appear in the source file. If the stayWithin
452     // argument is non-null, the traversal will stop once the specified node is reached.
453     // This can be used to restrict traversal to a particular sub-tree.
454     Node* traverseNextNode() const;
455     Node* traverseNextNode(const Node* stayWithin) const;
456
457     // Like traverseNextNode, but skips children and starts with the next sibling.
458     Node* traverseNextSibling() const;
459     Node* traverseNextSibling(const Node* stayWithin) const;
460
461     // Does a reverse pre-order traversal to find the node that comes before the current one in document order
462     Node* traversePreviousNode(const Node* stayWithin = 0) const;
463
464     // Like traversePreviousNode, but skips children and starts with the next sibling.
465     Node* traversePreviousSibling(const Node* stayWithin = 0) const;
466
467     // Like traverseNextNode, but visits parents after their children.
468     Node* traverseNextNodePostOrder() const;
469
470     // Like traversePreviousNode, but visits parents before their children.
471     Node* traversePreviousNodePostOrder(const Node* stayWithin = 0) const;
472     Node* traversePreviousSiblingPostOrder(const Node* stayWithin = 0) const;
473
474     void checkSetPrefix(const AtomicString& prefix, ExceptionCode&);
475     bool isDescendantOf(const Node*) const;
476     bool contains(const Node*) const;
477     bool containsIncludingShadowDOM(Node*);
478
479     // This method is used to do strict error-checking when adding children via
480     // the public DOM API (e.g., appendChild()).
481     void checkAddChild(Node* newChild, ExceptionCode&); // Error-checking when adding via the DOM API
482
483     void checkReplaceChild(Node* newChild, Node* oldChild, ExceptionCode&);
484     virtual bool canReplaceChild(Node* newChild, Node* oldChild);
485     
486     // Used to determine whether range offsets use characters or node indices.
487     virtual bool offsetInCharacters() const;
488     // Number of DOM 16-bit units contained in node. Note that rendered text length can be different - e.g. because of
489     // css-transform:capitalize breaking up precomposed characters and ligatures.
490     virtual int maxCharacterOffset() const;
491
492     // Whether or not a selection can be started in this object
493     virtual bool canStartSelection() const;
494
495     // Getting points into and out of screen space
496     FloatPoint convertToPage(const FloatPoint&) const;
497     FloatPoint convertFromPage(const FloatPoint&) const;
498
499     // -----------------------------------------------------------------------------
500     // Integration with rendering tree
501
502     RenderObject* renderer() const { return m_renderer; }
503     void setRenderer(RenderObject* renderer) { m_renderer = renderer; }
504     
505     // Use these two methods with caution.
506     RenderBox* renderBox() const;
507     RenderBoxModelObject* renderBoxModelObject() const;
508
509     // Attaches this node to the rendering tree. This calculates the style to be applied to the node and creates an
510     // appropriate RenderObject which will be inserted into the tree (except when the style has display: none). This
511     // makes the node visible in the FrameView.
512     virtual void attach();
513
514     // Detaches the node from the rendering tree, making it invisible in the rendered view. This method will remove
515     // the node's rendering object from the rendering tree and delete it.
516     virtual void detach();
517
518 #ifndef NDEBUG
519     bool inDetach() const;
520 #endif
521
522     void reattach();
523     void reattachIfAttached();
524     void createRendererIfNeeded();
525     virtual bool rendererIsNeeded(const NodeRenderingContext&);
526     virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const { return true; }
527     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
528     ContainerNode* parentNodeForRenderingAndStyle();
529     
530     // Wrapper for nodes that don't have a renderer, but still cache the style (like HTMLOptionElement).
531     RenderStyle* renderStyle() const;
532     virtual void setRenderStyle(PassRefPtr<RenderStyle>);
533
534     RenderStyle* computedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return virtualComputedStyle(pseudoElementSpecifier); }
535
536     // -----------------------------------------------------------------------------
537     // Notification of document structure changes (see ContainerNode.h for more notification methods)
538     //
539     // At first, WebKit notifies the node that it has been inserted into the document. This is called during document parsing, and also
540     // when a node is added through the DOM methods insertBefore(), appendChild() or replaceChild(). The call happens _after_ the node has been added to the tree.
541     // This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event
542     // dispatching.
543     //
544     // WebKit notifies this callback regardless if the subtree of the node is a document tree or a floating subtree.
545     // Implementation can determine the type of subtree by seeing insertionPoint->inDocument().
546     // For a performance reason, notifications are delivered only to ContainerNode subclasses if the insertionPoint is out of document.
547     //
548     // There are another callback named didNotifyDescendantInsertions(), which is called after all the descendant is notified.
549     // Only a few subclasses actually need this. To utilize this, the node should return InsertionShouldCallDidNotifyDescendantInsertions
550     // from insrtedInto().
551     //
552     enum InsertionNotificationRequest {
553         InsertionDone,
554         InsertionShouldCallDidNotifySubtreeInsertions
555     };
556
557     virtual InsertionNotificationRequest insertedInto(ContainerNode* insertionPoint);
558     virtual void didNotifySubtreeInsertions(ContainerNode*) { }
559
560     // Notifies the node that it is no longer part of the tree.
561     //
562     // This is a dual of insertedInto(), and is similar to the DOMNodeRemovedFromDocument DOM event, but does not require the overhead of event
563     // dispatching, and is called _after_ the node is removed from the tree.
564     //
565     virtual void removedFrom(ContainerNode* insertionPoint);
566
567 #ifndef NDEBUG
568     virtual void formatForDebugger(char* buffer, unsigned length) const;
569
570     void showNode(const char* prefix = "") const;
571     void showTreeForThis() const;
572     void showNodePathForThis() const;
573     void showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2 = 0, const char* markedLabel2 = 0) const;
574     void showTreeForThisAcrossFrame() const;
575 #endif
576
577     void invalidateNodeListCachesInAncestors(const QualifiedName* attrName = 0, Element* attributeOwnerElement = 0);
578     NodeListsNodeData* nodeLists();
579     void removeCachedChildNodeList();
580
581     PassRefPtr<NodeList> getElementsByTagName(const AtomicString&);
582     PassRefPtr<NodeList> getElementsByTagNameNS(const AtomicString& namespaceURI, const AtomicString& localName);
583     PassRefPtr<NodeList> getElementsByName(const String& elementName);
584     PassRefPtr<NodeList> getElementsByClassName(const String& classNames);
585     PassRefPtr<RadioNodeList> radioNodeList(const AtomicString&);
586
587     virtual bool willRespondToMouseMoveEvents();
588     virtual bool willRespondToMouseClickEvents();
589     virtual bool willRespondToTouchEvents();
590
591     PassRefPtr<Element> querySelector(const AtomicString& selectors, ExceptionCode&);
592     PassRefPtr<NodeList> querySelectorAll(const AtomicString& selectors, ExceptionCode&);
593
594     unsigned short compareDocumentPosition(Node*);
595
596     virtual Node* toNode();
597     virtual HTMLInputElement* toInputElement();
598
599     virtual const AtomicString& interfaceName() const;
600     virtual ScriptExecutionContext* scriptExecutionContext() const;
601
602     virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
603     virtual bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
604
605     // Handlers to do/undo actions on the target node before an event is dispatched to it and after the event
606     // has been dispatched.  The data pointer is handed back by the preDispatch and passed to postDispatch.
607     virtual void* preDispatchEventHandler(Event*) { return 0; }
608     virtual void postDispatchEventHandler(Event*, void* /*dataFromPreDispatch*/) { }
609
610     using EventTarget::dispatchEvent;
611     bool dispatchEvent(PassRefPtr<Event>);
612     void dispatchScopedEvent(PassRefPtr<Event>);
613     void dispatchScopedEventDispatchMediator(PassRefPtr<EventDispatchMediator>);
614
615     virtual void handleLocalEvents(Event*);
616
617     void dispatchSubtreeModifiedEvent();
618     bool dispatchDOMActivateEvent(int detail, PassRefPtr<Event> underlyingEvent);
619     void dispatchFocusInEvent(const AtomicString& eventType, PassRefPtr<Node> oldFocusedNode);
620     void dispatchFocusOutEvent(const AtomicString& eventType, PassRefPtr<Node> newFocusedNode);
621
622     bool dispatchKeyEvent(const PlatformKeyboardEvent&);
623     bool dispatchWheelEvent(const PlatformWheelEvent&);
624     bool dispatchMouseEvent(const PlatformMouseEvent&, const AtomicString& eventType, int clickCount = 0, Node* relatedTarget = 0);
625 #if ENABLE(GESTURE_EVENTS)
626     bool dispatchGestureEvent(const PlatformGestureEvent&);
627 #endif
628     void dispatchSimulatedClick(PassRefPtr<Event> underlyingEvent, bool sendMouseEvents = false, bool showPressedLook = true);
629     bool dispatchBeforeLoadEvent(const String& sourceURL);
630
631     virtual void dispatchFocusEvent(PassRefPtr<Node> oldFocusedNode);
632     virtual void dispatchBlurEvent(PassRefPtr<Node> newFocusedNode);
633     virtual void dispatchChangeEvent();
634     virtual void dispatchInputEvent();
635
636     // Perform the default action for an event.
637     virtual void defaultEventHandler(Event*);
638
639     // Used for disabled form elements; if true, prevents mouse events from being dispatched
640     // to event listeners, and prevents DOMActivate events from being sent at all.
641     virtual bool disabled() const;
642
643     using TreeShared<Node, ContainerNode>::ref;
644     using TreeShared<Node, ContainerNode>::deref;
645
646     virtual EventTargetData* eventTargetData();
647     virtual EventTargetData* ensureEventTargetData();
648
649 #if ENABLE(MICRODATA)
650     DOMSettableTokenList* itemProp();
651     DOMSettableTokenList* itemRef();
652     DOMSettableTokenList* itemType();
653     PassRefPtr<PropertyNodeList> propertyNodeList(const String&);
654 #endif
655
656 #if ENABLE(MUTATION_OBSERVERS)
657     void getRegisteredMutationObserversOfType(HashMap<MutationObserver*, MutationRecordDeliveryOptions>&, MutationObserver::MutationType, const QualifiedName* attributeName);
658     void registerMutationObserver(MutationObserver*, MutationObserverOptions, const HashSet<AtomicString>& attributeFilter);
659     void unregisterMutationObserver(MutationObserverRegistration*);
660     void registerTransientMutationObserver(MutationObserverRegistration*);
661     void unregisterTransientMutationObserver(MutationObserverRegistration*);
662     void notifyMutationObserversNodeWillDetach();
663 #endif // ENABLE(MUTATION_OBSERVERS)
664
665     void registerScopedHTMLStyleChild();
666     void unregisterScopedHTMLStyleChild();
667     size_t numberOfScopedHTMLStyleChildren() const;
668
669     virtual void reportMemoryUsage(MemoryObjectInfo*) const;
670
671     void textRects(Vector<IntRect>&) const;
672
673 private:
674     enum NodeFlags {
675         IsTextFlag = 1,
676         IsContainerFlag = 1 << 1,
677         IsElementFlag = 1 << 2,
678         IsStyledElementFlag = 1 << 3,
679         IsHTMLFlag = 1 << 4,
680         IsSVGFlag = 1 << 5,
681         IsAttachedFlag = 1 << 6,
682         ChildNeedsStyleRecalcFlag = 1 << 7,
683         InDocumentFlag = 1 << 8,
684         IsLinkFlag = 1 << 9,
685         IsActiveFlag = 1 << 10,
686         IsHoveredFlag = 1 << 11,
687         InActiveChainFlag = 1 << 12,
688         HasRareDataFlag = 1 << 13,
689         IsShadowRootFlag = 1 << 14,
690
691         // These bits are used by derived classes, pulled up here so they can
692         // be stored in the same memory word as the Node bits above.
693         IsParsingChildrenFinishedFlag = 1 << 15, // Element
694         IsStyleAttributeValidFlag = 1 << 16, // StyledElement
695 #if ENABLE(SVG)
696         AreSVGAttributesValidFlag = 1 << 17, // Element
697         IsSynchronizingSVGAttributesFlag = 1 << 18, // SVGElement
698         HasSVGRareDataFlag = 1 << 19, // SVGElement
699 #endif
700
701         StyleChangeMask = 1 << nodeStyleChangeShift | 1 << (nodeStyleChangeShift + 1),
702
703         SelfOrAncestorHasDirAutoFlag = 1 << 22,
704
705         HasNameFlag = 1 << 23,
706
707         AttributeStyleDirtyFlag = 1 << 24,
708
709 #if ENABLE(SVG)
710         DefaultNodeFlags = IsParsingChildrenFinishedFlag | IsStyleAttributeValidFlag | AreSVGAttributesValidFlag,
711 #else
712         DefaultNodeFlags = IsParsingChildrenFinishedFlag | IsStyleAttributeValidFlag,
713 #endif
714         InNamedFlowFlag = 1 << 26,
715         HasAttrListFlag = 1 << 27,
716         HasCustomCallbacksFlag = 1 << 28,
717         HasScopedHTMLStyleChildFlag = 1 << 29,
718         HasEventTargetDataFlag = 1 << 30,
719     };
720
721     // 2 bits remaining
722
723     bool getFlag(NodeFlags mask) const { return m_nodeFlags & mask; }
724     void setFlag(bool f, NodeFlags mask) const { m_nodeFlags = (m_nodeFlags & ~mask) | (-(int32_t)f & mask); } 
725     void setFlag(NodeFlags mask) const { m_nodeFlags |= mask; } 
726     void clearFlag(NodeFlags mask) const { m_nodeFlags &= ~mask; } 
727
728 protected:
729     enum ConstructionType { 
730         CreateOther = DefaultNodeFlags,
731         CreateText = DefaultNodeFlags | IsTextFlag,
732         CreateContainer = DefaultNodeFlags | IsContainerFlag, 
733         CreateElement = CreateContainer | IsElementFlag, 
734         CreateShadowRoot = CreateContainer | IsShadowRootFlag,
735         CreateStyledElement = CreateElement | IsStyledElementFlag, 
736         CreateHTMLElement = CreateStyledElement | IsHTMLFlag, 
737         CreateFrameOwnerElement = CreateHTMLElement | HasCustomCallbacksFlag,
738         CreateSVGElement = CreateStyledElement | IsSVGFlag,
739         CreateDocument = CreateContainer | InDocumentFlag
740     };
741     Node(Document*, ConstructionType);
742
743     virtual void didMoveToNewDocument(Document* oldDocument);
744     
745     virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const { }
746     void setTabIndexExplicitly(short);
747     void clearTabIndexExplicitly();
748     
749     bool hasRareData() const { return getFlag(HasRareDataFlag); }
750
751     NodeRareData* rareData() const;
752     NodeRareData* ensureRareData();
753     void clearRareData();
754
755     void clearEventTargetData();
756
757     void setHasCustomCallbacks() { setFlag(true, HasCustomCallbacksFlag); }
758
759     Document* documentInternal() const { return m_document; }
760
761 private:
762     friend class TreeShared<Node, ContainerNode>;
763
764     void removedLastRef();
765
766     // These API should be only used for a tree scope migration.
767     // setTreeScope() returns NodeRareData to save extra nodeRareData() invocations on the caller site.
768     NodeRareData* setTreeScope(TreeScope*);
769     void setDocument(Document*);
770
771     enum EditableLevel { Editable, RichlyEditable };
772     bool rendererIsEditable(EditableLevel) const;
773     bool isEditableToAccessibility(EditableLevel) const;
774
775     void setStyleChange(StyleChangeType);
776
777     // Used to share code between lazyAttach and setNeedsStyleRecalc.
778     void markAncestorsWithChildNeedsStyleRecalc();
779
780     virtual void refEventTarget();
781     virtual void derefEventTarget();
782
783     virtual OwnPtr<NodeRareData> createRareData();
784     bool rareDataFocused() const;
785
786     virtual RenderStyle* nonRendererRenderStyle() const;
787
788     virtual const AtomicString& virtualPrefix() const;
789     virtual const AtomicString& virtualLocalName() const;
790     virtual const AtomicString& virtualNamespaceURI() const;
791     virtual RenderStyle* virtualComputedStyle(PseudoId = NOPSEUDO);
792
793     Element* ancestorElement() const;
794
795     Node* traverseNextAncestorSibling() const;
796     Node* traverseNextAncestorSibling(const Node* stayWithin) const;
797
798     // Use Node::parentNode as the consistent way of querying a parent node.
799     // This method is made private to ensure a compiler error on call sites that
800     // don't follow this rule.
801     using TreeShared<Node, ContainerNode>::parent;
802     using TreeShared<Node, ContainerNode>::setParent;
803
804     void trackForDebugging();
805
806 #if ENABLE(MUTATION_OBSERVERS)
807     Vector<OwnPtr<MutationObserverRegistration> >* mutationObserverRegistry();
808     HashSet<MutationObserverRegistration*>* transientMutationObserverRegistry();
809 #endif
810
811     mutable uint32_t m_nodeFlags;
812     Document* m_document;
813     Node* m_previous;
814     Node* m_next;
815     RenderObject* m_renderer;
816
817 public:
818     bool isStyleAttributeValid() const { return getFlag(IsStyleAttributeValidFlag); }
819     void setIsStyleAttributeValid(bool f) { setFlag(f, IsStyleAttributeValidFlag); }
820     void setIsStyleAttributeValid() const { setFlag(IsStyleAttributeValidFlag); }
821     void clearIsStyleAttributeValid() { clearFlag(IsStyleAttributeValidFlag); }
822
823 protected:
824     bool isParsingChildrenFinished() const { return getFlag(IsParsingChildrenFinishedFlag); }
825     void setIsParsingChildrenFinished() { setFlag(IsParsingChildrenFinishedFlag); }
826     void clearIsParsingChildrenFinished() { clearFlag(IsParsingChildrenFinishedFlag); }
827
828 #if ENABLE(SVG)
829     bool areSVGAttributesValid() const { return getFlag(AreSVGAttributesValidFlag); }
830     void setAreSVGAttributesValid() const { setFlag(AreSVGAttributesValidFlag); }
831     void clearAreSVGAttributesValid() { clearFlag(AreSVGAttributesValidFlag); }
832     bool isSynchronizingSVGAttributes() const { return getFlag(IsSynchronizingSVGAttributesFlag); }
833     void setIsSynchronizingSVGAttributes() const { setFlag(IsSynchronizingSVGAttributesFlag); }
834     void clearIsSynchronizingSVGAttributes() const { clearFlag(IsSynchronizingSVGAttributesFlag); }
835     bool hasSVGRareData() const { return getFlag(HasSVGRareDataFlag); }
836     void setHasSVGRareData() { setFlag(HasSVGRareDataFlag); }
837     void clearHasSVGRareData() { clearFlag(HasSVGRareDataFlag); }
838 #endif
839
840 #if ENABLE(MICRODATA)
841     void setItemProp(const String&);
842     void setItemRef(const String&);
843     void setItemType(const String&);
844 #endif
845 };
846
847 // Used in Node::addSubresourceAttributeURLs() and in addSubresourceStyleURLs()
848 inline void addSubresourceURL(ListHashSet<KURL>& urls, const KURL& url)
849 {
850     if (!url.isNull())
851         urls.add(url);
852 }
853
854 inline ContainerNode* Node::parentNode() const
855 {
856     return getFlag(IsShadowRootFlag) ? 0 : parent();
857 }
858
859 inline void Node::setParentOrHostNode(ContainerNode* parent)
860 {
861     setParent(parent);
862 }
863
864 inline ContainerNode* Node::parentOrHostNode() const
865 {
866     return parent();
867 }
868
869 inline ContainerNode* Node::parentNodeGuaranteedHostFree() const
870 {
871     ASSERT(!getFlag(IsShadowRootFlag));
872     return parentOrHostNode();
873 }
874
875 inline void Node::reattach()
876 {
877     if (attached())
878         detach();
879     attach();
880 }
881
882 inline void Node::reattachIfAttached()
883 {
884     if (attached())
885         reattach();
886 }
887
888 inline void Node::lazyReattach(ShouldSetAttached shouldSetAttached)
889 {
890     if (attached())
891         detach();
892     lazyAttach(shouldSetAttached);
893 }
894
895 } //namespace
896
897 #ifndef NDEBUG
898 // Outside the WebCore namespace for ease of invocation from gdb.
899 void showTree(const WebCore::Node*);
900 void showNodePath(const WebCore::Node*);
901 #endif
902
903 #endif