Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

920 lines (748 sloc) 37.63 kb
* Copyright (C) 1999 Lars Knoll (
* (C) 1999 Antti Koivisto (
* (C) 2001 Dirk Mueller (
* Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
* Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* Library General Public License for more details.
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
#ifndef Node_h
#define Node_h
#include "EditingBoundary.h"
#include "EventTarget.h"
#include "KURLHash.h"
#include "LayoutRect.h"
#include "MutationObserver.h"
#include "RenderStyleConstants.h"
#include "ScriptWrappable.h"
#include "TreeShared.h"
#include <wtf/Forward.h>
#include <wtf/ListHashSet.h>
#include <wtf/text/AtomicString.h>
#if USE(JSC)
namespace JSC {
class JSGlobalData;
class SlotVisitor;
// This needs to be here because Document.h also depends on it.
namespace WebCore {
class Attribute;
class ClassNodeList;
class ContainerNode;
class DOMSettableTokenList;
class Document;
class DynamicSubtreeNodeList;
class Element;
class Event;
class EventContext;
class EventDispatchMediator;
class EventListener;
class FloatPoint;
class Frame;
class HTMLInputElement;
class IntRect;
class KeyboardEvent;
class NSResolver;
class NamedNodeMap;
class NameNodeList;
class NodeList;
class NodeListsNodeData;
class NodeRareData;
class NodeRenderingContext;
class PlatformKeyboardEvent;
class PlatformMouseEvent;
class PlatformWheelEvent;
class QualifiedName;
class RadioNodeList;
class RegisteredEventListener;
class RenderArena;
class RenderBox;
class RenderBoxModelObject;
class RenderObject;
class RenderStyle;
class ShadowRoot;
class TagNodeList;
class TreeScope;
class PlatformGestureEvent;
class HTMLPropertiesCollection;
class PropertyNodeList;
typedef int ExceptionCode;
const int nodeStyleChangeShift = 19;
// SyntheticStyleChange means that we need to go through the entire style change logic even though
// no style property has actually changed. It is used to restructure the tree when, for instance,
// RenderLayers are created or destroyed due to animation changes.
enum StyleChangeType {
NoStyleChange = 0,
InlineStyleChange = 1 << nodeStyleChangeShift,
FullStyleChange = 2 << nodeStyleChangeShift,
SyntheticStyleChange = 3 << nodeStyleChangeShift
class NodeRareDataBase {
RenderObject* renderer() const { return m_renderer; }
void setRenderer(RenderObject* renderer) { m_renderer = renderer; }
virtual ~NodeRareDataBase() { }
NodeRareDataBase() { }
RenderObject* m_renderer;
class Node : public EventTarget, public ScriptWrappable, public TreeShared<Node, ContainerNode> {
friend class Document;
friend class TreeScope;
friend class TreeScopeAdopter;
enum NodeType {
enum DocumentPosition {
static bool isSupported(const String& feature, const String& version);
static void startIgnoringLeaks();
static void stopIgnoringLeaks();
static void dumpStatistics();
enum StyleChange { NoChange, NoInherit, Inherit, Detach, Force };
static StyleChange diff(const RenderStyle*, const RenderStyle*, Document*);
virtual ~Node();
// DOM methods & attributes for Node
bool hasTagName(const QualifiedName&) const;
bool hasLocalName(const AtomicString&) const;
virtual String nodeName() const = 0;
virtual String nodeValue() const;
virtual void setNodeValue(const String&, ExceptionCode&);
virtual NodeType nodeType() const = 0;
ContainerNode* parentNode() const;
Element* parentElement() const;
Node* previousSibling() const { return m_previous; }
Node* nextSibling() const { return m_next; }
PassRefPtr<NodeList> childNodes();
Node* firstChild() const;
Node* lastChild() const;
bool hasAttributes() const;
NamedNodeMap* attributes() const;
virtual KURL baseURI() const;
void getSubresourceURLs(ListHashSet<KURL>&) const;
// These should all actually return a node, but this is only important for language bindings,
// which will already know and hold a ref on the right node to return. Returning bool allows
// these methods to be more efficient since they don't need to return a ref
bool insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode&, bool shouldLazyAttach = false);
bool replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode&, bool shouldLazyAttach = false);
bool removeChild(Node* child, ExceptionCode&);
bool appendChild(PassRefPtr<Node> newChild, ExceptionCode&, bool shouldLazyAttach = false);
void remove(ExceptionCode&);
bool hasChildNodes() const { return firstChild(); }
virtual PassRefPtr<Node> cloneNode(bool deep) = 0;
const AtomicString& localName() const { return virtualLocalName(); }
const AtomicString& namespaceURI() const { return virtualNamespaceURI(); }
const AtomicString& prefix() const { return virtualPrefix(); }
virtual void setPrefix(const AtomicString&, ExceptionCode&);
void normalize();
bool isSameNode(Node* other) const { return this == other; }
bool isEqualNode(Node*) const;
bool isDefaultNamespace(const AtomicString& namespaceURI) const;
String lookupPrefix(const AtomicString& namespaceURI) const;
String lookupNamespaceURI(const String& prefix) const;
String lookupNamespacePrefix(const AtomicString& namespaceURI, const Element* originalElement) const;
String textContent(bool convertBRsToNewlines = false) const;
void setTextContent(const String&, ExceptionCode&);
Node* lastDescendant() const;
Node* firstDescendant() const;
virtual bool isActiveNode() const { return false; }
// Other methods (not part of DOM)
bool isElementNode() const { return getFlag(IsElementFlag); }
bool isContainerNode() const { return getFlag(IsContainerFlag); }
bool isTextNode() const { return getFlag(IsTextFlag); }
bool isHTMLElement() const { return getFlag(IsHTMLFlag); }
bool isSVGElement() const { return getFlag(IsSVGFlag); }
virtual bool isMediaControlElement() const { return false; }
virtual bool isMediaControls() const { return false; }
bool isStyledElement() const { return getFlag(IsStyledElementFlag); }
virtual bool isAttributeNode() const { return false; }
virtual bool isCharacterDataNode() const { return false; }
virtual bool isFrameOwnerElement() const { return false; }
virtual bool isPluginElement() const { return false; }
bool isDocumentNode() const;
bool isShadowRoot() const { return getFlag(IsShadowRootFlag); }
bool isInsertionPoint() const { return getFlag(IsInsertionPointFlag); }
bool inNamedFlow() const { return getFlag(InNamedFlowFlag); }
bool hasCustomCallbacks() const { return getFlag(HasCustomCallbacksFlag); }
bool hasSyntheticAttrChildNodes() const { return getFlag(HasSyntheticAttrChildNodesFlag); }
void setHasSyntheticAttrChildNodes(bool flag) { setFlag(flag, HasSyntheticAttrChildNodesFlag); }
// If this node is in a shadow tree, returns its shadow host. Otherwise, returns 0.
Element* shadowHost() const;
// If this node is in a shadow tree, returns its shadow host. Otherwise, returns this.
// Deprecated. Should use shadowHost() and check the return value.
Node* shadowAncestorNode() const;
ShadowRoot* shadowRoot() const;
ShadowRoot* youngestShadowRoot() const;
// Returns 0, a child of ShadowRoot, or a legacy shadow root.
Node* nonBoundaryShadowTreeRootNode();
bool isInShadowTree() const;
// Node's parent, shadow tree host.
ContainerNode* parentOrHostNode() const;
Element* parentOrHostElement() const;
void setParentOrHostNode(ContainerNode*);
Node* highestAncestor() const;
// Use when it's guaranteed to that shadowHost is 0.
ContainerNode* parentNodeGuaranteedHostFree() const;
// Returns the parent node, but 0 if the parent node is a ShadowRoot.
ContainerNode* nonShadowBoundaryParentNode() const;
bool selfOrAncestorHasDirAutoAttribute() const { return getFlag(SelfOrAncestorHasDirAutoFlag); }
void setSelfOrAncestorHasDirAutoAttribute(bool flag) { setFlag(flag, SelfOrAncestorHasDirAutoFlag); }
// Returns the enclosing event parent node (or self) that, when clicked, would trigger a navigation.
Node* enclosingLinkEventParentOrSelf();
bool isBlockFlow() const;
// These low-level calls give the caller responsibility for maintaining the integrity of the tree.
void setPreviousSibling(Node* previous) { m_previous = previous; }
void setNextSibling(Node* next) { m_next = next; }
virtual bool canContainRangeEndPoint() const { return false; }
// FIXME: These two functions belong in editing -- "atomic node" is an editing concept.
Node* previousNodeConsideringAtomicNodes() const;
Node* nextNodeConsideringAtomicNodes() const;
// Returns the next leaf node or 0 if there are no more.
// Delivers leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
// Uses an editing-specific concept of what a leaf node is, and should probably be moved
// out of the Node class into an editing-specific source file.
Node* nextLeafNode() const;
// Returns the previous leaf node or 0 if there are no more.
// Delivers leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
// Uses an editing-specific concept of what a leaf node is, and should probably be moved
// out of the Node class into an editing-specific source file.
Node* previousLeafNode() const;
// enclosingBlockFlowElement() is deprecated. Use enclosingBlock instead.
Element* enclosingBlockFlowElement() const;
bool isRootEditableElement() const;
Element* rootEditableElement() const;
Element* rootEditableElement(EditableType) const;
bool inSameContainingBlockFlowElement(Node*);
// Called by the parser when this element's close tag is reached,
// signaling that all child tags have been parsed and added.
// This is needed for <applet> and <object> elements, which can't lay themselves out
// until they know all of their nested <param>s. [Radar 3603191, 4040848].
// Also used for script elements and some SVG elements for similar purposes,
// but making parsing a special case in this respect should be avoided if possible.
virtual void finishParsingChildren() { }
virtual void beginParsingChildren() { }
// For <link> and <style> elements.
virtual bool sheetLoaded() { return true; }
virtual void notifyLoadedSheetAndAllCriticalSubresources(bool /* error loading subresource */) { }
virtual void startLoadingDynamicSheet() { ASSERT_NOT_REACHED(); }
bool hasName() const { return getFlag(HasNameFlag); }
bool hasID() const;
bool hasClass() const;
bool active() const { return getFlag(IsActiveFlag); }
bool inActiveChain() const { return getFlag(InActiveChainFlag); }
bool hovered() const { return getFlag(IsHoveredFlag); }
bool focused() const { return hasRareData() ? rareDataFocused() : false; }
bool attached() const { return getFlag(IsAttachedFlag); }
void setAttached() { setFlag(IsAttachedFlag); }
bool needsStyleRecalc() const { return styleChangeType() != NoStyleChange; }
StyleChangeType styleChangeType() const { return static_cast<StyleChangeType>(m_nodeFlags & StyleChangeMask); }
bool childNeedsStyleRecalc() const { return getFlag(ChildNeedsStyleRecalcFlag); }
bool isLink() const { return getFlag(IsLinkFlag); }
void setHasName(bool f) { setFlag(f, HasNameFlag); }
void setChildNeedsStyleRecalc() { setFlag(ChildNeedsStyleRecalcFlag); }
void clearChildNeedsStyleRecalc() { clearFlag(ChildNeedsStyleRecalcFlag); }
void setInActiveChain() { setFlag(InActiveChainFlag); }
void clearInActiveChain() { clearFlag(InActiveChainFlag); }
void setNeedsStyleRecalc(StyleChangeType changeType = FullStyleChange);
void clearNeedsStyleRecalc() { m_nodeFlags &= ~StyleChangeMask; }
virtual void scheduleSetNeedsStyleRecalc(StyleChangeType changeType = FullStyleChange) { setNeedsStyleRecalc(changeType); }
void setIsLink(bool f) { setFlag(f, IsLinkFlag); }
void setIsLink() { setFlag(IsLinkFlag); }
void clearIsLink() { clearFlag(IsLinkFlag); }
void setInNamedFlow() { setFlag(InNamedFlowFlag); }
void clearInNamedFlow() { clearFlag(InNamedFlowFlag); }
bool hasScopedHTMLStyleChild() const { return getFlag(HasScopedHTMLStyleChildFlag); }
void setHasScopedHTMLStyleChild(bool flag) { setFlag(flag, HasScopedHTMLStyleChildFlag); }
bool hasEventTargetData() const { return getFlag(HasEventTargetDataFlag); }
void setHasEventTargetData(bool flag) { setFlag(flag, HasEventTargetDataFlag); }
bool inEden() const { return getFlag(InEdenFlag); }
void setEden(bool flag) { setFlag(flag, InEdenFlag); }
enum ShouldSetAttached {
void lazyAttach(ShouldSetAttached = SetAttached);
void lazyReattach(ShouldSetAttached = SetAttached);
virtual void setFocus(bool = true);
virtual void setActive(bool f = true, bool /*pause*/ = false) { setFlag(f, IsActiveFlag); }
virtual void setHovered(bool f = true) { setFlag(f, IsHoveredFlag); }
virtual short tabIndex() const;
// Whether this kind of node can receive focus by default. Most nodes are
// not focusable but some elements, such as form controls and links, are.
virtual bool supportsFocus() const;
// Whether the node can actually be focused.
virtual bool isFocusable() const;
virtual bool isKeyboardFocusable(KeyboardEvent*) const;
virtual bool isMouseFocusable() const;
virtual Node* focusDelegate();
enum UserSelectAllTreatment {
bool isContentEditable(UserSelectAllTreatment = UserSelectAllDoesNotAffectEditability);
bool isContentRichlyEditable();
void inspect();
bool rendererIsEditable(EditableType editableType = ContentIsEditable, UserSelectAllTreatment treatment = UserSelectAllIsAlwaysNonEditable) const
switch (editableType) {
case ContentIsEditable:
return rendererIsEditable(Editable, treatment);
case HasEditableAXRole:
return isEditableToAccessibility(Editable);
return false;
bool rendererIsRichlyEditable(EditableType editableType = ContentIsEditable) const
switch (editableType) {
case ContentIsEditable:
return rendererIsEditable(RichlyEditable, UserSelectAllIsAlwaysNonEditable);
case HasEditableAXRole:
return isEditableToAccessibility(RichlyEditable);
return false;
virtual bool shouldUseInputMethod();
virtual LayoutRect boundingBox() const;
IntRect pixelSnappedBoundingBox() const { return pixelSnappedIntRect(boundingBox()); }
LayoutRect renderRect(bool* isReplaced);
IntRect pixelSnappedRenderRect(bool* isReplaced) { return pixelSnappedIntRect(renderRect(isReplaced)); }
// Returns true if the node has a non-empty bounding box in layout.
// This does not 100% guarantee the user can see it, but is pretty close.
// Note: This method only works properly after layout has occurred.
bool hasNonEmptyBoundingBox() const;
unsigned nodeIndex() const;
// Returns the DOM ownerDocument attribute. This method never returns NULL, except in the case
// of (1) a Document node or (2) a DocumentType node that is not used with any Document yet.
Document* ownerDocument() const;
// Returns the document associated with this node. This method never returns NULL, except in the case
// of a DocumentType node that is not used with any Document yet. A Document node returns itself.
Document* document() const
// FIXME: below ASSERT is useful, but prevents the use of document() in the constructor or destructor
// due to the virtual function call to nodeType().
ASSERT(documentInternal() || (nodeType() == DOCUMENT_TYPE_NODE && !inDocument()));
return documentInternal();
TreeScope* treeScope() const;
// Returns true if this node is associated with a document and is in its associated document's
// node tree, false otherwise.
bool inDocument() const
ASSERT(m_document || !getFlag(InDocumentFlag));
return getFlag(InDocumentFlag);
bool isReadOnlyNode() const { return nodeType() == ENTITY_REFERENCE_NODE; }
virtual bool childTypeAllowed(NodeType) const { return false; }
unsigned childNodeCount() const;
Node* childNode(unsigned index) const;
// Does a pre-order traversal of the tree to find the next node after this one.
// This uses the same order that tags appear in the source file. If the stayWithin
// argument is non-null, the traversal will stop once the specified node is reached.
// This can be used to restrict traversal to a particular sub-tree.
Node* traverseNextNode() const;
Node* traverseNextNode(const Node* stayWithin) const;
// Like traverseNextNode, but skips children and starts with the next sibling.
Node* traverseNextSibling() const;
Node* traverseNextSibling(const Node* stayWithin) const;
// Does a reverse pre-order traversal to find the node that comes before the current one in document order
Node* traversePreviousNode(const Node* stayWithin = 0) const;
// Like traversePreviousNode, but skips children and starts with the next sibling.
Node* traversePreviousSibling(const Node* stayWithin = 0) const;
// Like traverseNextNode, but visits parents after their children.
Node* traverseNextNodePostOrder() const;
// Like traversePreviousNode, but visits parents before their children.
Node* traversePreviousNodePostOrder(const Node* stayWithin = 0) const;
Node* traversePreviousSiblingPostOrder(const Node* stayWithin = 0) const;
void checkSetPrefix(const AtomicString& prefix, ExceptionCode&);
bool isDescendantOf(const Node*) const;
bool contains(const Node*) const;
bool containsIncludingShadowDOM(Node*);
// This method is used to do strict error-checking when adding children via
// the public DOM API (e.g., appendChild()).
void checkAddChild(Node* newChild, ExceptionCode&); // Error-checking when adding via the DOM API
void checkReplaceChild(Node* newChild, Node* oldChild, ExceptionCode&);
virtual bool canReplaceChild(Node* newChild, Node* oldChild);
// Used to determine whether range offsets use characters or node indices.
virtual bool offsetInCharacters() const;
// Number of DOM 16-bit units contained in node. Note that rendered text length can be different - e.g. because of
// css-transform:capitalize breaking up precomposed characters and ligatures.
virtual int maxCharacterOffset() const;
// Whether or not a selection can be started in this object
virtual bool canStartSelection() const;
// Getting points into and out of screen space
FloatPoint convertToPage(const FloatPoint&) const;
FloatPoint convertFromPage(const FloatPoint&) const;
// -----------------------------------------------------------------------------
// Integration with rendering tree
// As renderer() includes a branch you should avoid calling it repeatedly in hot code paths.
RenderObject* renderer() const { return hasRareData() ? m_data.m_rareData->renderer() : m_data.m_renderer; };
void setRenderer(RenderObject* renderer)
if (hasRareData())
m_data.m_renderer = renderer;
// Use these two methods with caution.
RenderBox* renderBox() const;
RenderBoxModelObject* renderBoxModelObject() const;
// Attaches this node to the rendering tree. This calculates the style to be applied to the node and creates an
// appropriate RenderObject which will be inserted into the tree (except when the style has display: none). This
// makes the node visible in the FrameView.
virtual void attach();
// Detaches the node from the rendering tree, making it invisible in the rendered view. This method will remove
// the node's rendering object from the rendering tree and delete it.
virtual void detach();
#ifndef NDEBUG
bool inDetach() const;
void reattach();
void reattachIfAttached();
void createRendererIfNeeded();
virtual bool rendererIsNeeded(const NodeRenderingContext&);
virtual bool childShouldCreateRenderer(const NodeRenderingContext&) const { return true; }
virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
ContainerNode* parentNodeForRenderingAndStyle();
// Wrapper for nodes that don't have a renderer, but still cache the style (like HTMLOptionElement).
RenderStyle* renderStyle() const;
RenderStyle* computedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return virtualComputedStyle(pseudoElementSpecifier); }
// -----------------------------------------------------------------------------
// Notification of document structure changes (see ContainerNode.h for more notification methods)
// At first, WebKit notifies the node that it has been inserted into the document. This is called during document parsing, and also
// 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.
// This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event
// dispatching.
// WebKit notifies this callback regardless if the subtree of the node is a document tree or a floating subtree.
// Implementation can determine the type of subtree by seeing insertionPoint->inDocument().
// For a performance reason, notifications are delivered only to ContainerNode subclasses if the insertionPoint is out of document.
// There are another callback named didNotifyDescendantInsertions(), which is called after all the descendant is notified.
// Only a few subclasses actually need this. To utilize this, the node should return InsertionShouldCallDidNotifyDescendantInsertions
// from insrtedInto().
enum InsertionNotificationRequest {
virtual InsertionNotificationRequest insertedInto(ContainerNode* insertionPoint);
virtual void didNotifySubtreeInsertions(ContainerNode*) { }
// Notifies the node that it is no longer part of the tree.
// This is a dual of insertedInto(), and is similar to the DOMNodeRemovedFromDocument DOM event, but does not require the overhead of event
// dispatching, and is called _after_ the node is removed from the tree.
virtual void removedFrom(ContainerNode* insertionPoint);
#ifndef NDEBUG
virtual void formatForDebugger(char* buffer, unsigned length) const;
void showNode(const char* prefix = "") const;
void showTreeForThis() const;
void showNodePathForThis() const;
void showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2 = 0, const char* markedLabel2 = 0) const;
void showTreeForThisAcrossFrame() const;
void invalidateNodeListCachesInAncestors(const QualifiedName* attrName = 0, Element* attributeOwnerElement = 0);
NodeListsNodeData* nodeLists();
void removeCachedChildNodeList();
PassRefPtr<NodeList> getElementsByTagName(const AtomicString&);
PassRefPtr<NodeList> getElementsByTagNameNS(const AtomicString& namespaceURI, const AtomicString& localName);
PassRefPtr<NodeList> getElementsByName(const String& elementName);
PassRefPtr<NodeList> getElementsByClassName(const String& classNames);
PassRefPtr<RadioNodeList> radioNodeList(const AtomicString&);
virtual bool willRespondToMouseMoveEvents();
virtual bool willRespondToMouseClickEvents();
virtual bool willRespondToTouchEvents();
PassRefPtr<Element> querySelector(const AtomicString& selectors, ExceptionCode&);
PassRefPtr<NodeList> querySelectorAll(const AtomicString& selectors, ExceptionCode&);
unsigned short compareDocumentPosition(Node*);
virtual Node* toNode();
virtual HTMLInputElement* toInputElement();
virtual const AtomicString& interfaceName() const;
virtual ScriptExecutionContext* scriptExecutionContext() const;
virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
virtual bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
// Handlers to do/undo actions on the target node before an event is dispatched to it and after the event
// has been dispatched. The data pointer is handed back by the preDispatch and passed to postDispatch.
virtual void* preDispatchEventHandler(Event*) { return 0; }
virtual void postDispatchEventHandler(Event*, void* /*dataFromPreDispatch*/) { }
using EventTarget::dispatchEvent;
bool dispatchEvent(PassRefPtr<Event>);
void dispatchScopedEvent(PassRefPtr<Event>);
void dispatchScopedEventDispatchMediator(PassRefPtr<EventDispatchMediator>);
virtual void handleLocalEvents(Event*);
void dispatchSubtreeModifiedEvent();
bool dispatchDOMActivateEvent(int detail, PassRefPtr<Event> underlyingEvent);
void dispatchFocusInEvent(const AtomicString& eventType, PassRefPtr<Node> oldFocusedNode);
void dispatchFocusOutEvent(const AtomicString& eventType, PassRefPtr<Node> newFocusedNode);
bool dispatchKeyEvent(const PlatformKeyboardEvent&);
bool dispatchWheelEvent(const PlatformWheelEvent&);
bool dispatchMouseEvent(const PlatformMouseEvent&, const AtomicString& eventType, int clickCount = 0, Node* relatedTarget = 0);
bool dispatchGestureEvent(const PlatformGestureEvent&);
void dispatchSimulatedClick(Event* underlyingEvent, bool sendMouseEvents = false, bool showPressedLook = true);
bool dispatchBeforeLoadEvent(const String& sourceURL);
virtual void dispatchFocusEvent(PassRefPtr<Node> oldFocusedNode);
virtual void dispatchBlurEvent(PassRefPtr<Node> newFocusedNode);
virtual void dispatchChangeEvent();
virtual void dispatchInputEvent();
// Perform the default action for an event.
virtual void defaultEventHandler(Event*);
// Used for disabled form elements; if true, prevents mouse events from being dispatched
// to event listeners, and prevents DOMActivate events from being sent at all.
virtual bool disabled() const;
using TreeShared<Node, ContainerNode>::ref;
using TreeShared<Node, ContainerNode>::deref;
virtual EventTargetData* eventTargetData();
virtual EventTargetData* ensureEventTargetData();
DOMSettableTokenList* itemProp();
DOMSettableTokenList* itemRef();
DOMSettableTokenList* itemType();
PassRefPtr<PropertyNodeList> propertyNodeList(const String&);
void getRegisteredMutationObserversOfType(HashMap<MutationObserver*, MutationRecordDeliveryOptions>&, MutationObserver::MutationType, const QualifiedName* attributeName);
void registerMutationObserver(MutationObserver*, MutationObserverOptions, const HashSet<AtomicString>& attributeFilter);
void unregisterMutationObserver(MutationObserverRegistration*);
void registerTransientMutationObserver(MutationObserverRegistration*);
void unregisterTransientMutationObserver(MutationObserverRegistration*);
void notifyMutationObserversNodeWillDetach();
virtual void registerScopedHTMLStyleChild();
virtual void unregisterScopedHTMLStyleChild();
size_t numberOfScopedHTMLStyleChildren() const;
virtual void reportMemoryUsage(MemoryObjectInfo*) const;
void textRects(Vector<IntRect>&) const;
enum NodeFlags {
IsTextFlag = 1,
IsContainerFlag = 1 << 1,
IsElementFlag = 1 << 2,
IsStyledElementFlag = 1 << 3,
IsHTMLFlag = 1 << 4,
IsSVGFlag = 1 << 5,
IsAttachedFlag = 1 << 6,
ChildNeedsStyleRecalcFlag = 1 << 7,
InDocumentFlag = 1 << 8,
IsLinkFlag = 1 << 9,
IsActiveFlag = 1 << 10,
IsHoveredFlag = 1 << 11,
InActiveChainFlag = 1 << 12,
HasRareDataFlag = 1 << 13,
IsShadowRootFlag = 1 << 14,
// These bits are used by derived classes, pulled up here so they can
// be stored in the same memory word as the Node bits above.
IsParsingChildrenFinishedFlag = 1 << 15, // Element
AreSVGAttributesValidFlag = 1 << 16, // Element
IsSynchronizingSVGAttributesFlag = 1 << 17, // SVGElement
HasSVGRareDataFlag = 1 << 18, // SVGElement
StyleChangeMask = 1 << nodeStyleChangeShift | 1 << (nodeStyleChangeShift + 1),
SelfOrAncestorHasDirAutoFlag = 1 << 21,
HasNameFlag = 1 << 22,
InNamedFlowFlag = 1 << 23,
HasSyntheticAttrChildNodesFlag = 1 << 24,
HasCustomCallbacksFlag = 1 << 25,
HasScopedHTMLStyleChildFlag = 1 << 26,
HasEventTargetDataFlag = 1 << 27,
InEdenFlag = 1 << 28,
IsInsertionPointFlag = 1 << 29,
DefaultNodeFlags = IsParsingChildrenFinishedFlag | AreSVGAttributesValidFlag,
DefaultNodeFlags = IsParsingChildrenFinishedFlag,
// 2 bits remaining
bool getFlag(NodeFlags mask) const { return m_nodeFlags & mask; }
void setFlag(bool f, NodeFlags mask) const { m_nodeFlags = (m_nodeFlags & ~mask) | (-(int32_t)f & mask); }
void setFlag(NodeFlags mask) const { m_nodeFlags |= mask; }
void clearFlag(NodeFlags mask) const { m_nodeFlags &= ~mask; }
enum ConstructionType {
CreateOther = DefaultNodeFlags,
CreateText = DefaultNodeFlags | IsTextFlag,
CreateContainer = DefaultNodeFlags | IsContainerFlag,
CreateElement = CreateContainer | IsElementFlag,
CreateShadowRoot = CreateContainer | IsShadowRootFlag,
CreateStyledElement = CreateElement | IsStyledElementFlag,
CreateHTMLElement = CreateStyledElement | IsHTMLFlag,
CreateFrameOwnerElement = CreateHTMLElement | HasCustomCallbacksFlag,
CreateSVGElement = CreateStyledElement | IsSVGFlag,
CreateDocument = CreateContainer | InDocumentFlag,
CreateInsertionPoint = CreateHTMLElement | IsInsertionPointFlag
Node(Document*, ConstructionType);
virtual void didMoveToNewDocument(Document* oldDocument);
virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const { }
void setTabIndexExplicitly(short);
void clearTabIndexExplicitly();
bool hasRareData() const { return getFlag(HasRareDataFlag); }
NodeRareData* rareData() const;
NodeRareData* ensureRareData();
void clearRareData();
void clearEventTargetData();
void setHasCustomCallbacks() { setFlag(true, HasCustomCallbacksFlag); }
Document* documentInternal() const { return m_document; }
friend class TreeShared<Node, ContainerNode>;
void removedLastRef();
// These API should be only used for a tree scope migration.
// setTreeScope() returns NodeRareData to save extra nodeRareData() invocations on the caller site.
NodeRareData* setTreeScope(TreeScope*);
void setDocument(Document*);
enum EditableLevel { Editable, RichlyEditable };
bool rendererIsEditable(EditableLevel, UserSelectAllTreatment = UserSelectAllIsAlwaysNonEditable) const;
bool isEditableToAccessibility(EditableLevel) const;
void setStyleChange(StyleChangeType);
// Used to share code between lazyAttach and setNeedsStyleRecalc.
void markAncestorsWithChildNeedsStyleRecalc();
virtual void refEventTarget();
virtual void derefEventTarget();
virtual OwnPtr<NodeRareData> createRareData();
bool rareDataFocused() const;
virtual RenderStyle* nonRendererStyle() const { return 0; }
virtual const AtomicString& virtualPrefix() const;
virtual const AtomicString& virtualLocalName() const;
virtual const AtomicString& virtualNamespaceURI() const;
virtual RenderStyle* virtualComputedStyle(PseudoId = NOPSEUDO);
Element* ancestorElement() const;
Node* traverseNextAncestorSibling() const;
Node* traverseNextAncestorSibling(const Node* stayWithin) const;
// Use Node::parentNode as the consistent way of querying a parent node.
// This method is made private to ensure a compiler error on call sites that
// don't follow this rule.
using TreeShared<Node, ContainerNode>::parent;
using TreeShared<Node, ContainerNode>::setParent;
void trackForDebugging();
Vector<OwnPtr<MutationObserverRegistration> >* mutationObserverRegistry();
HashSet<MutationObserverRegistration*>* transientMutationObserverRegistry();
mutable uint32_t m_nodeFlags;
Document* m_document;
Node* m_previous;
Node* m_next;
// When a node has rare data we move the renderer into the rare data.
union DataUnion {
DataUnion() : m_renderer(0) { }
RenderObject* m_renderer;
NodeRareDataBase* m_rareData;
} m_data;
bool isParsingChildrenFinished() const { return getFlag(IsParsingChildrenFinishedFlag); }
void setIsParsingChildrenFinished() { setFlag(IsParsingChildrenFinishedFlag); }
void clearIsParsingChildrenFinished() { clearFlag(IsParsingChildrenFinishedFlag); }
bool areSVGAttributesValid() const { return getFlag(AreSVGAttributesValidFlag); }
void setAreSVGAttributesValid() const { setFlag(AreSVGAttributesValidFlag); }
void clearAreSVGAttributesValid() { clearFlag(AreSVGAttributesValidFlag); }
bool isSynchronizingSVGAttributes() const { return getFlag(IsSynchronizingSVGAttributesFlag); }
void setIsSynchronizingSVGAttributes() const { setFlag(IsSynchronizingSVGAttributesFlag); }
void clearIsSynchronizingSVGAttributes() const { clearFlag(IsSynchronizingSVGAttributesFlag); }
bool hasSVGRareData() const { return getFlag(HasSVGRareDataFlag); }
void setHasSVGRareData() { setFlag(HasSVGRareDataFlag); }
void clearHasSVGRareData() { clearFlag(HasSVGRareDataFlag); }
void setItemProp(const String&);
void setItemRef(const String&);
void setItemType(const String&);
// Used in Node::addSubresourceAttributeURLs() and in addSubresourceStyleURLs()
inline void addSubresourceURL(ListHashSet<KURL>& urls, const KURL& url)
if (!url.isNull())
inline ContainerNode* Node::parentNode() const
return getFlag(IsShadowRootFlag) ? 0 : parent();
inline void Node::setParentOrHostNode(ContainerNode* parent)
inline ContainerNode* Node::parentOrHostNode() const
return parent();
inline ContainerNode* Node::parentNodeGuaranteedHostFree() const
return parentOrHostNode();
inline void Node::reattach()
if (attached())
inline void Node::reattachIfAttached()
if (attached())
inline void Node::lazyReattach(ShouldSetAttached shouldSetAttached)
if (attached())
} //namespace
#ifndef NDEBUG
// Outside the WebCore namespace for ease of invocation from gdb.
void showTree(const WebCore::Node*);
void showNodePath(const WebCore::Node*);
Jump to Line
Something went wrong with that request. Please try again.