Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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
/*
* Base class for all DOM nodes.
*/
#include "nsINode.h"
#include "AccessCheck.h"
#include "jsapi.h"
#include "js/ForOfIterator.h" // JS::ForOfIterator
#include "js/JSON.h" // JS_ParseJSON
#include "mozAutoDocUpdate.h"
#include "mozilla/AsyncEventDispatcher.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/CORSMode.h"
#include "mozilla/EventDispatcher.h"
#include "mozilla/EventListenerManager.h"
#include "mozilla/HTMLEditor.h"
#include "mozilla/InternalMutationEvent.h"
#include "mozilla/Likely.h"
#include "mozilla/Maybe.h"
#include "mozilla/MemoryReporting.h"
#include "mozilla/PresShell.h"
#include "mozilla/ServoBindings.h"
#include "mozilla/Telemetry.h"
#include "mozilla/TextControlElement.h"
#include "mozilla/TextEditor.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/BindContext.h"
#include "mozilla/dom/CharacterData.h"
#include "mozilla/dom/ChildIterator.h"
#include "mozilla/dom/CustomElementRegistry.h"
#include "mozilla/dom/DebuggerNotificationBinding.h"
#include "mozilla/dom/DocumentType.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/ElementBinding.h"
#include "mozilla/dom/Event.h"
#include "mozilla/dom/Exceptions.h"
#include "mozilla/dom/Link.h"
#include "mozilla/dom/HTMLImageElement.h"
#include "mozilla/dom/HTMLMediaElement.h"
#include "mozilla/dom/HTMLTemplateElement.h"
#include "mozilla/dom/MutationObservers.h"
#include "mozilla/dom/Selection.h"
#include "mozilla/dom/ShadowRoot.h"
#include "mozilla/dom/SVGUseElement.h"
#include "mozilla/dom/ScriptSettings.h"
#include "mozilla/dom/L10nOverlays.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/StaticPrefs_layout.h"
#include "nsAttrValueOrString.h"
#include "nsCCUncollectableMarker.h"
#include "nsContentCreatorFunctions.h"
#include "nsContentList.h"
#include "nsContentUtils.h"
#include "nsCOMArray.h"
#include "nsCycleCollectionParticipant.h"
#include "mozilla/dom/Attr.h"
#include "nsDOMAttributeMap.h"
#include "nsDOMCID.h"
#include "nsDOMCSSAttrDeclaration.h"
#include "nsError.h"
#include "nsExpirationTracker.h"
#include "nsDOMMutationObserver.h"
#include "nsDOMString.h"
#include "nsDOMTokenList.h"
#include "nsFocusManager.h"
#include "nsFrameSelection.h"
#include "nsGenericHTMLElement.h"
#include "nsGkAtoms.h"
#include "nsIAnonymousContentCreator.h"
#include "nsAtom.h"
#include "nsIContentInlines.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/DocumentInlines.h"
#include "nsIFrameInlines.h"
#include "mozilla/dom/NodeInfo.h"
#include "mozilla/dom/NodeInfoInlines.h"
#include "nsIScriptGlobalObject.h"
#include "nsView.h"
#include "nsViewManager.h"
#include "nsIWidget.h"
#include "nsLayoutUtils.h"
#include "nsNameSpaceManager.h"
#include "nsNodeInfoManager.h"
#include "nsObjectLoadingContent.h"
#include "nsPIDOMWindow.h"
#include "nsPresContext.h"
#include "nsPrintfCString.h"
#include "nsRange.h"
#include "nsString.h"
#include "nsStyleConsts.h"
#include "nsTextNode.h"
#include "nsUnicharUtils.h"
#include "nsWindowSizes.h"
#include "mozilla/Preferences.h"
#include "xpcpublic.h"
#include "HTMLLegendElement.h"
#include "nsWrapperCacheInlines.h"
#include "WrapperFactory.h"
#include <algorithm>
#include "nsGlobalWindowInner.h"
#include "GeometryUtils.h"
#include "nsIAnimationObserver.h"
#include "nsChildContentList.h"
#include "mozilla/dom/NodeBinding.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "mozilla/dom/AncestorIterator.h"
#include "xpcprivate.h"
#include "XPathGenerator.h"
#ifdef ACCESSIBILITY
# include "mozilla/dom/AccessibleNode.h"
#endif
using namespace mozilla;
using namespace mozilla::dom;
static bool ShouldUseNACScope(const nsINode* aNode) {
return aNode->IsInNativeAnonymousSubtree();
}
static bool ShouldUseUAWidgetScope(const nsINode* aNode) {
return aNode->HasBeenInUAWidget();
}
void* nsINode::operator new(size_t aSize, nsNodeInfoManager* aManager) {
if (StaticPrefs::dom_arena_allocator_enabled_AtStartup()) {
MOZ_ASSERT(aManager, "nsNodeInfoManager needs to be initialized");
return aManager->Allocate(aSize);
}
return ::operator new(aSize);
}
void nsINode::operator delete(void* aPtr) { free_impl(aPtr); }
bool nsINode::IsInclusiveDescendantOf(const nsINode* aNode) const {
MOZ_ASSERT(aNode, "The node is nullptr.");
if (aNode == this) {
return true;
}
if (!aNode->HasFlag(NODE_MAY_HAVE_ELEMENT_CHILDREN)) {
return GetParentNode() == aNode;
}
for (nsINode* node : Ancestors(*this)) {
if (node == aNode) {
return true;
}
}
return false;
}
bool nsINode::IsInclusiveFlatTreeDescendantOf(const nsINode* aNode) const {
MOZ_ASSERT(aNode, "The node is nullptr.");
for (nsINode* node : InclusiveFlatTreeAncestors(*this)) {
if (node == aNode) {
return true;
}
}
return false;
}
bool nsINode::IsShadowIncludingInclusiveDescendantOf(
const nsINode* aNode) const {
MOZ_ASSERT(aNode, "The node is nullptr.");
if (this->GetComposedDoc() == aNode) {
return true;
}
const nsINode* node = this;
do {
if (node == aNode) {
return true;
}
node = node->GetParentOrShadowHostNode();
} while (node);
return false;
}
nsINode::nsSlots::nsSlots() : mWeakReference(nullptr) {}
nsINode::nsSlots::~nsSlots() {
if (mChildNodes) {
mChildNodes->InvalidateCacheIfAvailable();
}
if (mWeakReference) {
mWeakReference->NoticeNodeDestruction();
}
}
void nsINode::nsSlots::Traverse(nsCycleCollectionTraversalCallback& cb) {
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mSlots->mChildNodes");
cb.NoteXPCOMChild(mChildNodes);
for (auto& object : mBoundObjects) {
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mSlots->mBoundObjects[i]");
cb.NoteXPCOMChild(object.mObject);
}
}
static void ClearBoundObjects(nsINode::nsSlots& aSlots, nsINode& aNode) {
auto objects = std::move(aSlots.mBoundObjects);
for (auto& object : objects) {
if (object.mDtor) {
object.mDtor(object.mObject, &aNode);
}
}
MOZ_ASSERT(aSlots.mBoundObjects.IsEmpty());
}
void nsINode::nsSlots::Unlink(nsINode& aNode) {
if (mChildNodes) {
mChildNodes->InvalidateCacheIfAvailable();
ImplCycleCollectionUnlink(mChildNodes);
}
ClearBoundObjects(*this, aNode);
}
//----------------------------------------------------------------------
#ifdef MOZILLA_INTERNAL_API
nsINode::nsINode(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
: mNodeInfo(std::move(aNodeInfo)),
mParent(nullptr)
# ifndef BOOL_FLAGS_ON_WRAPPER_CACHE
,
mBoolFlags(0)
# endif
,
mChildCount(0),
mPreviousOrLastSibling(nullptr),
mSubtreeRoot(this),
mSlots(nullptr) {
SetIsOnMainThread();
}
#endif
nsINode::~nsINode() {
MOZ_ASSERT(!HasSlots(), "LastRelease was not called?");
MOZ_ASSERT(mSubtreeRoot == this, "Didn't restore state properly?");
}
#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
void nsINode::AssertInvariantsOnNodeInfoChange() {
MOZ_DIAGNOSTIC_ASSERT(!IsInComposedDoc());
if (nsCOMPtr<Link> link = do_QueryInterface(this)) {
MOZ_DIAGNOSTIC_ASSERT(!link->HasPendingLinkUpdate());
}
}
#endif
void* nsINode::GetProperty(const nsAtom* aPropertyName,
nsresult* aStatus) const {
if (!HasProperties()) { // a fast HasFlag() test
if (aStatus) {
*aStatus = NS_PROPTABLE_PROP_NOT_THERE;
}
return nullptr;
}
return OwnerDoc()->PropertyTable().GetProperty(this, aPropertyName, aStatus);
}
nsresult nsINode::SetProperty(nsAtom* aPropertyName, void* aValue,
NSPropertyDtorFunc aDtor, bool aTransfer) {
nsresult rv = OwnerDoc()->PropertyTable().SetProperty(
this, aPropertyName, aValue, aDtor, nullptr, aTransfer);
if (NS_SUCCEEDED(rv)) {
SetFlags(NODE_HAS_PROPERTIES);
}
return rv;
}
void nsINode::RemoveProperty(const nsAtom* aPropertyName) {
OwnerDoc()->PropertyTable().RemoveProperty(this, aPropertyName);
}
void* nsINode::TakeProperty(const nsAtom* aPropertyName, nsresult* aStatus) {
return OwnerDoc()->PropertyTable().TakeProperty(this, aPropertyName, aStatus);
}
nsIContentSecurityPolicy* nsINode::GetCsp() const {
return OwnerDoc()->GetCsp();
}
nsINode::nsSlots* nsINode::CreateSlots() { return new nsSlots(); }
static const nsINode* GetClosestCommonInclusiveAncestorForRangeInSelection(
const nsINode* aNode) {
while (aNode &&
!aNode->IsClosestCommonInclusiveAncestorForRangeInSelection()) {
const bool isNodeInShadowTree =
StaticPrefs::dom_shadowdom_selection_across_boundary_enabled() &&
aNode->IsInShadowTree();
if (!aNode
->IsDescendantOfClosestCommonInclusiveAncestorForRangeInSelection() &&
!isNodeInShadowTree) {
return nullptr;
}
aNode = StaticPrefs::dom_shadowdom_selection_across_boundary_enabled()
? aNode->GetParentOrShadowHostNode()
: aNode->GetParentNode();
}
return aNode;
}
/**
* A Comparator suitable for mozilla::BinarySearchIf for searching a collection
* of nsRange* for an overlap of (mNode, mStartOffset) .. (mNode, mEndOffset).
*/
class IsItemInRangeComparator {
public:
// @param aStartOffset has to be less or equal to aEndOffset.
IsItemInRangeComparator(const nsINode& aNode, const uint32_t aStartOffset,
const uint32_t aEndOffset,
nsContentUtils::NodeIndexCache* aCache)
: mNode(aNode),
mStartOffset(aStartOffset),
mEndOffset(aEndOffset),
mCache(aCache) {
MOZ_ASSERT(aStartOffset <= aEndOffset);
}
int operator()(const AbstractRange* const aRange) const {
int32_t cmp = nsContentUtils::ComparePoints_Deprecated(
&mNode, mEndOffset, aRange->GetMayCrossShadowBoundaryStartContainer(),
aRange->MayCrossShadowBoundaryStartOffset(), nullptr, mCache);
if (cmp == 1) {
cmp = nsContentUtils::ComparePoints_Deprecated(
&mNode, mStartOffset, aRange->GetMayCrossShadowBoundaryEndContainer(),
aRange->MayCrossShadowBoundaryEndOffset(), nullptr, mCache);
if (cmp == -1) {
return 0;
}
return 1;
}
return -1;
}
private:
const nsINode& mNode;
const uint32_t mStartOffset;
const uint32_t mEndOffset;
nsContentUtils::NodeIndexCache* mCache;
};
bool nsINode::IsSelected(const uint32_t aStartOffset, const uint32_t aEndOffset,
SelectionNodeCache* aCache) const {
MOZ_ASSERT(aStartOffset <= aEndOffset);
const nsINode* n = GetClosestCommonInclusiveAncestorForRangeInSelection(this);
NS_ASSERTION(n || !IsMaybeSelected(),
"A node without a common inclusive ancestor for a range in "
"Selection is for sure not selected.");
// Collect the selection objects for potential ranges.
AutoTArray<Selection*, 1> ancestorSelections;
for (; n; n = GetClosestCommonInclusiveAncestorForRangeInSelection(
n->GetParentNode())) {
const LinkedList<AbstractRange>* ranges =
n->GetExistingClosestCommonInclusiveAncestorRanges();
if (!ranges) {
continue;
}
for (const AbstractRange* range : *ranges) {
MOZ_ASSERT(range->IsInAnySelection(),
"Why is this range registered with a node?");
// Looks like that IsInSelection() assert fails sometimes...
if (range->IsInAnySelection()) {
for (const WeakPtr<Selection>& selection : range->GetSelections()) {
if (selection && !ancestorSelections.Contains(selection)) {
ancestorSelections.AppendElement(selection);
}
}
}
}
}
if (aCache && aCache->MaybeCollectNodesAndCheckIfFullySelectedInAnyOf(
this, ancestorSelections)) {
return true;
}
nsContentUtils::NodeIndexCache cache;
IsItemInRangeComparator comparator{*this, aStartOffset, aEndOffset, &cache};
for (Selection* selection : ancestorSelections) {
// Binary search the sorted ranges in this selection.
// (Selection::GetRangeAt returns its ranges ordered).
size_t low = 0;
size_t high = selection->RangeCount();
while (high != low) {
size_t middle = low + (high - low) / 2;
const AbstractRange* const range = selection->GetAbstractRangeAt(middle);
int result = comparator(range);
if (result == 0) {
if (!range->Collapsed()) {
return true;
}
if (range->MayCrossShadowBoundary()) {
MOZ_ASSERT(range->IsDynamicRange(),
"range->MayCrossShadowBoundary() can only return true for "
"dynamic range");
StaticRange* crossBoundaryRange =
range->AsDynamicRange()->GetCrossShadowBoundaryRange();
MOZ_ASSERT(crossBoundaryRange);
if (!crossBoundaryRange->Collapsed()) {
return true;
}
}
const AbstractRange* middlePlus1;
const AbstractRange* middleMinus1;
// if node end > start of middle+1, result = 1
if (middle + 1 < high &&
(middlePlus1 = selection->GetAbstractRangeAt(middle + 1)) &&
nsContentUtils::ComparePoints_Deprecated(
this, aEndOffset, middlePlus1->GetStartContainer(),
middlePlus1->StartOffset(), nullptr, &cache) > 0) {
result = 1;
// if node start < end of middle - 1, result = -1
} else if (middle >= 1 &&
(middleMinus1 = selection->GetAbstractRangeAt(middle - 1)) &&
nsContentUtils::ComparePoints_Deprecated(
this, aStartOffset, middleMinus1->GetEndContainer(),
middleMinus1->EndOffset(), nullptr, &cache) < 0) {
result = -1;
} else {
break;
}
}
if (result < 0) {
high = middle;
} else {
low = middle + 1;
}
}
}
return false;
}
Element* nsINode::GetAnonymousRootElementOfTextEditor(
TextEditor** aTextEditor) {
if (aTextEditor) {
*aTextEditor = nullptr;
}
RefPtr<TextControlElement> textControlElement;
if (IsInNativeAnonymousSubtree()) {
textControlElement = TextControlElement::FromNodeOrNull(
GetClosestNativeAnonymousSubtreeRootParentOrHost());
} else {
textControlElement = TextControlElement::FromNode(this);
}
if (!textControlElement) {
return nullptr;
}
RefPtr<TextEditor> textEditor = textControlElement->GetTextEditor();
if (!textEditor) {
// The found `TextControlElement` may be an input element which is not a
// text control element. In this case, such element must not be in a
// native anonymous tree of a `TextEditor` so this node is not in any
// `TextEditor`.
return nullptr;
}
Element* rootElement = textEditor->GetRoot();
if (aTextEditor) {
textEditor.forget(aTextEditor);
}
return rootElement;
}
void nsINode::QueueDevtoolsAnonymousEvent(bool aIsRemove) {
MOZ_ASSERT(IsRootOfNativeAnonymousSubtree());
MOZ_ASSERT(OwnerDoc()->DevToolsAnonymousAndShadowEventsEnabled());
AsyncEventDispatcher* dispatcher = new AsyncEventDispatcher(
this, aIsRemove ? u"anonymousrootremoved"_ns : u"anonymousrootcreated"_ns,
CanBubble::eYes, ChromeOnlyDispatch::eYes, Composed::eYes);
dispatcher->PostDOMEvent();
}
nsINode* nsINode::GetRootNode(const GetRootNodeOptions& aOptions) {
if (aOptions.mComposed) {
if (Document* doc = GetComposedDoc()) {
return doc;
}
nsINode* node = this;
while (node) {
node = node->SubtreeRoot();
ShadowRoot* shadow = ShadowRoot::FromNode(node);
if (!shadow) {
break;
}
node = shadow->GetHost();
}
return node;
}
return SubtreeRoot();
}
nsIContent* nsINode::GetFirstChildOfTemplateOrNode() {
if (IsTemplateElement()) {
DocumentFragment* frag = static_cast<HTMLTemplateElement*>(this)->Content();
return frag->GetFirstChild();
}
return GetFirstChild();
}
nsINode* nsINode::SubtreeRoot() const {
auto RootOfNode = [](const nsINode* aStart) -> nsINode* {
const nsINode* node = aStart;
const nsINode* iter = node;
while ((iter = iter->GetParentNode())) {
node = iter;
}
return const_cast<nsINode*>(node);
};
// There are four cases of interest here. nsINodes that are really:
// 1. Document nodes - Are always in the document.
// 2.a nsIContent nodes not in a shadow tree - Are either in the document,
// or mSubtreeRoot is updated in BindToTree/UnbindFromTree.
// 2.b nsIContent nodes in a shadow tree - Are never in the document,
// ignore mSubtreeRoot and return the containing shadow root.
// 4. Attr nodes - Are never in the document, and mSubtreeRoot
// is always 'this' (as set in nsINode's ctor).
nsINode* node;
if (IsInUncomposedDoc()) {
node = OwnerDocAsNode();
} else if (IsContent()) {
ShadowRoot* containingShadow = AsContent()->GetContainingShadow();
node = containingShadow ? containingShadow : mSubtreeRoot;
if (!node) {
NS_WARNING("Using SubtreeRoot() on unlinked element?");
node = RootOfNode(this);
}
} else {
node = mSubtreeRoot;
}
MOZ_ASSERT(node, "Should always have a node here!");
#ifdef DEBUG
{
const nsINode* slowNode = RootOfNode(this);
MOZ_ASSERT(slowNode == node, "These should always be in sync!");
}
#endif
return node;
}
static nsIContent* GetRootForContentSubtree(nsIContent* aContent) {
NS_ENSURE_TRUE(aContent, nullptr);
// Special case for ShadowRoot because the ShadowRoot itself is
// the root. This is necessary to prevent selection from crossing
// the ShadowRoot boundary.
//
// FIXME(emilio): The NAC check should probably be done before this? We can
// have NAC inside shadow DOM.
if (ShadowRoot* containingShadow = aContent->GetContainingShadow()) {
return containingShadow;
}
if (nsIContent* nativeAnonRoot =
aContent->GetClosestNativeAnonymousSubtreeRoot()) {
return nativeAnonRoot;
}
if (Document* doc = aContent->GetUncomposedDoc()) {
return doc->GetRootElement();
}
return nsIContent::FromNode(aContent->SubtreeRoot());
}
nsIContent* nsINode::GetSelectionRootContent(PresShell* aPresShell,
bool aAllowCrossShadowBoundary) {
NS_ENSURE_TRUE(aPresShell, nullptr);
const bool isContent = IsContent();
if (!isContent && !IsDocument()) {
return nullptr;
}
if (isContent) {
if (GetComposedDoc() != aPresShell->GetDocument()) {
return nullptr;
}
if (AsContent()->HasIndependentSelection() ||
IsInNativeAnonymousSubtree()) {
// This node should be an inclusive descendant of input/textarea editor.
// In that case, the anonymous <div> for TextEditor should be always the
// selection root.
// FIXME: If Selection for the document is collapsed in <input> or
// <textarea>, returning anonymous <div> may make the callers confused.
// Perhaps, we should do this only when this is in the native anonymous
// subtree unless the callers explicitly want to retrieve the anonymous
// <div> from a text control element.
if (Element* anonymousDivElement =
GetAnonymousRootElementOfTextEditor()) {
return anonymousDivElement;
}
}
}
if (nsPresContext* presContext = aPresShell->GetPresContext()) {
if (nsContentUtils::GetHTMLEditor(presContext)) {
// When there is an HTMLEditor, selection root should be one of focused
// editing host, <body> or root of the (sub)tree which this node belong.
// If this node is in design mode or this node is not editable, selection
// root should be the <body> if this node is not in any subtrees and there
// is a <body> or the root of the shadow DOM if this node is in a shadow
// or the document element.
// XXX If this node is not connected, it seems that this should return
// nullptr because this node is not selectable.
if (!IsInComposedDoc() || IsInDesignMode() ||
!HasFlag(NODE_IS_EDITABLE)) {
Element* const bodyOrDocumentElement = [&]() -> Element* {
if (Element* const bodyElement = OwnerDoc()->GetBodyElement()) {
return bodyElement;
}
return OwnerDoc()->GetDocumentElement();
}();
NS_ENSURE_TRUE(bodyOrDocumentElement, nullptr);
return nsContentUtils::IsInSameAnonymousTree(this,
bodyOrDocumentElement)
? bodyOrDocumentElement
: GetRootForContentSubtree(AsContent());
}
// If this node is editable but not in the design mode, this is always an
// editable node in an editing host of contenteditable. In this case,
// let's use the editing host element as selection root.
MOZ_ASSERT(IsEditable());
MOZ_ASSERT(!IsInDesignMode());
MOZ_ASSERT(IsContent());
return static_cast<nsIContent*>(this)->GetEditingHost();
}
}
if (!isContent) {
return nullptr;
}
RefPtr<nsFrameSelection> fs = aPresShell->FrameSelection();
nsCOMPtr<nsIContent> content = fs->GetLimiter();
if (!content) {
content = fs->GetAncestorLimiter();
if (!content) {
Document* doc = aPresShell->GetDocument();
NS_ENSURE_TRUE(doc, nullptr);
content = doc->GetRootElement();
if (!content) return nullptr;
}
}
// This node might be in another subtree, if so, we should find this subtree's
// root. Otherwise, we can return the content simply.
NS_ENSURE_TRUE(content, nullptr);
if (!nsContentUtils::IsInSameAnonymousTree(this, content)) {
content = GetRootForContentSubtree(AsContent());
// Fixup for ShadowRoot because the ShadowRoot itself does not have a frame.
// Use the host as the root.
if (ShadowRoot* shadowRoot = ShadowRoot::FromNode(content)) {
content = shadowRoot->GetHost();
if (content && aAllowCrossShadowBoundary) {
content = content->GetSelectionRootContent(aPresShell,
aAllowCrossShadowBoundary);
}
}
}
return content;
}
nsINodeList* nsINode::ChildNodes() {
nsSlots* slots = Slots();
if (!slots->mChildNodes) {
slots->mChildNodes = IsAttr() ? new nsAttrChildContentList(this)
: new nsParentNodeChildContentList(this);
}
return slots->mChildNodes;
}
nsIContent* nsINode::GetLastChild() const {
return mFirstChild ? mFirstChild->mPreviousOrLastSibling : nullptr;
}
void nsINode::InvalidateChildNodes() {
MOZ_ASSERT(!IsAttr());
nsSlots* slots = GetExistingSlots();
if (!slots || !slots->mChildNodes) {
return;
}
auto childNodes =
static_cast<nsParentNodeChildContentList*>(slots->mChildNodes.get());
childNodes->InvalidateCache();
}
void nsINode::GetTextContentInternal(nsAString& aTextContent,
OOMReporter& aError) {
SetDOMStringToNull(aTextContent);
}
DocumentOrShadowRoot* nsINode::GetContainingDocumentOrShadowRoot() const {
if (IsInUncomposedDoc()) {
return OwnerDoc();
}
if (IsInShadowTree()) {
return AsContent()->GetContainingShadow();
}
return nullptr;
}
DocumentOrShadowRoot* nsINode::GetUncomposedDocOrConnectedShadowRoot() const {
if (IsInUncomposedDoc()) {
return OwnerDoc();
}
if (IsInComposedDoc() && IsInShadowTree()) {
return AsContent()->GetContainingShadow();
}
return nullptr;
}
mozilla::SafeDoublyLinkedList<nsIMutationObserver>*
nsINode::GetMutationObservers() {
return HasSlots() ? &GetExistingSlots()->mMutationObservers : nullptr;
}
void nsINode::LastRelease() {
if (nsSlots* slots = GetExistingSlots()) {
if (!slots->mMutationObservers.isEmpty()) {
for (auto iter = slots->mMutationObservers.begin();
iter != slots->mMutationObservers.end(); ++iter) {
iter->NodeWillBeDestroyed(this);
}
}
ClearBoundObjects(*slots, *this);
if (IsContent()) {
nsIContent* content = AsContent();
if (HTMLSlotElement* slot = content->GetManualSlotAssignment()) {
content->SetManualSlotAssignment(nullptr);
slot->RemoveManuallyAssignedNode(*content);
}
}
if (Element* element = Element::FromNode(this)) {
if (CustomElementData* data = element->GetCustomElementData()) {
data->Unlink();
}
}
delete slots;
mSlots = nullptr;
}
// Kill properties first since that may run external code, so we want to
// be in as complete state as possible at that time.
if (IsDocument()) {
// Delete all properties before tearing down the document. Some of the
// properties are bound to nsINode objects and the destructor functions of
// the properties may want to use the owner document of the nsINode.
AsDocument()->RemoveAllProperties();
AsDocument()->DropStyleSet();
} else {
if (HasProperties()) {
// Strong reference to the document so that deleting properties can't
// delete the document.
nsCOMPtr<Document> document = OwnerDoc();
document->RemoveAllPropertiesFor(this);
}
if (HasFlag(ADDED_TO_FORM)) {
if (auto* formControl = nsGenericHTMLFormControlElement::FromNode(this)) {
// Tell the form (if any) this node is going away. Don't
// notify, since we're being destroyed in any case.
formControl->ClearForm(true, true);
} else if (auto* imageElem = HTMLImageElement::FromNode(this)) {
imageElem->ClearForm(true);
}
}
if (HasFlag(NODE_HAS_LISTENERMANAGER)) {
#ifdef DEBUG
if (nsContentUtils::IsInitialized()) {
EventListenerManager* manager =
nsContentUtils::GetExistingListenerManagerForNode(this);
if (!manager) {
NS_ERROR(
"Huh, our bit says we have a listener manager list, "
"but there's nothing in the hash!?!!");
}
}
#endif
nsContentUtils::RemoveListenerManager(this);
UnsetFlags(NODE_HAS_LISTENERMANAGER);
}
}
UnsetFlags(NODE_HAS_PROPERTIES);
ReleaseWrapper(this);
FragmentOrElement::RemoveBlackMarkedNode(this);
}
std::ostream& operator<<(std::ostream& aStream, const nsINode& aNode) {
nsAutoString elemDesc;
const nsINode* curr = &aNode;
while (curr) {
nsString id;
if (curr->IsElement()) {
curr->AsElement()->GetId(id);
}
if (!elemDesc.IsEmpty()) {
elemDesc = elemDesc + u"."_ns;
}
if (!curr->LocalName().IsEmpty()) {
elemDesc.Append(curr->LocalName());
} else {
elemDesc.Append(curr->NodeName());
}
if (!id.IsEmpty()) {
elemDesc = elemDesc + u"['"_ns + id + u"']"_ns;
}
if (curr->IsElement() &&
curr->AsElement()->HasAttr(nsGkAtoms::contenteditable)) {
nsAutoString val;
curr->AsElement()->GetAttr(nsGkAtoms::contenteditable, val);
elemDesc = elemDesc + u"[contenteditable=\""_ns + val + u"\"]"_ns;
}
if (curr->IsDocument() && curr->IsInDesignMode()) {
elemDesc.Append(u"[designMode=\"on\"]"_ns);
}
curr = curr->GetParentNode();
}
NS_ConvertUTF16toUTF8 str(elemDesc);
return aStream << str.get();
}
nsIContent* nsINode::DoGetShadowHost() const {
MOZ_ASSERT(IsShadowRoot());
return static_cast<const ShadowRoot*>(this)->GetHost();
}
ShadowRoot* nsINode::GetContainingShadow() const {
if (!IsInShadowTree()) {
return nullptr;
}
return AsContent()->GetContainingShadow();
}
Element* nsINode::GetContainingShadowHost() const {
if (ShadowRoot* shadow = GetContainingShadow()) {
return shadow->GetHost();
}
return nullptr;
}
SVGUseElement* nsINode::DoGetContainingSVGUseShadowHost() const {
MOZ_ASSERT(IsInShadowTree());
return SVGUseElement::FromNodeOrNull(GetContainingShadowHost());
}
void nsINode::GetNodeValueInternal(nsAString& aNodeValue) {
SetDOMStringToNull(aNodeValue);
}
static const char* NodeTypeAsString(nsINode* aNode) {
static const char* NodeTypeStrings[] = {
"", // No nodes of type 0
"an Element",
"an Attribute",
"a Text",
"a CDATASection",
"an EntityReference",
"an Entity",
"a ProcessingInstruction",
"a Comment",
"a Document",
"a DocumentType",
"a DocumentFragment",
"a Notation",
};
static_assert(ArrayLength(NodeTypeStrings) == nsINode::MAX_NODE_TYPE + 1,
"Max node type out of range for our array");
uint16_t nodeType = aNode->NodeType();
MOZ_RELEASE_ASSERT(nodeType < ArrayLength(NodeTypeStrings),
"Uknown out-of-range node type");
return NodeTypeStrings[nodeType];
}
nsINode* nsINode::RemoveChild(nsINode& aOldChild, ErrorResult& aError) {
if (!aOldChild.IsContent()) {
// aOldChild can't be one of our children.
aError.ThrowNotFoundError(
"The node to be removed is not a child of this node");
return nullptr;
}
if (aOldChild.GetParentNode() == this) {
nsContentUtils::MaybeFireNodeRemoved(&aOldChild, this);
}
// Check again, we may not be the child's parent anymore.
// Can be triggered by dom/base/crashtests/293388-1.html
if (aOldChild.IsRootOfNativeAnonymousSubtree() ||
aOldChild.GetParentNode() != this) {
// aOldChild isn't one of our children.
aError.ThrowNotFoundError(
"The node to be removed is not a child of this node");
return nullptr;
}
RemoveChildNode(aOldChild.AsContent(), true);
return &aOldChild;
}
void nsINode::Normalize() {
// First collect list of nodes to be removed
AutoTArray<nsCOMPtr<nsIContent>, 50> nodes;
bool canMerge = false;
for (nsIContent* node = this->GetFirstChild(); node;
node = node->GetNextNode(this)) {
if (node->NodeType() != TEXT_NODE) {
canMerge = false;
continue;
}
if (canMerge || node->TextLength() == 0) {
// No need to touch canMerge. That way we can merge across empty
// textnodes if and only if the node before is a textnode
nodes.AppendElement(node);
} else {
canMerge = true;
}
// If there's no following sibling, then we need to ensure that we don't
// collect following siblings of our (grand)parent as to-be-removed
canMerge = canMerge && !!node->GetNextSibling();
}
if (nodes.IsEmpty()) {
return;
}
// We're relying on mozAutoSubtreeModified to keep the doc alive here.
RefPtr<Document> doc = OwnerDoc();
// Batch possible DOMSubtreeModified events.
mozAutoSubtreeModified subtree(doc, nullptr);
// Fire all DOMNodeRemoved events. Optimize the common case of there being
// no listeners
bool hasRemoveListeners = nsContentUtils::HasMutationListeners(
doc, NS_EVENT_BITS_MUTATION_NODEREMOVED);
if (hasRemoveListeners) {
for (nsCOMPtr<nsIContent>& node : nodes) {
// Node may have already been removed.
if (nsCOMPtr<nsINode> parentNode = node->GetParentNode()) {
nsContentUtils::MaybeFireNodeRemoved(MOZ_KnownLive(node), parentNode);
}
}
}
mozAutoDocUpdate batch(doc, true);
// Merge and remove all nodes
nsAutoString tmpStr;
for (uint32_t i = 0; i < nodes.Length(); ++i) {
nsIContent* node = nodes[i];
// Merge with previous node unless empty
const nsTextFragment* text = node->GetText();
if (text->GetLength()) {
nsIContent* target = node->GetPreviousSibling();
NS_ASSERTION(
(target && target->NodeType() == TEXT_NODE) || hasRemoveListeners,
"Should always have a previous text sibling unless "
"mutation events messed us up");
if (!hasRemoveListeners || (target && target->NodeType() == TEXT_NODE)) {
nsTextNode* t = static_cast<nsTextNode*>(target);
if (text->Is2b()) {
t->AppendTextForNormalize(text->Get2b(), text->GetLength(), true,
node);
} else {
tmpStr.Truncate();
text->AppendTo(tmpStr);
t->AppendTextForNormalize(tmpStr.get(), tmpStr.Length(), true, node);
}
}
}
// Remove node
nsCOMPtr<nsINode> parent = node->GetParentNode();
NS_ASSERTION(parent || hasRemoveListeners,
"Should always have a parent unless "
"mutation events messed us up");
if (parent) {
parent->RemoveChildNode(node, true);
}
}
}
nsresult nsINode::GetBaseURI(nsAString& aURI) const {
nsIURI* baseURI = GetBaseURI();
nsAutoCString spec;
if (baseURI) {
nsresult rv = baseURI->GetSpec(spec);
NS_ENSURE_SUCCESS(rv, rv);
}
CopyUTF8toUTF16(spec, aURI);
return NS_OK;
}
void nsINode::GetBaseURIFromJS(nsAString& aURI, CallerType aCallerType,
ErrorResult& aRv) const {
nsIURI* baseURI = GetBaseURI(aCallerType == CallerType::System);
nsAutoCString spec;
if (baseURI) {
nsresult res = baseURI->GetSpec(spec);
if (NS_FAILED(res)) {
aRv.Throw(res);
return;
}
}
CopyUTF8toUTF16(spec, aURI);
}
nsIURI* nsINode::GetBaseURIObject() const { return GetBaseURI(true); }
void nsINode::LookupPrefix(const nsAString& aNamespaceURI, nsAString& aPrefix) {
if (Element* nsElement = GetNameSpaceElement()) {
// XXX Waiting for DOM spec to list error codes.
// Trace up the content parent chain looking for the namespace
// declaration that defines the aNamespaceURI namespace. Once found,
// return the prefix (i.e. the attribute localName).
for (Element* element : nsElement->InclusiveAncestorsOfType<Element>()) {
uint32_t attrCount = element->GetAttrCount();
for (uint32_t i = 0; i < attrCount; ++i) {
const nsAttrName* name = element->GetAttrNameAt(i);
if (name->NamespaceEquals(kNameSpaceID_XMLNS) &&
element->AttrValueIs(kNameSpaceID_XMLNS, name->LocalName(),
aNamespaceURI, eCaseMatters)) {
// If the localName is "xmlns", the prefix we output should be
// null.
nsAtom* localName = name->LocalName();
if (localName != nsGkAtoms::xmlns) {
localName->ToString(aPrefix);
} else {
SetDOMStringToNull(aPrefix);
}
return;
}
}
}
}
SetDOMStringToNull(aPrefix);
}
uint16_t nsINode::CompareDocumentPosition(nsINode& aOtherNode,
Maybe<uint32_t>* aThisIndex,
Maybe<uint32_t>* aOtherIndex) const {
if (this == &aOtherNode) {
return 0;
}
if (GetPreviousSibling() == &aOtherNode) {
MOZ_ASSERT(GetParentNode() == aOtherNode.GetParentNode());
return Node_Binding::DOCUMENT_POSITION_PRECEDING;
}
if (GetNextSibling() == &aOtherNode) {
MOZ_ASSERT(GetParentNode() == aOtherNode.GetParentNode());
return Node_Binding::DOCUMENT_POSITION_FOLLOWING;
}
AutoTArray<const nsINode*, 32> parents1, parents2;
const nsINode* node1 = &aOtherNode;
const nsINode* node2 = this;
// Check if either node is an attribute
const Attr* attr1 = Attr::FromNode(node1);
if (attr1) {
const Element* elem = attr1->GetElement();
// If there is an owner element add the attribute
// to the chain and walk up to the element
if (elem) {
node1 = elem;
parents1.AppendElement(attr1);
}
}
if (auto* attr2 = Attr::FromNode(node2)) {
const Element* elem = attr2->GetElement();
if (elem == node1 && attr1) {
// Both nodes are attributes on the same element.
// Compare position between the attributes.
uint32_t i;
const nsAttrName* attrName;
for (i = 0; (attrName = elem->GetAttrNameAt(i)); ++i) {
if (attrName->Equals(attr1->NodeInfo())) {
NS_ASSERTION(!attrName->Equals(attr2->NodeInfo()),
"Different attrs at same position");
return Node_Binding::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC |
Node_Binding::DOCUMENT_POSITION_PRECEDING;
}
if (attrName->Equals(attr2->NodeInfo())) {
return Node_Binding::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC |
Node_Binding::DOCUMENT_POSITION_FOLLOWING;
}
}
MOZ_ASSERT_UNREACHABLE("neither attribute in the element");
return Node_Binding::DOCUMENT_POSITION_DISCONNECTED;
}
if (elem) {
node2 = elem;
parents2.AppendElement(attr2);
}
}
// We now know that both nodes are either nsIContents or Documents.
// If either node started out as an attribute, that attribute will have
// the same relative position as its ownerElement, except if the
// ownerElement ends up being the container for the other node
// Build the chain of parents
do {
parents1.AppendElement(node1);
node1 = node1->GetParentNode();
} while (node1);
do {
parents2.AppendElement(node2);
node2 = node2->GetParentNode();
} while (node2);
// Check if the nodes are disconnected.
uint32_t pos1 = parents1.Length();
uint32_t pos2 = parents2.Length();
const nsINode* top1 = parents1.ElementAt(--pos1);
const nsINode* top2 = parents2.ElementAt(--pos2);
if (top1 != top2) {
return top1 < top2
? (Node_Binding::DOCUMENT_POSITION_PRECEDING |
Node_Binding::DOCUMENT_POSITION_DISCONNECTED |
Node_Binding::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC)
: (Node_Binding::DOCUMENT_POSITION_FOLLOWING |
Node_Binding::DOCUMENT_POSITION_DISCONNECTED |
Node_Binding::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC);
}
// Find where the parent chain differs and check indices in the parent.
const nsINode* parent = top1;
uint32_t len;
for (len = std::min(pos1, pos2); len > 0; --len) {
const nsINode* child1 = parents1.ElementAt(--pos1);
const nsINode* child2 = parents2.ElementAt(--pos2);
if (child1 != child2) {
// child1 or child2 can be an attribute here. This will work fine since
// ComputeIndexOf will return Nothing for the attribute making the
// attribute be considered before any child.
Maybe<uint32_t> child1Index;
bool cachedChild1Index = false;
if (&aOtherNode == child1 && aOtherIndex) {
cachedChild1Index = true;
child1Index = aOtherIndex->isSome() ? *aOtherIndex
: parent->ComputeIndexOf(child1);
} else {
child1Index = parent->ComputeIndexOf(child1);
}
Maybe<uint32_t> child2Index;
bool cachedChild2Index = false;
if (this == child2 && aThisIndex) {
cachedChild2Index = true;
child2Index =
aThisIndex->isSome() ? *aThisIndex : parent->ComputeIndexOf(child2);
} else {
child2Index = parent->ComputeIndexOf(child2);
}
uint16_t retVal = child1Index < child2Index
? Node_Binding::DOCUMENT_POSITION_PRECEDING
: Node_Binding::DOCUMENT_POSITION_FOLLOWING;
if (cachedChild1Index) {
*aOtherIndex = child1Index;
}
if (cachedChild2Index) {
*aThisIndex = child2Index;
}
return retVal;
}
parent = child1;
}
// We hit the end of one of the parent chains without finding a difference
// between the chains. That must mean that one node is an ancestor of the
// other. The one with the shortest chain must be the ancestor.
return pos1 < pos2 ? (Node_Binding::DOCUMENT_POSITION_PRECEDING |
Node_Binding::DOCUMENT_POSITION_CONTAINS)
: (Node_Binding::DOCUMENT_POSITION_FOLLOWING |
Node_Binding::DOCUMENT_POSITION_CONTAINED_BY);
}
bool nsINode::IsSameNode(nsINode* other) { return other == this; }
bool nsINode::IsEqualNode(nsINode* aOther) {
if (!aOther) {
return false;
}
// Might as well do a quick check to avoid walking our kids if we're
// obviously the same.
if (aOther == this) {
return true;
}
nsAutoString string1, string2;
nsINode* node1 = this;
nsINode* node2 = aOther;
do {
uint16_t nodeType = node1->NodeType();
if (nodeType != node2->NodeType()) {
return false;
}
mozilla::dom::NodeInfo* nodeInfo1 = node1->mNodeInfo;
mozilla::dom::NodeInfo* nodeInfo2 = node2->mNodeInfo;
if (!nodeInfo1->Equals(nodeInfo2) ||
nodeInfo1->GetExtraName() != nodeInfo2->GetExtraName()) {
return false;
}
switch (nodeType) {
case ELEMENT_NODE: {
// Both are elements (we checked that their nodeinfos are equal). Do the
// check on attributes.
Element* element1 = node1->AsElement();
Element* element2 = node2->AsElement();
uint32_t attrCount = element1->GetAttrCount();
if (attrCount != element2->GetAttrCount()) {
return false;
}
// Iterate over attributes.
for (uint32_t i = 0; i < attrCount; ++i) {
const nsAttrName* attrName = element1->GetAttrNameAt(i);
#ifdef DEBUG
bool hasAttr =
#endif
element1->GetAttr(attrName->NamespaceID(), attrName->LocalName(),
string1);
NS_ASSERTION(hasAttr, "Why don't we have an attr?");
if (!element2->AttrValueIs(attrName->NamespaceID(),
attrName->LocalName(), string1,
eCaseMatters)) {
return false;
}
}
break;
}
case TEXT_NODE:
case COMMENT_NODE:
case CDATA_SECTION_NODE:
case PROCESSING_INSTRUCTION_NODE: {
MOZ_ASSERT(node1->IsCharacterData());
MOZ_ASSERT(node2->IsCharacterData());
auto* data1 = static_cast<CharacterData*>(node1);
auto* data2 = static_cast<CharacterData*>(node2);
if (!data1->TextEquals(data2)) {
return false;
}
break;
}
case DOCUMENT_NODE:
case DOCUMENT_FRAGMENT_NODE:
break;
case ATTRIBUTE_NODE: {
NS_ASSERTION(node1 == this && node2 == aOther,
"Did we come upon an attribute node while walking a "
"subtree?");
node1->GetNodeValue(string1);
node2->GetNodeValue(string2);
// Returning here as to not bother walking subtree. And there is no
// risk that we're half way through walking some other subtree since
// attribute nodes doesn't appear in subtrees.
return string1.Equals(string2);
}
case DOCUMENT_TYPE_NODE: {
DocumentType* docType1 = static_cast<DocumentType*>(node1);
DocumentType* docType2 = static_cast<DocumentType*>(node2);