firefox-main/dom/serializers/nsDocumentEncoder.cpp (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

/* 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/. */
/*
* Object that can be used to serialize selections, ranges, or nodes
* to strings in a gazillion different ways.
*/
#include <utility>
#include "mozilla/Encoding.h"
#include "mozilla/IntegerRange.h"
#include "mozilla/Maybe.h"
#include "mozilla/RangeBoundary.h"
#include "mozilla/Result.h"
#include "mozilla/ScopeExit.h"
#include "mozilla/StringBuffer.h"
#include "mozilla/TextControlElement.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/dom/AbstractRange.h"
#include "mozilla/dom/Comment.h"
#include "mozilla/dom/Document.h"
#include "mozilla/dom/DocumentType.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/HTMLBRElement.h"
#include "mozilla/dom/ProcessingInstruction.h"
#include "mozilla/dom/Selection.h"
#include "mozilla/dom/ShadowRoot.h"
#include "mozilla/dom/Text.h"
#include "nsCOMPtr.h"
#include "nsCRT.h"
#include "nsComponentManagerUtils.h"
#include "nsContentUtils.h"
#include "nsElementTable.h"
#include "nsGkAtoms.h"
#include "nsHTMLDocument.h"
#include "nsIContent.h"
#include "nsIContentInlines.h"
#include "nsIContentSerializer.h"
#include "nsIDocumentEncoder.h"
#include "nsIFrame.h"
#include "nsINode.h"
#include "nsIOutputStream.h"
#include "nsIScriptContext.h"
#include "nsIScriptGlobalObject.h"
#include "nsISupports.h"
#include "nsITransferable.h"
#include "nsLayoutUtils.h"
#include "nsMimeTypes.h"
#include "nsRange.h"
#include "nsReadableUtils.h"
#include "nsTArray.h"
#include "nsUnicharUtils.h"
#include "nscore.h"
using namespace mozilla;
using namespace mozilla::dom;
enum nsRangeIterationDirection { kDirectionOut = -1, kDirectionIn = 1 };
class TextStreamer {
public:
/**
* @param aStream Will be kept alive by the TextStreamer.
* @param aUnicodeEncoder Needs to be non-nullptr.
*/
TextStreamer(nsIOutputStream& aStream, UniquePtr<Encoder> aUnicodeEncoder,
bool aIsPlainText, nsAString& aOutputBuffer);
/**
* String will be truncated if it is written to stream.
*/
nsresult FlushIfStringLongEnough();
/**
* String will be truncated.
*/
nsresult ForceFlush();
private:
const static uint32_t kMaxLengthBeforeFlush = 1024;
const static uint32_t kEncoderBufferSizeInBytes = 4096;
nsresult EncodeAndWrite();
nsresult EncodeAndWriteAndTruncate();
const nsCOMPtr<nsIOutputStream> mStream;
const UniquePtr<Encoder> mUnicodeEncoder;
const bool mIsPlainText;
nsAString& mOutputBuffer;
};
TextStreamer::TextStreamer(nsIOutputStream& aStream,
UniquePtr<Encoder> aUnicodeEncoder,
bool aIsPlainText, nsAString& aOutputBuffer)
: mStream{&aStream},
mUnicodeEncoder(std::move(aUnicodeEncoder)),
mIsPlainText(aIsPlainText),
mOutputBuffer(aOutputBuffer) {
MOZ_ASSERT(mUnicodeEncoder);
}
nsresult TextStreamer::FlushIfStringLongEnough() {
nsresult rv = NS_OK;
if (mOutputBuffer.Length() > kMaxLengthBeforeFlush) {
rv = EncodeAndWriteAndTruncate();
}
return rv;
}
nsresult TextStreamer::ForceFlush() { return EncodeAndWriteAndTruncate(); }
nsresult TextStreamer::EncodeAndWrite() {
if (mOutputBuffer.IsEmpty()) {
return NS_OK;
}
uint8_t buffer[kEncoderBufferSizeInBytes];
auto src = Span(mOutputBuffer);
auto bufferSpan = Span(buffer);
// Reserve space for terminator
auto dst = bufferSpan.To(bufferSpan.Length() - 1);
for (;;) {
uint32_t result;
size_t read;
size_t written;
if (mIsPlainText) {
std::tie(result, read, written) =
mUnicodeEncoder->EncodeFromUTF16WithoutReplacement(src, dst, false);
if (result != kInputEmpty && result != kOutputFull) {
// There's always room for one byte in the case of
// an unmappable character, because otherwise
// we'd have gotten `kOutputFull`.
dst[written++] = '?';
}
} else {
std::tie(result, read, written, std::ignore) =
mUnicodeEncoder->EncodeFromUTF16(src, dst, false);
}
src = src.From(read);
// Sadly, we still have test cases that implement nsIOutputStream in JS, so
// the buffer needs to be zero-terminated for XPConnect to do its thing.
// See bug 170416.
bufferSpan[written] = 0;
uint32_t streamWritten;
nsresult rv = mStream->Write(reinterpret_cast<char*>(dst.Elements()),
written, &streamWritten);
if (NS_FAILED(rv)) {
return rv;
}
if (result == kInputEmpty) {
return NS_OK;
}
}
}
nsresult TextStreamer::EncodeAndWriteAndTruncate() {
const nsresult rv = EncodeAndWrite();
mOutputBuffer.Truncate();
return rv;
}
/**
* The scope may be limited to either a selection, range, or node.
*/
class EncodingScope {
public:
/**
* @return true, iff the scope is limited to a selection, range or node.
*/
bool IsLimited() const;
RefPtr<Selection> mSelection;
RefPtr<nsRange> mRange;
nsCOMPtr<nsINode> mNode;
bool mNodeIsContainer = false;
};
bool EncodingScope::IsLimited() const { return mSelection || mRange || mNode; }
struct RangeBoundariesInclusiveAncestorsAndOffsets {
/**
*/
using InclusiveAncestors = AutoTArray<nsIContent*, 8>;
/**
*/
using InclusiveAncestorsOffsets = AutoTArray<Maybe<uint32_t>, 8>;
// The first node is the range's boundary node, the following ones the
// ancestors.
InclusiveAncestors mInclusiveAncestorsOfStart;
// The first offset represents where at the boundary node the range starts.
// Each other offset is the index of the child relative to its parent.
InclusiveAncestorsOffsets mInclusiveAncestorsOffsetsOfStart;
// The first node is the range's boundary node, the following one the
// ancestors.
InclusiveAncestors mInclusiveAncestorsOfEnd;
// The first offset represents where at the boundary node the range ends.
// Each other offset is the index of the child relative to its parent.
InclusiveAncestorsOffsets mInclusiveAncestorsOffsetsOfEnd;
};
struct ContextInfoDepth {
uint32_t mStart = 0;
uint32_t mEnd = 0;
};
class nsDocumentEncoder : public nsIDocumentEncoder {
protected:
class RangeNodeContext {
public:
virtual ~RangeNodeContext() = default;
virtual bool IncludeInContext(nsINode& aNode) const { return false; }
virtual int32_t GetImmediateContextCount(
const nsTArray<nsINode*>& aAncestorArray) const {
return -1;
}
};
public:
nsDocumentEncoder();
protected:
/**
* @param aRangeNodeContext has to be non-null.
*/
explicit nsDocumentEncoder(UniquePtr<RangeNodeContext> aRangeNodeContext);
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(nsDocumentEncoder)
NS_DECL_NSIDOCUMENTENCODER
protected:
virtual ~nsDocumentEncoder();
void Initialize(bool aClearCachedSerializer = true,
AllowRangeCrossShadowBoundary aAllowCrossShadowBoundary =
AllowRangeCrossShadowBoundary::No);
/**
* @param aMaxLength As described at
* `nsIDocumentEncodder.encodeToStringWithMaxLength`.
*/
nsresult SerializeDependingOnScope(uint32_t aMaxLength);
nsresult SerializeSelection();
nsresult SerializeNode();
/**
* @param aMaxLength As described at
* `nsIDocumentEncodder.encodeToStringWithMaxLength`.
*/
nsresult SerializeWholeDocument(uint32_t aMaxLength);
/**
* @param aFlags multiple of the flags defined in nsIDocumentEncoder.idl.o
*/
static bool IsInvisibleNodeAndShouldBeSkipped(const nsINode& aNode,
const uint32_t aFlags) {
if (aFlags & SkipInvisibleContent) {
// Treat the visibility of the ShadowRoot as if it were
// the host content.
//
// FIXME(emilio): I suspect instead of this a bunch of the GetParent()
// calls here should be doing GetFlattenedTreeParent, then this condition
// should be unreachable...
const nsINode* node{&aNode};
if (const ShadowRoot* shadowRoot = ShadowRoot::FromNode(node)) {
node = shadowRoot->GetHost();
}
if (node->IsContent()) {
nsIFrame* frame = node->AsContent()->GetPrimaryFrame();
if (!frame) {
if (node->IsElement() && node->AsElement()->IsDisplayContents()) {
return false;
}
if (node->IsText()) {
// We have already checked that our parent is visible.
//
// FIXME(emilio): Text not assigned to a <slot> in Shadow DOM should
// probably return false...
return false;
}
if (node->IsHTMLElement(nsGkAtoms::rp)) {
// Ruby parentheses are part of ruby structure, hence
// shouldn't be stripped out even if it is not displayed.
return false;
}
return true;
}
if (node->IsText() &&
(!frame->StyleVisibility()->IsVisible() ||
frame->IsHiddenByContentVisibilityOnAnyAncestor())) {
return true;
}
}
}
return false;
}
void ReleaseDocumentReferenceAndInitialize(bool aClearCachedSerializer);
class MOZ_STACK_CLASS AutoReleaseDocumentIfNeeded final {
public:
explicit AutoReleaseDocumentIfNeeded(nsDocumentEncoder* aEncoder)
: mEncoder(aEncoder) {}
~AutoReleaseDocumentIfNeeded() {
if (mEncoder->mFlags & RequiresReinitAfterOutput) {
const bool clearCachedSerializer = false;
mEncoder->ReleaseDocumentReferenceAndInitialize(clearCachedSerializer);
}
}
private:
nsDocumentEncoder* mEncoder;
};
nsCOMPtr<Document> mDocument;
EncodingScope mEncodingScope;
nsCOMPtr<nsIContentSerializer> mSerializer;
Maybe<TextStreamer> mTextStreamer;
nsCOMPtr<nsIDocumentEncoderNodeFixup> mNodeFixup;
nsString mMimeType;
const Encoding* mEncoding;
// Multiple of the flags defined in nsIDocumentEncoder.idl.
uint32_t mFlags;
uint32_t mWrapColumn;
// Whether the serializer cares about being notified to scan elements to
// keep track of whether they are preformatted. This stores the out
// argument of nsIContentSerializer::Init().
bool mNeedsPreformatScanning;
bool mIsCopying; // Set to true only while copying
RefPtr<StringBuffer> mCachedBuffer;
class NodeSerializer {
public:
/**
* @param aFlags multiple of the flags defined in nsIDocumentEncoder.idl.
*/
NodeSerializer(const bool& aNeedsPreformatScanning,
const nsCOMPtr<nsIContentSerializer>& aSerializer,
const uint32_t& aFlags,
const nsCOMPtr<nsIDocumentEncoderNodeFixup>& aNodeFixup,
Maybe<TextStreamer>& aTextStreamer)
: mNeedsPreformatScanning{aNeedsPreformatScanning},
mSerializer{aSerializer},
mFlags{aFlags},
mNodeFixup{aNodeFixup},
mTextStreamer{aTextStreamer} {}
nsresult SerializeNodeStart(nsINode& aOriginalNode, int32_t aStartOffset,
int32_t aEndOffset,
nsINode* aFixupNode = nullptr) const;
enum class SerializeRoot { eYes, eNo };
nsresult SerializeToStringRecursive(nsINode* aNode,
SerializeRoot aSerializeRoot,
uint32_t aMaxLength = 0) const;
nsresult SerializeNodeEnd(nsINode& aOriginalNode,
nsINode* aFixupNode = nullptr) const;
[[nodiscard]] nsresult SerializeTextNode(nsINode& aNode,
int32_t aStartOffset,
int32_t aEndOffset) const;
nsresult SerializeToStringIterative(nsINode* aNode) const;
private:
const bool& mNeedsPreformatScanning;
const nsCOMPtr<nsIContentSerializer>& mSerializer;
// Multiple of the flags defined in nsIDocumentEncoder.idl.
const uint32_t& mFlags;
const nsCOMPtr<nsIDocumentEncoderNodeFixup>& mNodeFixup;
Maybe<TextStreamer>& mTextStreamer;
};
NodeSerializer mNodeSerializer;
const UniquePtr<RangeNodeContext> mRangeNodeContext;
struct RangeContextSerializer final {
RangeContextSerializer(const RangeNodeContext& aRangeNodeContext,
const NodeSerializer& aNodeSerializer)
: mDisableContextSerialize{false},
mRangeNodeContext{aRangeNodeContext},
mNodeSerializer{aNodeSerializer} {}
nsresult SerializeRangeContextStart(
const nsTArray<nsINode*>& aAncestorArray);
nsresult SerializeRangeContextEnd();
// Used when context has already been serialized for
// table cell selections (where parent is <tr>)
bool mDisableContextSerialize;
AutoTArray<AutoTArray<nsINode*, 8>, 8> mRangeContexts;
const RangeNodeContext& mRangeNodeContext;
private:
const NodeSerializer& mNodeSerializer;
};
RangeContextSerializer mRangeContextSerializer;
struct RangeSerializer {
// @param aFlags multiple of the flags defined in nsIDocumentEncoder.idl.
RangeSerializer(const uint32_t& aFlags,
const NodeSerializer& aNodeSerializer,
RangeContextSerializer& aRangeContextSerializer)
: mStartRootIndex{0},
mEndRootIndex{0},
mHaltRangeHint{false},
mFlags{aFlags},
mNodeSerializer{aNodeSerializer},
mRangeContextSerializer{aRangeContextSerializer} {}
void Initialize(AllowRangeCrossShadowBoundary aAllowCrossShadowBoundary);
/**
* @param aDepth the distance (number of `GetParent` calls) from aNode to
* aRange's closest common inclusive ancestor.
*/
nsresult SerializeRangeNodes(const nsRange* aRange, nsINode* aNode,
int32_t aDepth);
/**
* Serialize aContent's children from aStartOffset to aEndOffset.
*
* @param aDepth the distance (number of `GetParent` calls) from aContent to
* aRange's closest common inclusive ancestor.
*/
[[nodiscard]] nsresult SerializeChildrenOfContent(nsIContent& aContent,
uint32_t aStartOffset,
uint32_t aEndOffset,
const nsRange* aRange,
int32_t aDepth);
nsresult SerializeRangeToString(const nsRange* aRange);
/**
*/
nsCOMPtr<nsINode> mClosestCommonInclusiveAncestorOfRange;
/**
*/
AutoTArray<nsINode*, 8> mCommonInclusiveAncestors;
ContextInfoDepth mContextInfoDepth;
private:
struct StartAndEndContent {
nsCOMPtr<nsIContent> mStart;
nsCOMPtr<nsIContent> mEnd;
};
StartAndEndContent GetStartAndEndContentForRecursionLevel(
int32_t aDepth) const;
bool HasInvisibleParentAndShouldBeSkipped(nsINode& aNode) const;
nsresult SerializeNodePartiallyContainedInRange(
nsIContent& aContent, const StartAndEndContent& aStartAndEndContent,
const nsRange& aRange, int32_t aDepth);
nsresult SerializeTextNode(nsIContent& aContent,
const StartAndEndContent& aStartAndEndContent,
const nsRange& aRange) const;
RangeBoundariesInclusiveAncestorsAndOffsets
mRangeBoundariesInclusiveAncestorsAndOffsets;
int32_t mStartRootIndex;
int32_t mEndRootIndex;
bool mHaltRangeHint;
// Multiple of the flags defined in nsIDocumentEncoder.idl.
const uint32_t& mFlags;
const NodeSerializer& mNodeSerializer;
RangeContextSerializer& mRangeContextSerializer;
AllowRangeCrossShadowBoundary mAllowCrossShadowBoundary =
AllowRangeCrossShadowBoundary::No;
};
RangeSerializer mRangeSerializer;
};
void nsDocumentEncoder::RangeSerializer::Initialize(
AllowRangeCrossShadowBoundary aAllowCrossShadowBoundary) {
mContextInfoDepth = {};
mStartRootIndex = 0;
mEndRootIndex = 0;
mHaltRangeHint = false;
mClosestCommonInclusiveAncestorOfRange = nullptr;
mRangeBoundariesInclusiveAncestorsAndOffsets = {};
mAllowCrossShadowBoundary = aAllowCrossShadowBoundary;
}
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsDocumentEncoder)
NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(
nsDocumentEncoder, ReleaseDocumentReferenceAndInitialize(true))
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsDocumentEncoder)
NS_INTERFACE_MAP_ENTRY(nsIDocumentEncoder)
NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END
NS_IMPL_CYCLE_COLLECTION(
nsDocumentEncoder, mDocument, mEncodingScope.mSelection,
mEncodingScope.mRange, mEncodingScope.mNode, mSerializer,
mRangeSerializer.mClosestCommonInclusiveAncestorOfRange)
nsDocumentEncoder::nsDocumentEncoder(
UniquePtr<RangeNodeContext> aRangeNodeContext)
: mEncoding(nullptr),
mIsCopying(false),
mCachedBuffer(nullptr),
mNodeSerializer(mNeedsPreformatScanning, mSerializer, mFlags, mNodeFixup,
mTextStreamer),
mRangeNodeContext(std::move(aRangeNodeContext)),
mRangeContextSerializer(*mRangeNodeContext, mNodeSerializer),
mRangeSerializer(mFlags, mNodeSerializer, mRangeContextSerializer) {
MOZ_ASSERT(mRangeNodeContext);
Initialize();
mMimeType.AssignLiteral("text/plain");
}
nsDocumentEncoder::nsDocumentEncoder()
: nsDocumentEncoder(MakeUnique<RangeNodeContext>()) {}
void nsDocumentEncoder::Initialize(
bool aClearCachedSerializer,
AllowRangeCrossShadowBoundary aAllowCrossShadowBoundary) {
mFlags = 0;
mWrapColumn = 72;
mRangeSerializer.Initialize(aAllowCrossShadowBoundary);
mNeedsPreformatScanning = false;
mRangeContextSerializer.mDisableContextSerialize = false;
mEncodingScope = {};
mNodeFixup = nullptr;
if (aClearCachedSerializer) {
mSerializer = nullptr;
}
}
static bool ParentIsTR(nsIContent* aContent) {
mozilla::dom::Element* parent = aContent->GetParentElement();
if (!parent) {
return false;
}
return parent->IsHTMLElement(nsGkAtoms::tr);
}
static AllowRangeCrossShadowBoundary GetAllowRangeCrossShadowBoundary(
const uint32_t aFlags) {
return (aFlags & nsIDocumentEncoder::AllowCrossShadowBoundary)
? AllowRangeCrossShadowBoundary::Yes
: AllowRangeCrossShadowBoundary::No;
}
nsresult nsDocumentEncoder::SerializeDependingOnScope(uint32_t aMaxLength) {
nsresult rv = NS_OK;
if (mEncodingScope.mSelection) {
rv = SerializeSelection();
} else if (nsRange* range = mEncodingScope.mRange) {
rv = mRangeSerializer.SerializeRangeToString(range);
} else if (mEncodingScope.mNode) {
rv = SerializeNode();
} else {
rv = SerializeWholeDocument(aMaxLength);
}
mEncodingScope = {};
return rv;
}
nsresult nsDocumentEncoder::SerializeSelection() {
NS_ENSURE_TRUE(mEncodingScope.mSelection, NS_ERROR_FAILURE);
nsresult rv = NS_OK;
const Selection* selection = mEncodingScope.mSelection;
nsCOMPtr<nsINode> node;
nsCOMPtr<nsINode> prevNode;
uint32_t firstRangeStartDepth = 0;
const uint32_t rangeCount = selection->RangeCount();
for (const uint32_t i : IntegerRange(rangeCount)) {
MOZ_ASSERT(selection->RangeCount() == rangeCount);
RefPtr<const nsRange> range = selection->GetRangeAt(i);
// Bug 236546: newlines not added when copying table cells into clipboard
// Each selected cell shows up as a range containing a row with a single
// cell get the row, compare it to previous row and emit </tr><tr> as
// needed Bug 137450: Problem copying/pasting a table from a web page to
// Excel. Each separate block of <tr></tr> produced above will be wrapped
// by the immediate context. This assumes that you can't select cells that
// are multiple selections from two tables simultaneously.
node = ShadowDOMSelectionHelpers::GetStartContainer(
range, GetAllowRangeCrossShadowBoundary(mFlags));
NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
if (node != prevNode) {
if (prevNode) {
rv = mNodeSerializer.SerializeNodeEnd(*prevNode);
NS_ENSURE_SUCCESS(rv, rv);
}
nsCOMPtr<nsIContent> content = nsIContent::FromNodeOrNull(node);
if (content && content->IsHTMLElement(nsGkAtoms::tr) &&
!ParentIsTR(content)) {
if (!prevNode) {
// Went from a non-<tr> to a <tr>
mRangeSerializer.mCommonInclusiveAncestors.Clear();
nsContentUtils::GetInclusiveAncestors(
node->GetParentNode(),
mRangeSerializer.mCommonInclusiveAncestors);
rv = mRangeContextSerializer.SerializeRangeContextStart(
mRangeSerializer.mCommonInclusiveAncestors);
NS_ENSURE_SUCCESS(rv, rv);
// Don't let SerializeRangeToString serialize the context again
mRangeContextSerializer.mDisableContextSerialize = true;
}
rv = mNodeSerializer.SerializeNodeStart(*node, 0, -1);
NS_ENSURE_SUCCESS(rv, rv);
prevNode = node;
} else if (prevNode) {
// Went from a <tr> to a non-<tr>
mRangeContextSerializer.mDisableContextSerialize = false;
// `mCommonInclusiveAncestors` is used in `EncodeToStringWithContext`
// too. Update it here to mimic the old behavior.
mRangeSerializer.mCommonInclusiveAncestors.Clear();
nsContentUtils::GetInclusiveAncestors(
prevNode->GetParentNode(),
mRangeSerializer.mCommonInclusiveAncestors);
rv = mRangeContextSerializer.SerializeRangeContextEnd();
NS_ENSURE_SUCCESS(rv, rv);
prevNode = nullptr;
}
}
rv = mRangeSerializer.SerializeRangeToString(range);
NS_ENSURE_SUCCESS(rv, rv);
if (i == 0) {
firstRangeStartDepth = mRangeSerializer.mContextInfoDepth.mStart;
}
}
mRangeSerializer.mContextInfoDepth.mStart = firstRangeStartDepth;
if (prevNode) {
rv = mNodeSerializer.SerializeNodeEnd(*prevNode);
NS_ENSURE_SUCCESS(rv, rv);
mRangeContextSerializer.mDisableContextSerialize = false;
// `mCommonInclusiveAncestors` is used in `EncodeToStringWithContext`
// too. Update it here to mimic the old behavior.
mRangeSerializer.mCommonInclusiveAncestors.Clear();
nsContentUtils::GetInclusiveAncestors(
prevNode->GetParentNode(), mRangeSerializer.mCommonInclusiveAncestors);
rv = mRangeContextSerializer.SerializeRangeContextEnd();
NS_ENSURE_SUCCESS(rv, rv);
}
// Just to be safe
mRangeContextSerializer.mDisableContextSerialize = false;
return rv;
}
nsresult nsDocumentEncoder::SerializeNode() {
NS_ENSURE_TRUE(mEncodingScope.mNode, NS_ERROR_FAILURE);
nsresult rv = NS_OK;
nsINode* node = mEncodingScope.mNode;
const bool nodeIsContainer = mEncodingScope.mNodeIsContainer;
if (!mNodeFixup && !(mFlags & SkipInvisibleContent) && !mTextStreamer &&
nodeIsContainer) {
rv = mNodeSerializer.SerializeToStringIterative(node);
} else {
rv = mNodeSerializer.SerializeToStringRecursive(
node, nodeIsContainer ? NodeSerializer::SerializeRoot::eNo
: NodeSerializer::SerializeRoot::eYes);
}
return rv;
}
nsresult nsDocumentEncoder::SerializeWholeDocument(uint32_t aMaxLength) {
NS_ENSURE_FALSE(mEncodingScope.mSelection, NS_ERROR_FAILURE);
NS_ENSURE_FALSE(mEncodingScope.mRange, NS_ERROR_FAILURE);
NS_ENSURE_FALSE(mEncodingScope.mNode, NS_ERROR_FAILURE);
nsresult rv = mSerializer->AppendDocumentStart(mDocument);
NS_ENSURE_SUCCESS(rv, rv);
rv = mNodeSerializer.SerializeToStringRecursive(
mDocument, NodeSerializer::SerializeRoot::eYes, aMaxLength);
return rv;
}
nsDocumentEncoder::~nsDocumentEncoder() = default;
NS_IMETHODIMP
nsDocumentEncoder::Init(Document* aDocument, const nsAString& aMimeType,
uint32_t aFlags) {
if (!aDocument) {
return NS_ERROR_INVALID_ARG;
}
Initialize(!mMimeType.Equals(aMimeType),
GetAllowRangeCrossShadowBoundary(aFlags));
mDocument = aDocument;
mMimeType = aMimeType;
mFlags = aFlags;
mIsCopying = false;
return NS_OK;
}
NS_IMETHODIMP
nsDocumentEncoder::SetWrapColumn(uint32_t aWC) {
mWrapColumn = aWC;
return NS_OK;
}
NS_IMETHODIMP
nsDocumentEncoder::SetSelection(Selection* aSelection) {
mEncodingScope.mSelection = aSelection;
return NS_OK;
}
NS_IMETHODIMP
nsDocumentEncoder::SetRange(nsRange* aRange) {
mEncodingScope.mRange = aRange;
return NS_OK;
}
NS_IMETHODIMP
nsDocumentEncoder::SetNode(nsINode* aNode) {
mEncodingScope.mNodeIsContainer = false;
mEncodingScope.mNode = aNode;
return NS_OK;
}
NS_IMETHODIMP
nsDocumentEncoder::SetContainerNode(nsINode* aContainer) {
mEncodingScope.mNodeIsContainer = true;
mEncodingScope.mNode = aContainer;
return NS_OK;
}
NS_IMETHODIMP
nsDocumentEncoder::SetCharset(const nsACString& aCharset) {
const Encoding* encoding = Encoding::ForLabel(aCharset);
if (!encoding) {
return NS_ERROR_UCONV_NOCONV;
}
mEncoding = encoding->OutputEncoding();
return NS_OK;
}
NS_IMETHODIMP
nsDocumentEncoder::GetMimeType(nsAString& aMimeType) {
aMimeType = mMimeType;
return NS_OK;
}
class FixupNodeDeterminer {
public:
FixupNodeDeterminer(nsIDocumentEncoderNodeFixup* aNodeFixup,
nsINode* aFixupNode, nsINode& aOriginalNode)
: mIsSerializationOfFixupChildrenNeeded{false},
mNodeFixup(aNodeFixup),
mOriginalNode(aOriginalNode) {
if (mNodeFixup) {
if (aFixupNode) {
mFixupNode = aFixupNode;
} else {
mNodeFixup->FixupNode(&mOriginalNode,
&mIsSerializationOfFixupChildrenNeeded,
getter_AddRefs(mFixupNode));
}
}
}
bool IsSerializationOfFixupChildrenNeeded() const {
return mIsSerializationOfFixupChildrenNeeded;
}
/**
* @return The fixup node, if available, otherwise the original node. The
* former is kept alive by this object.
*/
nsINode& GetFixupNodeFallBackToOriginalNode() const {
return mFixupNode ? *mFixupNode : mOriginalNode;
}
private:
bool mIsSerializationOfFixupChildrenNeeded;
nsIDocumentEncoderNodeFixup* mNodeFixup;
nsCOMPtr<nsINode> mFixupNode;
nsINode& mOriginalNode;
};
nsresult nsDocumentEncoder::NodeSerializer::SerializeNodeStart(
nsINode& aOriginalNode, int32_t aStartOffset, int32_t aEndOffset,
nsINode* aFixupNode) const {
if (mNeedsPreformatScanning) {
if (aOriginalNode.IsElement()) {
mSerializer->ScanElementForPreformat(aOriginalNode.AsElement());
} else if (aOriginalNode.IsText()) {
const nsCOMPtr<nsINode> parent = aOriginalNode.GetParent();
if (parent && parent->IsElement()) {
mSerializer->ScanElementForPreformat(parent->AsElement());
}
}
}
if (IsInvisibleNodeAndShouldBeSkipped(aOriginalNode, mFlags)) {
return NS_OK;
}
FixupNodeDeterminer fixupNodeDeterminer{mNodeFixup, aFixupNode,
aOriginalNode};
nsINode* node = &fixupNodeDeterminer.GetFixupNodeFallBackToOriginalNode();
nsresult rv = NS_OK;
if (node->IsElement()) {
if ((mFlags & (nsIDocumentEncoder::OutputPreformatted |
nsIDocumentEncoder::OutputDropInvisibleBreak)) &&
nsLayoutUtils::IsInvisibleBreak(node)) {
return rv;
}
rv = mSerializer->AppendElementStart(node->AsElement(),
aOriginalNode.AsElement());
return rv;
}
switch (node->NodeType()) {
case nsINode::TEXT_NODE: {
rv = mSerializer->AppendText(node->AsText(), aStartOffset, aEndOffset);
break;
}
case nsINode::CDATA_SECTION_NODE: {
rv = mSerializer->AppendCDATASection(node->AsText(), aStartOffset,
aEndOffset);
break;
}
case nsINode::PROCESSING_INSTRUCTION_NODE: {
rv = mSerializer->AppendProcessingInstruction(
static_cast<ProcessingInstruction*>(node), aStartOffset, aEndOffset);
break;
}
case nsINode::COMMENT_NODE: {
rv = mSerializer->AppendComment(static_cast<Comment*>(node), aStartOffset,
aEndOffset);
break;
}
case nsINode::DOCUMENT_TYPE_NODE: {
rv = mSerializer->AppendDoctype(static_cast<DocumentType*>(node));
break;
}
}
return rv;
}
nsresult nsDocumentEncoder::NodeSerializer::SerializeNodeEnd(
nsINode& aOriginalNode, nsINode* aFixupNode) const {
if (mNeedsPreformatScanning) {
if (aOriginalNode.IsElement()) {
mSerializer->ForgetElementForPreformat(aOriginalNode.AsElement());
} else if (aOriginalNode.IsText()) {
const nsCOMPtr<nsINode> parent = aOriginalNode.GetParent();
if (parent && parent->IsElement()) {
mSerializer->ForgetElementForPreformat(parent->AsElement());
}
}
}
if (IsInvisibleNodeAndShouldBeSkipped(aOriginalNode, mFlags)) {
return NS_OK;
}
nsresult rv = NS_OK;
FixupNodeDeterminer fixupNodeDeterminer{mNodeFixup, aFixupNode,
aOriginalNode};
nsINode* node = &fixupNodeDeterminer.GetFixupNodeFallBackToOriginalNode();
if (node->IsElement()) {
rv = mSerializer->AppendElementEnd(node->AsElement(),
aOriginalNode.AsElement());
}
return rv;
}
nsresult nsDocumentEncoder::NodeSerializer::SerializeToStringRecursive(
nsINode* aNode, SerializeRoot aSerializeRoot, uint32_t aMaxLength) const {
uint32_t outputLength{0};
nsresult rv = mSerializer->GetOutputLength(outputLength);
NS_ENSURE_SUCCESS(rv, rv);
if (aMaxLength > 0 && outputLength >= aMaxLength) {
return NS_OK;
}
NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
if (IsInvisibleNodeAndShouldBeSkipped(*aNode, mFlags)) {
return NS_OK;
}
FixupNodeDeterminer fixupNodeDeterminer{mNodeFixup, nullptr, *aNode};
nsINode* maybeFixedNode =
&fixupNodeDeterminer.GetFixupNodeFallBackToOriginalNode();
if (mFlags & SkipInvisibleContent) {
if (aNode->IsContent()) {
if (nsIFrame* frame = aNode->AsContent()->GetPrimaryFrame()) {
if (!frame->IsSelectable()) {
aSerializeRoot = SerializeRoot::eNo;
}
}
}
}
if (aSerializeRoot == SerializeRoot::eYes) {
int32_t endOffset = -1;
if (aMaxLength > 0) {
MOZ_ASSERT(aMaxLength >= outputLength);
endOffset = aMaxLength - outputLength;
}
rv = SerializeNodeStart(*aNode, 0, endOffset, maybeFixedNode);
NS_ENSURE_SUCCESS(rv, rv);
}
ShadowRoot* shadowRoot = ShadowDOMSelectionHelpers::GetShadowRoot(
aNode, GetAllowRangeCrossShadowBoundary(mFlags));
if (shadowRoot) {
MOZ_ASSERT(StaticPrefs::dom_shadowdom_selection_across_boundary_enabled());
// Serialize the ShadowRoot first when the entire node needs to be
// serialized.
SerializeToStringRecursive(shadowRoot, aSerializeRoot, aMaxLength);
}
nsINode* node = fixupNodeDeterminer.IsSerializationOfFixupChildrenNeeded()
? maybeFixedNode
: aNode;
int32_t counter = -1;
const bool allowCrossShadowBoundary =
GetAllowRangeCrossShadowBoundary(mFlags) ==
AllowRangeCrossShadowBoundary::Yes;
auto GetNextNode = [&counter, node, allowCrossShadowBoundary](
nsINode* aCurrentNode) -> nsINode* {
++counter;
if (allowCrossShadowBoundary) {
if (const auto* slot = HTMLSlotElement::FromNode(node)) {
auto assigned = slot->AssignedNodes();
if (size_t(counter) < assigned.Length()) {
return assigned[counter];
}
return nullptr;
}
}
if (counter == 0) {
return node->GetFirstChildOfTemplateOrNode();
}
// counter isn't really used for non-slot cases.
return aCurrentNode->GetNextSibling();
};
if (!shadowRoot) {
// We only iterate light DOM children of aNode if it isn't a shadow host
// since it doesn't make sense to iterate them this way. Slotted contents
// has been handled by serializing the <slot> element.
for (nsINode* child = GetNextNode(nullptr); child;
child = GetNextNode(child)) {
rv = SerializeToStringRecursive(child, SerializeRoot::eYes, aMaxLength);
NS_ENSURE_SUCCESS(rv, rv);
}
}
if (aSerializeRoot == SerializeRoot::eYes) {
rv = SerializeNodeEnd(*aNode, maybeFixedNode);
NS_ENSURE_SUCCESS(rv, rv);
}
if (mTextStreamer) {
rv = mTextStreamer->FlushIfStringLongEnough();
}
return rv;
}
nsresult nsDocumentEncoder::NodeSerializer::SerializeToStringIterative(
nsINode* aNode) const {
nsresult rv;
nsINode* node = aNode->GetFirstChildOfTemplateOrNode();
while (node) {
nsINode* current = node;
rv = SerializeNodeStart(*current, 0, -1, current);
NS_ENSURE_SUCCESS(rv, rv);
node = current->GetFirstChildOfTemplateOrNode();
while (!node && current && current != aNode) {
rv = SerializeNodeEnd(*current);
NS_ENSURE_SUCCESS(rv, rv);
// Check if we have siblings.
node = current->GetNextSibling();
if (!node) {
// Perhaps parent node has siblings.
current = current->GetParentNode();
// Handle template element. If the parent is a template's content,
// then adjust the parent to be the template element.
if (current && current != aNode && current->IsDocumentFragment()) {
nsIContent* host = current->AsDocumentFragment()->GetHost();
if (host && host->IsHTMLElement(nsGkAtoms::_template)) {
current = host;
}
}
}
}
}
return NS_OK;
}
static bool IsTextNode(nsINode* aNode) { return aNode && aNode->IsText(); }
nsresult nsDocumentEncoder::NodeSerializer::SerializeTextNode(
nsINode& aNode, int32_t aStartOffset, int32_t aEndOffset) const {
MOZ_ASSERT(IsTextNode(&aNode));
nsresult rv = SerializeNodeStart(aNode, aStartOffset, aEndOffset);
NS_ENSURE_SUCCESS(rv, rv);
rv = SerializeNodeEnd(aNode);
NS_ENSURE_SUCCESS(rv, rv);
return rv;
}
nsDocumentEncoder::RangeSerializer::StartAndEndContent
nsDocumentEncoder::RangeSerializer::GetStartAndEndContentForRecursionLevel(
const int32_t aDepth) const {
StartAndEndContent result;
const auto& inclusiveAncestorsOfStart =
mRangeBoundariesInclusiveAncestorsAndOffsets.mInclusiveAncestorsOfStart;
const auto& inclusiveAncestorsOfEnd =
mRangeBoundariesInclusiveAncestorsAndOffsets.mInclusiveAncestorsOfEnd;
int32_t start = mStartRootIndex - aDepth;
if (start >= 0 && (uint32_t)start <= inclusiveAncestorsOfStart.Length()) {
result.mStart = inclusiveAncestorsOfStart[start];
}
int32_t end = mEndRootIndex - aDepth;
if (end >= 0 && (uint32_t)end <= inclusiveAncestorsOfEnd.Length()) {
result.mEnd = inclusiveAncestorsOfEnd[end];
}
return result;
}
nsresult nsDocumentEncoder::RangeSerializer::SerializeTextNode(
nsIContent& aContent, const StartAndEndContent& aStartAndEndContent,
const nsRange& aRange) const {
const int32_t startOffset = (aStartAndEndContent.mStart == &aContent)
? ShadowDOMSelectionHelpers::StartOffset(
&aRange, mAllowCrossShadowBoundary)
: 0;
const int32_t endOffset = (aStartAndEndContent.mEnd == &aContent)
? ShadowDOMSelectionHelpers::EndOffset(
&aRange, mAllowCrossShadowBoundary)
: -1;
return mNodeSerializer.SerializeTextNode(aContent, startOffset, endOffset);
}
nsresult nsDocumentEncoder::RangeSerializer::SerializeRangeNodes(
const nsRange* const aRange, nsINode* const aNode, const int32_t aDepth) {
MOZ_ASSERT(aDepth >= 0);
MOZ_ASSERT(aRange);
nsCOMPtr<nsIContent> content = nsIContent::FromNodeOrNull(aNode);
NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
if (nsDocumentEncoder::IsInvisibleNodeAndShouldBeSkipped(*aNode, mFlags)) {
return NS_OK;
}
nsresult rv = NS_OK;
StartAndEndContent startAndEndContent =
GetStartAndEndContentForRecursionLevel(aDepth);
if (startAndEndContent.mStart != content &&
startAndEndContent.mEnd != content) {
// node is completely contained in range. Serialize the whole subtree
// rooted by this node.
rv = mNodeSerializer.SerializeToStringRecursive(
aNode, NodeSerializer::SerializeRoot::eYes);
NS_ENSURE_SUCCESS(rv, rv);
} else {
rv = SerializeNodePartiallyContainedInRange(*content, startAndEndContent,
*aRange, aDepth);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
}
return NS_OK;
}
nsresult
nsDocumentEncoder::RangeSerializer::SerializeNodePartiallyContainedInRange(
nsIContent& aContent, const StartAndEndContent& aStartAndEndContent,
const nsRange& aRange, const int32_t aDepth) {
// due to implementation it is impossible for text node to be both start and
// end of range. We would have handled that case without getting here.
// XXXsmaug What does this all mean?
if (IsTextNode(&aContent)) {
nsresult rv = SerializeTextNode(aContent, aStartAndEndContent, aRange);
NS_ENSURE_SUCCESS(rv, rv);
} else {
if (&aContent != mClosestCommonInclusiveAncestorOfRange) {
if (mRangeContextSerializer.mRangeNodeContext.IncludeInContext(
aContent)) {
// halt the incrementing of mContextInfoDepth. This
// is so paste client will include this node in paste.
mHaltRangeHint = true;
}
if ((aStartAndEndContent.mStart == &aContent) && !mHaltRangeHint) {
++mContextInfoDepth.mStart;
}
if ((aStartAndEndContent.mEnd == &aContent) && !mHaltRangeHint) {
++mContextInfoDepth.mEnd;
}
// serialize the start of this node
nsresult rv = mNodeSerializer.SerializeNodeStart(aContent, 0, -1);
NS_ENSURE_SUCCESS(rv, rv);
}
const auto& inclusiveAncestorsOffsetsOfStart =
mRangeBoundariesInclusiveAncestorsAndOffsets
.mInclusiveAncestorsOffsetsOfStart;
const auto& inclusiveAncestorsOffsetsOfEnd =
mRangeBoundariesInclusiveAncestorsAndOffsets
.mInclusiveAncestorsOffsetsOfEnd;
// do some calculations that will tell us which children of this
// node are in the range.
Maybe<uint32_t> startOffset = Some(0);
Maybe<uint32_t> endOffset;
if (aStartAndEndContent.mStart == &aContent && mStartRootIndex >= aDepth) {
startOffset = inclusiveAncestorsOffsetsOfStart[mStartRootIndex - aDepth];
}
if (aStartAndEndContent.mEnd == &aContent && mEndRootIndex >= aDepth) {
endOffset = inclusiveAncestorsOffsetsOfEnd[mEndRootIndex - aDepth];
}
// generated aContent will cause offset values of Nothing to be returned.
if (startOffset.isNothing()) {
startOffset = Some(0);
}
if (endOffset.isNothing()) {
endOffset = Some(aContent.GetChildCount());
if (mAllowCrossShadowBoundary == AllowRangeCrossShadowBoundary::Yes) {
if (const auto* slot = HTMLSlotElement::FromNode(aContent)) {
const auto& assignedNodes = slot->AssignedNodes();
if (!assignedNodes.IsEmpty()) {
endOffset = Some(assignedNodes.Length());
}
}
}
} else {
// if we are at the "tip" of the selection, endOffset is fine.
// otherwise, we need to add one. This is because of the semantics
// of the offset list created by GetInclusiveAncestorsAndOffsets(). The
// intermediate points on the list use the endOffset of the
// location of the ancestor, rather than just past it. So we need
// to add one here in order to include it in the children we serialize.
const nsINode* endContainer = ShadowDOMSelectionHelpers::GetEndContainer(
&aRange, mAllowCrossShadowBoundary);
if (&aContent != endContainer) {
MOZ_ASSERT(*endOffset != UINT32_MAX);
endOffset.ref()++;
}
}
MOZ_ASSERT(endOffset.isSome());
nsresult rv = SerializeChildrenOfContent(aContent, *startOffset, *endOffset,
&aRange, aDepth);
NS_ENSURE_SUCCESS(rv, rv);
// serialize the end of this node
if (&aContent != mClosestCommonInclusiveAncestorOfRange) {
nsresult rv = mNodeSerializer.SerializeNodeEnd(aContent);
NS_ENSURE_SUCCESS(rv, rv);
}
}
return NS_OK;
}
static nsINode* GetChildAtInFlatTreeForSelection(const nsINode& aNode,
const uint32_t aIndex) {
if (ShadowRoot* shadowRoot = aNode.GetShadowRoot()) {
if (shadowRoot->IsUAWidget()) {
return aNode.GetChildAt_Deprecated(aIndex);
}
}
return aNode.GetChildAtInFlatTree(aIndex);
}
nsresult nsDocumentEncoder::RangeSerializer::SerializeChildrenOfContent(
nsIContent& aContent, uint32_t aStartOffset, uint32_t aEndOffset,
const nsRange* aRange, int32_t aDepth) {
ShadowRoot* shadowRoot = ShadowDOMSelectionHelpers::GetShadowRoot(
&aContent, mAllowCrossShadowBoundary);
if (shadowRoot) {
// Serialize the ShadowRoot when the entire node needs to be serialized.
// Return early to skip light DOM children.
SerializeRangeNodes(aRange, shadowRoot, aDepth + 1);
return NS_OK;
}
if (!aEndOffset) {
return NS_OK;
}
nsINode* childAsNode =
mAllowCrossShadowBoundary == AllowRangeCrossShadowBoundary::Yes
? GetChildAtInFlatTreeForSelection(aContent, aStartOffset)
: aContent.GetChildAt_Deprecated(aStartOffset);
MOZ_ASSERT_IF(childAsNode, childAsNode->IsContent());
auto GetNextSibling = [this, &aContent](
nsINode* aCurrentNode,
uint32_t aCurrentIndex) -> nsIContent* {
if (mAllowCrossShadowBoundary == AllowRangeCrossShadowBoundary::Yes) {
if (const auto* slot = HTMLSlotElement::FromNode(&aContent)) {
auto assigned = slot->AssignedNodes();
if (++aCurrentIndex < assigned.Length()) {
return nsIContent::FromNode(assigned[aCurrentIndex]);
}
return nullptr;
}
}
return aCurrentNode->GetNextSibling();
};
for (size_t j = aStartOffset; childAsNode && j < aEndOffset; ++j) {
nsresult rv{NS_OK};
const bool isFirstOrLastNodeToSerialize =
j == aStartOffset || j == aEndOffset - 1;
if (isFirstOrLastNodeToSerialize) {
rv = SerializeRangeNodes(aRange, childAsNode, aDepth + 1);
} else {
rv = mNodeSerializer.SerializeToStringRecursive(
childAsNode, NodeSerializer::SerializeRoot::eYes);
}
if (NS_FAILED(rv)) {
return rv;
}
childAsNode = GetNextSibling(childAsNode, j);
}
return NS_OK;
}
nsresult nsDocumentEncoder::RangeContextSerializer::SerializeRangeContextStart(
const nsTArray<nsINode*>& aAncestorArray) {
if (mDisableContextSerialize) {
return NS_OK;
}
AutoTArray<nsINode*, 8>* serializedContext = mRangeContexts.AppendElement();
int32_t i = aAncestorArray.Length(), j;
nsresult rv = NS_OK;
// currently only for table-related elements; see Bug 137450
j = mRangeNodeContext.GetImmediateContextCount(aAncestorArray);
while (i > 0) {
nsINode* node = aAncestorArray.ElementAt(--i);
if (!node) break;
// Either a general inclusion or as immediate context
if (mRangeNodeContext.IncludeInContext(*node) || i < j) {
rv = mNodeSerializer.SerializeNodeStart(*node, 0, -1);
serializedContext->AppendElement(node);
if (NS_FAILED(rv)) break;
}
}
return rv;
}
nsresult nsDocumentEncoder::RangeContextSerializer::SerializeRangeContextEnd() {
if (mDisableContextSerialize) {
return NS_OK;
}
MOZ_RELEASE_ASSERT(!mRangeContexts.IsEmpty(),
"Tried to end context without starting one.");
AutoTArray<nsINode*, 8>& serializedContext = mRangeContexts.LastElement();
nsresult rv = NS_OK;
for (nsINode* node : Reversed(serializedContext)) {
rv = mNodeSerializer.SerializeNodeEnd(*node);
if (NS_FAILED(rv)) break;
}
mRangeContexts.RemoveLastElement();
return rv;
}
bool nsDocumentEncoder::RangeSerializer::HasInvisibleParentAndShouldBeSkipped(
nsINode& aNode) const {
if (!(mFlags & SkipInvisibleContent)) {
return false;
}
// Check that the parent is visible if we don't a frame.
// IsInvisibleNodeAndShouldBeSkipped() will do it when there's a frame.
nsCOMPtr<nsIContent> content = nsIContent::FromNode(aNode);
if (content && !content->GetPrimaryFrame()) {
nsIContent* parent = content->GetParent();
return !parent || IsInvisibleNodeAndShouldBeSkipped(*parent, mFlags);
}
return false;
}
nsresult nsDocumentEncoder::RangeSerializer::SerializeRangeToString(
const nsRange* aRange) {
if (!aRange ||
(aRange->Collapsed() &&
(mAllowCrossShadowBoundary == AllowRangeCrossShadowBoundary::No ||
!aRange->MayCrossShadowBoundary()))) {
return NS_OK;
}
// Consider a case where the boundary of the selection is ShadowRoot (ie, the
// first child of ShadowRoot is selected, so ShadowRoot is the container hence
// the boundary), allowing GetClosestCommonInclusiveAncestor to cross the
// boundary can return the host element as the container.
// SerializeRangeContextStart doesn't support this case.
mClosestCommonInclusiveAncestorOfRange =
aRange->GetClosestCommonInclusiveAncestor(mAllowCrossShadowBoundary);
if (!mClosestCommonInclusiveAncestorOfRange) {
return NS_OK;
}
nsINode* startContainer = ShadowDOMSelectionHelpers::GetStartContainer(
aRange, mAllowCrossShadowBoundary);
NS_ENSURE_TRUE(startContainer, NS_ERROR_FAILURE);
const int32_t startOffset =
ShadowDOMSelectionHelpers::StartOffset(aRange, mAllowCrossShadowBoundary);
nsINode* endContainer = ShadowDOMSelectionHelpers::GetEndContainer(
aRange, mAllowCrossShadowBoundary);
NS_ENSURE_TRUE(endContainer, NS_ERROR_FAILURE);
const int32_t endOffset =
ShadowDOMSelectionHelpers::EndOffset(aRange, mAllowCrossShadowBoundary);
mContextInfoDepth = {};
mCommonInclusiveAncestors.Clear();
mRangeBoundariesInclusiveAncestorsAndOffsets = {};
auto& inclusiveAncestorsOfStart =
mRangeBoundariesInclusiveAncestorsAndOffsets.mInclusiveAncestorsOfStart;
auto& inclusiveAncestorsOffsetsOfStart =
mRangeBoundariesInclusiveAncestorsAndOffsets
.mInclusiveAncestorsOffsetsOfStart;
auto& inclusiveAncestorsOfEnd =
mRangeBoundariesInclusiveAncestorsAndOffsets.mInclusiveAncestorsOfEnd;
auto& inclusiveAncestorsOffsetsOfEnd =
mRangeBoundariesInclusiveAncestorsAndOffsets
.mInclusiveAncestorsOffsetsOfEnd;
nsContentUtils::GetInclusiveAncestors(mClosestCommonInclusiveAncestorOfRange,
mCommonInclusiveAncestors);
if (mAllowCrossShadowBoundary == AllowRangeCrossShadowBoundary::Yes) {
nsContentUtils::GetFlattenedTreeAncestorsAndOffsets(
startContainer, startOffset, inclusiveAncestorsOfStart,
inclusiveAncestorsOffsetsOfStart);
nsContentUtils::GetFlattenedTreeAncestorsAndOffsets(
endContainer, endOffset, inclusiveAncestorsOfEnd,
inclusiveAncestorsOffsetsOfEnd);
} else {
nsContentUtils::GetInclusiveAncestorsAndOffsets(
startContainer, startOffset, inclusiveAncestorsOfStart,
inclusiveAncestorsOffsetsOfStart);
nsContentUtils::GetInclusiveAncestorsAndOffsets(
endContainer, endOffset, inclusiveAncestorsOfEnd,
inclusiveAncestorsOffsetsOfEnd);
}
nsCOMPtr<nsIContent> commonContent =
nsIContent::FromNodeOrNull(mClosestCommonInclusiveAncestorOfRange);
mStartRootIndex = inclusiveAncestorsOfStart.IndexOf(commonContent);
mEndRootIndex = inclusiveAncestorsOfEnd.IndexOf(commonContent);
nsresult rv = NS_OK;
rv = mRangeContextSerializer.SerializeRangeContextStart(
mCommonInclusiveAncestors);
NS_ENSURE_SUCCESS(rv, rv);
if (startContainer == endContainer && IsTextNode(startContainer)) {
if (HasInvisibleParentAndShouldBeSkipped(*startContainer)) {
return NS_OK;
}
rv = mNodeSerializer.SerializeTextNode(*startContainer, startOffset,
endOffset);
NS_ENSURE_SUCCESS(rv, rv);
} else {
rv = SerializeRangeNodes(aRange, mClosestCommonInclusiveAncestorOfRange, 0);
NS_ENSURE_SUCCESS(rv, rv);
}
rv = mRangeContextSerializer.SerializeRangeContextEnd();
NS_ENSURE_SUCCESS(rv, rv);
return rv;
}
void nsDocumentEncoder::ReleaseDocumentReferenceAndInitialize(
bool aClearCachedSerializer) {
mDocument = nullptr;
Initialize(aClearCachedSerializer);
}
NS_IMETHODIMP
nsDocumentEncoder::EncodeToString(nsAString& aOutputString) {
return EncodeToStringWithMaxLength(0, aOutputString);
}
NS_IMETHODIMP
nsDocumentEncoder::EncodeToStringWithMaxLength(uint32_t aMaxLength,
nsAString& aOutputString) {
MOZ_ASSERT(mRangeContextSerializer.mRangeContexts.IsEmpty(),
"Re-entrant call to nsDocumentEncoder.");
auto rangeContextGuard =
MakeScopeExit([&] { mRangeContextSerializer.mRangeContexts.Clear(); });
if (!mDocument) return NS_ERROR_NOT_INITIALIZED;
AutoReleaseDocumentIfNeeded autoReleaseDocument(this);
aOutputString.Truncate();
nsString output;
static const size_t kStringBufferSizeInBytes = 2048;
if (!mCachedBuffer) {
mCachedBuffer = StringBuffer::Alloc(kStringBufferSizeInBytes);
if (NS_WARN_IF(!mCachedBuffer)) {
return NS_ERROR_OUT_OF_MEMORY;
}
}
NS_ASSERTION(
!mCachedBuffer->IsReadonly(),
"nsIDocumentEncoder shouldn't keep reference to non-readonly buffer!");
static_cast<char16_t*>(mCachedBuffer->Data())[0] = char16_t(0);
output.Assign(mCachedBuffer.forget(), 0);
if (!mSerializer) {
nsAutoCString progId(NS_CONTENTSERIALIZER_CONTRACTID_PREFIX);
AppendUTF16toUTF8(mMimeType, progId);
mSerializer = do_CreateInstance(progId.get());
NS_ENSURE_TRUE(mSerializer, NS_ERROR_NOT_IMPLEMENTED);
}
nsresult rv = NS_OK;
bool rewriteEncodingDeclaration =
!mEncodingScope.IsLimited() &&
!(mFlags & OutputDontRewriteEncodingDeclaration);
mSerializer->Init(mFlags, mWrapColumn, mEncoding, mIsCopying,
rewriteEncodingDeclaration, &mNeedsPreformatScanning,
output);
rv = SerializeDependingOnScope(aMaxLength);
NS_ENSURE_SUCCESS(rv, rv);
rv = mSerializer->FlushAndFinish();
// We have to be careful how we set aOutputString, because we don't
// want it to end up sharing mCachedBuffer if we plan to reuse it.
bool setOutput = false;
MOZ_ASSERT(!mCachedBuffer);
// Try to cache the buffer.
if (StringBuffer* outputBuffer = output.GetStringBuffer()) {
if (outputBuffer->StorageSize() == kStringBufferSizeInBytes &&
!outputBuffer->IsReadonly()) {
mCachedBuffer = outputBuffer;
} else if (NS_SUCCEEDED(rv)) {
aOutputString.Assign(outputBuffer, output.Length());
setOutput = true;
}
}
if (!setOutput && NS_SUCCEEDED(rv)) {
aOutputString.Append(output.get(), output.Length());
}
return rv;
}
NS_IMETHODIMP
nsDocumentEncoder::EncodeToStream(nsIOutputStream* aStream) {
MOZ_ASSERT(mRangeContextSerializer.mRangeContexts.IsEmpty(),
"Re-entrant call to nsDocumentEncoder.");
auto rangeContextGuard =
MakeScopeExit([&] { mRangeContextSerializer.mRangeContexts.Clear(); });
NS_ENSURE_ARG_POINTER(aStream);
nsresult rv = NS_OK;
if (!mDocument) return NS_ERROR_NOT_INITIALIZED;
if (!mEncoding) {
return NS_ERROR_UCONV_NOCONV;
}
nsAutoString buf;
const bool isPlainText = mMimeType.LowerCaseEqualsLiteral(kTextMime);
mTextStreamer.emplace(*aStream, mEncoding->NewEncoder(), isPlainText, buf);
rv = EncodeToString(buf);
// Force a flush of the last chunk of data.
rv = mTextStreamer->ForceFlush();
NS_ENSURE_SUCCESS(rv, rv);
mTextStreamer.reset();
return rv;
}
NS_IMETHODIMP
nsDocumentEncoder::EncodeToStringWithContext(nsAString& aContextString,
nsAString& aInfoString,
nsAString& aEncodedString) {
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
nsDocumentEncoder::SetNodeFixup(nsIDocumentEncoderNodeFixup* aFixup) {
mNodeFixup = aFixup;
return NS_OK;
}
bool do_getDocumentTypeSupportedForEncoding(const char* aContentType) {
if (!nsCRT::strcmp(aContentType, TEXT_XML) ||
!nsCRT::strcmp(aContentType, APPLICATION_XML) ||
!nsCRT::strcmp(aContentType, APPLICATION_XHTML_XML) ||
!nsCRT::strcmp(aContentType, IMAGE_SVG_XML) ||
!nsCRT::strcmp(aContentType, TEXT_HTML) ||
!nsCRT::strcmp(aContentType, TEXT_PLAIN)) {
return true;
}
return false;
}
already_AddRefed<nsIDocumentEncoder> do_createDocumentEncoder(
const char* aContentType) {
if (do_getDocumentTypeSupportedForEncoding(aContentType)) {
return do_AddRef(new nsDocumentEncoder);
}
return nullptr;
}
class nsHTMLCopyEncoder final : public nsDocumentEncoder {
private:
class RangeNodeContext final : public nsDocumentEncoder::RangeNodeContext {
bool IncludeInContext(nsINode& aNode) const final;
int32_t GetImmediateContextCount(
const nsTArray<nsINode*>& aAncestorArray) const final;
};
public:
nsHTMLCopyEncoder();
~nsHTMLCopyEncoder();
NS_IMETHOD Init(Document* aDocument, const nsAString& aMimeType,
uint32_t aFlags) override;
// overridden methods from nsDocumentEncoder
MOZ_CAN_RUN_SCRIPT_BOUNDARY
NS_IMETHOD SetSelection(Selection* aSelection) override;
NS_IMETHOD EncodeToStringWithContext(nsAString& aContextString,
nsAString& aInfoString,
nsAString& aEncodedString) override;
NS_IMETHOD EncodeToString(nsAString& aOutputString) override;
protected:
[[nodiscard]] TreeKind GetTreeKind() const {
return mFlags & nsIDocumentEncoder::AllowCrossShadowBoundary
? TreeKind::Flat
: TreeKind::DOM;
}
nsresult PromoteRange(nsRange* inRange);
struct MOZ_STACK_CLASS RangeInNode {
[[nodiscard]] RawRangeBoundary StartRef() const {
return RawRangeBoundary(mContainer, mStartOffset,
// Do not compute previous sibling of the child at
// mStartOffset immediately.
RangeBoundarySetBy::Offset, mTreeKind);
}
[[nodiscard]] RawRangeBoundary EndRef() const {
return RawRangeBoundary(mContainer, mEndOffset,
// Do not compute previous sibling of the child at
// mEndOffset immediately.
RangeBoundarySetBy::Offset, mTreeKind);
}
[[nodiscard]] nsINode* GetParentNode() const {
MOZ_ASSERT(mContainer);
return mTreeKind == TreeKind::Flat
? mContainer->GetFlattenedTreeParentNodeForSelection()
: mContainer->GetParentNode();
}
nsINode* mContainer = nullptr;
uint32_t mStartOffset = 0;
uint32_t mEndOffset = 0;
const TreeKind mTreeKind;
};
Result<RangeInNode, nsresult> PromoteAncestorChain(
const RangeInNode& aRangeInNode) const;
/**
* Return a promoted start point which may be extended to a point at an
* ancestor element or error. This climbs up the flattened tree if
* aPoint.GetTreeKind() is TreeKind::Flat.
*
* @param aPoint Must be set to a valid point.
* @param aCommon This is used as an ancestor limiter when climbing up the
* tree.
* @return If it's not an error, the boundary is always set.
*/
Result<RawRangeBoundary, nsresult> GetPromotedStartPoint(
const RawRangeBoundary& aPoint, const nsINode* const aCommon) const;
/**
* Return a promoted end point which may be extended to a point after an
* ancestor element or error. This climbs up the flattened tree if
* aPoint.GetTreeKind() is TreeKind::Flat.
*
* @param aPoint Must be set to a valid point.
* @param aCommon This is used as an ancestor limiter when climbing up the
* tree.
* @return If it's not an error, the boundary is always set.
*/
Result<RawRangeBoundary, nsresult> GetPromotedEndPoint(
const RawRangeBoundary& aPoint, const nsINode* const aCommon) const;
/**
* Return a parent point of aPoint, i.e., a point referring the container node
* of aPoint. If the container is a root of a generated content, this returns
* unset boundary instead of an error.
*
* @param aPoint Must be set to a valid point.
* @return Even if it's not an error, the boundary may be unset if
* aPoint's container is a root node of generated content.
*/
static Result<RawRangeBoundary, nsresult> GetParentPoint(
const RawRangeBoundary& aPoint);
/**
* Return the point after the container node of aPoint. If the container is a
* root of a generated content, this returns unset boundary instead of an
* error.
*
* @param aPoint Must be set to a valid point.
* @return Even if it's not an error, the boundary may be unset if
* aPoint's container is a root node of generated content.
*/
static Result<RawRangeBoundary, nsresult> GetPointAfterContainer(
const RawRangeBoundary& aPoint);
[[nodiscard]] static Maybe<uint32_t> ComputeIndexOfContent(
const nsINode* aParent, const nsIContent* aChild, TreeKind aTreeKind);
static bool IsMozBR(Element* aNode);
bool IsRoot(nsINode* aNode, TreeKind aKind) const;
/**
* Return true if the child node at the offset of aPoint does not follow a
* meaningful child in the container. This checks the flattened tree siblings
* if aPoint.GetTreeKind() is TreeKind::Flat.
*
* @param aPoint Must refers a child node, i.e., must not point the end
* of the container.
*/
static bool ChildIsFirstNode(const RawRangeBoundary& aPoint);
/**
* Return true if the child node at the offset of aPoint is not followed by a
* meaningful child in the container. This checks the flattened tree siblings
* if aPoint.GetTreeKind() is TreeKind::Flat.
*
* @param aPoint Must refers a child node if not pointing to the end of
* the container.
*/
static bool ChildIsLastNode(const RawRangeBoundary& aPoint);
bool mIsTextWidget{false};
};
nsHTMLCopyEncoder::nsHTMLCopyEncoder()
: nsDocumentEncoder{MakeUnique<nsHTMLCopyEncoder::RangeNodeContext>()} {}
nsHTMLCopyEncoder::~nsHTMLCopyEncoder() = default;
NS_IMETHODIMP
nsHTMLCopyEncoder::Init(Document* aDocument, const nsAString& aMimeType,
uint32_t aFlags) {
if (!aDocument) return NS_ERROR_INVALID_ARG;
mIsTextWidget = false;
Initialize(true, GetAllowRangeCrossShadowBoundary(aFlags));
mIsCopying = true;
mDocument = aDocument;
// nsHTMLCopyEncoder only accepts "text/plain" or "text/html" MIME types, and
// the initial MIME type may change after setting the selection.
MOZ_ASSERT(aMimeType.EqualsLiteral(kTextMime) ||
aMimeType.EqualsLiteral(kHTMLMime));
if (aMimeType.EqualsLiteral(kTextMime)) {
mMimeType.AssignLiteral(kTextMime);
} else {
mMimeType.AssignLiteral(kHTMLMime);
}
// Make all links absolute when copying
// (see related bugs #57296, #41924, #58646, #32768)
mFlags = aFlags | OutputAbsoluteLinks;
if (!mDocument->IsScriptEnabled()) mFlags |= OutputNoScriptContent;
return NS_OK;
}
NS_IMETHODIMP
nsHTMLCopyEncoder::SetSelection(Selection* aSelection) {
// check for text widgets: we need to recognize these so that
// we don't tweak the selection to be outside of the magic
// div that ender-lite text widgets are embedded in.
if (!aSelection) return NS_ERROR_NULL_POINTER;
const uint32_t rangeCount = aSelection->RangeCount();
// if selection is uninitialized return
if (!rangeCount) {
return NS_ERROR_FAILURE;
}
// we'll just use the common parent of the first range. Implicit assumption
// here that multi-range selections are table cell selections, in which case
// the common parent is somewhere in the table and we don't really care where.
//
// FIXME(emilio, bug 1455894): This assumption is already wrong, and will
// probably be more wrong in a Shadow DOM world...
//
// We should be able to write this as "Find the common ancestor of the
// selection, then go through the flattened tree and serialize the selected
// nodes", effectively serializing the composed tree.
RefPtr<nsRange> range = aSelection->GetRangeAt(0);
nsINode* commonParent = range->GetClosestCommonInclusiveAncestor();
mIsTextWidget =
commonParent &&
TextControlElement::FromNodeOrNull(
commonParent->GetClosestNativeAnonymousSubtreeRootParentOrHost());
// normalize selection if we are not in a widget
if (mIsTextWidget) {
mEncodingScope.mSelection = aSelection;
mMimeType.AssignLiteral("text/plain");
return NS_OK;
}
// XXX We should try to get rid of the Selection object here.
// XXX bug 1245883
// also consider ourselves in a text widget if we can't find an html document
// XXX: nsCopySupport relies on the MIME type not being updated immediately
// here, so it can apply different encoding for XHTML documents.
if (!(mDocument && mDocument->IsHTMLDocument())) {
mIsTextWidget = true;
mEncodingScope.mSelection = aSelection;
// mMimeType is set to text/plain when encoding starts.
return NS_OK;
}
// there's no Clone() for selection! fix...
// nsresult rv = aSelection->Clone(getter_AddRefs(mSelection);
// NS_ENSURE_SUCCESS(rv, rv);
mEncodingScope.mSelection = new Selection(SelectionType::eNormal, nullptr);
// loop thru the ranges in the selection
for (const uint32_t rangeIdx : IntegerRange(rangeCount)) {
MOZ_ASSERT(aSelection->RangeCount() == rangeCount);
range = aSelection->GetRangeAt(rangeIdx);
NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
RefPtr<nsRange> myRange = range->CloneRange();
MOZ_ASSERT(myRange);
// adjust range to include any ancestors who's children are entirely
// selected
nsresult rv = PromoteRange(myRange);
NS_ENSURE_SUCCESS(rv, rv);
ErrorResult result;
RefPtr<Selection> selection(mEncodingScope.mSelection);
RefPtr<Document> document(mDocument);
selection->AddRangeAndSelectFramesAndNotifyListenersInternal(
*myRange, document, result);
rv = result.StealNSResult();
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
NS_IMETHODIMP
nsHTMLCopyEncoder::EncodeToString(nsAString& aOutputString) {
if (mIsTextWidget) {
mMimeType.AssignLiteral("text/plain");
}
return nsDocumentEncoder::EncodeToString(aOutputString);
}
NS_IMETHODIMP
nsHTMLCopyEncoder::EncodeToStringWithContext(nsAString& aContextString,
nsAString& aInfoString,
nsAString& aEncodedString) {
nsresult rv = EncodeToString(aEncodedString);
NS_ENSURE_SUCCESS(rv, rv);
// do not encode any context info or range hints if we are in a text widget.
if (mIsTextWidget) return NS_OK;
// now encode common ancestors into aContextString. Note that the common
// ancestors will be for the last range in the selection in the case of
// multirange selections. encoding ancestors every range in a multirange
// selection in a way that could be understood by the paste code would be a
// lot more work to do. As a practical matter, selections are single range,
// and the ones that aren't are table cell selections where all the cells are
// in the same table.
mSerializer->Init(mFlags, mWrapColumn, mEncoding, mIsCopying, false,
&mNeedsPreformatScanning, aContextString);
// leaf of ancestors might be text node. If so discard it.
int32_t count = mRangeSerializer.mCommonInclusiveAncestors.Length();
int32_t i;
nsCOMPtr<nsINode> node;
if (count > 0) {
node = mRangeSerializer.mCommonInclusiveAncestors.ElementAt(0);
}
if (node && IsTextNode(node)) {
mRangeSerializer.mCommonInclusiveAncestors.RemoveElementAt(0);
if (mRangeSerializer.mContextInfoDepth.mStart) {
--mRangeSerializer.mContextInfoDepth.mStart;
}
if (mRangeSerializer.mContextInfoDepth.mEnd) {
--mRangeSerializer.mContextInfoDepth.mEnd;
}
count--;
}
i = count;
while (i > 0) {
node = mRangeSerializer.mCommonInclusiveAncestors.ElementAt(--i);
rv = mNodeSerializer.SerializeNodeStart(*node, 0, -1);
NS_ENSURE_SUCCESS(rv, rv);
}
// i = 0; guaranteed by above
while (i < count) {
node = mRangeSerializer.mCommonInclusiveAncestors.ElementAt(i++);
rv = mNodeSerializer.SerializeNodeEnd(*node);
NS_ENSURE_SUCCESS(rv, rv);
}
mSerializer->Finish();
// encode range info : the start and end depth of the selection, where the
// depth is distance down in the parent hierarchy. Later we will need to add
// leading/trailing whitespace info to this.
nsAutoString infoString;
infoString.AppendInt(mRangeSerializer.mContextInfoDepth.mStart);
infoString.Append(char16_t(','));
infoString.AppendInt(mRangeSerializer.mContextInfoDepth.mEnd);
aInfoString = infoString;
return rv;
}
bool nsHTMLCopyEncoder::RangeNodeContext::IncludeInContext(
nsINode& aNode) const {
const nsIContent* const content = nsIContent::FromNodeOrNull(&aNode);
if (!content) {
return false;
}
// If it's an inline editing host, we should not treat it gives a context to
// avoid to duplicate its style.
if (content->IsEditingHost()) {
return false;
}
return content->IsAnyOfHTMLElements(
nsGkAtoms::b, nsGkAtoms::i, nsGkAtoms::u, nsGkAtoms::a, nsGkAtoms::tt,
nsGkAtoms::s, nsGkAtoms::big, nsGkAtoms::small, nsGkAtoms::strike,
nsGkAtoms::em, nsGkAtoms::strong, nsGkAtoms::dfn, nsGkAtoms::code,
nsGkAtoms::cite, nsGkAtoms::var, nsGkAtoms::abbr, nsGkAtoms::font,
nsGkAtoms::script, nsGkAtoms::span, nsGkAtoms::pre, nsGkAtoms::h1,
nsGkAtoms::h2, nsGkAtoms::h3, nsGkAtoms::h4, nsGkAtoms::h5,
nsGkAtoms::h6);
}
nsresult nsHTMLCopyEncoder::PromoteRange(nsRange* inRange) {
if (!inRange->IsPositioned()) {
return NS_ERROR_UNEXPECTED;
}
const RawRangeBoundary startRef = [&]() -> RawRangeBoundary {
const auto& ref = inRange->MayCrossShadowBoundaryStartRef();
// XXX If GetTreeKind() returns TreeKind::DOM but ref.GetTreeKind() returns
// TreeKind::Flat, what should we do? The result may cross the shadow DOM
// boundaries even though the our user do not want that.
if (GetTreeKind() == TreeKind::Flat && ref.GetTreeKind() == TreeKind::DOM) {
return ref.AsRaw().AsRangeBoundaryInFlatTree(
inRange->Collapsed() ? RangeBoundaryFor::Collapsed
: RangeBoundaryFor::Start);
}
return ref.AsRaw();
}();
const RawRangeBoundary endRef = [&]() -> RawRangeBoundary {
const auto& ref = inRange->MayCrossShadowBoundaryEndRef();
if (GetTreeKind() == TreeKind::Flat && ref.GetTreeKind() == TreeKind::DOM) {
return ref.AsRaw().AsRangeBoundaryInFlatTree(
inRange->Collapsed() ? RangeBoundaryFor::Collapsed
: RangeBoundaryFor::End);
}
return ref.AsRaw();
}();
MOZ_ASSERT(startRef.GetTreeKind() == endRef.GetTreeKind());
const nsINode* const commonAncestor =
inRange->GetClosestCommonInclusiveAncestor(
AllowRangeCrossShadowBoundary::Yes);
MOZ_ASSERT(commonAncestor);
// examine range endpoints.
Result<RawRangeBoundary, nsresult> promotedStartPointOrError =
GetPromotedStartPoint(startRef, commonAncestor);
if (NS_WARN_IF(promotedStartPointOrError.isErr())) {
return NS_ERROR_FAILURE;
}
Result<RawRangeBoundary, nsresult> promotedEndPointOrError =
GetPromotedEndPoint(endRef, commonAncestor);
if (NS_WARN_IF(promotedEndPointOrError.isErr())) {
return NS_ERROR_FAILURE;
}
RawRangeBoundary promotedStartPoint = promotedStartPointOrError.unwrap();
MOZ_ASSERT(promotedStartPoint.IsSet());
RawRangeBoundary promotedEndPoint = promotedEndPointOrError.unwrap();
MOZ_ASSERT(promotedEndPoint.IsSet());
// if both range endpoints are at the common ancestor, check for possible
// inclusion of ancestors
using OffsetFilter = RawRangeBoundary::OffsetFilter;
if (StaticPrefs::dom_serializer_includeCommonAncestor_enabled() &&
promotedStartPoint.GetContainer() == commonAncestor &&
promotedEndPoint.GetContainer() == commonAncestor) {
MOZ_ASSERT(promotedStartPoint.GetTreeKind() ==
promotedEndPoint.GetTreeKind());
Result<RangeInNode, nsresult> promotedRangeOrError =
PromoteAncestorChain(RangeInNode{
promotedStartPoint.GetContainer(),
*promotedStartPoint.Offset(OffsetFilter::kValidOrInvalidOffsets),
*promotedEndPoint.Offset(OffsetFilter::kValidOrInvalidOffsets),
promotedStartPoint.GetTreeKind()});
if (MOZ_UNLIKELY(promotedRangeOrError.isErr())) {
return promotedRangeOrError.propagateErr();
}
const RangeInNode promotedRange = promotedRangeOrError.unwrap();
promotedStartPoint = promotedRange.StartRef();
promotedEndPoint = promotedRange.EndRef();
}
// set the range to the new values
ErrorResult err;
inRange->SetStart(promotedStartPoint.AsRangeBoundaryInDOMTree(), err,
GetAllowRangeCrossShadowBoundary(mFlags));
if (NS_WARN_IF(err.Failed())) {
return err.StealNSResult();
}
inRange->SetEnd(RawRangeBoundary(promotedEndPoint.AsRangeBoundaryInDOMTree()),
err, GetAllowRangeCrossShadowBoundary(mFlags));
if (NS_WARN_IF(err.Failed())) {
return err.StealNSResult();
}
return NS_OK;
}
// PromoteAncestorChain will promote a range represented by aRangeInNode.
// The promotion is different from that found in GetPromoted(Start|End)Point: it
// will only promote one endpoint if it can promote the other. Thus,
// RangeInNode has only one nsINode* member, mContainer.
Result<nsHTMLCopyEncoder::RangeInNode, nsresult>
nsHTMLCopyEncoder::PromoteAncestorChain(const RangeInNode& aRangeInNode) const {
MOZ_ASSERT(aRangeInNode.mContainer);
using OffsetFilter = RawRangeBoundary::OffsetFilter;
RangeInNode rangeInNode = aRangeInNode;
while (true) {
nsINode* const parentNode = rangeInNode.GetParentNode();
if (MOZ_UNLIKELY(!parentNode)) {
break;
}
// passing parent as last param to GetPromotedStartPoint() allows it to
// promote only one level up the hierarchy.
Result<RawRangeBoundary, nsresult> promotedStartPointOrError =
GetPromotedStartPoint(rangeInNode.StartRef(), parentNode);
if (NS_WARN_IF(promotedStartPointOrError.isErr())) {
return Err(NS_ERROR_FAILURE);
}
// then we make the same attempt with the endpoint
Result<RawRangeBoundary, nsresult> promotedEndPointOrError =
GetPromotedEndPoint(rangeInNode.EndRef(), parentNode);
if (NS_WARN_IF(promotedEndPointOrError.isErr())) {
return Err(NS_ERROR_FAILURE);
}
const RawRangeBoundary promotedStartPoint =
promotedStartPointOrError.unwrap();
MOZ_ASSERT(promotedStartPoint.IsSet());
const RawRangeBoundary promotedEndPoint = promotedEndPointOrError.unwrap();
MOZ_ASSERT(promotedEndPoint.IsSet());
// if both endpoints were promoted one level and isEditable is the same as
// the original node, keep looping - otherwise we are done.
if (promotedStartPoint.GetContainer() != parentNode ||
promotedEndPoint.GetContainer() != parentNode ||
parentNode->IsEditable() != aRangeInNode.mContainer->IsEditable()) {
break;
}
rangeInNode.mContainer = parentNode;
rangeInNode.mStartOffset =
*promotedStartPoint.Offset(OffsetFilter::kValidOrInvalidOffsets);
rangeInNode.mEndOffset =
*promotedEndPoint.Offset(OffsetFilter::kValidOrInvalidOffsets);
}
return rangeInNode;
}
Result<RawRangeBoundary, nsresult> nsHTMLCopyEncoder::GetPromotedStartPoint(
const RawRangeBoundary& aPoint, const nsINode* const aCommon) const {
MOZ_ASSERT(aPoint.IsSet());
using OffsetFilter = RawRangeBoundary::OffsetFilter;
// default values
if (aCommon == aPoint.GetContainer() ||
IsRoot(aPoint.GetContainer(), aPoint.GetTreeKind())) {
return aPoint;
}
RawRangeBoundary point(aPoint.GetTreeKind());
bool resetPromotion = false;
// some special casing for text nodes
if (auto* const nodeAsText = Text::FromNode(aPoint.GetContainer())) {
// if not at beginning of text node, we are done
if (!aPoint.IsStartOfContainer()) {
// unless everything before us in just whitespace. NOTE: we need a more
// general solution that truly detects all cases of non-significant
// whitesace with no false alarms.
if (!nodeAsText->TextStartsWithOnlyWhitespace(
*aPoint.Offset(OffsetFilter::kValidOrInvalidOffsets))) {
return aPoint;
}
resetPromotion = true;
}
// If it points the start of a `Text`, we want to extend the start boundary
// to the parent element.
Result<RawRangeBoundary, nsresult> parentPointOrError =
GetParentPoint(aPoint);
if (NS_WARN_IF(parentPointOrError.isErr())) {
return parentPointOrError.propagateErr();
}
point = parentPointOrError.unwrap();
if (MOZ_UNLIKELY(!point.IsSet())) {
NS_WARNING(fmt::format("aPoint={}", aPoint).c_str());
MOZ_ASSERT_UNREACHABLE(
"Selection shouldn't start/end in generated content nor content "
"being removed");
return aPoint;
}
if (point.GetContainer() == aCommon) {
return aPoint;
}
} else {
// If aPoint points a child node, try to climbing up the tree from the
// point.
// XXX: Should we only start from the container of aPoint when it points to
// start of the container and the container has no children? Currently we
// start from the container even when aPoint is invalid, which seems wrong.
if (aPoint.GetContainer()->HasChildNodes() && !aPoint.IsEndOfContainer()) {
if (aPoint.GetContainer() == aCommon) {
return aPoint;
}
point = aPoint;
}
// Otherwise, aPoint points the end of the container (including when the
// container has no child), we can climbing up the tree from its parent.
else {
Result<RawRangeBoundary, nsresult> parentPointOrError =
GetParentPoint(aPoint);
if (NS_WARN_IF(parentPointOrError.isErr())) {
return parentPointOrError.propagateErr();
}
point = parentPointOrError.unwrap();
if (MOZ_UNLIKELY(!point.IsSet())) {
NS_WARNING(fmt::format("aPoint={}", aPoint).c_str());
MOZ_ASSERT_UNREACHABLE(
"Selection shouldn't start/end in generated content nor content "
"being removed");
return aPoint;
}
}
}
NS_WARNING_ASSERTION(
point.GetChildAtOffset(),
nsFmtCString(
FMT_STRING("Not pointing a child node:\npoint={}\naPoint={}\n"),
point, aPoint)
.get());
MOZ_ASSERT(point.GetChildAtOffset());
// finding the real start for this point. look up the tree for as long as
// we are the first node in the container, and as long as we haven't hit the
// body node.
if (aPoint.GetContainer() != point.GetChildAtOffset() &&
IsRoot(point.GetChildAtOffset(), point.GetTreeKind())) {
return aPoint;
}
while (point.GetContainer() != aCommon &&
!IsRoot(point.GetContainer(), point.GetTreeKind()) &&
ChildIsFirstNode(point)) {
if (resetPromotion) {
nsIContent* const parentContent =
nsIContent::FromNodeOrNull(point.GetContainer());
if (parentContent && parentContent->IsHTMLElement() &&
nsHTMLElement::IsBlock(
nsHTMLTags::AtomTagToId(parentContent->NodeInfo()->NameAtom()))) {
resetPromotion = false;
}
}
Result<RawRangeBoundary, nsresult> parentPointOrError =
GetParentPoint(point);
if (MOZ_UNLIKELY(parentPointOrError.isErr())) {
return parentPointOrError.propagateErr();
}
if (MOZ_UNLIKELY(!parentPointOrError.inspect().IsSet())) {
NS_WARNING(fmt::format("aPoint={}", aPoint).c_str());
MOZ_ASSERT_UNREACHABLE(
"Selection shouldn't start/end in generated content nor content "
"being removed");
return Err(NS_ERROR_FAILURE);
}
point = parentPointOrError.unwrap();
}
return resetPromotion ? aPoint : point;
}
Result<RawRangeBoundary, nsresult> nsHTMLCopyEncoder::GetPromotedEndPoint(
const RawRangeBoundary& aPoint, const nsINode* const aCommon) const {
MOZ_ASSERT(aPoint.IsSet());
using OffsetFilter = RawRangeBoundary::OffsetFilter;
// default values
if (aCommon == aPoint.GetContainer() ||
IsRoot(aPoint.GetContainer(), aPoint.GetTreeKind())) {
return aPoint;
}
RawRangeBoundary point(aPoint.GetTreeKind());
bool resetPromotion = false;
// Some special casing for CharacterData nodes.
if (aPoint.GetContainer()->IsCharacterData()) {
if (auto* const nodeAsText = Text::FromNode(aPoint.GetContainer())) {
// if not at end of text node, we are done
if (!aPoint.IsEndOfContainer()) {
// unless everything after us is just whitespace. NOTE: we need a more
// general solution that truly detects all cases of non-significant
// whitespace with no false alarms.
if (!nodeAsText->TextEndsWithOnlyWhitespace(
*aPoint.Offset(OffsetFilter::kValidOrInvalidOffsets))) {
return aPoint;
}
resetPromotion = true;
}
// If it points the end of a `Text`, we want to extend the end boundary
// to the parent element.
}
// For other CharacterData nodes, we always extend the end boundary to the
// parent element.
Result<RawRangeBoundary, nsresult> parentPointOrError =
GetPointAfterContainer(aPoint);
if (NS_WARN_IF(parentPointOrError.isErr())) {
return parentPointOrError.propagateErr();
}
point = parentPointOrError.unwrap();
if (MOZ_UNLIKELY(!point.IsSet())) {
NS_WARNING(fmt::format("aPoint={}", aPoint).c_str());
MOZ_ASSERT_UNREACHABLE(
"Selection shouldn't start/end in generated content nor content "
"being removed");
return aPoint;
}
if (point.GetContainer() == aCommon ||
IsRoot(point.GetContainer(), point.GetTreeKind())) {
return aPoint;
}
NS_WARNING_ASSERTION(
point.GetPreviousSiblingOfChildAtOffset(),
nsFmtCString(
FMT_STRING("Not pointing a child node:\npoint={}\naPoint={}\n"),
point, aPoint)
.get());
MOZ_ASSERT(point.GetPreviousSiblingOfChildAtOffset());
} else {
point = aPoint;
}
MOZ_ASSERT(point.IsSet());
MOZ_ASSERT(!IsRoot(point.GetContainer(), point.GetTreeKind()));
// finding the real end for this point. look up the tree for as long as we
// are the last node in the container, and as long as we haven't hit the
// body node.
while (point.GetContainer() != aCommon &&
!IsRoot(point.GetContainer(), point.GetTreeKind()) &&
ChildIsLastNode(point)) {
if (resetPromotion) {
nsIContent* const parentContent =
nsIContent::FromNodeOrNull(point.GetContainer());
if (parentContent && parentContent->IsHTMLElement() &&
nsHTMLElement::IsBlock(
nsHTMLTags::AtomTagToId(parentContent->NodeInfo()->NameAtom()))) {
resetPromotion = false;
}
}
Result<RawRangeBoundary, nsresult> parentPointOrError =
GetPointAfterContainer(point);
if (MOZ_UNLIKELY(parentPointOrError.isErr())) {
NS_WARNING(fmt::format("point={}", point).c_str());
return parentPointOrError.propagateErr();
}
if (MOZ_UNLIKELY(!parentPointOrError.inspect().IsSet())) {
NS_WARNING(fmt::format("point={}", point).c_str());
MOZ_ASSERT_UNREACHABLE(
"Selection shouldn't start/end in generated content nor content "
"being removed");
return Err(NS_ERROR_FAILURE);
}
point = parentPointOrError.unwrap();
}
return resetPromotion ? aPoint : point;
}
bool nsHTMLCopyEncoder::IsMozBR(Element* aElement) {
HTMLBRElement* brElement = HTMLBRElement::FromNodeOrNull(aElement);
return brElement && brElement->IsPaddingForEmptyLastLine();
}
// static
Maybe<uint32_t> nsHTMLCopyEncoder::ComputeIndexOfContent(
const nsINode* aParent, const nsIContent* aChild, TreeKind aTreeKind) {
MOZ_ASSERT(aParent);
MOZ_ASSERT(aChild);
if (aTreeKind == TreeKind::DOM) {
return aParent->ComputeIndexOf(aChild);
}
// If the parent of the container has a shadow root which is for <use> or a
// UI widget, we shouldn't treat it as a shadow host.
if (aParent->GetShadowRoot() && !aParent->GetShadowRootForSelection()) {
return aParent->ComputeIndexOf(aChild);
}
return aParent->ComputeFlatTreeIndexOf(aChild);
}
Result<RawRangeBoundary, nsresult> nsHTMLCopyEncoder::GetParentPoint(
const RawRangeBoundary& aPoint) {
MOZ_ASSERT(aPoint.IsSet());
nsIContent* const containerContent =
nsIContent::FromNodeOrNull(aPoint.GetContainer());
if (MOZ_UNLIKELY(!containerContent)) {
return Err(NS_ERROR_NULL_POINTER);
}
// If the container is a ShadowRoot, GetFlattenedTreeParentNodeForSelection()
// returns nullptr. However, we want to keep handling in the host.
if (aPoint.GetTreeKind() == TreeKind::Flat) {
if (ShadowRoot* const shadowRoot = ShadowRoot::FromNode(containerContent)) {
Element* const host = shadowRoot->GetHost();
if (MOZ_UNLIKELY(!host)) {
return Err(NS_ERROR_NULL_POINTER);
}
// Return the point of the host element. Then, the caller can check
// whether the host element is the first/last meaningful node in its
// parent.
RawRangeBoundary atHost =
RawRangeBoundary::FromChild(*host, aPoint.GetTreeKind());
if (MOZ_UNLIKELY(!atHost.IsSet())) {
// The host element may not be a part of the flattened tree, i.e., its
// parent node is another shadow host and not assigned to any <slot>.
return Err(NS_ERROR_NULL_POINTER);
}
return std::move(atHost);
}
}
nsINode* const containerParentNode =
aPoint.GetTreeKind() == TreeKind::Flat
? containerContent->GetFlattenedTreeParentNodeForSelection()
: containerContent->GetParentNode();
if (MOZ_UNLIKELY(!containerParentNode)) {
return Err(NS_ERROR_NULL_POINTER);
}
const Maybe<uint32_t> indexOfContainer = ComputeIndexOfContent(
containerParentNode, containerContent, aPoint.GetTreeKind());
if (MOZ_UNLIKELY(indexOfContainer.isNothing())) {
return RawRangeBoundary(aPoint.GetTreeKind());
}
return RawRangeBoundary(
containerParentNode, *indexOfContainer,
// Do not compute the previous sibling of the child immediately because it
// may not be cheap if we're handling in the flat tree.
RangeBoundarySetBy::Offset, aPoint.GetTreeKind());
}
Result<RawRangeBoundary, nsresult> nsHTMLCopyEncoder::GetPointAfterContainer(
const RawRangeBoundary& aPoint) {
MOZ_ASSERT(aPoint.IsSet());
nsIContent* const containerContent =
nsIContent::FromNodeOrNull(aPoint.GetContainer());
if (MOZ_UNLIKELY(!containerContent)) {
return Err(NS_ERROR_NULL_POINTER);
}
// If the container is a ShadowRoot, RawRangeBoundary::After() returns an
// unset point. However, we want to keep handling in the host.
if (aPoint.GetTreeKind() == TreeKind::Flat) {
if (ShadowRoot* const shadowRoot = ShadowRoot::FromNode(containerContent)) {
Element* const host = shadowRoot->GetHost();
if (MOZ_UNLIKELY(!host)) {
return Err(NS_ERROR_NULL_POINTER);
}
// Return the point after the host element.
RawRangeBoundary afterHost =
RawRangeBoundary::After(*host, aPoint.GetTreeKind());
if (MOZ_UNLIKELY(!afterHost.IsSet())) {
// The host element may not be a part of the flattened tree, i.e., its
// parent node is another shadow host and not assigned to any <slot>.
return Err(NS_ERROR_NULL_POINTER);
}
return std::move(afterHost);
}
}
return RawRangeBoundary::After(*containerContent, aPoint.GetTreeKind());
}
bool nsHTMLCopyEncoder::IsRoot(nsINode* aNode, TreeKind aKind) const {
nsCOMPtr<nsIContent> content = nsIContent::FromNodeOrNull(aNode);
if (!content) {
return false;
}
if (mIsTextWidget) {
return content->IsHTMLElement(nsGkAtoms::div);
}
if (aKind == TreeKind::Flat) {
// If we're handling the flattened tree and aNode is a ShadowRoot,
// GetParentPoint() for a point whose container is aNode will return the
// point at the host. However, if the host is not a part of the flattened
// tree, it will return an error instead. In this case, if we didn't reach
// the ShadowRoot, we succeeded promoting the range. Therefore, we should
// treat the ShadowRoot as a root.
if (const ShadowRoot* const shadowRoot = ShadowRoot::FromNode(*content)) {
if (MOZ_UNLIKELY(shadowRoot->IsUAWidget())) {
// Special case for the fallback content of <slot> in the non-content
// shadow. E.g., the default summary of <details>.
return true;
}
const Element* const host = shadowRoot->GetHost();
if (NS_WARN_IF(!host)) {
return true;
}
const nsINode* const flattenedTreeParentNode =
host->GetFlattenedTreeParentNodeForSelection();
if (MOZ_UNLIKELY(!flattenedTreeParentNode)) {
return true;
}
}
}
// XXX(sefeng): This is some old code from 2006, so I can't
// promise my comment is correct. However, I think these elements
// are considered to be `Root` because if we keep going up
// in nsHTMLCopyEncoder::GetPromoted(Start|End)Point, we would lose the
// correct representation of the point, so we have to stop at
// these nodes.
// nsGkAtoms::slot is here because we'd lose the index
// of the slotted element if we keep going up as
// `nsHTMLCopyEncoder::GetNodeLocation` would promote the
// offset to be index of the <slot> that is relative to
// the <slot>'s parent.
return content->IsAnyOfHTMLElements(nsGkAtoms::body, nsGkAtoms::td,
nsGkAtoms::th, nsGkAtoms::slot);
}
bool nsHTMLCopyEncoder::ChildIsFirstNode(const RawRangeBoundary& aPoint) {
MOZ_ASSERT(aPoint.GetChildAtOffset());
// need to check if any nodes before us are really visible.
// Mike wrote something for me along these lines in nsSelectionController,
// but I don't think it's ready for use yet - revisit.
// HACK: for now, simply consider all whitespace text nodes to be
// invisible formatting nodes.
const auto ChildIsSignificant = [](nsIContent& aContent) {
return !aContent.TextIsOnlyWhitespace();
};
if (aPoint.GetTreeKind() == TreeKind::Flat) {
if (const HTMLSlotElement* slot =
HTMLSlotElement::FromNode(aPoint.GetContainer())) {
const auto assignedNodes = slot->AssignedNodes();
if (!assignedNodes.IsEmpty()) {
for (const uint32_t offset : Reversed(IntegerRange(*aPoint.Offset(
RawRangeBoundary::OffsetFilter::kValidOrInvalidOffsets)))) {
nsIContent* const sibling =
nsIContent::FromNode(assignedNodes[offset]);
if (sibling && ChildIsSignificant(*sibling)) {
return false;
}
}
return true;
}
}
}
for (nsIContent* sibling = aPoint.GetPreviousSiblingOfChildAtOffset();
sibling; sibling = sibling->GetPreviousSibling()) {
if (ChildIsSignificant(*sibling)) {
return false;
}
}
return true;
}
bool nsHTMLCopyEncoder::ChildIsLastNode(const RawRangeBoundary& aPoint) {
MOZ_ASSERT(aPoint.IsSet());
MOZ_ASSERT_IF(!aPoint.IsEndOfContainer(), aPoint.GetChildAtOffset());
// need to check if any nodes after us are really visible.
// Mike wrote something for me along these lines in nsSelectionController,
// but I don't think it's ready for use yet - revisit.
// HACK: for now, simply consider all whitespace text nodes to be
// invisible formatting nodes.
const auto ChildIsSignificant = [](nsIContent& aContent) {
if (aContent.IsElement() && IsMozBR(aContent.AsElement())) {
// we ignore trailing moz BRs.
return false;
}
return !aContent.TextIsOnlyWhitespace();
};
if (aPoint.GetTreeKind() == TreeKind::Flat) {
if (const HTMLSlotElement* slot =
HTMLSlotElement::FromNode(aPoint.GetContainer())) {
const auto assignedNodes = slot->AssignedNodes();
if (!assignedNodes.IsEmpty()) {
const uint32_t length = assignedNodes.Length();
const uint32_t nextOffset = *aPoint.Offset(
RawRangeBoundary::OffsetFilter::kValidOrInvalidOffsets);
if (nextOffset >= length) {
return true;
}
for (const uint32_t offset : IntegerRange(nextOffset, length)) {
nsIContent* const sibling =
nsIContent::FromNode(assignedNodes[offset]);
if (sibling && ChildIsSignificant(*sibling)) {
return false;
}
}
return true;
}
}
}
for (nsIContent* sibling = aPoint.GetChildAtOffset(); sibling;
sibling = sibling->GetNextSibling()) {
if (ChildIsSignificant(*sibling)) {
return false;
}
}
return true;
}
already_AddRefed<nsIDocumentEncoder> do_createHTMLCopyEncoder() {
return do_AddRef(new nsHTMLCopyEncoder);
}
int32_t nsHTMLCopyEncoder::RangeNodeContext::GetImmediateContextCount(
const nsTArray<nsINode*>& aAncestorArray) const {
int32_t i = aAncestorArray.Length(), j = 0;
while (j < i) {
nsINode* node = aAncestorArray.ElementAt(j);
if (!node) {
break;
}
nsCOMPtr<nsIContent> content(nsIContent::FromNodeOrNull(node));
if (!content || !content->IsAnyOfHTMLElements(
nsGkAtoms::tr, nsGkAtoms::thead, nsGkAtoms::tbody,
nsGkAtoms::tfoot, nsGkAtoms::table)) {
break;
}
++j;
}
return j;
}