The Tor Browser: comparison content/base/public/nsINode.h

--1:000000000000
+:f8b9c6ca9427
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#ifndef nsINode_h___
+#define nsINode_h___
+#include "mozilla/Likely.h"
+#include "nsCOMPtr.h"               // for member, local
+#include "nsGkAtoms.h"              // for nsGkAtoms::baseURIProperty
+#include "nsIDOMNode.h"
+#include "nsINodeInfo.h"            // member (in nsCOMPtr)
+#include "nsIVariant.h"             // for use in GetUserData()
+#include "nsNodeInfoManager.h"      // for use in NodePrincipal()
+#include "nsPropertyTable.h"        // for typedefs
+#include "nsTObserverArray.h"       // for member
+#include "mozilla/ErrorResult.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/dom/EventTarget.h" // for base class
+#include "js/TypeDecls.h"     // for Handle, Value, JSObject, JSContext
+#include "mozilla/dom/DOMString.h"
+#include "mozilla/dom/BindingDeclarations.h"
+// Including 'windows.h' will #define GetClassInfo to something else.
+#ifdef XP_WIN
+#ifdef GetClassInfo
+#undef GetClassInfo
+#endif
+#endif
+class nsAttrAndChildArray;
+class nsChildContentList;
+class nsCSSSelectorList;
+class nsDOMAttributeMap;
+class nsIContent;
+class nsIDocument;
+class nsIDOMElement;
+class nsIDOMNodeList;
+class nsIDOMUserDataHandler;
+class nsIEditor;
+class nsIFrame;
+class nsIMutationObserver;
+class nsINodeList;
+class nsIPresShell;
+class nsIPrincipal;
+class nsIURI;
+class nsNodeSupportsWeakRefTearoff;
+class nsNodeWeakReference;
+class nsXPCClassInfo;
+class nsDOMMutationObserver;
+namespace mozilla {
+class EventListenerManager;
+namespace dom {
+/**
+* @return true if aChar is what the DOM spec defines as 'space character'.
+* http://dom.spec.whatwg.org/#space-character
+*/
+inline bool IsSpaceCharacter(char16_t aChar) {
+return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||
+aChar == '\f';
+}
+inline bool IsSpaceCharacter(char aChar) {
+return aChar == ' ' || aChar == '\t' || aChar == '\n' || aChar == '\r' ||
+aChar == '\f';
+}
+struct BoxQuadOptions;
+struct ConvertCoordinateOptions;
+class DOMPoint;
+class DOMQuad;
+class DOMRectReadOnly;
+class Element;
+class EventHandlerNonNull;
+class OnErrorEventHandlerNonNull;
+template<typename T> class Optional;
+class TextOrElementOrDocument;
+struct DOMPointInit;
+} // namespace dom
+} // namespace mozilla
+#define NODE_FLAG_BIT(n_) (1U << (WRAPPER_CACHE_FLAGS_BITS_USED + (n_)))
+enum {
+// This bit will be set if the node has a listener manager.
+NODE_HAS_LISTENERMANAGER =              NODE_FLAG_BIT(0),
+// Whether this node has had any properties set on it
+NODE_HAS_PROPERTIES =                   NODE_FLAG_BIT(1),
+// Whether this node is the root of an anonymous subtree.  Note that this
+// need not be a native anonymous subtree.  Any anonymous subtree, including
+// XBL-generated ones, will do.  This flag is set-once: once a node has it,
+// it must not be removed.
+// NOTE: Should only be used on nsIContent nodes
+NODE_IS_ANONYMOUS_ROOT =                NODE_FLAG_BIT(2),
+// Whether the node has some ancestor, possibly itself, that is native
+// anonymous.  This includes ancestors crossing XBL scopes, in cases when an
+// XBL binding is attached to an element which has a native anonymous
+// ancestor.  This flag is set-once: once a node has it, it must not be
+// removed.
+// NOTE: Should only be used on nsIContent nodes
+NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE =          NODE_FLAG_BIT(3),
+// Whether this node is the root of a native anonymous (from the perspective
+// of its parent) subtree.  This flag is set-once: once a node has it, it
+// must not be removed.
+// NOTE: Should only be used on nsIContent nodes
+NODE_IS_NATIVE_ANONYMOUS_ROOT =         NODE_FLAG_BIT(4),
+// Forces the XBL code to treat this node as if it were
+// in the document and therefore should get bindings attached.
+NODE_FORCE_XBL_BINDINGS =               NODE_FLAG_BIT(5),
+// Whether a binding manager may have a pointer to this
+NODE_MAY_BE_IN_BINDING_MNGR =           NODE_FLAG_BIT(6),
+NODE_IS_EDITABLE =                      NODE_FLAG_BIT(7),
+// For all Element nodes, NODE_MAY_HAVE_CLASS is guaranteed to be set if the
+// node in fact has a class, but may be set even if it doesn't.
+NODE_MAY_HAVE_CLASS =                   NODE_FLAG_BIT(8),
+// Whether the node participates in a shadow tree.
+NODE_IS_IN_SHADOW_TREE =                NODE_FLAG_BIT(9),
+// Node has an :empty or :-moz-only-whitespace selector
+NODE_HAS_EMPTY_SELECTOR =               NODE_FLAG_BIT(10),
+// A child of the node has a selector such that any insertion,
+// removal, or appending of children requires restyling the parent.
+NODE_HAS_SLOW_SELECTOR =                NODE_FLAG_BIT(11),
+// A child of the node has a :first-child, :-moz-first-node,
+// :only-child, :last-child or :-moz-last-node selector.
+NODE_HAS_EDGE_CHILD_SELECTOR =          NODE_FLAG_BIT(12),
+// A child of the node has a selector such that any insertion or
+// removal of children requires restyling later siblings of that
+// element.  Additionally (in this manner it is stronger than
+// NODE_HAS_SLOW_SELECTOR), if a child's style changes due to any
+// other content tree changes (e.g., the child changes to or from
+// matching :empty due to a grandchild insertion or removal), the
+// child's later siblings must also be restyled.
+NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS = NODE_FLAG_BIT(13),
+NODE_ALL_SELECTOR_FLAGS =               NODE_HAS_EMPTY_SELECTOR |
+NODE_HAS_SLOW_SELECTOR |
+NODE_HAS_EDGE_CHILD_SELECTOR |
+NODE_HAS_SLOW_SELECTOR_LATER_SIBLINGS,
+NODE_ATTACH_BINDING_ON_POSTCREATE =     NODE_FLAG_BIT(14),
+// This node needs to go through frame construction to get a frame (or
+// undisplayed entry).
+NODE_NEEDS_FRAME =                      NODE_FLAG_BIT(15),
+// At least one descendant in the flattened tree has NODE_NEEDS_FRAME set.
+// This should be set on every node on the flattened tree path between the
+// node(s) with NODE_NEEDS_FRAME and the root content.
+NODE_DESCENDANTS_NEED_FRAMES =          NODE_FLAG_BIT(16),
+// Set if the node has the accesskey attribute set.
+NODE_HAS_ACCESSKEY =                    NODE_FLAG_BIT(17),
+// Set if the node has right-to-left directionality
+NODE_HAS_DIRECTION_RTL =                NODE_FLAG_BIT(18),
+// Set if the node has left-to-right directionality
+NODE_HAS_DIRECTION_LTR =                NODE_FLAG_BIT(19),
+NODE_ALL_DIRECTION_FLAGS =              NODE_HAS_DIRECTION_LTR |
+NODE_HAS_DIRECTION_RTL,
+NODE_CHROME_ONLY_ACCESS =               NODE_FLAG_BIT(20),
+NODE_IS_ROOT_OF_CHROME_ONLY_ACCESS =    NODE_FLAG_BIT(21),
+// Remaining bits are node type specific.
+NODE_TYPE_SPECIFIC_BITS_OFFSET =        22
+};
+// Make sure we have space for our bits
+#define ASSERT_NODE_FLAGS_SPACE(n) \
+static_assert(WRAPPER_CACHE_FLAGS_BITS_USED + (n) <= 32, \
+"Not enough space for our bits")
+ASSERT_NODE_FLAGS_SPACE(NODE_TYPE_SPECIFIC_BITS_OFFSET);
+/**
+* Class used to detect unexpected mutations. To use the class create an
+* nsMutationGuard on the stack before unexpected mutations could occur.
+* You can then at any time call Mutated to check if any unexpected mutations
+* have occurred.
+*
+* When a guard is instantiated sMutationCount is set to 300. It is then
+* decremented by every mutation (capped at 0). This means that we can only
+* detect 300 mutations during the lifetime of a single guard, however that
+* should be more then we ever care about as we usually only care if more then
+* one mutation has occurred.
+*
+* When the guard goes out of scope it will adjust sMutationCount so that over
+* the lifetime of the guard the guard itself has not affected sMutationCount,
+* while mutations that happened while the guard was alive still will. This
+* allows a guard to be instantiated even if there is another guard higher up
+* on the callstack watching for mutations.
+*
+* The only thing that has to be avoided is for an outer guard to be used
+* while an inner guard is alive. This can be avoided by only ever
+* instantiating a single guard per scope and only using the guard in the
+* current scope.
+*/
+class nsMutationGuard {
+public:
+nsMutationGuard()
+{
+mDelta = eMaxMutations - sMutationCount;
+sMutationCount = eMaxMutations;
+}
+~nsMutationGuard()
+{
+sMutationCount =
+mDelta > sMutationCount ? 0 : sMutationCount - mDelta;
+}
+/**
+* Returns true if any unexpected mutations have occurred. You can pass in
+* an 8-bit ignore count to ignore a number of expected mutations.
+*/
+bool Mutated(uint8_t aIgnoreCount)
+{
+return sMutationCount < static_cast<uint32_t>(eMaxMutations - aIgnoreCount);
+}
+// This function should be called whenever a mutation that we want to keep
+// track of happen. For now this is only done when children are added or
+// removed, but we might do it for attribute changes too in the future.
+static void DidMutate()
+{
+if (sMutationCount) {
+--sMutationCount;
+}
+}
+private:
+// mDelta is the amount sMutationCount was adjusted when the guard was
+// initialized. It is needed so that we can undo that adjustment once
+// the guard dies.
+uint32_t mDelta;
+// The value 300 is not important, as long as it is bigger then anything
+// ever passed to Mutated().
+enum { eMaxMutations = 300 };
+// sMutationCount is a global mutation counter which is decreased by one at
+// every mutation. It is capped at 0 to avoid wrapping.
+// Its value is always between 0 and 300, inclusive.
+static uint32_t sMutationCount;
+};
+// This should be used for any nsINode sub-class that has fields of its own
+// that it needs to measure;  any sub-class that doesn't use it will inherit
+// SizeOfExcludingThis from its super-class.  SizeOfIncludingThis() need not be
+// defined, it is inherited from nsINode.
+// This macro isn't actually specific to nodes, and bug 956400 will move it into MFBT.
+#define NS_DECL_SIZEOF_EXCLUDING_THIS \
+virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+// Categories of node properties
+// 0 is global.
+#define DOM_USER_DATA         1
+#define DOM_USER_DATA_HANDLER 2
+#define SMIL_MAPPED_ATTR_ANIMVAL 3
+// IID for the nsINode interface
+#define NS_INODE_IID \
+{ 0x77a62cd0, 0xb34f, 0x42cb, \
+{ 0x94, 0x52, 0xae, 0xb2, 0x4d, 0x93, 0x2c, 0xb4 } }
+/**
+* An internal interface that abstracts some DOMNode-related parts that both
+* nsIContent and nsIDocument share.  An instance of this interface has a list
+* of nsIContent children and provides access to them.
+*/
+class nsINode : public mozilla::dom::EventTarget
+{
+public:
+typedef mozilla::dom::BoxQuadOptions BoxQuadOptions;
+typedef mozilla::dom::ConvertCoordinateOptions ConvertCoordinateOptions;
+typedef mozilla::dom::DOMPoint DOMPoint;
+typedef mozilla::dom::DOMPointInit DOMPointInit;
+typedef mozilla::dom::DOMQuad DOMQuad;
+typedef mozilla::dom::DOMRectReadOnly DOMRectReadOnly;
+typedef mozilla::dom::TextOrElementOrDocument TextOrElementOrDocument;
+typedef mozilla::ErrorResult ErrorResult;
+NS_DECLARE_STATIC_IID_ACCESSOR(NS_INODE_IID)
+// Among the sub-classes that inherit (directly or indirectly) from nsINode,
+// measurement of the following members may be added later if DMD finds it is
+// worthwhile:
+// - nsGenericHTMLElement:  mForm, mFieldSet
+// - nsGenericHTMLFrameElement: mFrameLoader (bug 672539)
+// - HTMLBodyElement:       mContentStyleRule
+// - HTMLDataListElement:   mOptions
+// - HTMLFieldSetElement:   mElements, mDependentElements, mFirstLegend
+// - HTMLFormElement:       many!
+// - HTMLFrameSetElement:   mRowSpecs, mColSpecs
+// - HTMLInputElement:      mInputData, mFiles, mFileList, mStaticDocfileList
+// - nsHTMLMapElement:      mAreas
+// - HTMLMediaElement:      many!
+// - nsHTMLOutputElement:   mDefaultValue, mTokenList
+// - nsHTMLRowElement:      mCells
+// - nsHTMLSelectElement:   mOptions, mRestoreState
+// - nsHTMLTableElement:    mTBodies, mRows, mTableInheritedAttributes
+// - nsHTMLTableSectionElement: mRows
+// - nsHTMLTextAreaElement: mControllers, mState
+//
+// The following members don't need to be measured:
+// - nsIContent: mPrimaryFrame, because it's non-owning and measured elsewhere
+//
+NS_DECL_SIZEOF_EXCLUDING_THIS
+// SizeOfIncludingThis doesn't need to be overridden by sub-classes because
+// sub-classes of nsINode are guaranteed to be laid out in memory in such a
+// way that |this| points to the start of the allocated object, even in
+// methods of nsINode's sub-classes, and so |aMallocSizeOf(this)| is always
+// safe to call no matter which object it was invoked on.
+virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
+return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+}
+friend class nsNodeUtils;
+friend class nsNodeWeakReference;
+friend class nsNodeSupportsWeakRefTearoff;
+friend class nsAttrAndChildArray;
+#ifdef MOZILLA_INTERNAL_API
+nsINode(already_AddRefed<nsINodeInfo>& aNodeInfo)
+: mNodeInfo(aNodeInfo),
+mParent(nullptr),
+mBoolFlags(0),
+mNextSibling(nullptr),
+mPreviousSibling(nullptr),
+mFirstChild(nullptr),
+mSubtreeRoot(MOZ_THIS_IN_INITIALIZER_LIST()),
+mSlots(nullptr)
+{
+SetIsDOMBinding();
+}
+#endif
+virtual ~nsINode();
+/**
+* Bit-flags to pass (or'ed together) to IsNodeOfType()
+*/
+enum {
+/** nsIContent nodes */
+eCONTENT             = 1 << 0,
+/** nsIDocument nodes */
+eDOCUMENT            = 1 << 1,
+/** nsIAttribute nodes */
+eATTRIBUTE           = 1 << 2,
+/** text nodes */
+eTEXT                = 1 << 3,
+/** xml processing instructions */
+ePROCESSING_INSTRUCTION = 1 << 4,
+/** comment nodes */
+eCOMMENT             = 1 << 5,
+/** form control elements */
+eHTML_FORM_CONTROL   = 1 << 6,
+/** document fragments */
+eDOCUMENT_FRAGMENT   = 1 << 7,
+/** data nodes (comments, PIs, text). Nodes of this type always
+returns a non-null value for nsIContent::GetText() */
+eDATA_NODE           = 1 << 8,
+/** HTMLMediaElement */
+eMEDIA               = 1 << 9,
+/** animation elements */
+eANIMATION           = 1 << 10,
+/** filter elements that implement SVGFilterPrimitiveStandardAttributes */
+eFILTER              = 1 << 11
+};
+/**
+* API for doing a quick check if a content is of a given
+* type, such as Text, Document, Comment ...  Use this when you can instead of
+* checking the tag.
+*
+* @param aFlags what types you want to test for (see above)
+* @return whether the content matches ALL flags passed in
+*/
+virtual bool IsNodeOfType(uint32_t aFlags) const = 0;
+virtual JSObject* WrapObject(JSContext *aCx) MOZ_OVERRIDE;
+protected:
+/**
+* WrapNode is called from WrapObject to actually wrap this node, WrapObject
+* does some additional checks and fix-up that's common to all nodes. WrapNode
+* should just call the DOM binding's Wrap function.
+*/
+virtual JSObject* WrapNode(JSContext *aCx)
+{
+MOZ_ASSERT(!IsDOMBinding(), "Someone forgot to override WrapNode");
+return nullptr;
+}
+// Subclasses that wish to override the parent behavior should return the
+// result of GetParentObjectIntenral, which handles the XBL scope stuff.
+//
+mozilla::dom::ParentObject GetParentObjectInternal(nsINode* aNativeParent) const {
+mozilla::dom::ParentObject p(aNativeParent);
+// Note that mUseXBLScope is a no-op for chrome, and other places where we
+// don't use XBL scopes.
+p.mUseXBLScope = IsInAnonymousSubtree() && !IsAnonymousContentInSVGUseSubtree();
+return p;
+}
+public:
+mozilla::dom::ParentObject GetParentObject() const; // Implemented in nsIDocument.h
+/**
+* Return whether the node is an Element node
+*/
+bool IsElement() const {
+return GetBoolFlag(NodeIsElement);
+}
+/**
+* Return this node as an Element.  Should only be used for nodes
+* for which IsElement() is true.  This is defined inline in Element.h.
+*/
+mozilla::dom::Element* AsElement();
+const mozilla::dom::Element* AsElement() const;
+/**
+* Return this node as nsIContent.  Should only be used for nodes for which
+* IsContent() is true.  This is defined inline in nsIContent.h.
+*/
+nsIContent* AsContent();
+const nsIContent* AsContent() const
+{
+return const_cast<nsINode*>(this)->AsContent();
+}
+virtual nsIDOMNode* AsDOMNode() = 0;
+/**
+* Return if this node has any children.
+*/
+bool HasChildren() const { return !!mFirstChild; }
+/**
+* Get the number of children
+* @return the number of children
+*/
+virtual uint32_t GetChildCount() const = 0;
+/**
+* Get a child by index
+* @param aIndex the index of the child to get
+* @return the child, or null if index out of bounds
+*/
+virtual nsIContent* GetChildAt(uint32_t aIndex) const = 0;
+/**
+* Get a raw pointer to the child array.  This should only be used if you
+* plan to walk a bunch of the kids, promise to make sure that nothing ever
+* mutates (no attribute changes, not DOM tree changes, no script execution,
+* NOTHING), and will never ever peform an out-of-bounds access here.  This
+* method may return null if there are no children, or it may return a
+* garbage pointer.  In all cases the out param will be set to the number of
+* children.
+*/
+virtual nsIContent * const * GetChildArray(uint32_t* aChildCount) const = 0;
+/**
+* Get the index of a child within this content
+* @param aPossibleChild the child to get the index of.
+* @return the index of the child, or -1 if not a child
+*
+* If the return value is not -1, then calling GetChildAt() with that value
+* will return aPossibleChild.
+*/
+virtual int32_t IndexOf(const nsINode* aPossibleChild) const = 0;
+/**
+* Return the "owner document" of this node.  Note that this is not the same
+* as the DOM ownerDocument -- that's null for Document nodes, whereas for a
+* nsIDocument GetOwnerDocument returns the document itself.  For nsIContent
+* implementations the two are the same.
+*/
+nsIDocument *OwnerDoc() const
+{
+return mNodeInfo->GetDocument();
+}
+/**
+* Return the "owner document" of this node as an nsINode*.  Implemented
+* in nsIDocument.h.
+*/
+nsINode *OwnerDocAsNode() const;
+/**
+* Returns true if the content has an ancestor that is a document.
+*
+* @return whether this content is in a document tree
+*/
+bool IsInDoc() const
+{
+return GetBoolFlag(IsInDocument);
+}
+/**
+* Get the document that this content is currently in, if any. This will be
+* null if the content has no ancestor that is a document.
+*
+* @return the current document
+*/
+nsIDocument *GetCurrentDoc() const
+{
+return IsInDoc() ? OwnerDoc() : nullptr;
+}
+/**
+* The values returned by this function are the ones defined for
+* nsIDOMNode.nodeType
+*/
+uint16_t NodeType() const
+{
+return mNodeInfo->NodeType();
+}
+const nsString& NodeName() const
+{
+return mNodeInfo->NodeName();
+}
+const nsString& LocalName() const
+{
+return mNodeInfo->LocalName();
+}
+/**
+* Get the tag for this element. This will always return a non-null atom
+* pointer (as implied by the naming of the method).  For elements this is
+* the non-namespaced tag, and for other nodes it's something like "#text",
+* "#comment", "#document", etc.
+*/
+nsIAtom* Tag() const
+{
+return mNodeInfo->NameAtom();
+}
+/**
+* Insert a content node at a particular index.  This method handles calling
+* BindToTree on the child appropriately.
+*
+* @param aKid the content to insert
+* @param aIndex the index it is being inserted at (the index it will have
+*        after it is inserted)
+* @param aNotify whether to notify the document (current document for
+*        nsIContent, and |this| for nsIDocument) that the insert has
+*        occurred
+*
+* @throws NS_ERROR_DOM_HIERARCHY_REQUEST_ERR if one attempts to have more
+* than one element node as a child of a document.  Doing this will also
+* assert -- you shouldn't be doing it!  Check with
+* nsIDocument::GetRootElement() first if you're not sure.  Apart from this
+* one constraint, this doesn't do any checking on whether aKid is a valid
+* child of |this|.
+*
+* @throws NS_ERROR_OUT_OF_MEMORY in some cases (from BindToTree).
+*/
+virtual nsresult InsertChildAt(nsIContent* aKid, uint32_t aIndex,
+bool aNotify) = 0;
+/**
+* Append a content node to the end of the child list.  This method handles
+* calling BindToTree on the child appropriately.
+*
+* @param aKid the content to append
+* @param aNotify whether to notify the document (current document for
+*        nsIContent, and |this| for nsIDocument) that the append has
+*        occurred
+*
+* @throws NS_ERROR_DOM_HIERARCHY_REQUEST_ERR if one attempts to have more
+* than one element node as a child of a document.  Doing this will also
+* assert -- you shouldn't be doing it!  Check with
+* nsIDocument::GetRootElement() first if you're not sure.  Apart from this
+* one constraint, this doesn't do any checking on whether aKid is a valid
+* child of |this|.
+*
+* @throws NS_ERROR_OUT_OF_MEMORY in some cases (from BindToTree).
+*/
+nsresult AppendChildTo(nsIContent* aKid, bool aNotify)
+{
+return InsertChildAt(aKid, GetChildCount(), aNotify);
+}
+/**
+* Remove a child from this node.  This method handles calling UnbindFromTree
+* on the child appropriately.
+*
+* @param aIndex the index of the child to remove
+* @param aNotify whether to notify the document (current document for
+*        nsIContent, and |this| for nsIDocument) that the remove has
+*        occurred
+*
+* Note: If there is no child at aIndex, this method will simply do nothing.
+*/
+virtual void RemoveChildAt(uint32_t aIndex, bool aNotify) = 0;
+/**
+* Get a property associated with this node.
+*
+* @param aPropertyName  name of property to get.
+* @param aStatus        out parameter for storing resulting status.
+*                       Set to NS_PROPTABLE_PROP_NOT_THERE if the property
+*                       is not set.
+* @return               the property. Null if the property is not set
+*                       (though a null return value does not imply the
+*                       property was not set, i.e. it can be set to null).
+*/
+void* GetProperty(nsIAtom *aPropertyName,
+nsresult *aStatus = nullptr) const
+{
+return GetProperty(0, aPropertyName, aStatus);
+}
+/**
+* Get a property associated with this node.
+*
+* @param aCategory      category of property to get.
+* @param aPropertyName  name of property to get.
+* @param aStatus        out parameter for storing resulting status.
+*                       Set to NS_PROPTABLE_PROP_NOT_THERE if the property
+*                       is not set.
+* @return               the property. Null if the property is not set
+*                       (though a null return value does not imply the
+*                       property was not set, i.e. it can be set to null).
+*/
+virtual void* GetProperty(uint16_t aCategory,
+nsIAtom *aPropertyName,
+nsresult *aStatus = nullptr) const;
+/**
+* Set a property to be associated with this node. This will overwrite an
+* existing value if one exists. The existing value is destroyed using the
+* destructor function given when that value was set.
+*
+* @param aPropertyName  name of property to set.
+* @param aValue         new value of property.
+* @param aDtor          destructor function to be used when this property
+*                       is destroyed.
+* @param aTransfer      if true the property will not be deleted when the
+*                       ownerDocument of the node changes, if false it
+*                       will be deleted.
+*
+* @return NS_PROPTABLE_PROP_OVERWRITTEN (success value) if the property
+*                                       was already set
+* @throws NS_ERROR_OUT_OF_MEMORY if that occurs
+*/
+nsresult SetProperty(nsIAtom *aPropertyName,
+void *aValue,
+NSPropertyDtorFunc aDtor = nullptr,
+bool aTransfer = false)
+{
+return SetProperty(0, aPropertyName, aValue, aDtor, aTransfer);
+}
+/**
+* Set a property to be associated with this node. This will overwrite an
+* existing value if one exists. The existing value is destroyed using the
+* destructor function given when that value was set.
+*
+* @param aCategory       category of property to set.
+* @param aPropertyName   name of property to set.
+* @param aValue          new value of property.
+* @param aDtor           destructor function to be used when this property
+*                        is destroyed.
+* @param aTransfer       if true the property will not be deleted when the
+*                        ownerDocument of the node changes, if false it
+*                        will be deleted.
+* @param aOldValue [out] previous value of property.
+*
+* @return NS_PROPTABLE_PROP_OVERWRITTEN (success value) if the property
+*                                       was already set
+* @throws NS_ERROR_OUT_OF_MEMORY if that occurs
+*/
+virtual nsresult SetProperty(uint16_t aCategory,
+nsIAtom *aPropertyName,
+void *aValue,
+NSPropertyDtorFunc aDtor = nullptr,
+bool aTransfer = false,
+void **aOldValue = nullptr);
+/**
+* A generic destructor for property values allocated with new.
+*/
+template<class T>
+static void DeleteProperty(void *, nsIAtom *, void *aPropertyValue, void *)
+{
+delete static_cast<T *>(aPropertyValue);
+}
+/**
+* Destroys a property associated with this node. The value is destroyed
+* using the destruction function given when that value was set.
+*
+* @param aPropertyName  name of property to destroy.
+*/
+void DeleteProperty(nsIAtom *aPropertyName)
+{
+DeleteProperty(0, aPropertyName);
+}
+/**
+* Destroys a property associated with this node. The value is destroyed
+* using the destruction function given when that value was set.
+*
+* @param aCategory      category of property to destroy.
+* @param aPropertyName  name of property to destroy.
+*/
+virtual void DeleteProperty(uint16_t aCategory, nsIAtom *aPropertyName);
+/**
+* Unset a property associated with this node. The value will not be
+* destroyed but rather returned. It is the caller's responsibility to
+* destroy the value after that point.
+*
+* @param aPropertyName  name of property to unset.
+* @param aStatus        out parameter for storing resulting status.
+*                       Set to NS_PROPTABLE_PROP_NOT_THERE if the property
+*                       is not set.
+* @return               the property. Null if the property is not set
+*                       (though a null return value does not imply the
+*                       property was not set, i.e. it can be set to null).
+*/
+void* UnsetProperty(nsIAtom  *aPropertyName,
+nsresult *aStatus = nullptr)
+{
+return UnsetProperty(0, aPropertyName, aStatus);
+}
+/**
+* Unset a property associated with this node. The value will not be
+* destroyed but rather returned. It is the caller's responsibility to
+* destroy the value after that point.
+*
+* @param aCategory      category of property to unset.
+* @param aPropertyName  name of property to unset.
+* @param aStatus        out parameter for storing resulting status.
+*                       Set to NS_PROPTABLE_PROP_NOT_THERE if the property
+*                       is not set.
+* @return               the property. Null if the property is not set
+*                       (though a null return value does not imply the
+*                       property was not set, i.e. it can be set to null).
+*/
+virtual void* UnsetProperty(uint16_t aCategory,
+nsIAtom *aPropertyName,
+nsresult *aStatus = nullptr);
+bool HasProperties() const
+{
+return HasFlag(NODE_HAS_PROPERTIES);
+}
+/**
+* Return the principal of this node.  This is guaranteed to never be a null
+* pointer.
+*/
+nsIPrincipal* NodePrincipal() const {
+return mNodeInfo->NodeInfoManager()->DocumentPrincipal();
+}
+/**
+* Get the parent nsIContent for this node.
+* @return the parent, or null if no parent or the parent is not an nsIContent
+*/
+nsIContent* GetParent() const {
+return MOZ_LIKELY(GetBoolFlag(ParentIsContent)) ?
+reinterpret_cast<nsIContent*>(mParent) : nullptr;
+}
+/**
+* Get the parent nsINode for this node. This can be either an nsIContent,
+* an nsIDocument or an nsIAttribute.
+* @return the parent node
+*/
+nsINode* GetParentNode() const
+{
+return mParent;
+}
+/**
+* Get the parent nsINode for this node if it is an Element.
+* @return the parent node
+*/
+mozilla::dom::Element* GetParentElement() const
+{
+return mParent && mParent->IsElement() ? mParent->AsElement() : nullptr;
+}
+/**
+* Get the root of the subtree this node belongs to.  This never returns
+* null.  It may return 'this' (e.g. for document nodes, and nodes that
+* are the roots of disconnected subtrees).
+*/
+nsINode* SubtreeRoot() const
+{
+// There are three cases of interest here.  nsINodes that are really:
+// 1. nsIDocument nodes - Are always in the document.
+// 2. nsIContent nodes - Are either in the document, or mSubtreeRoot
+//    is updated in BindToTree/UnbindFromTree.
+// 3. nsIAttribute nodes - Are never in the document, and mSubtreeRoot
+//    is always 'this' (as set in nsINode's ctor).
+nsINode* node = IsInDoc() ? OwnerDocAsNode() : mSubtreeRoot;
+NS_ASSERTION(node, "Should always have a node here!");
+#ifdef DEBUG
+{
+const nsINode* slowNode = this;
+const nsINode* iter = slowNode;
+while ((iter = iter->GetParentNode())) {
+slowNode = iter;
+}
+NS_ASSERTION(slowNode == node, "These should always be in sync!");
+}
+#endif
+return node;
+}
+/**
+* See nsIDOMEventTarget
+*/
+NS_DECL_NSIDOMEVENTTARGET
+virtual mozilla::EventListenerManager*
+GetExistingListenerManager() const MOZ_OVERRIDE;
+virtual mozilla::EventListenerManager*
+GetOrCreateListenerManager() MOZ_OVERRIDE;
+using mozilla::dom::EventTarget::RemoveEventListener;
+using nsIDOMEventTarget::AddEventListener;
+virtual void AddEventListener(const nsAString& aType,
+mozilla::dom::EventListener* aListener,
+bool aUseCapture,
+const mozilla::dom::Nullable<bool>& aWantsUntrusted,
+mozilla::ErrorResult& aRv) MOZ_OVERRIDE;
+using nsIDOMEventTarget::AddSystemEventListener;
+virtual nsIDOMWindow* GetOwnerGlobal() MOZ_OVERRIDE;
+/**
+* Adds a mutation observer to be notified when this node, or any of its
+* descendants, are modified. The node will hold a weak reference to the
+* observer, which means that it is the responsibility of the observer to
+* remove itself in case it dies before the node.  If an observer is added
+* while observers are being notified, it may also be notified.  In general,
+* adding observers while inside a notification is not a good idea.  An
+* observer that is already observing the node must not be added without
+* being removed first.
+*/
+void AddMutationObserver(nsIMutationObserver* aMutationObserver)
+{
+nsSlots* s = Slots();
+NS_ASSERTION(s->mMutationObservers.IndexOf(aMutationObserver) ==
+nsTArray<int>::NoIndex,
+"Observer already in the list");
+s->mMutationObservers.AppendElement(aMutationObserver);
+}
+/**
+* Same as above, but only adds the observer if its not observing
+* the node already.
+*/
+void AddMutationObserverUnlessExists(nsIMutationObserver* aMutationObserver)
+{
+nsSlots* s = Slots();
+s->mMutationObservers.AppendElementUnlessExists(aMutationObserver);
+}
+/**
+* Removes a mutation observer.
+*/
+void RemoveMutationObserver(nsIMutationObserver* aMutationObserver)
+{
+nsSlots* s = GetExistingSlots();
+if (s) {
+s->mMutationObservers.RemoveElement(aMutationObserver);
+}
+}
+/**
+* Clones this node. This needs to be overriden by all node classes. aNodeInfo
+* should be identical to this node's nodeInfo, except for the document which
+* may be different. When cloning an element, all attributes of the element
+* will be cloned. The children of the node will not be cloned.
+*
+* @param aNodeInfo the nodeinfo to use for the clone
+* @param aResult the clone
+*/
+virtual nsresult Clone(nsINodeInfo *aNodeInfo, nsINode **aResult) const = 0;
+// This class can be extended by subclasses that wish to store more
+// information in the slots.
+class nsSlots
+{
+public:
+nsSlots()
+: mChildNodes(nullptr),
+mWeakReference(nullptr)
+{
+}
+// If needed we could remove the vtable pointer this dtor causes by
+// putting a DestroySlots function on nsINode
+virtual ~nsSlots();
+void Traverse(nsCycleCollectionTraversalCallback &cb);
+void Unlink();
+/**
+* A list of mutation observers
+*/
+nsTObserverArray<nsIMutationObserver*> mMutationObservers;
+/**
+* An object implementing nsIDOMNodeList for this content (childNodes)
+* @see nsIDOMNodeList
+* @see nsGenericHTMLElement::GetChildNodes
+*
+* MSVC 7 doesn't like this as an nsRefPtr
+*/
+nsChildContentList* mChildNodes;
+/**
+* Weak reference to this node
+*/
+nsNodeWeakReference* mWeakReference;
+};
+/**
+* Functions for managing flags and slots
+*/
+#ifdef DEBUG
+nsSlots* DebugGetSlots()
+{
+return Slots();
+}
+#endif
+void SetFlags(uint32_t aFlagsToSet)
+{
+NS_ASSERTION(!(aFlagsToSet & (NODE_IS_ANONYMOUS_ROOT |
+NODE_IS_NATIVE_ANONYMOUS_ROOT |
+NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE |
+NODE_ATTACH_BINDING_ON_POSTCREATE |
+NODE_DESCENDANTS_NEED_FRAMES |
+NODE_NEEDS_FRAME |
+NODE_CHROME_ONLY_ACCESS)) ||
+IsNodeOfType(eCONTENT),
+"Flag only permitted on nsIContent nodes");
+nsWrapperCache::SetFlags(aFlagsToSet);
+}
+void UnsetFlags(uint32_t aFlagsToUnset)
+{
+NS_ASSERTION(!(aFlagsToUnset &
+(NODE_IS_ANONYMOUS_ROOT |
+NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE |
+NODE_IS_NATIVE_ANONYMOUS_ROOT)),
+"Trying to unset write-only flags");
+nsWrapperCache::UnsetFlags(aFlagsToUnset);
+}
+void SetEditableFlag(bool aEditable)
+{
+if (aEditable) {
+SetFlags(NODE_IS_EDITABLE);
+}
+else {
+UnsetFlags(NODE_IS_EDITABLE);
+}
+}
+bool IsEditable() const
+{
+#ifdef MOZILLA_INTERNAL_API
+return IsEditableInternal();
+#else
+return IsEditableExternal();
+#endif
+}
+/**
+* Returns true if |this| or any of its ancestors is native anonymous.
+*/
+bool IsInNativeAnonymousSubtree() const
+{
+#ifdef DEBUG
+if (HasFlag(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE)) {
+return true;
+}
+CheckNotNativeAnonymous();
+return false;
+#else
+return HasFlag(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE);
+#endif
+}
+bool IsInAnonymousSubtree() const;
+// Note: This asserts |IsInAnonymousSubtree()|.
+bool IsAnonymousContentInSVGUseSubtree() const;
+// True for native anonymous content and for XBL content if the binging
+// has chromeOnlyContent="true".
+bool ChromeOnlyAccess() const
+{
+return HasFlag(NODE_IS_IN_NATIVE_ANONYMOUS_SUBTREE | NODE_CHROME_ONLY_ACCESS);
+}
+/**
+* Returns true if |this| node is the common ancestor of the start/end
+* nodes of a Range in a Selection or a descendant of such a common ancestor.
+* This node is definitely not selected when |false| is returned, but it may
+* or may not be selected when |true| is returned.
+*/
+bool IsSelectionDescendant() const
+{
+return IsDescendantOfCommonAncestorForRangeInSelection() ||
+IsCommonAncestorForRangeInSelection();
+}
+/**
+* Get the root content of an editor. So, this node must be a descendant of
+* an editor. Note that this should be only used for getting input or textarea
+* editor's root content. This method doesn't support HTML editors.
+*/
+nsIContent* GetTextEditorRootContent(nsIEditor** aEditor = nullptr);
+/**
+* Get the nearest selection root, ie. the node that will be selected if the
+* user does "Select All" while the focus is in this node. Note that if this
+* node is not in an editor, the result comes from the nsFrameSelection that
+* is related to aPresShell, so the result might not be the ancestor of this
+* node. Be aware that if this node and the computed selection limiter are
+* not in same subtree, this returns the root content of the closeset subtree.
+*/
+nsIContent* GetSelectionRootContent(nsIPresShell* aPresShell);
+virtual nsINodeList* ChildNodes();
+nsIContent* GetFirstChild() const { return mFirstChild; }
+nsIContent* GetLastChild() const
+{
+uint32_t count;
+nsIContent* const* children = GetChildArray(&count);
+return count > 0 ? children[count - 1] : nullptr;
+}
+/**
+* Implementation is in nsIDocument.h, because it needs to cast from
+* nsIDocument* to nsINode*.
+*/
+nsIDocument* GetOwnerDocument() const;
+void Normalize();
+/**
+* Get the base URI for any relative URIs within this piece of
+* content. Generally, this is the document's base URI, but certain
+* content carries a local base for backward compatibility, and XML
+* supports setting a per-node base URI.
+*
+* @return the base URI
+*/
+virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const = 0;
+already_AddRefed<nsIURI> GetBaseURIObject() const;
+/**
+* Facility for explicitly setting a base URI on a node.
+*/
+nsresult SetExplicitBaseURI(nsIURI* aURI);
+/**
+* The explicit base URI, if set, otherwise null
+*/
+protected:
+nsIURI* GetExplicitBaseURI() const {
+if (HasExplicitBaseURI()) {
+return static_cast<nsIURI*>(GetProperty(nsGkAtoms::baseURIProperty));
+}
+return nullptr;
+}
+public:
+void GetTextContent(nsAString& aTextContent)
+{
+GetTextContentInternal(aTextContent);
+}
+void SetTextContent(const nsAString& aTextContent,
+mozilla::ErrorResult& aError)
+{
+SetTextContentInternal(aTextContent, aError);
+}
+mozilla::dom::Element* QuerySelector(const nsAString& aSelector,
+mozilla::ErrorResult& aResult);
+already_AddRefed<nsINodeList> QuerySelectorAll(const nsAString& aSelector,
+mozilla::ErrorResult& aResult);
+nsresult QuerySelector(const nsAString& aSelector, nsIDOMElement **aReturn);
+nsresult QuerySelectorAll(const nsAString& aSelector, nsIDOMNodeList **aReturn);
+protected:
+// nsIDocument overrides this with its own (faster) version.  This
+// should really only be called for elements and document fragments.
+mozilla::dom::Element* GetElementById(const nsAString& aId);
+public:
+/**
+* Associate an object aData to aKey on this node. If aData is null any
+* previously registered object and UserDataHandler associated to aKey on
+* this node will be removed.
+* Should only be used to implement the DOM Level 3 UserData API.
+*
+* @param aKey the key to associate the object to
+* @param aData the object to associate to aKey on this node (may be null)
+* @param aHandler the UserDataHandler to call when the node is
+*                 cloned/deleted/imported/renamed (may be null)
+* @param aResult [out] the previously registered object for aKey on this
+*                      node, if any
+* @return whether adding the object and UserDataHandler succeeded
+*/
+nsresult SetUserData(const nsAString& aKey, nsIVariant* aData,
+nsIDOMUserDataHandler* aHandler, nsIVariant** aResult);
+/**
+* Get the UserData object registered for a Key on this node, if any.
+* Should only be used to implement the DOM Level 3 UserData API.
+*
+* @param aKey the key to get UserData for
+* @return aResult the previously registered object for aKey on this node, if
+*                 any
+*/
+nsIVariant* GetUserData(const nsAString& aKey);
+nsresult GetUserData(const nsAString& aKey, nsIVariant** aResult)
+{
+NS_IF_ADDREF(*aResult = GetUserData(aKey));
+return NS_OK;
+}
+void LookupPrefix(const nsAString& aNamespace, nsAString& aResult);
+bool IsDefaultNamespace(const nsAString& aNamespaceURI)
+{
+nsAutoString defaultNamespace;
+LookupNamespaceURI(EmptyString(), defaultNamespace);
+return aNamespaceURI.Equals(defaultNamespace);
+}
+void LookupNamespaceURI(const nsAString& aNamespacePrefix,
+nsAString& aNamespaceURI);
+nsresult IsEqualNode(nsIDOMNode* aOther, bool* aReturn);
+nsIContent* GetNextSibling() const { return mNextSibling; }
+nsIContent* GetPreviousSibling() const { return mPreviousSibling; }
+/**
+* Get the next node in the pre-order tree traversal of the DOM.  If
+* aRoot is non-null, then it must be an ancestor of |this|
+* (possibly equal to |this|) and only nodes that are descendants of
+* aRoot, not including aRoot itself, will be returned.  Returns
+* null if there are no more nodes to traverse.
+*/
+nsIContent* GetNextNode(const nsINode* aRoot = nullptr) const
+{
+return GetNextNodeImpl(aRoot, false);
+}
+/**
+* Get the next node in the pre-order tree traversal of the DOM but ignoring
+* the children of this node.  If aRoot is non-null, then it must be an
+* ancestor of |this| (possibly equal to |this|) and only nodes that are
+* descendants of aRoot, not including aRoot itself, will be returned.
+* Returns null if there are no more nodes to traverse.
+*/
+nsIContent* GetNextNonChildNode(const nsINode* aRoot = nullptr) const
+{
+return GetNextNodeImpl(aRoot, true);
+}
+/**
+* Returns true if 'this' is either document or element or
+* document fragment and aOther is a descendant in the same
+* anonymous tree.
+*/
+bool Contains(const nsINode* aOther) const;
+nsresult Contains(nsIDOMNode* aOther, bool* aReturn);
+bool UnoptimizableCCNode() const;
+private:
+nsIContent* GetNextNodeImpl(const nsINode* aRoot,
+const bool aSkipChildren) const
+{
+// Can't use nsContentUtils::ContentIsDescendantOf here, since we
+// can't include it here.
+#ifdef DEBUG
+if (aRoot) {
+const nsINode* cur = this;
+for (; cur; cur = cur->GetParentNode())
+if (cur == aRoot) break;
+NS_ASSERTION(cur, "aRoot not an ancestor of |this|?");
+}
+#endif
+if (!aSkipChildren) {
+nsIContent* kid = GetFirstChild();
+if (kid) {
+return kid;
+}
+}
+if (this == aRoot) {
+return nullptr;
+}
+const nsINode* cur = this;
+while (1) {
+nsIContent* next = cur->GetNextSibling();
+if (next) {
+return next;
+}
+nsINode* parent = cur->GetParentNode();
+if (parent == aRoot) {
+return nullptr;
+}
+cur = parent;
+}
+NS_NOTREACHED("How did we get here?");
+}
+public:
+/**
+* Get the previous nsIContent in the pre-order tree traversal of the DOM.  If
+* aRoot is non-null, then it must be an ancestor of |this|
+* (possibly equal to |this|) and only nsIContents that are descendants of
+* aRoot, including aRoot itself, will be returned.  Returns
+* null if there are no more nsIContents to traverse.
+*/
+nsIContent* GetPreviousContent(const nsINode* aRoot = nullptr) const
+{
+// Can't use nsContentUtils::ContentIsDescendantOf here, since we
+// can't include it here.
+#ifdef DEBUG
+if (aRoot) {
+const nsINode* cur = this;
+for (; cur; cur = cur->GetParentNode())
+if (cur == aRoot) break;
+NS_ASSERTION(cur, "aRoot not an ancestor of |this|?");
+}
+#endif
+if (this == aRoot) {
+return nullptr;
+}
+nsIContent* cur = this->GetParent();
+nsIContent* iter = this->GetPreviousSibling();
+while (iter) {
+cur = iter;
+iter = reinterpret_cast<nsINode*>(iter)->GetLastChild();
+}
+return cur;
+}
+/**
+* Boolean flags
+*/
+private:
+enum BooleanFlag {
+// Set if we're being used from -moz-element
+NodeHasRenderingObservers,
+// Set if our parent chain (including this node itself) terminates
+// in a document
+IsInDocument,
+// Set if mParent is an nsIContent
+ParentIsContent,
+// Set if this node is an Element
+NodeIsElement,
+// Set if the element has a non-empty id attribute. This can in rare
+// cases lie for nsXMLElement, such as when the node has been moved between
+// documents with different id mappings.
+ElementHasID,
+// Set if the element might have inline style.
+ElementMayHaveStyle,
+// Set if the element has a name attribute set.
+ElementHasName,
+// Set if the element might have a contenteditable attribute set.
+ElementMayHaveContentEditableAttr,
+// Set if the node is the common ancestor of the start/end nodes of a Range
+// that is in a Selection.
+NodeIsCommonAncestorForRangeInSelection,
+// Set if the node is a descendant of a node with the above bit set.
+NodeIsDescendantOfCommonAncestorForRangeInSelection,
+// Set if CanSkipInCC check has been done for this subtree root.
+NodeIsCCMarkedRoot,
+// Maybe set if this node is in black subtree.
+NodeIsCCBlackTree,
+// Maybe set if the node is a root of a subtree
+// which needs to be kept in the purple buffer.
+NodeIsPurpleRoot,
+// Set if the node has an explicit base URI stored
+NodeHasExplicitBaseURI,
+// Set if the element has some style states locked
+ElementHasLockedStyleStates,
+// Set if element has pointer locked
+ElementHasPointerLock,
+// Set if the node may have DOMMutationObserver attached to it.
+NodeMayHaveDOMMutationObserver,
+// Set if node is Content
+NodeIsContent,
+// Set if the node has animations or transitions
+ElementHasAnimations,
+// Set if node has a dir attribute with a valid value (ltr, rtl, or auto)
+NodeHasValidDirAttribute,
+// Set if node has a dir attribute with a fixed value (ltr or rtl, NOT auto)
+NodeHasFixedDir,
+// Set if the node has dir=auto and has a property pointing to the text
+// node that determines its direction
+NodeHasDirAutoSet,
+// Set if the node is a text node descendant of a node with dir=auto
+// and has a TextNodeDirectionalityMap property listing the elements whose
+// direction it determines.
+NodeHasTextNodeDirectionalityMap,
+// Set if the node has dir=auto.
+NodeHasDirAuto,
+// Set if a node in the node's parent chain has dir=auto.
+NodeAncestorHasDirAuto,
+// Set if the element is in the scope of a scoped style sheet; this flag is
+// only accurate for elements bound to a document
+ElementIsInStyleScope,
+// Set if the element is a scoped style sheet root
+ElementIsScopedStyleRoot,
+// Set if the node is handling a click.
+NodeHandlingClick,
+// Set if the node has had :hover selectors matched against it
+NodeHasRelevantHoverRules,
+// Set if the element has a parser insertion mode other than "in body",
+// per the HTML5 "Parse state" section.
+ElementHasWeirdParserInsertionMode,
+// Guard value
+BooleanFlagCount
+};
+void SetBoolFlag(BooleanFlag name, bool value) {
+static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
+"Too many boolean flags");
+mBoolFlags = (mBoolFlags & ~(1 << name)) | (value << name);
+}
+void SetBoolFlag(BooleanFlag name) {
+static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
+"Too many boolean flags");
+mBoolFlags |= (1 << name);
+}
+void ClearBoolFlag(BooleanFlag name) {
+static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
+"Too many boolean flags");
+mBoolFlags &= ~(1 << name);
+}
+bool GetBoolFlag(BooleanFlag name) const {
+static_assert(BooleanFlagCount <= 8*sizeof(mBoolFlags),
+"Too many boolean flags");
+return mBoolFlags & (1 << name);
+}
+public:
+bool HasRenderingObservers() const
+{ return GetBoolFlag(NodeHasRenderingObservers); }
+void SetHasRenderingObservers(bool aValue)
+{ SetBoolFlag(NodeHasRenderingObservers, aValue); }
+bool IsContent() const { return GetBoolFlag(NodeIsContent); }
+bool HasID() const { return GetBoolFlag(ElementHasID); }
+bool MayHaveStyle() const { return GetBoolFlag(ElementMayHaveStyle); }
+bool HasName() const { return GetBoolFlag(ElementHasName); }
+bool MayHaveContentEditableAttr() const
+{ return GetBoolFlag(ElementMayHaveContentEditableAttr); }
+bool IsCommonAncestorForRangeInSelection() const
+{ return GetBoolFlag(NodeIsCommonAncestorForRangeInSelection); }
+void SetCommonAncestorForRangeInSelection()
+{ SetBoolFlag(NodeIsCommonAncestorForRangeInSelection); }
+void ClearCommonAncestorForRangeInSelection()
+{ ClearBoolFlag(NodeIsCommonAncestorForRangeInSelection); }
+bool IsDescendantOfCommonAncestorForRangeInSelection() const
+{ return GetBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection); }
+void SetDescendantOfCommonAncestorForRangeInSelection()
+{ SetBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection); }
+void ClearDescendantOfCommonAncestorForRangeInSelection()
+{ ClearBoolFlag(NodeIsDescendantOfCommonAncestorForRangeInSelection); }
+void SetCCMarkedRoot(bool aValue)
+{ SetBoolFlag(NodeIsCCMarkedRoot, aValue); }
+bool CCMarkedRoot() const { return GetBoolFlag(NodeIsCCMarkedRoot); }
+void SetInCCBlackTree(bool aValue)
+{ SetBoolFlag(NodeIsCCBlackTree, aValue); }
+bool InCCBlackTree() const { return GetBoolFlag(NodeIsCCBlackTree); }
+void SetIsPurpleRoot(bool aValue)
+{ SetBoolFlag(NodeIsPurpleRoot, aValue); }
+bool IsPurpleRoot() const { return GetBoolFlag(NodeIsPurpleRoot); }
+bool MayHaveDOMMutationObserver()
+{ return GetBoolFlag(NodeMayHaveDOMMutationObserver); }
+void SetMayHaveDOMMutationObserver()
+{ SetBoolFlag(NodeMayHaveDOMMutationObserver, true); }
+bool HasListenerManager() { return HasFlag(NODE_HAS_LISTENERMANAGER); }
+bool HasPointerLock() const { return GetBoolFlag(ElementHasPointerLock); }
+void SetPointerLock() { SetBoolFlag(ElementHasPointerLock); }
+void ClearPointerLock() { ClearBoolFlag(ElementHasPointerLock); }
+bool MayHaveAnimations() { return GetBoolFlag(ElementHasAnimations); }
+void SetMayHaveAnimations() { SetBoolFlag(ElementHasAnimations); }
+void SetHasValidDir() { SetBoolFlag(NodeHasValidDirAttribute); }
+void ClearHasValidDir() { ClearBoolFlag(NodeHasValidDirAttribute); }
+bool HasValidDir() const { return GetBoolFlag(NodeHasValidDirAttribute); }
+void SetHasFixedDir() {
+MOZ_ASSERT(NodeType() != nsIDOMNode::TEXT_NODE,
+"SetHasFixedDir on text node");
+SetBoolFlag(NodeHasFixedDir);
+}
+void ClearHasFixedDir() {
+MOZ_ASSERT(NodeType() != nsIDOMNode::TEXT_NODE,
+"ClearHasFixedDir on text node");
+ClearBoolFlag(NodeHasFixedDir);
+}
+bool HasFixedDir() const { return GetBoolFlag(NodeHasFixedDir); }
+void SetHasDirAutoSet() {
+MOZ_ASSERT(NodeType() != nsIDOMNode::TEXT_NODE,
+"SetHasDirAutoSet on text node");
+SetBoolFlag(NodeHasDirAutoSet);
+}
+void ClearHasDirAutoSet() {
+MOZ_ASSERT(NodeType() != nsIDOMNode::TEXT_NODE,
+"ClearHasDirAutoSet on text node");
+ClearBoolFlag(NodeHasDirAutoSet);
+}
+bool HasDirAutoSet() const
+{ return GetBoolFlag(NodeHasDirAutoSet); }
+void SetHasTextNodeDirectionalityMap() {
+MOZ_ASSERT(NodeType() == nsIDOMNode::TEXT_NODE,
+"SetHasTextNodeDirectionalityMap on non-text node");
+SetBoolFlag(NodeHasTextNodeDirectionalityMap);
+}
+void ClearHasTextNodeDirectionalityMap() {
+MOZ_ASSERT(NodeType() == nsIDOMNode::TEXT_NODE,
+"ClearHasTextNodeDirectionalityMap on non-text node");
+ClearBoolFlag(NodeHasTextNodeDirectionalityMap);
+}
+bool HasTextNodeDirectionalityMap() const
+{ return GetBoolFlag(NodeHasTextNodeDirectionalityMap); }
+void SetHasDirAuto() { SetBoolFlag(NodeHasDirAuto); }
+void ClearHasDirAuto() { ClearBoolFlag(NodeHasDirAuto); }
+bool HasDirAuto() const { return GetBoolFlag(NodeHasDirAuto); }
+void SetAncestorHasDirAuto() { SetBoolFlag(NodeAncestorHasDirAuto); }
+void ClearAncestorHasDirAuto() { ClearBoolFlag(NodeAncestorHasDirAuto); }
+bool AncestorHasDirAuto() const { return GetBoolFlag(NodeAncestorHasDirAuto); }
+bool NodeOrAncestorHasDirAuto() const
+{ return HasDirAuto() || AncestorHasDirAuto(); }
+void SetIsElementInStyleScope(bool aValue) {
+MOZ_ASSERT(IsElement(), "SetIsInStyleScope on a non-Element node");
+SetBoolFlag(ElementIsInStyleScope, aValue);
+}
+void SetIsElementInStyleScope() {
+MOZ_ASSERT(IsElement(), "SetIsInStyleScope on a non-Element node");
+SetBoolFlag(ElementIsInStyleScope);
+}
+void ClearIsElementInStyleScope() {
+MOZ_ASSERT(IsElement(), "ClearIsInStyleScope on a non-Element node");
+ClearBoolFlag(ElementIsInStyleScope);
+}
+bool IsElementInStyleScope() const { return GetBoolFlag(ElementIsInStyleScope); }
+void SetIsScopedStyleRoot() { SetBoolFlag(ElementIsScopedStyleRoot); }
+void ClearIsScopedStyleRoot() { ClearBoolFlag(ElementIsScopedStyleRoot); }
+bool IsScopedStyleRoot() { return GetBoolFlag(ElementIsScopedStyleRoot); }
+bool HasRelevantHoverRules() const { return GetBoolFlag(NodeHasRelevantHoverRules); }
+void SetHasRelevantHoverRules() { SetBoolFlag(NodeHasRelevantHoverRules); }
+protected:
+void SetParentIsContent(bool aValue) { SetBoolFlag(ParentIsContent, aValue); }
+void SetInDocument() { SetBoolFlag(IsInDocument); }
+void SetNodeIsContent() { SetBoolFlag(NodeIsContent); }
+void ClearInDocument() { ClearBoolFlag(IsInDocument); }
+void SetIsElement() { SetBoolFlag(NodeIsElement); }
+void SetHasID() { SetBoolFlag(ElementHasID); }
+void ClearHasID() { ClearBoolFlag(ElementHasID); }
+void SetMayHaveStyle() { SetBoolFlag(ElementMayHaveStyle); }
+void SetHasName() { SetBoolFlag(ElementHasName); }
+void ClearHasName() { ClearBoolFlag(ElementHasName); }
+void SetMayHaveContentEditableAttr()
+{ SetBoolFlag(ElementMayHaveContentEditableAttr); }
+bool HasExplicitBaseURI() const { return GetBoolFlag(NodeHasExplicitBaseURI); }
+void SetHasExplicitBaseURI() { SetBoolFlag(NodeHasExplicitBaseURI); }
+void SetHasLockedStyleStates() { SetBoolFlag(ElementHasLockedStyleStates); }
+void ClearHasLockedStyleStates() { ClearBoolFlag(ElementHasLockedStyleStates); }
+bool HasLockedStyleStates() const
+{ return GetBoolFlag(ElementHasLockedStyleStates); }
+void SetHasWeirdParserInsertionMode() { SetBoolFlag(ElementHasWeirdParserInsertionMode); }
+bool HasWeirdParserInsertionMode() const
+{ return GetBoolFlag(ElementHasWeirdParserInsertionMode); }
+bool HandlingClick() const { return GetBoolFlag(NodeHandlingClick); }
+void SetHandlingClick() { SetBoolFlag(NodeHandlingClick); }
+void ClearHandlingClick() { ClearBoolFlag(NodeHandlingClick); }
+void SetSubtreeRootPointer(nsINode* aSubtreeRoot)
+{
+NS_ASSERTION(aSubtreeRoot, "aSubtreeRoot can never be null!");
+NS_ASSERTION(!(IsNodeOfType(eCONTENT) && IsInDoc()), "Shouldn't be here!");
+mSubtreeRoot = aSubtreeRoot;
+}
+void ClearSubtreeRootPointer()
+{
+mSubtreeRoot = nullptr;
+}
+public:
+// Makes nsINode object to keep aObject alive.
+void BindObject(nsISupports* aObject);
+// After calling UnbindObject nsINode object doesn't keep
+// aObject alive anymore.
+void UnbindObject(nsISupports* aObject);
+void GetBoundMutationObservers(nsTArray<nsRefPtr<nsDOMMutationObserver> >& aResult);
+/**
+* Returns the length of this node, as specified at
+* <http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#concept-node-length>
+*/
+uint32_t Length() const;
+void GetNodeName(mozilla::dom::DOMString& aNodeName)
+{
+const nsString& nodeName = NodeName();
+aNodeName.SetStringBuffer(nsStringBuffer::FromString(nodeName),
+nodeName.Length());
+}
+void GetBaseURI(nsAString& aBaseURI) const;
+// Return the base URI for the document.
+// The returned value may differ if the document is loaded via XHR, and
+// when accessed from chrome privileged script and
+// from content privileged script for compatibility.
+void GetBaseURIFromJS(nsAString& aBaseURI) const;
+bool HasChildNodes() const
+{
+return HasChildren();
+}
+uint16_t CompareDocumentPosition(nsINode& aOther) const;
+void GetNodeValue(nsAString& aNodeValue)
+{
+GetNodeValueInternal(aNodeValue);
+}
+void SetNodeValue(const nsAString& aNodeValue,
+mozilla::ErrorResult& aError)
+{
+SetNodeValueInternal(aNodeValue, aError);
+}
+virtual void GetNodeValueInternal(nsAString& aNodeValue);
+virtual void SetNodeValueInternal(const nsAString& aNodeValue,
+mozilla::ErrorResult& aError)
+{
+// The DOM spec says that when nodeValue is defined to be null "setting it
+// has no effect", so we don't throw an exception.
+}
+nsINode* InsertBefore(nsINode& aNode, nsINode* aChild,
+mozilla::ErrorResult& aError)
+{
+return ReplaceOrInsertBefore(false, &aNode, aChild, aError);
+}
+nsINode* AppendChild(nsINode& aNode, mozilla::ErrorResult& aError)
+{
+return InsertBefore(aNode, nullptr, aError);
+}
+nsINode* ReplaceChild(nsINode& aNode, nsINode& aChild,
+mozilla::ErrorResult& aError)
+{
+return ReplaceOrInsertBefore(true, &aNode, &aChild, aError);
+}
+nsINode* RemoveChild(nsINode& aChild, mozilla::ErrorResult& aError);
+already_AddRefed<nsINode> CloneNode(bool aDeep, mozilla::ErrorResult& aError);
+bool IsEqualNode(nsINode* aNode);
+void GetNamespaceURI(nsAString& aNamespaceURI) const
+{
+mNodeInfo->GetNamespaceURI(aNamespaceURI);
+}
+#ifdef MOZILLA_INTERNAL_API
+void GetPrefix(nsAString& aPrefix)
+{
+mNodeInfo->GetPrefix(aPrefix);
+}
+#endif
+void GetLocalName(mozilla::dom::DOMString& aLocalName)
+{
+const nsString& localName = LocalName();
+if (localName.IsVoid()) {
+aLocalName.SetNull();
+} else {
+aLocalName.SetStringBuffer(nsStringBuffer::FromString(localName),
+localName.Length());
+}
+}
+// HasAttributes is defined inline in Element.h.
+bool HasAttributes() const;
+nsDOMAttributeMap* GetAttributes();
+void SetUserData(JSContext* aCx, const nsAString& aKey,
+JS::Handle<JS::Value> aData,
+nsIDOMUserDataHandler* aHandler,
+JS::MutableHandle<JS::Value> aRetval,
+mozilla::ErrorResult& aError);
+void GetUserData(JSContext* aCx, const nsAString& aKey,
+JS::MutableHandle<JS::Value> aRetval,
+mozilla::ErrorResult& aError);
+// Helper method to remove this node from its parent. This is not exposed
+// through WebIDL.
+// Only call this if the node has a parent node.
+nsresult RemoveFromParent()
+{
+nsINode* parent = GetParentNode();
+mozilla::ErrorResult rv;
+parent->RemoveChild(*this, rv);
+return rv.ErrorCode();
+}
+// ChildNode methods
+mozilla::dom::Element* GetPreviousElementSibling() const;
+mozilla::dom::Element* GetNextElementSibling() const;
+/**
+* Remove this node from its parent, if any.
+*/
+void Remove();
+// ParentNode methods
+mozilla::dom::Element* GetFirstElementChild() const;
+mozilla::dom::Element* GetLastElementChild() const;
+void GetBoxQuads(const BoxQuadOptions& aOptions,
+nsTArray<nsRefPtr<DOMQuad> >& aResult,
+mozilla::ErrorResult& aRv);
+already_AddRefed<DOMQuad> ConvertQuadFromNode(DOMQuad& aQuad,
+const TextOrElementOrDocument& aFrom,
+const ConvertCoordinateOptions& aOptions,
+ErrorResult& aRv);
+already_AddRefed<DOMQuad> ConvertRectFromNode(DOMRectReadOnly& aRect,
+const TextOrElementOrDocument& aFrom,
+const ConvertCoordinateOptions& aOptions,
+ErrorResult& aRv);
+already_AddRefed<DOMPoint> ConvertPointFromNode(const DOMPointInit& aPoint,
+const TextOrElementOrDocument& aFrom,
+const ConvertCoordinateOptions& aOptions,
+ErrorResult& aRv);
+protected:
+// Override this function to create a custom slots class.
+// Must not return null.
+virtual nsINode::nsSlots* CreateSlots();
+bool HasSlots() const
+{
+return mSlots != nullptr;
+}
+nsSlots* GetExistingSlots() const
+{
+return mSlots;
+}
+nsSlots* Slots()
+{
+if (!HasSlots()) {
+mSlots = CreateSlots();
+MOZ_ASSERT(mSlots);
+}
+return GetExistingSlots();
+}
+nsTObserverArray<nsIMutationObserver*> *GetMutationObservers()
+{
+return HasSlots() ? &GetExistingSlots()->mMutationObservers : nullptr;
+}
+bool IsEditableInternal() const;
+virtual bool IsEditableExternal() const
+{
+return IsEditableInternal();
+}
+virtual void GetTextContentInternal(nsAString& aTextContent);
+virtual void SetTextContentInternal(const nsAString& aTextContent,
+mozilla::ErrorResult& aError)
+{
+}
+#ifdef DEBUG
+// Note: virtual so that IsInNativeAnonymousSubtree can be called accross
+// module boundaries.
+virtual void CheckNotNativeAnonymous() const;
+#endif
+// These are just used to implement nsIDOMNode using
+// NS_FORWARD_NSIDOMNODE_TO_NSINODE_HELPER and for quickstubs.
+nsresult GetParentNode(nsIDOMNode** aParentNode);
+nsresult GetParentElement(nsIDOMElement** aParentElement);
+nsresult GetChildNodes(nsIDOMNodeList** aChildNodes);
+nsresult GetFirstChild(nsIDOMNode** aFirstChild);
+nsresult GetLastChild(nsIDOMNode** aLastChild);
+nsresult GetPreviousSibling(nsIDOMNode** aPrevSibling);
+nsresult GetNextSibling(nsIDOMNode** aNextSibling);
+nsresult GetOwnerDocument(nsIDOMDocument** aOwnerDocument);
+nsresult CompareDocumentPosition(nsIDOMNode* aOther,
+uint16_t* aReturn);
+nsresult ReplaceOrInsertBefore(bool aReplace, nsIDOMNode *aNewChild,
+nsIDOMNode *aRefChild, nsIDOMNode **aReturn);
+nsINode* ReplaceOrInsertBefore(bool aReplace, nsINode* aNewChild,
+nsINode* aRefChild,
+mozilla::ErrorResult& aError);
+nsresult RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aReturn);
+/**
+* Returns the Element that should be used for resolving namespaces
+* on this node (ie the ownerElement for attributes, the documentElement for
+* documents, the node itself for elements and for other nodes the parentNode
+* if it is an element).
+*/
+virtual mozilla::dom::Element* GetNameSpaceElement() = 0;
+/**
+* Most of the implementation of the nsINode RemoveChildAt method.
+* Should only be called on document, element, and document fragment
+* nodes.  The aChildArray passed in should be the one for |this|.
+*
+* @param aIndex The index to remove at.
+* @param aNotify Whether to notify.
+* @param aKid The kid at aIndex.  Must not be null.
+* @param aChildArray The child array to work with.
+* @param aMutationEvent whether to fire a mutation event for this removal.
+*/
+void doRemoveChildAt(uint32_t aIndex, bool aNotify, nsIContent* aKid,
+nsAttrAndChildArray& aChildArray);
+/**
+* Most of the implementation of the nsINode InsertChildAt method.
+* Should only be called on document, element, and document fragment
+* nodes.  The aChildArray passed in should be the one for |this|.
+*
+* @param aKid The child to insert.
+* @param aIndex The index to insert at.
+* @param aNotify Whether to notify.
+* @param aChildArray The child array to work with
+*/
+nsresult doInsertChildAt(nsIContent* aKid, uint32_t aIndex,
+bool aNotify, nsAttrAndChildArray& aChildArray);
+/**
+* Parse the given selector string into an nsCSSSelectorList.
+*
+* A null return value with a non-failing aRv means the string only
+* contained pseudo-element selectors.
+*
+* A failing aRv means the string was not a valid selector.
+*/
+nsCSSSelectorList* ParseSelectorList(const nsAString& aSelectorString,
+mozilla::ErrorResult& aRv);
+public:
+/* Event stuff that documents and elements share.  This needs to be
+NS_IMETHOD because some subclasses implement DOM methods with
+this exact name and signature and then the calling convention
+needs to match.
+Note that we include DOCUMENT_ONLY_EVENT events here so that we
+can forward all the document stuff to this implementation.
+*/
+#define EVENT(name_, id_, type_, struct_)                             \
+mozilla::dom::EventHandlerNonNull* GetOn##name_();                  \
+void SetOn##name_(mozilla::dom::EventHandlerNonNull* listener);
+#define TOUCH_EVENT EVENT
+#define DOCUMENT_ONLY_EVENT EVENT
+#include "mozilla/EventNameList.h"
+#undef DOCUMENT_ONLY_EVENT
+#undef TOUCH_EVENT
+#undef EVENT
+protected:
+static bool Traverse(nsINode *tmp, nsCycleCollectionTraversalCallback &cb);
+static void Unlink(nsINode *tmp);
+nsCOMPtr<nsINodeInfo> mNodeInfo;
+nsINode* mParent;
+private:
+// Boolean flags.
+uint32_t mBoolFlags;
+protected:
+nsIContent* mNextSibling;
+nsIContent* mPreviousSibling;
+nsIContent* mFirstChild;
+union {
+// Pointer to our primary frame.  Might be null.
+nsIFrame* mPrimaryFrame;
+// Pointer to the root of our subtree.  Might be null.
+nsINode* mSubtreeRoot;
+};
+// Storage for more members that are usually not needed; allocated lazily.
+nsSlots* mSlots;
+};
+// Useful inline function for getting a node given an nsIContent and an
+// nsIDocument.  Returns the first argument cast to nsINode if it is non-null,
+// otherwise returns the second (which may be null).  We use type variables
+// instead of nsIContent* and nsIDocument* because the actual types must be
+// known for the cast to work.
+template<class C, class D>
+inline nsINode* NODE_FROM(C& aContent, D& aDocument)
+{
+if (aContent)
+return static_cast<nsINode*>(aContent);
+return static_cast<nsINode*>(aDocument);
+}
+NS_DEFINE_STATIC_IID_ACCESSOR(nsINode, NS_INODE_IID)
+inline nsISupports*
+ToSupports(nsINode* aPointer)
+{
+return aPointer;
+}
+inline nsISupports*
+ToCanonicalSupports(nsINode* aPointer)
+{
+return aPointer;
+}
+#define NS_FORWARD_NSIDOMNODE_TO_NSINODE_HELPER(...) \
+NS_IMETHOD GetNodeName(nsAString& aNodeName) __VA_ARGS__ \
+{ \
+aNodeName = nsINode::NodeName(); \
+return NS_OK; \
+} \
+NS_IMETHOD GetNodeValue(nsAString& aNodeValue) __VA_ARGS__ \
+{ \
+nsINode::GetNodeValue(aNodeValue); \
+return NS_OK; \
+} \
+NS_IMETHOD SetNodeValue(const nsAString& aNodeValue) __VA_ARGS__ \
+{ \
+mozilla::ErrorResult rv; \
+nsINode::SetNodeValue(aNodeValue, rv); \
+return rv.ErrorCode(); \
+} \
+NS_IMETHOD GetNodeType(uint16_t* aNodeType) __VA_ARGS__ \
+{ \
+*aNodeType = nsINode::NodeType(); \
+return NS_OK; \
+} \
+NS_IMETHOD GetParentNode(nsIDOMNode** aParentNode) __VA_ARGS__ \
+{ \
+return nsINode::GetParentNode(aParentNode); \
+} \
+NS_IMETHOD GetParentElement(nsIDOMElement** aParentElement) __VA_ARGS__ \
+{ \
+return nsINode::GetParentElement(aParentElement); \
+} \
+NS_IMETHOD GetChildNodes(nsIDOMNodeList** aChildNodes) __VA_ARGS__ \
+{ \
+return nsINode::GetChildNodes(aChildNodes); \
+} \
+NS_IMETHOD GetFirstChild(nsIDOMNode** aFirstChild) __VA_ARGS__ \
+{ \
+return nsINode::GetFirstChild(aFirstChild); \
+} \
+NS_IMETHOD GetLastChild(nsIDOMNode** aLastChild) __VA_ARGS__ \
+{ \
+return nsINode::GetLastChild(aLastChild); \
+} \
+NS_IMETHOD GetPreviousSibling(nsIDOMNode** aPreviousSibling) __VA_ARGS__ \
+{ \
+return nsINode::GetPreviousSibling(aPreviousSibling); \
+} \
+NS_IMETHOD GetNextSibling(nsIDOMNode** aNextSibling) __VA_ARGS__ \
+{ \
+return nsINode::GetNextSibling(aNextSibling); \
+} \
+NS_IMETHOD GetOwnerDocument(nsIDOMDocument** aOwnerDocument) __VA_ARGS__ \
+{ \
+return nsINode::GetOwnerDocument(aOwnerDocument); \
+} \
+NS_IMETHOD InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild, nsIDOMNode** aResult) __VA_ARGS__ \
+{ \
+return ReplaceOrInsertBefore(false, aNewChild, aRefChild, aResult); \
+} \
+NS_IMETHOD ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild, nsIDOMNode** aResult) __VA_ARGS__ \
+{ \
+return ReplaceOrInsertBefore(true, aNewChild, aOldChild, aResult); \
+} \
+NS_IMETHOD RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aResult) __VA_ARGS__ \
+{ \
+return nsINode::RemoveChild(aOldChild, aResult); \
+} \
+NS_IMETHOD AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aResult) __VA_ARGS__ \
+{ \
+return InsertBefore(aNewChild, nullptr, aResult); \
+} \
+NS_IMETHOD HasChildNodes(bool* aResult) __VA_ARGS__ \
+{ \
+*aResult = nsINode::HasChildNodes(); \
+return NS_OK; \
+} \
+NS_IMETHOD CloneNode(bool aDeep, uint8_t aArgc, nsIDOMNode** aResult) __VA_ARGS__ \
+{ \
+if (aArgc == 0) { \
+aDeep = true; \
+} \
+mozilla::ErrorResult rv; \
+nsCOMPtr<nsINode> clone = nsINode::CloneNode(aDeep, rv); \
+if (rv.Failed()) { \
+return rv.ErrorCode(); \
+} \
+*aResult = clone.forget().take()->AsDOMNode(); \
+return NS_OK; \
+} \
+NS_IMETHOD Normalize() __VA_ARGS__ \
+{ \
+nsINode::Normalize(); \
+return NS_OK; \
+} \
+NS_IMETHOD GetNamespaceURI(nsAString& aNamespaceURI) __VA_ARGS__ \
+{ \
+nsINode::GetNamespaceURI(aNamespaceURI); \
+return NS_OK; \
+} \
+NS_IMETHOD GetPrefix(nsAString& aPrefix) __VA_ARGS__ \
+{ \
+nsINode::GetPrefix(aPrefix); \
+return NS_OK; \
+} \
+NS_IMETHOD GetLocalName(nsAString& aLocalName) __VA_ARGS__ \
+{ \
+aLocalName = nsINode::LocalName(); \
+return NS_OK; \
+} \
+using nsINode::HasAttributes; \
+NS_IMETHOD HasAttributes(bool* aResult) __VA_ARGS__ \
+{ \
+*aResult = nsINode::HasAttributes(); \
+return NS_OK; \
+} \
+NS_IMETHOD GetDOMBaseURI(nsAString& aBaseURI) __VA_ARGS__ \
+{ \
+nsINode::GetBaseURI(aBaseURI); \
+return NS_OK; \
+} \
+NS_IMETHOD CompareDocumentPosition(nsIDOMNode* aOther, uint16_t* aResult) __VA_ARGS__ \
+{ \
+return nsINode::CompareDocumentPosition(aOther, aResult); \
+} \
+NS_IMETHOD GetTextContent(nsAString& aTextContent) __VA_ARGS__ \
+{ \
+nsINode::GetTextContent(aTextContent); \
+return NS_OK; \
+} \
+NS_IMETHOD SetTextContent(const nsAString& aTextContent) __VA_ARGS__ \
+{ \
+mozilla::ErrorResult rv; \
+nsINode::SetTextContent(aTextContent, rv); \
+return rv.ErrorCode(); \
+} \
+NS_IMETHOD LookupPrefix(const nsAString& aNamespaceURI, nsAString& aResult) __VA_ARGS__ \
+{ \
+nsINode::LookupPrefix(aNamespaceURI, aResult); \
+return NS_OK; \
+} \
+NS_IMETHOD IsDefaultNamespace(const nsAString& aNamespaceURI, bool* aResult) __VA_ARGS__ \
+{ \
+*aResult = nsINode::IsDefaultNamespace(aNamespaceURI); \
+return NS_OK; \
+} \
+NS_IMETHOD LookupNamespaceURI(const nsAString& aPrefix, nsAString& aResult) __VA_ARGS__ \
+{ \
+nsINode::LookupNamespaceURI(aPrefix, aResult); \
+return NS_OK; \
+} \
+NS_IMETHOD IsEqualNode(nsIDOMNode* aArg, bool* aResult) __VA_ARGS__ \
+{ \
+return nsINode::IsEqualNode(aArg, aResult); \
+} \
+NS_IMETHOD SetUserData(const nsAString& aKey, nsIVariant* aData, nsIDOMUserDataHandler* aHandler, nsIVariant** aResult) __VA_ARGS__ \
+{ \
+return nsINode::SetUserData(aKey, aData, aHandler, aResult); \
+} \
+NS_IMETHOD GetUserData(const nsAString& aKey, nsIVariant** aResult) __VA_ARGS__ \
+{ \
+return nsINode::GetUserData(aKey, aResult); \
+} \
+NS_IMETHOD Contains(nsIDOMNode* aOther, bool* aResult) __VA_ARGS__ \
+{ \
+return nsINode::Contains(aOther, aResult); \
+}
+#define NS_FORWARD_NSIDOMNODE_TO_NSINODE \
+NS_FORWARD_NSIDOMNODE_TO_NSINODE_HELPER(MOZ_FINAL)
+#define NS_FORWARD_NSIDOMNODE_TO_NSINODE_OVERRIDABLE \
+NS_FORWARD_NSIDOMNODE_TO_NSINODE_HELPER()
+#endif /* nsINode_h___ */

The Tor Browser / file comparison

comparison: content/base/public/nsINode.h

content/base/public/nsINode.h