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
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* Implementation of the DOM Range object.
*/
#include "nscore.h"
#include "nsRange.h"
#include "nsDebug.h"
#include "nsString.h"
#include "nsReadableUtils.h"
#include "nsIContent.h"
#include "mozilla/dom/Document.h"
#include "nsError.h"
#include "nsINodeList.h"
#include "nsGkAtoms.h"
#include "nsContentUtils.h"
#include "nsLayoutUtils.h"
#include "nsTextFrame.h"
#include "nsContainerFrame.h"
#include "mozilla/Assertions.h"
#include "mozilla/CheckedInt.h"
#include "mozilla/ContentIterator.h"
#include "mozilla/dom/CharacterData.h"
#include "mozilla/dom/ChildIterator.h"
#include "mozilla/dom/DOMRect.h"
#include "mozilla/dom/DOMStringList.h"
#include "mozilla/dom/DocumentFragment.h"
#include "mozilla/dom/DocumentType.h"
#include "mozilla/dom/RangeBinding.h"
#include "mozilla/dom/Selection.h"
#include "mozilla/dom/Text.h"
#include "mozilla/Logging.h"
#include "mozilla/Maybe.h"
#include "mozilla/PresShell.h"
#include "mozilla/RangeUtils.h"
#include "mozilla/Telemetry.h"
#include "mozilla/ToString.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/Likely.h"
#include "nsCSSFrameConstructor.h"
#include "nsStyleStruct.h"
#include "nsStyleStructInlines.h"
#include "nsComputedDOMStyle.h"
#include "mozilla/dom/InspectorFontFace.h"
namespace mozilla {
extern LazyLogModule sSelectionAPILog;
extern void LogStackForSelectionAPI();
template <typename SPT, typename SRT, typename EPT, typename ERT>
static void LogSelectionAPI(const dom::Selection* aSelection,
const char* aFuncName, const char* aArgName1,
const RangeBoundaryBase<SPT, SRT>& aBoundary1,
const char* aArgName2,
const RangeBoundaryBase<EPT, ERT>& aBoundary2,
const char* aArgName3, bool aBoolArg) {
if (aBoundary1 == aBoundary2) {
MOZ_LOG(sSelectionAPILog, LogLevel::Info,
("%p nsRange::%s(%s=%s=%s, %s=%s)", aSelection, aFuncName,
aArgName1, aArgName2, ToString(aBoundary1).c_str(), aArgName3,
aBoolArg ? "true" : "false"));
} else {
MOZ_LOG(
sSelectionAPILog, LogLevel::Info,
("%p nsRange::%s(%s=%s, %s=%s, %s=%s)", aSelection, aFuncName,
aArgName1, ToString(aBoundary1).c_str(), aArgName2,
ToString(aBoundary2).c_str(), aArgName3, aBoolArg ? "true" : "false"));
}
}
} // namespace mozilla
using namespace mozilla;
using namespace mozilla::dom;
SelectionListWrapper::SelectionListWrapper(Selection* aSelection)
: mSelection(aSelection) {}
NS_IMPL_CYCLE_COLLECTION(SelectionListWrapper)
Selection* SelectionListWrapper::Get() const { return mSelection; }
template already_AddRefed<nsRange> nsRange::Create(
const RangeBoundary& aStartBoundary, const RangeBoundary& aEndBoundary,
ErrorResult& aRv);
template already_AddRefed<nsRange> nsRange::Create(
const RangeBoundary& aStartBoundary, const RawRangeBoundary& aEndBoundary,
ErrorResult& aRv);
template already_AddRefed<nsRange> nsRange::Create(
const RawRangeBoundary& aStartBoundary, const RangeBoundary& aEndBoundary,
ErrorResult& aRv);
template already_AddRefed<nsRange> nsRange::Create(
const RawRangeBoundary& aStartBoundary,
const RawRangeBoundary& aEndBoundary, ErrorResult& aRv);
template nsresult nsRange::SetStartAndEnd(const RangeBoundary& aStartBoundary,
const RangeBoundary& aEndBoundary);
template nsresult nsRange::SetStartAndEnd(const RangeBoundary& aStartBoundary,
const RawRangeBoundary& aEndBoundary);
template nsresult nsRange::SetStartAndEnd(
const RawRangeBoundary& aStartBoundary, const RangeBoundary& aEndBoundary);
template nsresult nsRange::SetStartAndEnd(
const RawRangeBoundary& aStartBoundary,
const RawRangeBoundary& aEndBoundary);
template void nsRange::DoSetRange(const RangeBoundary& aStartBoundary,
const RangeBoundary& aEndBoundary,
nsINode* aRootNode, bool aNotInsertedYet);
template void nsRange::DoSetRange(const RangeBoundary& aStartBoundary,
const RawRangeBoundary& aEndBoundary,
nsINode* aRootNode, bool aNotInsertedYet);
template void nsRange::DoSetRange(const RawRangeBoundary& aStartBoundary,
const RangeBoundary& aEndBoundary,
nsINode* aRootNode, bool aNotInsertedYet);
template void nsRange::DoSetRange(const RawRangeBoundary& aStartBoundary,
const RawRangeBoundary& aEndBoundary,
nsINode* aRootNode, bool aNotInsertedYet);
JSObject* nsRange::WrapObject(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto) {
return Range_Binding::Wrap(aCx, this, aGivenProto);
}
DocGroup* nsRange::GetDocGroup() const {
return mOwner ? mOwner->GetDocGroup() : nullptr;
}
/******************************************************
* stack based utility class for managing monitor
******************************************************/
static void InvalidateAllFrames(nsINode* aNode) {
MOZ_ASSERT(aNode, "bad arg");
nsIFrame* frame = nullptr;
switch (aNode->NodeType()) {
case nsINode::TEXT_NODE:
case nsINode::ELEMENT_NODE: {
nsIContent* content = static_cast<nsIContent*>(aNode);
frame = content->GetPrimaryFrame();
break;
}
case nsINode::DOCUMENT_NODE: {
Document* doc = static_cast<Document*>(aNode);
PresShell* presShell = doc ? doc->GetPresShell() : nullptr;
frame = presShell ? presShell->GetRootFrame() : nullptr;
break;
}
}
for (nsIFrame* f = frame; f; f = f->GetNextContinuation()) {
f->InvalidateFrameSubtree();
}
}
/******************************************************
* constructor/destructor
******************************************************/
nsTArray<RefPtr<nsRange>>* nsRange::sCachedRanges = nullptr;
nsRange::~nsRange() {
NS_ASSERTION(!IsInAnySelection(), "deleting nsRange that is in use");
// we want the side effects (releases and list removals)
DoSetRange(RawRangeBoundary(), RawRangeBoundary(), nullptr);
}
nsRange::nsRange(nsINode* aNode)
: AbstractRange(aNode, /* aIsDynamicRange = */ true),
mRegisteredClosestCommonInclusiveAncestor(nullptr),
mNextStartRef(nullptr),
mNextEndRef(nullptr) {
// printf("Size of nsRange: %zu\n", sizeof(nsRange));
static_assert(sizeof(nsRange) <= 216,
"nsRange size shouldn't be increased as far as possible");
}
/* static */
already_AddRefed<nsRange> nsRange::Create(nsINode* aNode) {
MOZ_ASSERT(aNode);
if (!sCachedRanges || sCachedRanges->IsEmpty()) {
return do_AddRef(new nsRange(aNode));
}
RefPtr<nsRange> range = sCachedRanges->PopLastElement().forget();
range->Init(aNode);
return range.forget();
}
/* static */
template <typename SPT, typename SRT, typename EPT, typename ERT>
already_AddRefed<nsRange> nsRange::Create(
const RangeBoundaryBase<SPT, SRT>& aStartBoundary,
const RangeBoundaryBase<EPT, ERT>& aEndBoundary, ErrorResult& aRv) {
// If we fail to initialize the range a lot, nsRange should have a static
// initializer since the allocation cost is not cheap in hot path.
RefPtr<nsRange> range = nsRange::Create(aStartBoundary.Container());
aRv = range->SetStartAndEnd(aStartBoundary, aEndBoundary);
if (NS_WARN_IF(aRv.Failed())) {
return nullptr;
}
return range.forget();
}
/******************************************************
* nsISupports
******************************************************/
NS_IMPL_MAIN_THREAD_ONLY_CYCLE_COLLECTING_ADDREF(nsRange)
NS_IMPL_MAIN_THREAD_ONLY_CYCLE_COLLECTING_RELEASE_WITH_INTERRUPTABLE_LAST_RELEASE(
nsRange, DoSetRange(RawRangeBoundary(), RawRangeBoundary(), nullptr),
MaybeInterruptLastRelease())
// QueryInterface implementation for nsRange
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsRange)
NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
NS_INTERFACE_MAP_END_INHERITING(AbstractRange)
NS_IMPL_CYCLE_COLLECTION_CLASS(nsRange)
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsRange, AbstractRange)
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSelections);
// We _could_ just rely on Reset() to
// UnregisterClosestCommonInclusiveAncestor(), but it wouldn't know we're
// calling it from Unlink and so would do more work than it really needs to.
if (tmp->mRegisteredClosestCommonInclusiveAncestor) {
tmp->UnregisterClosestCommonInclusiveAncestor(
tmp->mRegisteredClosestCommonInclusiveAncestor, true);
}
tmp->Reset();
MOZ_DIAGNOSTIC_ASSERT(!tmp->isInList(),
"Shouldn't be registered now that we're unlinking");
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsRange, AbstractRange)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRoot)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelections)
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN_INHERITED(nsRange, AbstractRange)
NS_IMPL_CYCLE_COLLECTION_TRACE_END
bool nsRange::MaybeInterruptLastRelease() {
bool interrupt = AbstractRange::MaybeCacheToReuse(*this);
MOZ_ASSERT(!interrupt || IsCleared());
return interrupt;
}
static void MarkDescendants(nsINode* aNode) {
// Set NodeIsDescendantOfClosestCommonInclusiveAncestorForRangeInSelection on
// aNode's descendants unless aNode is already marked as a range common
// ancestor or a descendant of one, in which case all of our descendants have
// the bit set already.
if (!aNode->IsMaybeSelected()) {
// don't set the Descendant bit on |aNode| itself
nsINode* node = aNode->GetNextNode(aNode);
while (node) {
node->SetDescendantOfClosestCommonInclusiveAncestorForRangeInSelection();
if (!node->IsClosestCommonInclusiveAncestorForRangeInSelection()) {
node = node->GetNextNode(aNode);
} else {
// optimize: skip this sub-tree since it's marked already.
node = node->GetNextNonChildNode(aNode);
}
}
}
}
static void UnmarkDescendants(nsINode* aNode) {
// Unset NodeIsDescendantOfClosestCommonInclusiveAncestorForRangeInSelection
// on aNode's descendants unless aNode is a descendant of another range common
// ancestor. Also, exclude descendants of range common ancestors (but not the
// common ancestor itself).
if (!aNode
->IsDescendantOfClosestCommonInclusiveAncestorForRangeInSelection()) {
// we know |aNode| doesn't have any bit set
nsINode* node = aNode->GetNextNode(aNode);
while (node) {
node->ClearDescendantOfClosestCommonInclusiveAncestorForRangeInSelection();
if (!node->IsClosestCommonInclusiveAncestorForRangeInSelection()) {
node = node->GetNextNode(aNode);
} else {
// We found an ancestor of an overlapping range, skip its descendants.
node = node->GetNextNonChildNode(aNode);
}
}
}
}
void nsRange::RegisterClosestCommonInclusiveAncestor(nsINode* aNode) {
MOZ_ASSERT(aNode, "bad arg");
MOZ_DIAGNOSTIC_ASSERT(IsInAnySelection(),
"registering range not in selection");
mRegisteredClosestCommonInclusiveAncestor = aNode;
MarkDescendants(aNode);
UniquePtr<LinkedList<nsRange>>& ranges =
aNode->GetClosestCommonInclusiveAncestorRangesPtr();
if (!ranges) {
ranges = MakeUnique<LinkedList<nsRange>>();
}
MOZ_DIAGNOSTIC_ASSERT(!isInList());
ranges->insertBack(this);
aNode->SetClosestCommonInclusiveAncestorForRangeInSelection();
}
void nsRange::UnregisterClosestCommonInclusiveAncestor(nsINode* aNode,
bool aIsUnlinking) {
MOZ_ASSERT(aNode, "bad arg");
NS_ASSERTION(aNode->IsClosestCommonInclusiveAncestorForRangeInSelection(),
"wrong node");
MOZ_DIAGNOSTIC_ASSERT(aNode == mRegisteredClosestCommonInclusiveAncestor,
"wrong node");
LinkedList<nsRange>* ranges =
aNode->GetExistingClosestCommonInclusiveAncestorRanges();
MOZ_ASSERT(ranges);
mRegisteredClosestCommonInclusiveAncestor = nullptr;
#ifdef DEBUG
bool found = false;
for (nsRange* range : *ranges) {
if (range == this) {
found = true;
break;
}
}
MOZ_ASSERT(found,
"We should be in the list on our registered common ancestor");
#endif // DEBUG
remove();
// We don't want to waste time unmarking flags on nodes that are
// being unlinked anyway.
if (!aIsUnlinking && ranges->isEmpty()) {
aNode->ClearClosestCommonInclusiveAncestorForRangeInSelection();
UnmarkDescendants(aNode);
}
}
void nsRange::AdjustNextRefsOnCharacterDataSplit(
const nsIContent& aContent, const CharacterDataChangeInfo& aInfo) {
// If the splitted text node is immediately before a range boundary point
// that refers to a child index (i.e. its parent is the boundary container)
// then we need to adjust the corresponding boundary to account for the new
// text node that will be inserted. However, because the new sibling hasn't
// been inserted yet, that would result in an invalid boundary. Therefore,
// we store the new child in mNext*Ref to make sure we adjust the boundary
// in the next ContentInserted or ContentAppended call.
nsINode* parentNode = aContent.GetParentNode();
if (parentNode == mEnd.Container()) {
if (&aContent == mEnd.Ref()) {
MOZ_ASSERT(aInfo.mDetails->mNextSibling);
mNextEndRef = aInfo.mDetails->mNextSibling;
}
}
if (parentNode == mStart.Container()) {
if (&aContent == mStart.Ref()) {
MOZ_ASSERT(aInfo.mDetails->mNextSibling);
mNextStartRef = aInfo.mDetails->mNextSibling;
}
}
}
nsRange::RangeBoundariesAndRoot
nsRange::DetermineNewRangeBoundariesAndRootOnCharacterDataMerge(
nsIContent* aContent, const CharacterDataChangeInfo& aInfo) const {
RawRangeBoundary newStart;
RawRangeBoundary newEnd;
nsINode* newRoot = nullptr;
// normalize(), aInfo.mDetails->mNextSibling is the merged text node
// that will be removed
nsIContent* removed = aInfo.mDetails->mNextSibling;
if (removed == mStart.Container()) {
CheckedUint32 newStartOffset{
*mStart.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets)};
newStartOffset += aInfo.mChangeStart;
// newStartOffset.isValid() isn't checked explicitly here, because
// newStartOffset.value() contains an assertion.
newStart = {aContent, newStartOffset.value()};
if (MOZ_UNLIKELY(removed == mRoot)) {
newRoot = RangeUtils::ComputeRootNode(newStart.Container());
}
}
if (removed == mEnd.Container()) {
CheckedUint32 newEndOffset{
*mEnd.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets)};
newEndOffset += aInfo.mChangeStart;
// newEndOffset.isValid() isn't checked explicitly here, because
// newEndOffset.value() contains an assertion.
newEnd = {aContent, newEndOffset.value()};
if (MOZ_UNLIKELY(removed == mRoot)) {
newRoot = {RangeUtils::ComputeRootNode(newEnd.Container())};
}
}
// When the removed text node's parent is one of our boundary nodes we may
// need to adjust the offset to account for the removed node. However,
// there will also be a ContentRemoved notification later so the only cases
// we need to handle here is when the removed node is the text node after
// the boundary. (The m*Offset > 0 check is an optimization - a boundary
// point before the first child is never affected by normalize().)
nsINode* parentNode = aContent->GetParentNode();
if (parentNode == mStart.Container() &&
*mStart.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets) > 0 &&
*mStart.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets) <
parentNode->GetChildCount() &&
removed == mStart.GetChildAtOffset()) {
newStart = {aContent, aInfo.mChangeStart};
}
if (parentNode == mEnd.Container() &&
*mEnd.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets) > 0 &&
*mEnd.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets) <
parentNode->GetChildCount() &&
removed == mEnd.GetChildAtOffset()) {
newEnd = {aContent, aInfo.mChangeEnd};
}
return {newStart, newEnd, newRoot};
}
/******************************************************
* nsIMutationObserver implementation
******************************************************/
void nsRange::CharacterDataChanged(nsIContent* aContent,
const CharacterDataChangeInfo& aInfo) {
MOZ_ASSERT(aContent);
MOZ_ASSERT(mIsPositioned);
MOZ_ASSERT(!mNextEndRef);
MOZ_ASSERT(!mNextStartRef);
nsINode* newRoot = nullptr;
RawRangeBoundary newStart;
RawRangeBoundary newEnd;
if (aInfo.mDetails &&
aInfo.mDetails->mType == CharacterDataChangeInfo::Details::eSplit) {
AdjustNextRefsOnCharacterDataSplit(*aContent, aInfo);
}
// If the changed node contains our start boundary and the change starts
// before the boundary we'll need to adjust the offset.
if (aContent == mStart.Container() &&
aInfo.mChangeStart <
*mStart.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets)) {
if (aInfo.mDetails) {
// splitText(), aInfo->mDetails->mNextSibling is the new text node
NS_ASSERTION(
aInfo.mDetails->mType == CharacterDataChangeInfo::Details::eSplit,
"only a split can start before the end");
NS_ASSERTION(
*mStart.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets) <=
aInfo.mChangeEnd + 1,
"mStart.Offset() is beyond the end of this node");
const uint32_t newStartOffset =
*mStart.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets) -
aInfo.mChangeStart;
newStart = {aInfo.mDetails->mNextSibling, newStartOffset};
if (MOZ_UNLIKELY(aContent == mRoot)) {
newRoot = RangeUtils::ComputeRootNode(newStart.Container());
}
bool isCommonAncestor =
IsInAnySelection() && mStart.Container() == mEnd.Container();
if (isCommonAncestor) {
UnregisterClosestCommonInclusiveAncestor(mStart.Container(), false);
RegisterClosestCommonInclusiveAncestor(newStart.Container());
}
if (mStart.Container()
->IsDescendantOfClosestCommonInclusiveAncestorForRangeInSelection()) {
newStart.Container()
->SetDescendantOfClosestCommonInclusiveAncestorForRangeInSelection();
}
} else {
// If boundary is inside changed text, position it before change
// else adjust start offset for the change in length.
CheckedUint32 newStartOffset{0};
if (*mStart.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets) <=
aInfo.mChangeEnd) {
newStartOffset = aInfo.mChangeStart;
} else {
newStartOffset =
*mStart.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets);
newStartOffset -= aInfo.LengthOfRemovedText();
newStartOffset += aInfo.mReplaceLength;
}
// newStartOffset.isValid() isn't checked explicitly here, because
// newStartOffset.value() contains an assertion.
newStart = {mStart.Container(), newStartOffset.value()};
}
}
// Do the same thing for the end boundary, except for splitText of a node
// with no parent then only switch to the new node if the start boundary
// did so too (otherwise the range would end up with disconnected nodes).
if (aContent == mEnd.Container() &&
aInfo.mChangeStart <
*mEnd.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets)) {
if (aInfo.mDetails && (aContent->GetParentNode() || newStart.Container())) {
// splitText(), aInfo.mDetails->mNextSibling is the new text node
NS_ASSERTION(
aInfo.mDetails->mType == CharacterDataChangeInfo::Details::eSplit,
"only a split can start before the end");
MOZ_ASSERT(
*mEnd.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets) <=
aInfo.mChangeEnd + 1,
"mEnd.Offset() is beyond the end of this node");
const uint32_t newEndOffset{
*mEnd.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets) -
aInfo.mChangeStart};
newEnd = {aInfo.mDetails->mNextSibling, newEndOffset};
bool isCommonAncestor =
IsInAnySelection() && mStart.Container() == mEnd.Container();
if (isCommonAncestor && !newStart.Container()) {
// The split occurs inside the range.
UnregisterClosestCommonInclusiveAncestor(mStart.Container(), false);
RegisterClosestCommonInclusiveAncestor(
mStart.Container()->GetParentNode());
newEnd.Container()
->SetDescendantOfClosestCommonInclusiveAncestorForRangeInSelection();
} else if (
mEnd.Container()
->IsDescendantOfClosestCommonInclusiveAncestorForRangeInSelection()) {
newEnd.Container()
->SetDescendantOfClosestCommonInclusiveAncestorForRangeInSelection();
}
} else {
CheckedUint32 newEndOffset{0};
if (*mEnd.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets) <=
aInfo.mChangeEnd) {
newEndOffset = aInfo.mChangeStart;
} else {
newEndOffset =
*mEnd.Offset(RangeBoundary::OffsetFilter::kValidOrInvalidOffsets);
newEndOffset -= aInfo.LengthOfRemovedText();
newEndOffset += aInfo.mReplaceLength;
}
// newEndOffset.isValid() isn't checked explicitly here, because
// newEndOffset.value() contains an assertion.
newEnd = {mEnd.Container(), newEndOffset.value()};
}
}
if (aInfo.mDetails &&
aInfo.mDetails->mType == CharacterDataChangeInfo::Details::eMerge) {
MOZ_ASSERT(!newStart.IsSet());
MOZ_ASSERT(!newEnd.IsSet());
RangeBoundariesAndRoot rangeBoundariesAndRoot =
DetermineNewRangeBoundariesAndRootOnCharacterDataMerge(aContent, aInfo);
newStart = rangeBoundariesAndRoot.mStart;
newEnd = rangeBoundariesAndRoot.mEnd;
newRoot = rangeBoundariesAndRoot.mRoot;
}
if (newStart.IsSet() || newEnd.IsSet()) {
if (!newStart.IsSet()) {
newStart = mStart;
}
if (!newEnd.IsSet()) {
newEnd = mEnd;
}
DoSetRange(newStart, newEnd, newRoot ? newRoot : mRoot.get(),
!newEnd.Container()->GetParentNode() ||
!newStart.Container()->GetParentNode());
} else {
nsRange::AssertIfMismatchRootAndRangeBoundaries(
mStart, mEnd, mRoot,
(mStart.IsSet() && !mStart.Container()->GetParentNode()) ||
(mEnd.IsSet() && !mEnd.Container()->GetParentNode()));
}
}
void nsRange::ContentAppended(nsIContent* aFirstNewContent) {
MOZ_ASSERT(mIsPositioned);
nsINode* container = aFirstNewContent->GetParentNode();
MOZ_ASSERT(container);
if (container->IsMaybeSelected() && IsInAnySelection()) {
nsINode* child = aFirstNewContent;
while (child) {
if (!child
->IsDescendantOfClosestCommonInclusiveAncestorForRangeInSelection()) {
MarkDescendants(child);
child
->SetDescendantOfClosestCommonInclusiveAncestorForRangeInSelection();
}
child = child->GetNextSibling();
}
}
if (mNextStartRef || mNextEndRef) {
// A splitText has occurred, if any mNext*Ref was set, we need to adjust
// the range boundaries.
if (mNextStartRef) {
mStart = {mStart.Container(), mNextStartRef};
MOZ_ASSERT(mNextStartRef == aFirstNewContent);
mNextStartRef = nullptr;
}
if (mNextEndRef) {
mEnd = {mEnd.Container(), mNextEndRef};
MOZ_ASSERT(mNextEndRef == aFirstNewContent);
mNextEndRef = nullptr;
}
DoSetRange(mStart, mEnd, mRoot, true);
} else {
nsRange::AssertIfMismatchRootAndRangeBoundaries(mStart, mEnd, mRoot);
}
}
void nsRange::ContentInserted(nsIContent* aChild) {
MOZ_ASSERT(mIsPositioned);
bool updateBoundaries = false;
nsINode* container = aChild->GetParentNode();
MOZ_ASSERT(container);
RawRangeBoundary newStart(mStart);
RawRangeBoundary newEnd(mEnd);
MOZ_ASSERT(aChild->GetParentNode() == container);
// Invalidate boundary offsets if a child that may have moved them was
// inserted.
if (container == mStart.Container()) {
newStart.InvalidateOffset();
updateBoundaries = true;
}
if (container == mEnd.Container()) {
newEnd.InvalidateOffset();
updateBoundaries = true;
}
if (container->IsMaybeSelected() &&
!aChild
->IsDescendantOfClosestCommonInclusiveAncestorForRangeInSelection()) {
MarkDescendants(aChild);
aChild->SetDescendantOfClosestCommonInclusiveAncestorForRangeInSelection();
}
if (mNextStartRef || mNextEndRef) {
if (mNextStartRef) {
newStart = {mStart.Container(), mNextStartRef};
MOZ_ASSERT(mNextStartRef == aChild);
mNextStartRef = nullptr;
}
if (mNextEndRef) {
newEnd = {mEnd.Container(), mNextEndRef};
MOZ_ASSERT(mNextEndRef == aChild);
mNextEndRef = nullptr;
}
updateBoundaries = true;
}
if (updateBoundaries) {
DoSetRange(newStart, newEnd, mRoot);
} else {
nsRange::AssertIfMismatchRootAndRangeBoundaries(mStart, mEnd, mRoot);
}
}
void nsRange::ContentRemoved(nsIContent* aChild, nsIContent* aPreviousSibling) {
MOZ_ASSERT(mIsPositioned);
nsINode* container = aChild->GetParentNode();
MOZ_ASSERT(container);
nsINode* startContainer = mStart.Container();
nsINode* endContainer = mEnd.Container();
RawRangeBoundary newStart;
RawRangeBoundary newEnd;
Maybe<bool> gravitateStart;
bool gravitateEnd;
// Adjust position if a sibling was removed...
if (container == startContainer) {
// We're only interested if our boundary reference was removed, otherwise
// we can just invalidate the offset.
if (aChild == mStart.Ref()) {
newStart = {container, aPreviousSibling};
} else {
newStart = mStart;
newStart.InvalidateOffset();
}
} else {
gravitateStart = Some(startContainer->IsInclusiveDescendantOf(aChild));
if (gravitateStart.value()) {
newStart = {container, aPreviousSibling};
}
}
// Do same thing for end boundry.
if (container == endContainer) {
if (aChild == mEnd.Ref()) {
newEnd = {container, aPreviousSibling};
} else {
newEnd = mEnd;
newEnd.InvalidateOffset();
}
} else {
if (startContainer == endContainer && gravitateStart.isSome()) {
gravitateEnd = gravitateStart.value();
} else {
gravitateEnd = endContainer->IsInclusiveDescendantOf(aChild);
}
if (gravitateEnd) {
newEnd = {container, aPreviousSibling};
}
}
bool newStartIsSet = newStart.IsSet();
bool newEndIsSet = newEnd.IsSet();
if (newStartIsSet || newEndIsSet) {
DoSetRange(newStartIsSet ? newStart : mStart.AsRaw(),
newEndIsSet ? newEnd : mEnd.AsRaw(), mRoot);
} else {
nsRange::AssertIfMismatchRootAndRangeBoundaries(mStart, mEnd, mRoot);
}
MOZ_ASSERT(mStart.Ref() != aChild);
MOZ_ASSERT(mEnd.Ref() != aChild);
if (container->IsMaybeSelected() &&
aChild
->IsDescendantOfClosestCommonInclusiveAncestorForRangeInSelection()) {
aChild
->ClearDescendantOfClosestCommonInclusiveAncestorForRangeInSelection();
UnmarkDescendants(aChild);
}
}
void nsRange::ParentChainChanged(nsIContent* aContent) {
NS_ASSERTION(mRoot == aContent, "Wrong ParentChainChanged notification?");
nsINode* newRoot = RangeUtils::ComputeRootNode(mStart.Container());
NS_ASSERTION(newRoot, "No valid boundary or root found!");
if (newRoot != RangeUtils::ComputeRootNode(mEnd.Container())) {
// Sometimes ordering involved in cycle collection can lead to our
// start parent and/or end parent being disconnected from our root
// without our getting a ContentRemoved notification.
// See bug 846096 for more details.
NS_ASSERTION(mEnd.Container()->IsInNativeAnonymousSubtree(),
"This special case should happen only with "
"native-anonymous content");
// When that happens, bail out and set pointers to null; since we're
// in cycle collection and unreachable it shouldn't matter.
Reset();
return;
}
// This is safe without holding a strong ref to self as long as the change
// of mRoot is the last thing in DoSetRange.
DoSetRange(mStart, mEnd, newRoot);
}
bool nsRange::IsPointComparableToRange(const nsINode& aContainer,
uint32_t aOffset,
ErrorResult& aRv) const {
// our range is in a good state?
if (!mIsPositioned) {
aRv.Throw(NS_ERROR_NOT_INITIALIZED);
return false;
}
if (!aContainer.IsInclusiveDescendantOf(mRoot)) {
// TODO(emilio): Switch to ThrowWrongDocumentError, but IsPointInRange
// relies on the error code right now in order to suppress the exception.
aRv.Throw(NS_ERROR_DOM_WRONG_DOCUMENT_ERR);
return false;
}
auto chromeOnlyAccess = mStart.Container()->ChromeOnlyAccess();
NS_ASSERTION(chromeOnlyAccess == mEnd.Container()->ChromeOnlyAccess(),
"Start and end of a range must be either both native anonymous "
"content or not.");
if (aContainer.ChromeOnlyAccess() != chromeOnlyAccess) {
aRv.ThrowInvalidNodeTypeError(
"Trying to compare restricted with unrestricted nodes");
return false;
}
if (aContainer.NodeType() == nsINode::DOCUMENT_TYPE_NODE) {
aRv.ThrowInvalidNodeTypeError("Trying to compare with a document");
return false;
}
if (aOffset > aContainer.Length()) {
aRv.ThrowIndexSizeError("Offset is out of bounds");
return false;
}
return true;
}
bool nsRange::IsPointInRange(const nsINode& aContainer, uint32_t aOffset,
ErrorResult& aRv) const {
uint16_t compareResult = ComparePoint(aContainer, aOffset, aRv);
// If the node isn't in the range's document, it clearly isn't in the range.
if (aRv.ErrorCodeIs(NS_ERROR_DOM_WRONG_DOCUMENT_ERR)) {
aRv.SuppressException();
return false;
}
return compareResult == 0;
}
int16_t nsRange::ComparePoint(const nsINode& aContainer, uint32_t aOffset,
ErrorResult& aRv) const {
if (!IsPointComparableToRange(aContainer, aOffset, aRv)) {
return 0;
}
const RawRangeBoundary point{const_cast<nsINode*>(&aContainer), aOffset};
MOZ_ASSERT(point.IsSetAndValid());
if (Maybe<int32_t> order = nsContentUtils::ComparePoints(point, mStart);
order && *order <= 0) {
return int16_t(*order);
}
if (Maybe<int32_t> order = nsContentUtils::ComparePoints(mEnd, point);
order && *order == -1) {
return 1;
}
return 0;
}
bool nsRange::IntersectsNode(nsINode& aNode, ErrorResult& aRv) {
if (!mIsPositioned) {
aRv.Throw(NS_ERROR_NOT_INITIALIZED);
return false;
}
nsINode* parent = aNode.GetParentNode();
if (!parent) {
// |parent| is null, so |node|'s root is |node| itself.
return GetRoot() == &aNode;
}
const Maybe<uint32_t> nodeIndex = parent->ComputeIndexOf(&aNode);
if (nodeIndex.isNothing()) {
return false;
}
if (!IsPointComparableToRange(*parent, *nodeIndex, IgnoreErrors())) {
return false;
}
const Maybe<int32_t> startOrder = nsContentUtils::ComparePoints(
mStart.Container(),
*mStart.Offset(RangeBoundary::OffsetFilter::kValidOffsets), parent,
*nodeIndex + 1u);
if (startOrder && (*startOrder < 0)) {
const Maybe<int32_t> endOrder = nsContentUtils::ComparePoints(
parent, *nodeIndex, mEnd.Container(),
*mEnd.Offset(RangeBoundary::OffsetFilter::kValidOffsets));
return endOrder && (*endOrder < 0);
}
return false;
}
/**
* @brief Helper class that creates a local copy of `nsRange::mSelections`.
*
* This class uses the RAII principle to create a local copy of
* `nsRange::mSelections`, which is safely iterable while modifications may
* occur on the original.
* When going out of scope, the local copy is being deleted.
*/
class MOZ_RAII SelectionListLocalCopy final {
public:
explicit SelectionListLocalCopy(
mozilla::LinkedList<RefPtr<SelectionListWrapper>>& aSelectionList) {
for (const auto* elem : aSelectionList) {
mSelectionList.insertBack(new SelectionListWrapper(elem->Get()));
}
}
mozilla::LinkedList<RefPtr<SelectionListWrapper>>& Get() {
return mSelectionList;
}
~SelectionListLocalCopy() { mSelectionList.clear(); }
private:
mozilla::LinkedList<RefPtr<SelectionListWrapper>> mSelectionList;
};
void nsRange::NotifySelectionListenersAfterRangeSet() {
if (!mSelections.isEmpty()) {
// Our internal code should not move focus with using this instance while
// it's calling Selection::NotifySelectionListeners() which may move focus
// or calls selection listeners. So, let's set mCalledByJS to false here
// since non-*JS() methods don't set it to false.
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = false;
// Notify all Selections. This may modify the range,
// remove it from the selection, or the selection itself may have gone after
// the call. Also, new selections may be added.
// To ensure that listeners are notified for all *current* selections,
// create a copy of the list of selections and use that for iterating. This
// way selections can be added or removed safely during iteration.
// To save allocation cost, the copy is only created if there is more than
// one Selection present (which will barely ever be the case).
if (IsPartOfOneSelectionOnly()) {
RefPtr<Selection> selection = mSelections.getFirst()->Get();
selection->NotifySelectionListeners(calledByJSRestorer.SavedValue());
} else {
SelectionListLocalCopy copiedSelections{mSelections};
for (const auto* selectionWrapper : copiedSelections.Get()) {
RefPtr<Selection> selection = selectionWrapper->Get();
selection->NotifySelectionListeners(calledByJSRestorer.SavedValue());
}
}
}
}
/******************************************************
* Private helper routines
******************************************************/
// static
template <typename SPT, typename SRT, typename EPT, typename ERT>
void nsRange::AssertIfMismatchRootAndRangeBoundaries(
const RangeBoundaryBase<SPT, SRT>& aStartBoundary,
const RangeBoundaryBase<EPT, ERT>& aEndBoundary, const nsINode* aRootNode,
bool aNotInsertedYet /* = false */) {
#ifdef DEBUG
if (!aRootNode) {
MOZ_ASSERT(!aStartBoundary.IsSet());
MOZ_ASSERT(!aEndBoundary.IsSet());
return;
}
MOZ_ASSERT(aStartBoundary.IsSet());
MOZ_ASSERT(aEndBoundary.IsSet());
if (!aNotInsertedYet) {
// Compute temporary root for given range boundaries. If a range in native
// anonymous subtree is being removed, tempRoot may return the fragment's
// root content, but it shouldn't be used for new root node because the node
// may be bound to the root element again.
nsINode* tempRoot = RangeUtils::ComputeRootNode(aStartBoundary.Container());
// The new range should be in the temporary root node at least.
MOZ_ASSERT(tempRoot ==
RangeUtils::ComputeRootNode(aEndBoundary.Container()));
MOZ_ASSERT(aStartBoundary.Container()->IsInclusiveDescendantOf(tempRoot));
MOZ_ASSERT(aEndBoundary.Container()->IsInclusiveDescendantOf(tempRoot));
// If the new range is not disconnected or not in native anonymous subtree,
// the temporary root must be same as the new root node. Otherwise,
// aRootNode should be the parent of root of the NAC (e.g., `<input>` if the
// range is in NAC under `<input>`), but tempRoot is now root content node
// of the disconnected subtree (e.g., `<div>` element in `<input>` element).
const bool tempRootIsDisconnectedNAC =
tempRoot->IsInNativeAnonymousSubtree() && !tempRoot->GetParentNode();
MOZ_ASSERT_IF(!tempRootIsDisconnectedNAC, tempRoot == aRootNode);
}
MOZ_ASSERT(aRootNode->IsDocument() || aRootNode->IsAttr() ||
aRootNode->IsDocumentFragment() || aRootNode->IsContent());
#endif // #ifdef DEBUG
}
// It's important that all setting of the range start/end points
// go through this function, which will do all the right voodoo
// for content notification of range ownership.
// Calling DoSetRange with either parent argument null will collapse
// the range to have both endpoints point to the other node
template <typename SPT, typename SRT, typename EPT, typename ERT>
void nsRange::DoSetRange(const RangeBoundaryBase<SPT, SRT>& aStartBoundary,
const RangeBoundaryBase<EPT, ERT>& aEndBoundary,
nsINode* aRootNode,
bool aNotInsertedYet /* = false */) {
mIsPositioned = aStartBoundary.IsSetAndValid() &&
aEndBoundary.IsSetAndValid() && aRootNode;
MOZ_ASSERT_IF(!mIsPositioned, !aStartBoundary.IsSet());
MOZ_ASSERT_IF(!mIsPositioned, !aEndBoundary.IsSet());
MOZ_ASSERT_IF(!mIsPositioned, !aRootNode);
nsRange::AssertIfMismatchRootAndRangeBoundaries(aStartBoundary, aEndBoundary,
aRootNode, aNotInsertedYet);
if (mRoot != aRootNode) {
if (mRoot) {
mRoot->RemoveMutationObserver(this);
}
if (aRootNode) {
aRootNode->AddMutationObserver(this);
}
}
bool checkCommonAncestor =
(mStart.Container() != aStartBoundary.Container() ||
mEnd.Container() != aEndBoundary.Container()) &&
IsInAnySelection() && !aNotInsertedYet;
// GetClosestCommonInclusiveAncestor is unreliable while we're unlinking
// (could return null if our start/end have already been unlinked), so make
// sure to not use it here to determine our "old" current ancestor.
mStart = aStartBoundary;
mEnd = aEndBoundary;
if (checkCommonAncestor) {
nsINode* oldCommonAncestor = mRegisteredClosestCommonInclusiveAncestor;
nsINode* newCommonAncestor = GetClosestCommonInclusiveAncestor();
if (newCommonAncestor != oldCommonAncestor) {
if (oldCommonAncestor) {
UnregisterClosestCommonInclusiveAncestor(oldCommonAncestor, false);
}
if (newCommonAncestor) {
RegisterClosestCommonInclusiveAncestor(newCommonAncestor);
} else {
MOZ_DIAGNOSTIC_ASSERT(!mIsPositioned, "unexpected disconnected nodes");
mSelections.clear();
MOZ_DIAGNOSTIC_ASSERT(
!mRegisteredClosestCommonInclusiveAncestor,
"How can we have a registered common ancestor when we "
"didn't register ourselves?");
MOZ_DIAGNOSTIC_ASSERT(!isInList(),
"Shouldn't be registered if we have no "
"mRegisteredClosestCommonInclusiveAncestor");
}
}
}
// This needs to be the last thing this function does, other than notifying
// selection listeners. See comment in ParentChainChanged.
if (mRoot != aRootNode) {
mRoot = aRootNode;
}
// Notify any selection listeners. This has to occur last because otherwise
// the world could be observed by a selection listener while the range was in
// an invalid state. So we run it off of a script runner to ensure it runs
// after the mutation observers have finished running.
if (!mSelections.isEmpty()) {
if (MOZ_LOG_TEST(sSelectionAPILog, LogLevel::Info)) {
for (const RefPtr<SelectionListWrapper>& wrapper : mSelections) {
if (wrapper && wrapper->Get() &&
wrapper->Get()->Type() == SelectionType::eNormal) {
LogSelectionAPI(wrapper->Get(), __FUNCTION__, "aStartBoundary",
aStartBoundary, "aEndBoundary", aEndBoundary,
"aNotInsertedYet", aNotInsertedYet);
LogStackForSelectionAPI();
}
}
}
nsContentUtils::AddScriptRunner(
NewRunnableMethod("NotifySelectionListenersAfterRangeSet", this,
&nsRange::NotifySelectionListenersAfterRangeSet));
}
}
bool nsRange::IsInSelection(const Selection& aSelection) const {
for (const auto* selectionWrapper : mSelections) {
if (selectionWrapper->Get() == &aSelection) {
return true;
}
}
return false;
}
void nsRange::RegisterSelection(Selection& aSelection) {
if (IsInSelection(aSelection)) {
return;
}
bool isFirstSelection = mSelections.isEmpty();
mSelections.insertBack(new SelectionListWrapper(&aSelection));
if (isFirstSelection && !mRegisteredClosestCommonInclusiveAncestor) {
nsINode* commonAncestor = GetClosestCommonInclusiveAncestor();
MOZ_ASSERT(commonAncestor, "unexpected disconnected nodes");
RegisterClosestCommonInclusiveAncestor(commonAncestor);
}
}
const mozilla::LinkedList<RefPtr<mozilla::SelectionListWrapper>>&
nsRange::GetSelections() const {
return mSelections;
}
void nsRange::UnregisterSelection(Selection& aSelection) {
for (auto* selectionWrapper : mSelections) {
if (selectionWrapper->Get() == &aSelection) {
selectionWrapper->remove();
break;
}
}
if (mSelections.isEmpty() && mRegisteredClosestCommonInclusiveAncestor) {
UnregisterClosestCommonInclusiveAncestor(
mRegisteredClosestCommonInclusiveAncestor, false);
MOZ_DIAGNOSTIC_ASSERT(
!mRegisteredClosestCommonInclusiveAncestor,
"How can we have a registered common ancestor when we "
"just unregistered?");
MOZ_DIAGNOSTIC_ASSERT(
!isInList(),
"Shouldn't be registered if we have no "
"mRegisteredClosestCommonInclusiveAncestor after unregistering");
}
}
void nsRange::Reset() {
DoSetRange(RawRangeBoundary(), RawRangeBoundary(), nullptr);
}
/******************************************************
* public functionality
******************************************************/
void nsRange::SetStartJS(nsINode& aNode, uint32_t aOffset, ErrorResult& aErr) {
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = true;
SetStart(aNode, aOffset, aErr);
}
bool nsRange::CanAccess(const nsINode& aNode) const {
if (nsContentUtils::LegacyIsCallerNativeCode()) {
return true;
}
return nsContentUtils::CanCallerAccess(&aNode);
}
void nsRange::SetStart(nsINode& aNode, uint32_t aOffset, ErrorResult& aRv) {
if (!CanAccess(aNode)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
AutoInvalidateSelection atEndOfBlock(this);
SetStart(RawRangeBoundary(&aNode, aOffset), aRv);
}
void nsRange::SetStart(const RawRangeBoundary& aPoint, ErrorResult& aRv) {
nsINode* newRoot = RangeUtils::ComputeRootNode(aPoint.Container());
if (!newRoot) {
aRv.Throw(NS_ERROR_DOM_INVALID_NODE_TYPE_ERR);
return;
}
if (!aPoint.IsSetAndValid()) {
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return;
}
// Collapse if not positioned yet, if positioned in another doc or
// if the new start is after end.
const bool collapse = [&]() {
if (!mIsPositioned || (newRoot != mRoot)) {
return true;
}
const Maybe<int32_t> order = nsContentUtils::ComparePoints(aPoint, mEnd);
if (order) {
return *order == 1;
}
MOZ_ASSERT_UNREACHABLE();
return true;
}();
if (collapse) {
DoSetRange(aPoint, aPoint, newRoot);
return;
}
DoSetRange(aPoint, mEnd, mRoot);
}
void nsRange::SetStartBeforeJS(nsINode& aNode, ErrorResult& aErr) {
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = true;
SetStartBefore(aNode, aErr);
}
void nsRange::SetStartBefore(nsINode& aNode, ErrorResult& aRv) {
if (!CanAccess(aNode)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
AutoInvalidateSelection atEndOfBlock(this);
// If the node is being removed from its parent, GetRawRangeBoundaryBefore()
// returns unset instance. Then, SetStart() will throw
// NS_ERROR_DOM_INVALID_NODE_TYPE_ERR.
SetStart(RangeUtils::GetRawRangeBoundaryBefore(&aNode), aRv);
}
void nsRange::SetStartAfterJS(nsINode& aNode, ErrorResult& aErr) {
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = true;
SetStartAfter(aNode, aErr);
}
void nsRange::SetStartAfter(nsINode& aNode, ErrorResult& aRv) {
if (!CanAccess(aNode)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
AutoInvalidateSelection atEndOfBlock(this);
// If the node is being removed from its parent, GetRawRangeBoundaryAfter()
// returns unset instance. Then, SetStart() will throw
// NS_ERROR_DOM_INVALID_NODE_TYPE_ERR.
SetStart(RangeUtils::GetRawRangeBoundaryAfter(&aNode), aRv);
}
void nsRange::SetEndJS(nsINode& aNode, uint32_t aOffset, ErrorResult& aErr) {
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = true;
SetEnd(aNode, aOffset, aErr);
}
void nsRange::SetEnd(nsINode& aNode, uint32_t aOffset, ErrorResult& aRv) {
if (!CanAccess(aNode)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
AutoInvalidateSelection atEndOfBlock(this);
SetEnd(RawRangeBoundary(&aNode, aOffset), aRv);
}
void nsRange::SetEnd(const RawRangeBoundary& aPoint, ErrorResult& aRv) {
nsINode* newRoot = RangeUtils::ComputeRootNode(aPoint.Container());
if (!newRoot) {
aRv.Throw(NS_ERROR_DOM_INVALID_NODE_TYPE_ERR);
return;
}
if (!aPoint.IsSetAndValid()) {
aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
return;
}
// Collapse if not positioned yet, if positioned in another doc or
// if the new end is before start.
const bool collapse = [&]() {
if (!mIsPositioned || (newRoot != mRoot)) {
return true;
}
const Maybe<int32_t> order = nsContentUtils::ComparePoints(mStart, aPoint);
if (order) {
return *order == 1;
}
MOZ_ASSERT_UNREACHABLE();
return true;
}();
if (collapse) {
DoSetRange(aPoint, aPoint, newRoot);
return;
}
DoSetRange(mStart, aPoint, mRoot);
}
void nsRange::SelectNodesInContainer(nsINode* aContainer,
nsIContent* aStartContent,
nsIContent* aEndContent) {
MOZ_ASSERT(aContainer);
MOZ_ASSERT(aContainer->ComputeIndexOf(aStartContent).valueOr(0) <=
aContainer->ComputeIndexOf(aEndContent).valueOr(0));
MOZ_ASSERT(aStartContent &&
aContainer->ComputeIndexOf(aStartContent).isSome());
MOZ_ASSERT(aEndContent && aContainer->ComputeIndexOf(aEndContent).isSome());
nsINode* newRoot = RangeUtils::ComputeRootNode(aContainer);
MOZ_ASSERT(newRoot);
if (!newRoot) {
return;
}
RawRangeBoundary start(aContainer, aStartContent->GetPreviousSibling());
RawRangeBoundary end(aContainer, aEndContent);
DoSetRange(start, end, newRoot);
}
void nsRange::SetEndBeforeJS(nsINode& aNode, ErrorResult& aErr) {
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = true;
SetEndBefore(aNode, aErr);
}
void nsRange::SetEndBefore(nsINode& aNode, ErrorResult& aRv) {
if (!CanAccess(aNode)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
AutoInvalidateSelection atEndOfBlock(this);
// If the node is being removed from its parent, GetRawRangeBoundaryBefore()
// returns unset instance. Then, SetEnd() will throw
// NS_ERROR_DOM_INVALID_NODE_TYPE_ERR.
SetEnd(RangeUtils::GetRawRangeBoundaryBefore(&aNode), aRv);
}
void nsRange::SetEndAfterJS(nsINode& aNode, ErrorResult& aErr) {
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = true;
SetEndAfter(aNode, aErr);
}
void nsRange::SetEndAfter(nsINode& aNode, ErrorResult& aRv) {
if (!CanAccess(aNode)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
AutoInvalidateSelection atEndOfBlock(this);
// If the node is being removed from its parent, GetRawRangeBoundaryAfter()
// returns unset instance. Then, SetEnd() will throw
// NS_ERROR_DOM_INVALID_NODE_TYPE_ERR.
SetEnd(RangeUtils::GetRawRangeBoundaryAfter(&aNode), aRv);
}
void nsRange::Collapse(bool aToStart) {
if (!mIsPositioned) return;
AutoInvalidateSelection atEndOfBlock(this);
if (aToStart) {
DoSetRange(mStart, mStart, mRoot);
} else {
DoSetRange(mEnd, mEnd, mRoot);
}
}
void nsRange::CollapseJS(bool aToStart) {
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = true;
Collapse(aToStart);
}
void nsRange::SelectNodeJS(nsINode& aNode, ErrorResult& aErr) {
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = true;
SelectNode(aNode, aErr);
}
void nsRange::SelectNode(nsINode& aNode, ErrorResult& aRv) {
if (!CanAccess(aNode)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
nsINode* container = aNode.GetParentNode();
nsINode* newRoot = RangeUtils::ComputeRootNode(container);
if (!newRoot) {
aRv.Throw(NS_ERROR_DOM_INVALID_NODE_TYPE_ERR);
return;
}
const Maybe<uint32_t> index = container->ComputeIndexOf(&aNode);
// MOZ_ASSERT(index.isSome());
// We need to compute the index here unfortunately, because, while we have
// support for XBL, |container| may be the node's binding parent without
// actually containing it.
if (MOZ_UNLIKELY(NS_WARN_IF(index.isNothing()))) {
aRv.Throw(NS_ERROR_DOM_INVALID_NODE_TYPE_ERR);
return;
}
AutoInvalidateSelection atEndOfBlock(this);
DoSetRange(RawRangeBoundary{container, *index},
RawRangeBoundary{container, *index + 1u}, newRoot);
}
void nsRange::SelectNodeContentsJS(nsINode& aNode, ErrorResult& aErr) {
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = true;
SelectNodeContents(aNode, aErr);
}
void nsRange::SelectNodeContents(nsINode& aNode, ErrorResult& aRv) {
if (!CanAccess(aNode)) {
aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
return;
}
nsINode* newRoot = RangeUtils::ComputeRootNode(&aNode);
if (!newRoot) {
aRv.Throw(NS_ERROR_DOM_INVALID_NODE_TYPE_ERR);
return;
}
AutoInvalidateSelection atEndOfBlock(this);
DoSetRange(RawRangeBoundary(&aNode, 0u),
RawRangeBoundary(&aNode, aNode.Length()), newRoot);
}
// The Subtree Content Iterator only returns subtrees that are
// completely within a given range. It doesn't return a CharacterData
// node that contains either the start or end point of the range.,
// nor does it return element nodes when nothing in the element is selected.
// We need an iterator that will also include these start/end points
// so that our methods/algorithms aren't cluttered with special
// case code that tries to include these points while iterating.
//
// The RangeSubtreeIterator class mimics the ContentSubtreeIterator
// methods we need, so should the Content Iterator support the
// start/end points in the future, we can switchover relatively
// easy.
class MOZ_STACK_CLASS RangeSubtreeIterator {
private:
enum RangeSubtreeIterState { eDone = 0, eUseStart, eUseIterator, eUseEnd };
Maybe<ContentSubtreeIterator> mSubtreeIter;
RangeSubtreeIterState mIterState;
nsCOMPtr<nsINode> mStart;
nsCOMPtr<nsINode> mEnd;
public:
RangeSubtreeIterator() : mIterState(eDone) {}
~RangeSubtreeIterator() = default;
nsresult Init(nsRange* aRange);
already_AddRefed<nsINode> GetCurrentNode();
void First();
void Last();
void Next();
void Prev();
bool IsDone() { return mIterState == eDone; }
};
nsresult RangeSubtreeIterator::Init(nsRange* aRange) {
mIterState = eDone;
if (aRange->Collapsed()) {
return NS_OK;
}
// Grab the start point of the range and QI it to
// a CharacterData pointer. If it is CharacterData store
// a pointer to the node.
if (!aRange->IsPositioned()) {
return NS_ERROR_FAILURE;
}
nsINode* node = aRange->GetStartContainer();
if (NS_WARN_IF(!node)) {
return NS_ERROR_FAILURE;
}
if (node->IsCharacterData() ||
(node->IsElement() &&
node->AsElement()->GetChildCount() == aRange->StartOffset())) {
mStart = node;
}
// Grab the end point of the range and QI it to
// a CharacterData pointer. If it is CharacterData store
// a pointer to the node.
node = aRange->GetEndContainer();
if (NS_WARN_IF(!node)) {
return NS_ERROR_FAILURE;
}
if (node->IsCharacterData() ||
(node->IsElement() && aRange->EndOffset() == 0)) {
mEnd = node;
}
if (mStart && mStart == mEnd) {
// The range starts and stops in the same CharacterData
// node. Null out the end pointer so we only visit the
// node once!
mEnd = nullptr;
} else {
// Now create a Content Subtree Iterator to be used
// for the subtrees between the end points!
mSubtreeIter.emplace();
nsresult res = mSubtreeIter->Init(aRange);
if (NS_FAILED(res)) return res;
if (mSubtreeIter->IsDone()) {
// The subtree iterator thinks there's nothing
// to iterate over, so just free it up so we
// don't accidentally call into it.
mSubtreeIter.reset();
}
}
// Initialize the iterator by calling First().
// Note that we are ignoring the return value on purpose!
First();
return NS_OK;
}
already_AddRefed<nsINode> RangeSubtreeIterator::GetCurrentNode() {
nsCOMPtr<nsINode> node;
if (mIterState == eUseStart && mStart) {
node = mStart;
} else if (mIterState == eUseEnd && mEnd) {
node = mEnd;
} else if (mIterState == eUseIterator && mSubtreeIter) {
node = mSubtreeIter->GetCurrentNode();
}
return node.forget();
}
void RangeSubtreeIterator::First() {
if (mStart)
mIterState = eUseStart;
else if (mSubtreeIter) {
mSubtreeIter->First();
mIterState = eUseIterator;
} else if (mEnd)
mIterState = eUseEnd;
else
mIterState = eDone;
}
void RangeSubtreeIterator::Last() {
if (mEnd)
mIterState = eUseEnd;
else if (mSubtreeIter) {
mSubtreeIter->Last();
mIterState = eUseIterator;
} else if (mStart)
mIterState = eUseStart;
else
mIterState = eDone;
}
void RangeSubtreeIterator::Next() {
if (mIterState == eUseStart) {
if (mSubtreeIter) {
mSubtreeIter->First();
mIterState = eUseIterator;
} else if (mEnd)