Masayuki Nakano
deec723b5a
Currently, we allow extending selection range into a shadow of `<use>` even though it's our own closed shadow. Therefore, we need to be consistent about this in the each DOM API. I.e., we should treat the shadow for SVG `<use>` as a part of the flat tree for selection. Additionally, this makes `AbstractRange::RegisterSelection` fallible. When the range boundaries are judged as disconnected, it's our bug, but the crash report does not provide the enough information to us, and it seems that not working selection may make users complain about that. So, we could expect some tests would report the bug. Differential Revision: https://phabricator.services.mozilla.com/D309988
1623 lines
52 KiB
C++
1623 lines
52 KiB
C++
/* 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/. */
|
|
|
|
#include "ContentIterator.h"
|
|
|
|
#include "mozilla/Assertions.h"
|
|
#include "mozilla/DebugOnly.h"
|
|
#include "mozilla/RangeBoundary.h"
|
|
#include "mozilla/RangeUtils.h"
|
|
#include "mozilla/Result.h"
|
|
#include "mozilla/dom/HTMLSlotElement.h"
|
|
#include "mozilla/dom/ShadowRoot.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsElementTable.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIContentInlines.h"
|
|
#include "nsRange.h"
|
|
|
|
namespace mozilla {
|
|
|
|
using namespace dom;
|
|
|
|
#define NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(aResultType, aMethodName, ...) \
|
|
template aResultType ContentIteratorBase<RefPtr<nsINode>>::aMethodName( \
|
|
__VA_ARGS__); \
|
|
template aResultType ContentIteratorBase<nsINode*>::aMethodName(__VA_ARGS__)
|
|
|
|
static bool ComparePostMode(const RawRangeBoundary& aStart,
|
|
const RawRangeBoundary& aEnd, nsINode& aNode) {
|
|
nsINode* parent = aNode.GetParentNode();
|
|
if (!parent) {
|
|
return false;
|
|
}
|
|
|
|
// aNode should always be content, as we have a parent, but let's just be
|
|
// extra careful and check.
|
|
nsIContent* content =
|
|
NS_WARN_IF(!aNode.IsContent()) ? nullptr : aNode.AsContent();
|
|
|
|
// Post mode: start < node <= end.
|
|
RawRangeBoundary afterNode(parent, content);
|
|
const auto isStartLessThanAfterNode = [&]() {
|
|
const Maybe<int32_t> startComparedToAfterNode =
|
|
nsContentUtils::ComparePoints<TreeKind::ShadowIncludingDOM>(aStart,
|
|
afterNode);
|
|
return !NS_WARN_IF(!startComparedToAfterNode) &&
|
|
(*startComparedToAfterNode < 0);
|
|
};
|
|
|
|
const auto isAfterNodeLessOrEqualToEnd = [&]() {
|
|
const Maybe<int32_t> afterNodeComparedToEnd =
|
|
nsContentUtils::ComparePoints<TreeKind::ShadowIncludingDOM>(afterNode,
|
|
aEnd);
|
|
return !NS_WARN_IF(!afterNodeComparedToEnd) &&
|
|
(*afterNodeComparedToEnd <= 0);
|
|
};
|
|
|
|
return isStartLessThanAfterNode() && isAfterNodeLessOrEqualToEnd();
|
|
}
|
|
|
|
static bool ComparePreMode(const RawRangeBoundary& aStart,
|
|
const RawRangeBoundary& aEnd, nsINode& aNode) {
|
|
nsINode* parent = aNode.GetParentNode();
|
|
if (!parent) {
|
|
return false;
|
|
}
|
|
|
|
// Pre mode: start <= node < end.
|
|
RawRangeBoundary beforeNode(parent, aNode.GetPreviousSibling());
|
|
|
|
const auto isStartLessOrEqualToBeforeNode = [&]() {
|
|
const Maybe<int32_t> startComparedToBeforeNode =
|
|
nsContentUtils::ComparePoints<TreeKind::ShadowIncludingDOM>(aStart,
|
|
beforeNode);
|
|
return !NS_WARN_IF(!startComparedToBeforeNode) &&
|
|
(*startComparedToBeforeNode <= 0);
|
|
};
|
|
|
|
const auto isBeforeNodeLessThanEndNode = [&]() {
|
|
const Maybe<int32_t> beforeNodeComparedToEnd =
|
|
nsContentUtils::ComparePoints<TreeKind::ShadowIncludingDOM>(beforeNode,
|
|
aEnd);
|
|
return !NS_WARN_IF(!beforeNodeComparedToEnd) &&
|
|
(*beforeNodeComparedToEnd < 0);
|
|
};
|
|
|
|
return isStartLessOrEqualToBeforeNode() && isBeforeNodeLessThanEndNode();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// NodeIsInTraversalRange: returns true if content is visited during
|
|
// the traversal of the range in the specified mode.
|
|
//
|
|
static bool NodeIsInTraversalRange(nsINode* aNode, bool aIsPreMode,
|
|
const RawRangeBoundary& aStart,
|
|
const RawRangeBoundary& aEnd) {
|
|
if (NS_WARN_IF(!aStart.IsSet()) || NS_WARN_IF(!aEnd.IsSet()) ||
|
|
NS_WARN_IF(!aNode)) {
|
|
return false;
|
|
}
|
|
|
|
// If a leaf node contains an end point of the traversal range, it is
|
|
// always in the traversal range.
|
|
if (aNode == aStart.GetContainer() || aNode == aEnd.GetContainer()) {
|
|
if (aNode->IsCharacterData()) {
|
|
return true; // text node or something
|
|
}
|
|
if (!aNode->HasChildren()) {
|
|
MOZ_ASSERT(
|
|
aNode != aStart.GetContainer() || aStart.IsStartOfContainer(),
|
|
"aStart.GetContainer() doesn't have children and not a data node, "
|
|
"aStart should be at the beginning of its container");
|
|
MOZ_ASSERT(
|
|
aNode != aEnd.GetContainer() || aEnd.IsStartOfContainer(),
|
|
"aEnd.GetContainer() doesn't have children and not a data node, "
|
|
"aEnd should be at the beginning of its container");
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (aIsPreMode) {
|
|
return ComparePreMode(aStart, aEnd, *aNode);
|
|
}
|
|
|
|
return ComparePostMode(aStart, aEnd, *aNode);
|
|
}
|
|
|
|
void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
|
|
PostContentIterator& aField, const char* aName,
|
|
uint32_t aFlags = 0) {
|
|
ImplCycleCollectionTraverse(
|
|
aCallback, static_cast<SafeContentIteratorBase&>(aField), aName, aFlags);
|
|
}
|
|
|
|
void ImplCycleCollectionUnlink(PostContentIterator& aField) {
|
|
ImplCycleCollectionUnlink(static_cast<SafeContentIteratorBase&>(aField));
|
|
}
|
|
|
|
void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
|
|
PreContentIterator& aField, const char* aName,
|
|
uint32_t aFlags = 0) {
|
|
ImplCycleCollectionTraverse(
|
|
aCallback, static_cast<SafeContentIteratorBase&>(aField), aName, aFlags);
|
|
}
|
|
|
|
void ImplCycleCollectionUnlink(PreContentIterator& aField) {
|
|
ImplCycleCollectionUnlink(static_cast<SafeContentIteratorBase&>(aField));
|
|
}
|
|
|
|
void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
|
|
ContentSubtreeIterator& aField,
|
|
const char* aName, uint32_t aFlags = 0) {
|
|
ImplCycleCollectionTraverse(aCallback, aField.mRange, aName, aFlags);
|
|
ImplCycleCollectionTraverse(
|
|
aCallback, static_cast<SafeContentIteratorBase&>(aField), aName, aFlags);
|
|
}
|
|
|
|
void ImplCycleCollectionUnlink(ContentSubtreeIterator& aField) {
|
|
ImplCycleCollectionUnlink(aField.mRange);
|
|
ImplCycleCollectionUnlink(static_cast<SafeContentIteratorBase&>(aField));
|
|
}
|
|
|
|
/******************************************************
|
|
* ContentIteratorBase
|
|
******************************************************/
|
|
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(, ContentIteratorBase, Order);
|
|
|
|
template <typename NodeType>
|
|
ContentIteratorBase<NodeType>::ContentIteratorBase(Order aOrder)
|
|
: mOrder(aOrder) {}
|
|
|
|
template ContentIteratorBase<RefPtr<nsINode>>::~ContentIteratorBase();
|
|
template ContentIteratorBase<nsINode*>::~ContentIteratorBase();
|
|
|
|
template <typename NodeType>
|
|
ContentIteratorBase<NodeType>::~ContentIteratorBase() {
|
|
MOZ_DIAGNOSTIC_ASSERT_IF(mMutationGuard.isSome(),
|
|
!mMutationGuard->Mutated(0));
|
|
}
|
|
|
|
/******************************************************
|
|
* Init routines
|
|
******************************************************/
|
|
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(nsresult, Init, nsINode*);
|
|
|
|
template <typename NodeType>
|
|
nsresult ContentIteratorBase<NodeType>::Init(nsINode* aRoot) {
|
|
if (NS_WARN_IF(!aRoot)) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
|
|
if (mOrder == Order::Pre) {
|
|
mFirst = aRoot;
|
|
mLast = ContentIteratorBase::GetDeepLastInclusiveDescendant<TreeKind::DOM>(
|
|
aRoot);
|
|
NS_WARNING_ASSERTION(mLast, "GetDeepLastInclusiveDescendant returned null");
|
|
} else {
|
|
mFirst =
|
|
ContentIteratorBase::GetDeepFirstInclusiveDescendant<TreeKind::DOM>(
|
|
aRoot);
|
|
NS_WARNING_ASSERTION(mFirst,
|
|
"GetDeepFirstInclusiveDescendant returned null");
|
|
mLast = aRoot;
|
|
}
|
|
|
|
mClosestCommonInclusiveAncestor = aRoot;
|
|
mCurNode = mFirst;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(nsresult, Init, AbstractRange*);
|
|
|
|
template <typename NodeType>
|
|
nsresult ContentIteratorBase<NodeType>::Init(AbstractRange* aRange) {
|
|
if (NS_WARN_IF(!aRange)) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
if (NS_WARN_IF(!aRange->IsPositioned())) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
return InitInternal(aRange->StartRef().AsRaw(), aRange->EndRef().AsRaw());
|
|
}
|
|
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(nsresult, Init, nsINode*, uint32_t,
|
|
nsINode*, uint32_t);
|
|
|
|
template <typename NodeType>
|
|
nsresult ContentIteratorBase<NodeType>::Init(nsINode* aStartContainer,
|
|
uint32_t aStartOffset,
|
|
nsINode* aEndContainer,
|
|
uint32_t aEndOffset) {
|
|
if (NS_WARN_IF(!RangeUtils::IsValidPoints(aStartContainer, aStartOffset,
|
|
aEndContainer, aEndOffset))) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
return InitInternal(RawRangeBoundary(aStartContainer, aStartOffset),
|
|
RawRangeBoundary(aEndContainer, aEndOffset));
|
|
}
|
|
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(nsresult, Init, const RawRangeBoundary&,
|
|
const RawRangeBoundary&);
|
|
|
|
template <typename NodeType>
|
|
nsresult ContentIteratorBase<NodeType>::Init(const RawRangeBoundary& aStart,
|
|
const RawRangeBoundary& aEnd) {
|
|
if (NS_WARN_IF(!RangeUtils::IsValidPoints(aStart, aEnd))) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
return InitInternal(aStart, aEnd);
|
|
}
|
|
|
|
template <typename NodeType>
|
|
nsresult ContentIteratorBase<NodeType>::InitWithoutValidatingPoints(
|
|
const RawRangeBoundary& aStart, const RawRangeBoundary& aEnd) {
|
|
MOZ_DIAGNOSTIC_ASSERT(RangeUtils::IsValidPoints(aStart, aEnd));
|
|
return InitInternal(aStart, aEnd);
|
|
}
|
|
|
|
template <typename NodeType>
|
|
class MOZ_STACK_CLASS ContentIteratorBase<NodeType>::Initializer final {
|
|
public:
|
|
Initializer(ContentIteratorBase<NodeType>& aIterator,
|
|
const RawRangeBoundary& aStart, const RawRangeBoundary& aEnd)
|
|
: mIterator{aIterator},
|
|
mStart{aStart},
|
|
mEnd{aEnd},
|
|
mStartIsCharacterData{mStart.GetContainer()->IsCharacterData()} {
|
|
MOZ_ASSERT(mStart.IsSetAndValid());
|
|
MOZ_ASSERT(mEnd.IsSetAndValid());
|
|
}
|
|
|
|
nsresult Run();
|
|
|
|
private:
|
|
/**
|
|
* @return may be nullptr.
|
|
*/
|
|
nsINode* DetermineFirstNode() const;
|
|
|
|
/**
|
|
* @return may be nullptr.
|
|
*/
|
|
[[nodiscard]] Result<nsINode*, nsresult> DetermineLastNode() const;
|
|
|
|
bool IsCollapsedNonCharacterRange() const;
|
|
bool IsSingleNodeCharacterRange() const;
|
|
|
|
ContentIteratorBase& mIterator;
|
|
const RawRangeBoundary& mStart;
|
|
const RawRangeBoundary& mEnd;
|
|
const bool mStartIsCharacterData;
|
|
};
|
|
|
|
template <>
|
|
nsresult ContentIteratorBase<RefPtr<nsINode>>::InitInternal(
|
|
const RawRangeBoundary& aStart, const RawRangeBoundary& aEnd) {
|
|
Initializer initializer{*this, aStart, aEnd};
|
|
return initializer.Run();
|
|
}
|
|
|
|
template <>
|
|
nsresult ContentIteratorBase<nsINode*>::InitInternal(
|
|
const RawRangeBoundary& aStart, const RawRangeBoundary& aEnd) {
|
|
Initializer initializer{*this, aStart, aEnd};
|
|
nsresult rv = initializer.Run();
|
|
if (NS_FAILED(rv)) {
|
|
return rv;
|
|
}
|
|
mMutationGuard.emplace();
|
|
mAssertNoGC.emplace();
|
|
return NS_OK;
|
|
}
|
|
|
|
template <typename NodeType>
|
|
bool ContentIteratorBase<NodeType>::Initializer::IsCollapsedNonCharacterRange()
|
|
const {
|
|
return !mStartIsCharacterData && mStart == mEnd;
|
|
}
|
|
|
|
template <typename NodeType>
|
|
bool ContentIteratorBase<NodeType>::Initializer::IsSingleNodeCharacterRange()
|
|
const {
|
|
return mStartIsCharacterData && mStart.GetContainer() == mEnd.GetContainer();
|
|
}
|
|
|
|
template <typename NodeType>
|
|
nsresult ContentIteratorBase<NodeType>::Initializer::Run() {
|
|
// get common content parent
|
|
mIterator.mClosestCommonInclusiveAncestor =
|
|
nsContentUtils::GetClosestCommonInclusiveAncestor(mStart.GetContainer(),
|
|
mEnd.GetContainer());
|
|
if (NS_WARN_IF(!mIterator.mClosestCommonInclusiveAncestor)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Check to see if we have a collapsed range, if so, there is nothing to
|
|
// iterate over.
|
|
//
|
|
// XXX: CharacterDataNodes (text nodes) are currently an exception, since
|
|
// we always want to be able to iterate text nodes at the end points
|
|
// of a range.
|
|
|
|
if (IsCollapsedNonCharacterRange()) {
|
|
mIterator.SetEmpty();
|
|
return NS_OK;
|
|
}
|
|
|
|
if (IsSingleNodeCharacterRange()) {
|
|
mIterator.mFirst = mStart.GetContainer()->AsContent();
|
|
mIterator.mLast = mIterator.mFirst;
|
|
mIterator.mCurNode = mIterator.mFirst;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
mIterator.mFirst = DetermineFirstNode();
|
|
|
|
if (Result<nsINode*, nsresult> lastNode = DetermineLastNode();
|
|
NS_WARN_IF(lastNode.isErr())) {
|
|
return lastNode.unwrapErr();
|
|
} else {
|
|
mIterator.mLast = lastNode.unwrap();
|
|
}
|
|
|
|
// If either first or last is null, they both have to be null!
|
|
if (!mIterator.mFirst || !mIterator.mLast) {
|
|
mIterator.SetEmpty();
|
|
}
|
|
|
|
mIterator.mCurNode = mIterator.mFirst;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
template <typename NodeType>
|
|
nsINode* ContentIteratorBase<NodeType>::Initializer::DetermineFirstNode()
|
|
const {
|
|
nsIContent* cChild = nullptr;
|
|
|
|
// Try to get the child at our starting point. This might return null if
|
|
// mStart is immediately after the last node in mStart.GetContainer().
|
|
if (!mStartIsCharacterData) {
|
|
cChild = mStart.GetChildAtOffset();
|
|
}
|
|
|
|
if (!cChild) {
|
|
// No children (possibly a <br> or text node), or index is after last child.
|
|
|
|
if (mIterator.mOrder == Order::Pre) {
|
|
// XXX: In the future, if start offset is after the last
|
|
// character in the cdata node, should we set mFirst to
|
|
// the next sibling?
|
|
|
|
// Normally we would skip the start node because the start node is outside
|
|
// of the range in pre mode. However, if aStartOffset == 0, and the node
|
|
// is a non-container node (e.g. <br>), we don't skip the node in this
|
|
// case in order to address bug 1215798.
|
|
bool startIsContainer = true;
|
|
if (mStart.GetContainer()->IsHTMLElement()) {
|
|
nsAtom* name = mStart.GetContainer()->NodeInfo()->NameAtom();
|
|
startIsContainer =
|
|
nsHTMLElement::IsContainer(nsHTMLTags::AtomTagToId(name));
|
|
}
|
|
if (!mStartIsCharacterData &&
|
|
(startIsContainer || !mStart.IsStartOfContainer())) {
|
|
nsINode* const result =
|
|
ContentIteratorBase::GetNextSibling<TreeKind::DOM>(
|
|
mStart.GetContainer());
|
|
NS_WARNING_ASSERTION(result, "GetNextSibling returned null");
|
|
|
|
// Does mFirst node really intersect the range? The range could be
|
|
// 'degenerate', i.e., not collapsed but still contain no content.
|
|
if (result &&
|
|
NS_WARN_IF(!NodeIsInTraversalRange(
|
|
result, mIterator.mOrder == Order::Pre, mStart, mEnd))) {
|
|
return nullptr;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
return mStart.GetContainer()->AsContent();
|
|
}
|
|
|
|
// post-order
|
|
if (NS_WARN_IF(!mStart.GetContainer()->IsContent())) {
|
|
// What else can we do?
|
|
return nullptr;
|
|
}
|
|
return mStart.GetContainer()->AsContent();
|
|
}
|
|
|
|
if (mIterator.mOrder == Order::Pre) {
|
|
return cChild;
|
|
}
|
|
|
|
// post-order
|
|
nsINode* const result =
|
|
ContentIteratorBase::GetDeepFirstInclusiveDescendant<TreeKind::DOM>(
|
|
cChild);
|
|
NS_WARNING_ASSERTION(result, "GetDeepFirstInclusiveDescendant returned null");
|
|
|
|
// Does mFirst node really intersect the range? The range could be
|
|
// 'degenerate', i.e., not collapsed but still contain no content.
|
|
if (result && !NodeIsInTraversalRange(result, mIterator.mOrder == Order::Pre,
|
|
mStart, mEnd)) {
|
|
return nullptr;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
template <typename NodeType>
|
|
Result<nsINode*, nsresult>
|
|
ContentIteratorBase<NodeType>::Initializer::DetermineLastNode() const {
|
|
const bool endIsCharacterData = mEnd.GetContainer()->IsCharacterData();
|
|
|
|
if (endIsCharacterData || !mEnd.GetContainer()->HasChildren() ||
|
|
mEnd.IsStartOfContainer()) {
|
|
if (mIterator.mOrder == Order::Pre) {
|
|
if (NS_WARN_IF(!mEnd.GetContainer()->IsContent())) {
|
|
// Not much else to do here...
|
|
return nullptr;
|
|
}
|
|
|
|
// If the end node is a non-container element and the end offset is 0,
|
|
// the last element should be the previous node (i.e., shouldn't
|
|
// include the end node in the range).
|
|
bool endIsContainer = true;
|
|
if (mEnd.GetContainer()->IsHTMLElement()) {
|
|
nsAtom* name = mEnd.GetContainer()->NodeInfo()->NameAtom();
|
|
endIsContainer =
|
|
nsHTMLElement::IsContainer(nsHTMLTags::AtomTagToId(name));
|
|
}
|
|
if (!endIsCharacterData && !endIsContainer && mEnd.IsStartOfContainer()) {
|
|
nsINode* const result =
|
|
mIterator.PrevNode<TreeKind::DOM>(mEnd.GetContainer());
|
|
NS_WARNING_ASSERTION(result, "PrevNode returned null");
|
|
if (result && result != mIterator.mFirst &&
|
|
NS_WARN_IF(!NodeIsInTraversalRange(
|
|
result, mIterator.mOrder == Order::Pre,
|
|
RawRangeBoundary::StartOfParent(*mIterator.mFirst), mEnd))) {
|
|
return nullptr;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
return mEnd.GetContainer()->AsContent();
|
|
}
|
|
|
|
// post-order
|
|
//
|
|
// XXX: In the future, if end offset is before the first character in the
|
|
// cdata node, should we set mLast to the prev sibling?
|
|
|
|
if (!endIsCharacterData) {
|
|
nsINode* const result =
|
|
ContentIteratorBase::GetPrevSibling<TreeKind::DOM>(
|
|
mEnd.GetContainer());
|
|
NS_WARNING_ASSERTION(result, "GetPrevSibling returned null");
|
|
|
|
if (!NodeIsInTraversalRange(result, mIterator.mOrder == Order::Pre,
|
|
mStart, mEnd)) {
|
|
return nullptr;
|
|
}
|
|
return result;
|
|
}
|
|
return mEnd.GetContainer()->AsContent();
|
|
}
|
|
|
|
nsIContent* cChild = mEnd.Ref();
|
|
|
|
if (NS_WARN_IF(!cChild)) {
|
|
// No child at offset!
|
|
MOZ_ASSERT_UNREACHABLE("ContentIterator::ContentIterator");
|
|
return Err(NS_ERROR_FAILURE);
|
|
}
|
|
|
|
if (mIterator.mOrder == Order::Pre) {
|
|
nsINode* const result =
|
|
ContentIteratorBase::GetDeepLastInclusiveDescendant<TreeKind::DOM>(
|
|
cChild);
|
|
NS_WARNING_ASSERTION(result,
|
|
"GetDeepLastInclusiveDescendant returned null");
|
|
|
|
if (NS_WARN_IF(!NodeIsInTraversalRange(
|
|
result, mIterator.mOrder == Order::Pre, mStart, mEnd))) {
|
|
return nullptr;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// post-order
|
|
return cChild;
|
|
}
|
|
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(void, SetEmpty);
|
|
|
|
template <typename NodeType>
|
|
void ContentIteratorBase<NodeType>::SetEmpty() {
|
|
mCurNode = nullptr;
|
|
mFirst = nullptr;
|
|
mLast = nullptr;
|
|
mClosestCommonInclusiveAncestor = nullptr;
|
|
}
|
|
|
|
// static
|
|
template <typename NodeType>
|
|
template <TreeKind aKind>
|
|
nsINode* ContentIteratorBase<NodeType>::GetDeepFirstInclusiveDescendant(
|
|
nsINode* aNode) {
|
|
if (NS_WARN_IF(!aNode)) {
|
|
return aNode;
|
|
}
|
|
nsIContent* const firstChild = aNode->GetFirstChild<aKind>();
|
|
if (!firstChild) {
|
|
return aNode;
|
|
}
|
|
return ContentIteratorBase::GetDeepFirstInclusiveDescendant<aKind>(
|
|
firstChild);
|
|
}
|
|
|
|
// static
|
|
template <typename NodeType>
|
|
template <TreeKind aKind>
|
|
nsIContent* ContentIteratorBase<NodeType>::GetDeepFirstInclusiveDescendant(
|
|
nsIContent* aContent) {
|
|
if (NS_WARN_IF(!aContent)) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsIContent* lastContent = aContent;
|
|
while (nsIContent* const firstChild = lastContent->GetFirstChild<aKind>()) {
|
|
lastContent = firstChild;
|
|
}
|
|
return lastContent;
|
|
}
|
|
|
|
// static
|
|
template <typename NodeType>
|
|
template <TreeKind aKind>
|
|
nsINode* ContentIteratorBase<NodeType>::GetDeepLastInclusiveDescendant(
|
|
nsINode* aNode) {
|
|
if (NS_WARN_IF(!aNode)) {
|
|
return aNode;
|
|
}
|
|
nsIContent* const lastChild = aNode->GetLastChild<aKind>();
|
|
if (!lastChild) {
|
|
return aNode;
|
|
}
|
|
return ContentIteratorBase::GetDeepLastInclusiveDescendant<aKind>(lastChild);
|
|
}
|
|
|
|
// static
|
|
template <typename NodeType>
|
|
template <TreeKind aKind>
|
|
nsIContent* ContentIteratorBase<NodeType>::GetDeepLastInclusiveDescendant(
|
|
nsIContent* aContent) {
|
|
if (NS_WARN_IF(!aContent)) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsIContent* lastContent = aContent;
|
|
while (nsIContent* const lastChild = lastContent->GetLastChild<aKind>()) {
|
|
lastContent = lastChild;
|
|
}
|
|
return lastContent;
|
|
}
|
|
|
|
// Get the next sibling, or parent's next sibling, or shadow host's next
|
|
// sibling (when aAllowCrossShadowBoundary is true), or grandpa's next
|
|
// sibling...
|
|
//
|
|
// static
|
|
//
|
|
template <typename NodeType>
|
|
template <TreeKind aKind>
|
|
nsIContent* ContentIteratorBase<NodeType>::GetNextSibling(
|
|
nsINode* aNode, nsTArray<AncestorInfo>* aInclusiveAncestorsOfEndContainer) {
|
|
if (NS_WARN_IF(!aNode)) {
|
|
return nullptr;
|
|
}
|
|
|
|
if constexpr (ShouldHandleAssignedNodesOnSlot<aKind>()) {
|
|
if (aNode->IsContent()) {
|
|
// Could have nested slots
|
|
while (HTMLSlotElement* slot =
|
|
aNode->AsContent()->GetAssignedSlot<aKind>()) {
|
|
// Next sibling of a slotted node should be the next slotted node
|
|
auto assigned = slot->AssignedNodes();
|
|
auto cur = assigned.IndexOf(aNode);
|
|
if (cur != assigned.npos && cur + 1 < assigned.Length()) {
|
|
return assigned[cur + 1]->AsContent();
|
|
}
|
|
// Move on to assigned slot's next sibling
|
|
aNode = slot;
|
|
}
|
|
if (nsIContent* const next =
|
|
ChildIteratorBase<aKind>::GetNextChild(aNode->AsContent())) {
|
|
return next;
|
|
}
|
|
}
|
|
} else {
|
|
if (nsIContent* const next = aNode->GetNextSibling()) {
|
|
return next;
|
|
}
|
|
}
|
|
|
|
nsINode* parent = ShadowDOMSelectionHelpers::GetParentNodeInSameSelection(
|
|
*aNode, aKind == TreeKind::DOM ? AllowRangeCrossShadowBoundary::No
|
|
: AllowRangeCrossShadowBoundary::Yes);
|
|
if (NS_WARN_IF(!parent)) {
|
|
return nullptr;
|
|
}
|
|
|
|
// We now have finished iterating descendants within this shadow root, and
|
|
// reached to the shadow host.
|
|
if constexpr (ShouldHandleAssignedNodesOnSlot<aKind>()) {
|
|
if (aInclusiveAncestorsOfEndContainer &&
|
|
parent->GetShadowRoot<aKind>() == aNode) {
|
|
const int32_t i = aInclusiveAncestorsOfEndContainer->IndexOf(
|
|
parent, 0, InclusiveAncestorComparator());
|
|
|
|
// If parent is an ancestor of the end container, we return the parent so
|
|
// that the caller (ContentSubtreeIterator::Next) can stop the iteration.
|
|
//
|
|
// This is only a special case for ShadowDOM selection where
|
|
// the end container is in light DOM and we have to iterate
|
|
// shadow DOM nodes first. We would have reached to mLast
|
|
// already if this isn't the case.
|
|
if (i != -1) {
|
|
MOZ_ASSERT(!aInclusiveAncestorsOfEndContainer->ElementAt(i)
|
|
.mIsDescendantInShadowTree);
|
|
return parent->AsContent();
|
|
}
|
|
}
|
|
}
|
|
|
|
return ContentIteratorBase::GetNextSibling<aKind>(
|
|
parent, aInclusiveAncestorsOfEndContainer);
|
|
}
|
|
|
|
// Get the prev sibling, or parent's prev sibling, or shadow host's prev sibling
|
|
// (when aAllowCrossShadowBoundary is true), or grandpa's prev sibling... static
|
|
template <typename NodeType>
|
|
template <TreeKind aKind>
|
|
nsIContent* ContentIteratorBase<NodeType>::GetPrevSibling(nsINode* aNode) {
|
|
if (NS_WARN_IF(!aNode)) {
|
|
return nullptr;
|
|
}
|
|
|
|
if constexpr (ShouldHandleAssignedNodesOnSlot<aKind>()) {
|
|
if (aNode->IsContent()) {
|
|
// Could have nested slots.
|
|
while (HTMLSlotElement* slot =
|
|
aNode->AsContent()->GetAssignedSlot<aKind>()) {
|
|
// prev sibling of a slotted node should be the prev slotted node
|
|
auto assigned = slot->AssignedNodes();
|
|
auto cur = assigned.IndexOf(aNode);
|
|
if (cur != assigned.npos && cur != 0) {
|
|
return assigned[cur - 1]->AsContent();
|
|
}
|
|
aNode = slot;
|
|
}
|
|
if (nsIContent* const prev =
|
|
ChildIteratorBase<aKind>::GetPreviousChild(aNode->AsContent())) {
|
|
return prev;
|
|
}
|
|
}
|
|
} else {
|
|
if (nsIContent* const prev = aNode->GetPreviousSibling()) {
|
|
return prev;
|
|
}
|
|
}
|
|
|
|
nsINode* parent = ShadowDOMSelectionHelpers::GetParentNodeInSameSelection(
|
|
*aNode, aKind == TreeKind::DOM ? AllowRangeCrossShadowBoundary::No
|
|
: AllowRangeCrossShadowBoundary::Yes);
|
|
if (NS_WARN_IF(!parent)) {
|
|
return nullptr;
|
|
}
|
|
|
|
return ContentIteratorBase::GetPrevSibling<aKind>(parent);
|
|
}
|
|
|
|
template <typename NodeType>
|
|
template <TreeKind aKind>
|
|
nsINode* ContentIteratorBase<NodeType>::NextNode(nsINode* aNode) {
|
|
nsINode* node = aNode;
|
|
|
|
// if we are a Pre-order iterator, use pre-order
|
|
if (mOrder == Order::Pre) {
|
|
// if it has children then next node is first child
|
|
if (nsIContent* const firstChild = node->GetFirstChild<aKind>()) {
|
|
return firstChild;
|
|
}
|
|
|
|
// else next sibling is next
|
|
return ContentIteratorBase::GetNextSibling<aKind>(node);
|
|
}
|
|
|
|
// post-order
|
|
nsINode* parent = node->GetParentNode<aKind>();
|
|
if (NS_WARN_IF(!parent)) {
|
|
MOZ_ASSERT(parent, "The node is the root node but not the last node");
|
|
mCurNode = nullptr;
|
|
return node;
|
|
}
|
|
|
|
if constexpr (aKind == TreeKind::DOM) {
|
|
if (nsIContent* const sibling = node->GetNextSibling()) {
|
|
// next node is sibling's "deep left" child
|
|
return ContentIteratorBase::GetDeepFirstInclusiveDescendant<aKind>(
|
|
sibling);
|
|
}
|
|
} else if (node->IsContent()) {
|
|
if (nsIContent* const sibling =
|
|
ChildIteratorBase<aKind>::GetNextChild(node->AsContent())) {
|
|
return ContentIteratorBase::GetDeepFirstInclusiveDescendant<aKind>(
|
|
sibling);
|
|
}
|
|
}
|
|
return parent;
|
|
}
|
|
|
|
template <typename NodeType>
|
|
template <TreeKind aKind>
|
|
nsINode* ContentIteratorBase<NodeType>::PrevNode(nsINode* aNode) {
|
|
nsINode* node = aNode;
|
|
|
|
// if we are a Pre-order iterator, use pre-order
|
|
if (mOrder == Order::Pre) {
|
|
nsINode* parent = node->GetParentNode<aKind>();
|
|
if (NS_WARN_IF(!parent)) {
|
|
MOZ_ASSERT(parent, "The node is the root node but not the first node");
|
|
mCurNode = nullptr;
|
|
return aNode;
|
|
}
|
|
if constexpr (aKind == TreeKind::DOM) {
|
|
if (nsIContent* const sibling = node->GetPreviousSibling()) {
|
|
return ContentIteratorBase::GetDeepLastInclusiveDescendant<aKind>(
|
|
sibling);
|
|
}
|
|
} else if (node->IsContent()) {
|
|
if (nsIContent* const sibling =
|
|
ChildIteratorBase<aKind>::GetPreviousChild(node->AsContent())) {
|
|
return ContentIteratorBase::GetDeepLastInclusiveDescendant<aKind>(
|
|
sibling);
|
|
}
|
|
}
|
|
return parent;
|
|
}
|
|
|
|
// post-order
|
|
if (nsIContent* const lastChild = node->GetLastChild<aKind>()) {
|
|
return lastChild;
|
|
}
|
|
|
|
// else prev sibling is previous
|
|
return ContentIteratorBase::GetPrevSibling<aKind>(node);
|
|
}
|
|
|
|
/******************************************************
|
|
* ContentIteratorBase routines
|
|
******************************************************/
|
|
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(void, First);
|
|
|
|
template <typename NodeType>
|
|
void ContentIteratorBase<NodeType>::First() {
|
|
if (!mFirst) {
|
|
MOZ_ASSERT(IsDone());
|
|
mCurNode = nullptr;
|
|
return;
|
|
}
|
|
|
|
mozilla::DebugOnly<nsresult> rv = PositionAt(mFirst);
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to position iterator!");
|
|
}
|
|
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(void, Last);
|
|
|
|
template <typename NodeType>
|
|
void ContentIteratorBase<NodeType>::Last() {
|
|
// Note that mLast can be nullptr if SetEmpty() is called in Init()
|
|
// since at that time, Init() returns NS_OK.
|
|
if (!mLast) {
|
|
MOZ_ASSERT(IsDone());
|
|
mCurNode = nullptr;
|
|
return;
|
|
}
|
|
|
|
mozilla::DebugOnly<nsresult> rv = PositionAt(mLast);
|
|
NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to position iterator!");
|
|
}
|
|
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(void, Next);
|
|
|
|
template <typename NodeType>
|
|
void ContentIteratorBase<NodeType>::Next() {
|
|
if (IsDone()) {
|
|
return;
|
|
}
|
|
|
|
if (mCurNode == mLast) {
|
|
mCurNode = nullptr;
|
|
return;
|
|
}
|
|
|
|
mCurNode = NextNode<TreeKind::DOM>(mCurNode);
|
|
}
|
|
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(void, Prev);
|
|
|
|
template <typename NodeType>
|
|
void ContentIteratorBase<NodeType>::Prev() {
|
|
if (IsDone()) {
|
|
return;
|
|
}
|
|
|
|
if (mCurNode == mFirst) {
|
|
mCurNode = nullptr;
|
|
return;
|
|
}
|
|
|
|
mCurNode = PrevNode<TreeKind::DOM>(mCurNode);
|
|
}
|
|
|
|
// Keeping arrays of indexes for the stack of nodes makes PositionAt
|
|
// interesting...
|
|
NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD(nsresult, PositionAt, nsINode*);
|
|
|
|
template <typename NodeType>
|
|
nsresult ContentIteratorBase<NodeType>::PositionAt(nsINode* aCurNode) {
|
|
if (NS_WARN_IF(!aCurNode)) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
|
|
// take an early out if this doesn't actually change the position
|
|
if (mCurNode == aCurNode) {
|
|
return NS_OK;
|
|
}
|
|
mCurNode = aCurNode;
|
|
|
|
// Check to see if the node falls within the traversal range.
|
|
|
|
RawRangeBoundary first(mFirst, 0u);
|
|
RawRangeBoundary last(mLast, 0u);
|
|
|
|
if (mFirst && mLast) {
|
|
if (mOrder == Order::Pre) {
|
|
// In pre we want to record the point immediately before mFirst, which is
|
|
// the point immediately after mFirst's previous sibling.
|
|
first = {mFirst->GetParentNode(), mFirst->GetPreviousSibling()};
|
|
|
|
// If mLast has no children, then we want to make sure to include it.
|
|
if (!mLast->HasChildren()) {
|
|
last = {mLast->GetParentNode(), mLast->AsContent()};
|
|
}
|
|
} else {
|
|
// If the first node has any children, we want to be immediately after the
|
|
// last. Otherwise we want to be immediately before mFirst.
|
|
if (mFirst->HasChildren()) {
|
|
first = {mFirst, mFirst->GetLastChild()};
|
|
} else {
|
|
first = {mFirst->GetParentNode(), mFirst->GetPreviousSibling()};
|
|
}
|
|
|
|
// Set the last point immediately after the final node.
|
|
last = {mLast->GetParentNode(), mLast->AsContent()};
|
|
}
|
|
}
|
|
|
|
NS_WARNING_ASSERTION(first.IsSetAndValid(), "first is not valid");
|
|
NS_WARNING_ASSERTION(last.IsSetAndValid(), "last is not valid");
|
|
|
|
// The end positions are always in the range even if it has no parent. We
|
|
// need to allow that or 'iter->Init(root)' would assert in Last() or First()
|
|
// for example, bug 327694.
|
|
if (mFirst != mCurNode && mLast != mCurNode &&
|
|
(NS_WARN_IF(!first.IsSet()) || NS_WARN_IF(!last.IsSet()) ||
|
|
NS_WARN_IF(!NodeIsInTraversalRange(mCurNode, mOrder == Order::Pre, first,
|
|
last)))) {
|
|
mCurNode = nullptr;
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/******************************************************
|
|
* ContentSubtreeIterator init routines
|
|
******************************************************/
|
|
|
|
nsresult ContentSubtreeIterator::Init(nsINode* aRoot) {
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
nsresult ContentSubtreeIterator::Init(AbstractRange* aRange) {
|
|
MOZ_ASSERT(aRange);
|
|
|
|
if (NS_WARN_IF(!aRange->IsPositioned())) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
mRange = aRange;
|
|
|
|
return InitWithRange();
|
|
}
|
|
|
|
nsresult ContentSubtreeIterator::Init(nsINode* aStartContainer,
|
|
uint32_t aStartOffset,
|
|
nsINode* aEndContainer,
|
|
uint32_t aEndOffset) {
|
|
return Init(RawRangeBoundary(aStartContainer, aStartOffset),
|
|
RawRangeBoundary(aEndContainer, aEndOffset));
|
|
}
|
|
|
|
nsresult ContentSubtreeIterator::Init(const RawRangeBoundary& aStartBoundary,
|
|
const RawRangeBoundary& aEndBoundary) {
|
|
RefPtr<nsRange> range =
|
|
nsRange::Create(aStartBoundary, aEndBoundary, IgnoreErrors());
|
|
if (NS_WARN_IF(!range) || NS_WARN_IF(!range->IsPositioned())) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
if (NS_WARN_IF(range->MayCrossShadowBoundaryStartRef() != aStartBoundary) ||
|
|
NS_WARN_IF(range->MayCrossShadowBoundaryEndRef() != aEndBoundary)) {
|
|
// Could happen if the above nsRange::Create decides to collapse
|
|
// the range, like aStartBoundary is "after" aEndBoundary.
|
|
return NS_ERROR_UNEXPECTED;
|
|
}
|
|
|
|
mRange = std::move(range);
|
|
|
|
return InitWithRange();
|
|
}
|
|
|
|
nsresult ContentSubtreeIterator::InitWithAllowCrossShadowBoundary(
|
|
AbstractRange* aRange) {
|
|
MOZ_ASSERT(aRange);
|
|
|
|
if (NS_WARN_IF(!aRange->IsPositioned())) {
|
|
return NS_ERROR_INVALID_ARG;
|
|
}
|
|
|
|
if (aRange->IsDynamicRange()) {
|
|
// When we handle flattened tree, we should ignore unformatted nodes.
|
|
// Therefore, we need to adjust the range into the formatted flattened tree.
|
|
mRange = aRange->AsDynamicRange()->GetRangeInFlatTree();
|
|
} else {
|
|
mRange = aRange;
|
|
}
|
|
|
|
mAllowCrossShadowBoundary = AllowRangeCrossShadowBoundary::Yes;
|
|
return InitWithRange();
|
|
}
|
|
|
|
void ContentSubtreeIterator::CacheInclusiveAncestorsOfEndContainer() {
|
|
mInclusiveAncestorsOfEndContainer.Clear();
|
|
nsINode* const endContainer = ShadowDOMSelectionHelpers::GetEndContainer(
|
|
mRange, mAllowCrossShadowBoundary);
|
|
nsIContent* endNode =
|
|
endContainer->IsContent() ? endContainer->AsContent() : nullptr;
|
|
|
|
AncestorInfo info{endNode, false};
|
|
while (info.mAncestor) {
|
|
const nsINode* child = info.mAncestor;
|
|
mInclusiveAncestorsOfEndContainer.AppendElement(info);
|
|
// Cross the boundary for contents in shadow tree.
|
|
nsINode* parent = ShadowDOMSelectionHelpers::GetParentNodeInSameSelection(
|
|
*child, mAllowCrossShadowBoundary);
|
|
if (!parent || !parent->IsContent()) {
|
|
break;
|
|
}
|
|
|
|
// `ShadowDOMSelectionHelpers::GetShadowRoot` would return non-null shadow
|
|
// root if parent is a shadow host that we support cross boundary selection.
|
|
const bool isChildAShadowRootForSelection =
|
|
ShadowDOMSelectionHelpers::GetShadowRoot(
|
|
parent, mAllowCrossShadowBoundary) == child;
|
|
|
|
info.mAncestor = parent->AsContent();
|
|
// mIsDescendantInShadowTree indicates that whether child is in the
|
|
// shadow tree of parent or in the regular light DOM tree of parent.
|
|
// So that later, when info.mAncestor is reached, we can decide whether
|
|
// we should dive into the shadow tree.
|
|
info.mIsDescendantInShadowTree =
|
|
IterAllowCrossShadowBoundary() && isChildAShadowRootForSelection;
|
|
}
|
|
}
|
|
|
|
nsIContent* ContentSubtreeIterator::DetermineCandidateForFirstContent() const {
|
|
nsINode* startContainer = ShadowDOMSelectionHelpers::GetStartContainer(
|
|
mRange, mAllowCrossShadowBoundary);
|
|
nsIContent* firstCandidate = nullptr;
|
|
// find first node in range
|
|
nsINode* node = nullptr;
|
|
if (IterAllowCrossShadowBoundary()
|
|
? !startContainer->HasChildren<TreeKind::FlatForSelection>()
|
|
: !startContainer->HasChildren<TreeKind::DOM>()) {
|
|
// no children, start at the node itself
|
|
node = startContainer;
|
|
} else {
|
|
nsIContent* child =
|
|
IterAllowCrossShadowBoundary()
|
|
? mRange->GetMayCrossShadowBoundaryChildAtStartOffset()
|
|
: mRange->GetChildAtStartOffset();
|
|
|
|
#ifdef DEBUG
|
|
const auto& startRef = IterAllowCrossShadowBoundary()
|
|
? mRange->MayCrossShadowBoundaryStartRef()
|
|
: mRange->StartRef();
|
|
MOZ_ASSERT(startRef.IsSetAndValid());
|
|
#endif
|
|
if (!child) {
|
|
// offset after last child
|
|
node = startContainer;
|
|
} else {
|
|
firstCandidate = child;
|
|
}
|
|
}
|
|
|
|
if (!firstCandidate) {
|
|
// then firstCandidate is next node after node
|
|
firstCandidate =
|
|
IterAllowCrossShadowBoundary()
|
|
? ContentIteratorBase::GetNextSibling<TreeKind::FlatForSelection>(
|
|
node)
|
|
: ContentIteratorBase::GetNextSibling<TreeKind::DOM>(node);
|
|
}
|
|
|
|
if (firstCandidate) {
|
|
firstCandidate = IterAllowCrossShadowBoundary()
|
|
? ContentIteratorBase::GetDeepFirstInclusiveDescendant<
|
|
TreeKind::FlatForSelection>(firstCandidate)
|
|
: ContentIteratorBase::GetDeepFirstInclusiveDescendant<
|
|
TreeKind::DOM>(firstCandidate);
|
|
}
|
|
|
|
return firstCandidate;
|
|
}
|
|
|
|
nsIContent* ContentSubtreeIterator::DetermineFirstContent() const {
|
|
nsIContent* firstCandidate = DetermineCandidateForFirstContent();
|
|
if (!firstCandidate) {
|
|
return nullptr;
|
|
}
|
|
|
|
// confirm that this first possible contained node is indeed contained. Else
|
|
// we have a range that does not fully contain any node.
|
|
const Maybe<bool> isNodeContainedInRange =
|
|
IterAllowCrossShadowBoundary()
|
|
? RangeUtils::IsNodeContainedInRange<TreeKind::FlatForSelection>(
|
|
*firstCandidate, mRange)
|
|
: RangeUtils::IsNodeContainedInRange<TreeKind::ShadowIncludingDOM>(
|
|
*firstCandidate, mRange);
|
|
MOZ_ALWAYS_TRUE(isNodeContainedInRange);
|
|
if (!isNodeContainedInRange.value()) {
|
|
return nullptr;
|
|
}
|
|
|
|
// cool, we have the first node in the range. Now we walk up its ancestors
|
|
// to find the most senior that is still in the range. That's the real first
|
|
// node.
|
|
return GetTopAncestorInRange(firstCandidate);
|
|
}
|
|
|
|
nsIContent* ContentSubtreeIterator::DetermineCandidateForLastContent() const {
|
|
nsIContent* lastCandidate{nullptr};
|
|
nsINode* endContainer = ShadowDOMSelectionHelpers::GetEndContainer(
|
|
mRange, mAllowCrossShadowBoundary);
|
|
// now to find the last node
|
|
int32_t offset =
|
|
ShadowDOMSelectionHelpers::EndOffset(mRange, mAllowCrossShadowBoundary);
|
|
|
|
const int32_t numChildren =
|
|
IterAllowCrossShadowBoundary()
|
|
? endContainer->GetFlatTreeForSelectionChildCount()
|
|
: endContainer->GetChildCount();
|
|
nsINode* node = nullptr;
|
|
if (offset > numChildren) {
|
|
// Can happen for text nodes
|
|
offset = numChildren;
|
|
}
|
|
if (!offset || !numChildren) {
|
|
node = endContainer;
|
|
} else {
|
|
lastCandidate = IterAllowCrossShadowBoundary()
|
|
? mRange->MayCrossShadowBoundaryEndRef().Ref()
|
|
: mRange->EndRef().Ref();
|
|
#ifdef DEBUG
|
|
const auto& endRef = IterAllowCrossShadowBoundary()
|
|
? mRange->MayCrossShadowBoundaryEndRef()
|
|
: mRange->EndRef();
|
|
MOZ_ASSERT(endRef.IsSetAndValid());
|
|
#endif
|
|
NS_ASSERTION(lastCandidate,
|
|
"tree traversal trouble in ContentSubtreeIterator::Init");
|
|
}
|
|
|
|
if (!lastCandidate) {
|
|
// then lastCandidate is prev node before node
|
|
lastCandidate =
|
|
IterAllowCrossShadowBoundary()
|
|
? ContentIteratorBase::GetPrevSibling<TreeKind::FlatForSelection>(
|
|
node)
|
|
: ContentIteratorBase::GetPrevSibling<TreeKind::DOM>(node);
|
|
}
|
|
|
|
if (lastCandidate) {
|
|
lastCandidate = IterAllowCrossShadowBoundary()
|
|
? ContentIteratorBase::GetDeepLastInclusiveDescendant<
|
|
TreeKind::FlatForSelection>(lastCandidate)
|
|
: ContentIteratorBase::GetDeepLastInclusiveDescendant<
|
|
TreeKind::DOM>(lastCandidate);
|
|
}
|
|
|
|
return lastCandidate;
|
|
}
|
|
|
|
nsresult ContentSubtreeIterator::InitWithRange() {
|
|
MOZ_ASSERT(mRange);
|
|
MOZ_ASSERT(mRange->IsPositioned());
|
|
|
|
// get the start node and offset, convert to nsINode
|
|
mClosestCommonInclusiveAncestor =
|
|
mRange->GetClosestCommonInclusiveAncestor(mAllowCrossShadowBoundary);
|
|
|
|
const RawRangeBoundary startRef =
|
|
ShadowDOMSelectionHelpers::StartRef(mRange, mAllowCrossShadowBoundary);
|
|
const RawRangeBoundary endRef =
|
|
ShadowDOMSelectionHelpers::EndRef(mRange, mAllowCrossShadowBoundary);
|
|
if (!mClosestCommonInclusiveAncestor) [[unlikely]] {
|
|
NS_WARNING(fmt::format("startRef:{}", startRef).c_str());
|
|
NS_WARNING(fmt::format("endRef: {}", endRef).c_str());
|
|
MOZ_ASSERT_UNREACHABLE("mRange boundaries must be connected");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
MOZ_ASSERT(startRef.IsSet());
|
|
MOZ_ASSERT(endRef.IsSet());
|
|
|
|
// short circuit when start node == end node
|
|
if (startRef.GetContainer() == endRef.GetContainer()) {
|
|
nsIContent* const child =
|
|
IterAllowCrossShadowBoundary()
|
|
? startRef.GetContainer()->GetFlattenedTreeFirstChildForSelection()
|
|
: startRef.GetContainer()->GetFirstChild();
|
|
|
|
if (!child || startRef == endRef) {
|
|
// Text node, empty container, or collapsed
|
|
SetEmpty();
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
CacheInclusiveAncestorsOfEndContainer();
|
|
|
|
mFirst = DetermineFirstContent();
|
|
if (!mFirst) {
|
|
SetEmpty();
|
|
return NS_OK;
|
|
}
|
|
|
|
mLast = DetermineLastContent();
|
|
if (!mLast) {
|
|
SetEmpty();
|
|
return NS_OK;
|
|
}
|
|
|
|
mCurNode = mFirst;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsIContent* ContentSubtreeIterator::DetermineLastContent() const {
|
|
nsIContent* lastCandidate = DetermineCandidateForLastContent();
|
|
if (!lastCandidate) {
|
|
return nullptr;
|
|
}
|
|
|
|
// confirm that this last possible contained node is indeed contained. Else
|
|
// we have a range that does not fully contain any node.
|
|
|
|
const Maybe<bool> isNodeContainedInRange =
|
|
IterAllowCrossShadowBoundary()
|
|
? RangeUtils::IsNodeContainedInRange<TreeKind::FlatForSelection>(
|
|
*lastCandidate, mRange)
|
|
: RangeUtils::IsNodeContainedInRange<TreeKind::ShadowIncludingDOM>(
|
|
*lastCandidate, mRange);
|
|
MOZ_ALWAYS_TRUE(isNodeContainedInRange);
|
|
if (!isNodeContainedInRange.value()) {
|
|
return nullptr;
|
|
}
|
|
|
|
// cool, we have the last node in the range. Now we walk up its ancestors to
|
|
// find the most senior that is still in the range. That's the real first
|
|
// node.
|
|
return GetTopAncestorInRange(lastCandidate);
|
|
}
|
|
|
|
/****************************************************************
|
|
* ContentSubtreeIterator overrides of ContentIterator routines
|
|
****************************************************************/
|
|
|
|
// we can't call PositionAt in a subtree iterator...
|
|
void ContentSubtreeIterator::First() { mCurNode = mFirst; }
|
|
|
|
// we can't call PositionAt in a subtree iterator...
|
|
void ContentSubtreeIterator::Last() { mCurNode = mLast; }
|
|
|
|
void ContentSubtreeIterator::Next() {
|
|
if (IsDone()) {
|
|
return;
|
|
}
|
|
|
|
if (mCurNode == mLast) {
|
|
mCurNode = nullptr;
|
|
return;
|
|
}
|
|
|
|
nsINode* nextNode =
|
|
IterAllowCrossShadowBoundary()
|
|
? ContentIteratorBase::GetNextSibling<TreeKind::FlatForSelection>(
|
|
mCurNode, &mInclusiveAncestorsOfEndContainer)
|
|
: ContentIteratorBase::GetNextSibling<TreeKind::DOM>(
|
|
mCurNode, &mInclusiveAncestorsOfEndContainer);
|
|
|
|
NS_ASSERTION(nextNode, "No next sibling!?! This could mean deadlock!");
|
|
|
|
int32_t i = mInclusiveAncestorsOfEndContainer.IndexOf(
|
|
nextNode, 0, InclusiveAncestorComparator());
|
|
|
|
while (i != -1) {
|
|
// as long as we are finding ancestors of the endpoint of the range,
|
|
// dive down into their children
|
|
ShadowRoot* root = ShadowDOMSelectionHelpers::GetShadowRoot(
|
|
nextNode, mAllowCrossShadowBoundary);
|
|
if (mInclusiveAncestorsOfEndContainer[i].mIsDescendantInShadowTree) {
|
|
MOZ_ASSERT(root);
|
|
nextNode = IterAllowCrossShadowBoundary()
|
|
? root->GetFlattenedTreeFirstChildForSelection()
|
|
: root->GetFirstChild();
|
|
} else if (HTMLSlotElement* const slot =
|
|
nextNode->GetAsHTMLSlotElementIfFilledForSelection();
|
|
slot && IterAllowCrossShadowBoundary()) {
|
|
// Ancestor is a slot, we start from the first assigned node within this
|
|
// slot
|
|
nextNode = slot->AssignedNodes()[0];
|
|
} else {
|
|
if (root) {
|
|
// nextNode is a shadow host but the descendant in the light DOM
|
|
// of it. There's no need to iterate light DOM elements for a
|
|
// shadow tree. Stop here.
|
|
mCurNode = nullptr;
|
|
return;
|
|
}
|
|
nextNode = IterAllowCrossShadowBoundary()
|
|
? nextNode->GetFlattenedTreeFirstChildForSelection()
|
|
: nextNode->GetFirstChild();
|
|
}
|
|
NS_ASSERTION(nextNode, "Iterator error, expected a child node!");
|
|
|
|
// should be impossible to get a null pointer. If we went all the way
|
|
// down the child chain to the bottom without finding an interior node,
|
|
// then the previous node should have been the last, which was
|
|
// was tested at top of routine.
|
|
i = mInclusiveAncestorsOfEndContainer.IndexOf(
|
|
nextNode, 0, InclusiveAncestorComparator());
|
|
}
|
|
|
|
mCurNode = nextNode;
|
|
}
|
|
|
|
void ContentSubtreeIterator::Prev() {
|
|
// Prev should be optimized to use the mStartNodes, just as Next
|
|
// uses mInclusiveAncestorsOfEndContainer.
|
|
if (IsDone()) {
|
|
return;
|
|
}
|
|
|
|
if (mCurNode == mFirst) {
|
|
mCurNode = nullptr;
|
|
return;
|
|
}
|
|
|
|
// If any of these function calls return null, so will all succeeding ones,
|
|
// so mCurNode will wind up set to null.
|
|
nsINode* prevNode =
|
|
IterAllowCrossShadowBoundary()
|
|
? ContentIteratorBase::GetDeepFirstInclusiveDescendant<
|
|
TreeKind::FlatForSelection>(mCurNode)
|
|
: ContentIteratorBase::GetDeepFirstInclusiveDescendant<TreeKind::DOM>(
|
|
mCurNode);
|
|
|
|
prevNode = IterAllowCrossShadowBoundary()
|
|
? PrevNode<TreeKind::FlatForSelection>(prevNode)
|
|
: PrevNode<TreeKind::DOM>(prevNode);
|
|
|
|
prevNode =
|
|
IterAllowCrossShadowBoundary()
|
|
? ContentIteratorBase::GetDeepLastInclusiveDescendant<
|
|
TreeKind::FlatForSelection>(prevNode)
|
|
: ContentIteratorBase::GetDeepLastInclusiveDescendant<TreeKind::DOM>(
|
|
prevNode);
|
|
|
|
mCurNode = GetTopAncestorInRange(prevNode);
|
|
}
|
|
|
|
nsresult ContentSubtreeIterator::PositionAt(nsINode* aCurNode) {
|
|
NS_ERROR("Not implemented!");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
/****************************************************************
|
|
* ContentSubtreeIterator helper routines
|
|
****************************************************************/
|
|
|
|
nsIContent* ContentSubtreeIterator::GetTopAncestorInRange(
|
|
nsINode* aNode) const {
|
|
if (!aNode || !ShadowDOMSelectionHelpers::GetParentNodeInSameSelection(
|
|
*aNode, mAllowCrossShadowBoundary)) {
|
|
return nullptr;
|
|
}
|
|
|
|
// aNode has a parent, so it must be content.
|
|
nsIContent* content = aNode->AsContent();
|
|
|
|
// sanity check: aNode is itself in the range
|
|
Maybe<bool> isNodeContainedInRange =
|
|
IterAllowCrossShadowBoundary()
|
|
? RangeUtils::IsNodeContainedInRange<TreeKind::FlatForSelection>(
|
|
*aNode, mRange)
|
|
: RangeUtils::IsNodeContainedInRange<TreeKind::ShadowIncludingDOM>(
|
|
*aNode, mRange);
|
|
|
|
NS_ASSERTION(isNodeContainedInRange && isNodeContainedInRange.value(),
|
|
"aNode isn't in mRange, or something else weird happened");
|
|
if (!isNodeContainedInRange || !isNodeContainedInRange.value()) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsIContent* lastContentInShadowTree = nullptr;
|
|
while (content) {
|
|
nsINode* parent = ShadowDOMSelectionHelpers::GetParentNodeInSameSelection(
|
|
*content, mAllowCrossShadowBoundary);
|
|
|
|
// content always has a parent. If its parent is the root, however --
|
|
// i.e., either it's not content, or it is content but its own parent is
|
|
// null -- then we're finished, since we don't go up to the root.
|
|
//
|
|
// Caveat: If iteration crossing shadow boundary is allowed
|
|
// and the root is a shadow root, we keep going up to the
|
|
// shadow host and continue.
|
|
//
|
|
// We have to special-case this because CompareNodeToRange treats the root
|
|
// node differently -- see bug 765205.
|
|
if (!parent || !ShadowDOMSelectionHelpers::GetParentNodeInSameSelection(
|
|
*parent, mAllowCrossShadowBoundary)) {
|
|
return content;
|
|
}
|
|
|
|
isNodeContainedInRange =
|
|
IterAllowCrossShadowBoundary()
|
|
? RangeUtils::IsNodeContainedInRange<TreeKind::FlatForSelection>(
|
|
*parent, mRange)
|
|
: RangeUtils::IsNodeContainedInRange<TreeKind::ShadowIncludingDOM>(
|
|
*parent, mRange);
|
|
|
|
MOZ_ALWAYS_TRUE(isNodeContainedInRange);
|
|
if (!isNodeContainedInRange.value()) {
|
|
if (IterAllowCrossShadowBoundary() && content->IsShadowRoot()) {
|
|
MOZ_ASSERT(parent->GetShadowRoot() == content);
|
|
// host element is not in range, the last content in tree
|
|
// should be the ancestor.
|
|
MOZ_ASSERT(lastContentInShadowTree);
|
|
return lastContentInShadowTree;
|
|
}
|
|
return content;
|
|
}
|
|
|
|
// When we cross the boundary, we keep a reference to the
|
|
// last content that is in tree, because if we later
|
|
// find the shadow host element is not in the range, that means
|
|
// the last content in the tree should be top ancestor in range.
|
|
//
|
|
// Using shadow root doesn't make sense here because it doesn't
|
|
// represent a actual content.
|
|
if (IterAllowCrossShadowBoundary() && parent->IsShadowRoot()) {
|
|
lastContentInShadowTree = content;
|
|
}
|
|
|
|
content = parent->AsContent();
|
|
}
|
|
|
|
MOZ_CRASH("This should only be possible if aNode was null");
|
|
}
|
|
|
|
nsresult RangeSubtreeIterator::Init(
|
|
AbstractRange* aRange,
|
|
dom::AllowRangeCrossShadowBoundary aAllowCrossShadowBoundary) {
|
|
mIterState = eDone;
|
|
if (aRange->AreNormalRangeAndCrossShadowBoundaryRangeCollapsed()) {
|
|
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;
|
|
}
|
|
|
|
// XXX It's odd to me that why does here may use the may cross shadow boundary
|
|
// range even if aAllowCrossShadowBoundary??
|
|
nsINode* node = aRange->GetMayCrossShadowBoundaryStartContainer();
|
|
if (NS_WARN_IF(!node)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (node->IsCharacterData() ||
|
|
(node->IsElement() &&
|
|
aRange->MayCrossShadowBoundaryStartRef().IsEndOfContainer())) {
|
|
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->GetMayCrossShadowBoundaryEndContainer();
|
|
if (NS_WARN_IF(!node)) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
if (node->IsCharacterData() ||
|
|
(node->IsElement() &&
|
|
aRange->MayCrossShadowBoundaryEndRef().IsStartOfContainer())) {
|
|
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 =
|
|
aAllowCrossShadowBoundary == dom::AllowRangeCrossShadowBoundary::Yes
|
|
? mSubtreeIter->InitWithAllowCrossShadowBoundary(aRange)
|
|
: 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) {
|
|
mIterState = eUseEnd;
|
|
} else {
|
|
mIterState = eDone;
|
|
}
|
|
} else if (mIterState == eUseIterator) {
|
|
mSubtreeIter->Next();
|
|
|
|
if (mSubtreeIter->IsDone()) {
|
|
if (mEnd) {
|
|
mIterState = eUseEnd;
|
|
} else {
|
|
mIterState = eDone;
|
|
}
|
|
}
|
|
} else {
|
|
mIterState = eDone;
|
|
}
|
|
}
|
|
|
|
void RangeSubtreeIterator::Prev() {
|
|
if (mIterState == eUseEnd) {
|
|
if (mSubtreeIter) {
|
|
mSubtreeIter->Last();
|
|
|
|
mIterState = eUseIterator;
|
|
} else if (mStart) {
|
|
mIterState = eUseStart;
|
|
} else {
|
|
mIterState = eDone;
|
|
}
|
|
} else if (mIterState == eUseIterator) {
|
|
mSubtreeIter->Prev();
|
|
|
|
if (mSubtreeIter->IsDone()) {
|
|
if (mStart) {
|
|
mIterState = eUseStart;
|
|
} else {
|
|
mIterState = eDone;
|
|
}
|
|
}
|
|
} else {
|
|
mIterState = eDone;
|
|
}
|
|
}
|
|
|
|
#undef NS_INSTANTIATE_CONTENT_ITER_BASE_METHOD
|
|
|
|
} // namespace mozilla
|