--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/nsContentIterator.cpp
@@ -41,36 +41,36 @@ NodeToParentOffset(nsINode* aNode, int32
///////////////////////////////////////////////////////////////////////////
// NodeIsInTraversalRange: returns true if content is visited during
// the traversal of the range in the specified mode.
//
static bool
NodeIsInTraversalRange(nsINode* aNode, bool aIsPreMode,
nsINode* aStartContainer, int32_t aStartOffset,
- nsINode* aEndNode, int32_t aEndOffset)
+ nsINode* aEndContainer, int32_t aEndOffset)
{
- if (NS_WARN_IF(!aStartContainer) || NS_WARN_IF(!aEndNode) ||
+ if (NS_WARN_IF(!aStartContainer) || NS_WARN_IF(!aEndContainer) ||
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 == aStartContainer || aNode == aEndNode) {
+ if (aNode == aStartContainer || aNode == aEndContainer) {
if (aNode->IsNodeOfType(nsINode::eDATA_NODE)) {
return true; // text node or something
}
if (!aNode->HasChildren()) {
MOZ_ASSERT(aNode != aStartContainer || !aStartOffset,
"aStartContainer doesn't have children and not a data node, "
"aStartOffset should be 0");
- MOZ_ASSERT(aNode != aEndNode || !aEndOffset,
- "aStartContainer doesn't have children and not a data node, "
- "aStartOffset should be 0");
+ MOZ_ASSERT(aNode != aEndContainer || !aEndOffset,
+ "aEndContainer doesn't have children and not a data node, "
+ "aEndOffset should be 0");
return true;
}
}
nsINode* parent = aNode->GetParentNode();
if (!parent) {
return false;
}
@@ -79,17 +79,17 @@ NodeIsInTraversalRange(nsINode* aNode, b
NS_WARNING_ASSERTION(indx != -1, "bad indx");
if (!aIsPreMode) {
++indx;
}
return nsContentUtils::ComparePoints(aStartContainer, aStartOffset,
parent, indx) <= 0 &&
- nsContentUtils::ComparePoints(aEndNode, aEndOffset,
+ nsContentUtils::ComparePoints(aEndContainer, aEndOffset,
parent, indx) >= 0;
}
/*
* A simple iterator class for traversing the content in "close tag" order
*/
--- a/dom/base/nsRange.cpp
+++ b/dom/base/nsRange.cpp
@@ -1056,22 +1056,22 @@ nsRange::GetStartOffset(ErrorResult& aRv
aRv.Throw(NS_ERROR_NOT_INITIALIZED);
return 0;
}
return mStartOffset;
}
NS_IMETHODIMP
-nsRange::GetEndContainer(nsIDOMNode** aEndParent)
+nsRange::GetEndContainer(nsIDOMNode** aEndContainer)
{
if (!mIsPositioned)
return NS_ERROR_NOT_INITIALIZED;
- return CallQueryInterface(mEndContainer, aEndParent);
+ return CallQueryInterface(mEndContainer, aEndContainer);
}
nsINode*
nsRange::GetEndContainer(ErrorResult& aRv) const
{
if (!mIsPositioned) {
aRv.Throw(NS_ERROR_NOT_INITIALIZED);
return nullptr;
@@ -1383,70 +1383,73 @@ nsRange::SetEnd(nsINode* aContainer, int
DoSetRange(mStartContainer, mStartOffset, aContainer, aOffset, mRoot);
return NS_OK;
}
nsresult
nsRange::SetStartAndEnd(nsINode* aStartContainer, int32_t aStartOffset,
- nsINode* aEndParent, int32_t aEndOffset)
+ nsINode* aEndContainer, int32_t aEndOffset)
{
- if (NS_WARN_IF(!aStartContainer) || NS_WARN_IF(!aEndParent)) {
+ if (NS_WARN_IF(!aStartContainer) || NS_WARN_IF(!aEndContainer)) {
return NS_ERROR_INVALID_ARG;
}
nsINode* newStartRoot = IsValidBoundary(aStartContainer);
if (!newStartRoot) {
return NS_ERROR_DOM_INVALID_NODE_TYPE_ERR;
}
if (!IsValidOffset(aStartContainer, aStartOffset)) {
return NS_ERROR_DOM_INDEX_SIZE_ERR;
}
- if (aStartContainer == aEndParent) {
- if (!IsValidOffset(aEndParent, aEndOffset)) {
+ if (aStartContainer == aEndContainer) {
+ if (!IsValidOffset(aEndContainer, aEndOffset)) {
return NS_ERROR_DOM_INDEX_SIZE_ERR;
}
// If the end offset is less than the start offset, this should be
// collapsed at the end offset.
if (aStartOffset > aEndOffset) {
- DoSetRange(aEndParent, aEndOffset, aEndParent, aEndOffset, newStartRoot);
+ DoSetRange(aEndContainer, aEndOffset,
+ aEndContainer, aEndOffset, newStartRoot);
} else {
DoSetRange(aStartContainer, aStartOffset,
- aEndParent, aEndOffset, newStartRoot);
+ aEndContainer, aEndOffset, newStartRoot);
}
return NS_OK;
}
- nsINode* newEndRoot = IsValidBoundary(aEndParent);
+ nsINode* newEndRoot = IsValidBoundary(aEndContainer);
if (!newEndRoot) {
return NS_ERROR_DOM_INVALID_NODE_TYPE_ERR;
}
- if (!IsValidOffset(aEndParent, aEndOffset)) {
+ if (!IsValidOffset(aEndContainer, aEndOffset)) {
return NS_ERROR_DOM_INDEX_SIZE_ERR;
}
// If they have different root, this should be collapsed at the end point.
if (newStartRoot != newEndRoot) {
- DoSetRange(aEndParent, aEndOffset, aEndParent, aEndOffset, newEndRoot);
+ DoSetRange(aEndContainer, aEndOffset,
+ aEndContainer, aEndOffset, newEndRoot);
return NS_OK;
}
// If the end point is before the start point, this should be collapsed at
// the end point.
if (nsContentUtils::ComparePoints(aStartContainer, aStartOffset,
- aEndParent, aEndOffset) == 1) {
- DoSetRange(aEndParent, aEndOffset, aEndParent, aEndOffset, newEndRoot);
+ aEndContainer, aEndOffset) == 1) {
+ DoSetRange(aEndContainer, aEndOffset,
+ aEndContainer, aEndOffset, newEndRoot);
return NS_OK;
}
// Otherwise, set the range as specified.
DoSetRange(aStartContainer, aStartOffset,
- aEndParent, aEndOffset, newStartRoot);
+ aEndContainer, aEndOffset, newStartRoot);
return NS_OK;
}
void
nsRange::SetEndBeforeJS(nsINode& aNode, ErrorResult& aErr)
{
AutoCalledByJSRestore calledByJSRestorer(*this);
mCalledByJS = true;
@@ -1941,35 +1944,35 @@ CollapseRangeAfterDelete(nsRange* aRange
return aRange->Collapse(false);
}
/**
* Split a data node into two parts.
*
* @param aStartContainer The original node we are trying to split.
* @param aStartOffset The offset at which to split.
- * @param aEndNode The second node.
+ * @param aEndContainer The second node.
* @param aCloneAfterOriginal Set false if the original node should be the
* latter one after split.
*/
static nsresult SplitDataNode(nsIDOMCharacterData* aStartContainer,
uint32_t aStartOffset,
- nsIDOMCharacterData** aEndNode,
+ nsIDOMCharacterData** aEndContainer,
bool aCloneAfterOriginal = true)
{
nsresult rv;
nsCOMPtr<nsINode> node = do_QueryInterface(aStartContainer);
NS_ENSURE_STATE(node && node->IsNodeOfType(nsINode::eDATA_NODE));
nsGenericDOMDataNode* dataNode = static_cast<nsGenericDOMDataNode*>(node.get());
nsCOMPtr<nsIContent> newData;
rv = dataNode->SplitData(aStartOffset, getter_AddRefs(newData),
aCloneAfterOriginal);
NS_ENSURE_SUCCESS(rv, rv);
- return CallQueryInterface(newData, aEndNode);
+ return CallQueryInterface(newData, aEndContainer);
}
NS_IMETHODIMP
PrependChild(nsINode* aContainer, nsINode* aChild)
{
nsCOMPtr<nsINode> first = aContainer->GetFirstChild();
ErrorResult rv;
aContainer->InsertBefore(*aChild, first, rv);
@@ -3093,22 +3096,23 @@ static nsresult GetPartialTextRect(nsLay
}
/* static */ void
nsRange::CollectClientRectsAndText(nsLayoutUtils::RectCallback* aCollector,
Sequence<nsString>* aTextList,
nsRange* aRange,
nsINode* aStartContainer,
int32_t aStartOffset,
- nsINode* aEndParent, int32_t aEndOffset,
+ nsINode* aEndContainer,
+ int32_t aEndOffset,
bool aClampToEdge, bool aFlushLayout)
{
// Hold strong pointers across the flush
nsCOMPtr<nsINode> startContainer = aStartContainer;
- nsCOMPtr<nsINode> endContainer = aEndParent;
+ nsCOMPtr<nsINode> endContainer = aEndContainer;
// Flush out layout so our frames are up to date.
if (!aStartContainer->IsInUncomposedDoc()) {
return;
}
if (aFlushLayout) {
aStartContainer->OwnerDoc()->FlushPendingNotifications(FlushType::Layout);
@@ -3616,42 +3620,42 @@ IsLastNonemptyRowGroupOfTable(nsIFrame*
}
}
return true;
}
void
nsRange::GetInnerTextNoFlush(DOMString& aValue, ErrorResult& aError,
nsIContent* aStartContainer, uint32_t aStartOffset,
- nsIContent* aEndParent, uint32_t aEndOffset)
+ nsIContent* aEndContainer, uint32_t aEndOffset)
{
InnerTextAccumulator result(aValue);
nsIContent* currentNode = aStartContainer;
TreeTraversalState currentState = AFTER_NODE;
if (aStartContainer->IsNodeOfType(nsINode::eTEXT)) {
auto t = static_cast<nsGenericDOMDataNode*>(aStartContainer);
- if (aStartContainer == aEndParent) {
+ if (aStartContainer == aEndContainer) {
AppendTransformedText(result, t, aStartOffset, aEndOffset);
return;
}
AppendTransformedText(result, t, aStartOffset, t->TextLength());
} else {
if (uint32_t(aStartOffset) < aStartContainer->GetChildCount()) {
currentNode = aStartContainer->GetChildAt(aStartOffset);
currentState = AT_NODE;
}
}
- nsIContent* endNode = aEndParent;
+ nsIContent* endNode = aEndContainer;
TreeTraversalState endState = AFTER_NODE;
- if (aEndParent->IsNodeOfType(nsINode::eTEXT)) {
+ if (aEndContainer->IsNodeOfType(nsINode::eTEXT)) {
endState = AT_NODE;
} else {
- if (uint32_t(aEndOffset) < aEndParent->GetChildCount()) {
- endNode = aEndParent->GetChildAt(aEndOffset);
+ if (uint32_t(aEndOffset) < aEndContainer->GetChildCount()) {
+ endNode = aEndContainer->GetChildAt(aEndOffset);
endState = AT_NODE;
}
}
while (currentNode != endNode || currentState != endState) {
nsIFrame* f = currentNode->GetPrimaryFrame();
bool isVisibleAndNotReplaced = IsVisibleAndNotInReplacedElement(f);
if (currentState == AT_NODE) {
@@ -3703,15 +3707,15 @@ nsRange::GetInnerTextNoFlush(DOMString&
if (next) {
currentNode = next;
currentState = AT_NODE;
} else {
currentNode = currentNode->GetParent();
}
}
- if (aEndParent->IsNodeOfType(nsINode::eTEXT)) {
- nsGenericDOMDataNode* t = static_cast<nsGenericDOMDataNode*>(aEndParent);
+ if (aEndContainer->IsNodeOfType(nsINode::eTEXT)) {
+ nsGenericDOMDataNode* t = static_cast<nsGenericDOMDataNode*>(aEndContainer);
AppendTransformedText(result, t, 0, aEndOffset);
}
// Do not flush trailing line breaks! Required breaks at the end of the text
// are suppressed.
}
--- a/dom/base/nsRange.h
+++ b/dom/base/nsRange.h
@@ -43,23 +43,23 @@ class nsRange final : public nsIDOMRange
typedef mozilla::dom::DOMRectList DOMRectList;
virtual ~nsRange();
public:
explicit nsRange(nsINode* aNode);
static nsresult CreateRange(nsIDOMNode* aStartContainer, int32_t aStartOffset,
- nsIDOMNode* aEndParent, int32_t aEndOffset,
+ nsIDOMNode* aEndContainer, int32_t aEndOffset,
nsRange** aRange);
static nsresult CreateRange(nsIDOMNode* aStartContainer, int32_t aStartOffset,
- nsIDOMNode* aEndParent, int32_t aEndOffset,
+ nsIDOMNode* aEndContainer, int32_t aEndOffset,
nsIDOMRange** aRange);
static nsresult CreateRange(nsINode* aStartContainer, int32_t aStartOffset,
- nsINode* aEndParent, int32_t aEndOffset,
+ nsINode* aEndContainer, int32_t aEndOffset,
nsRange** aRange);
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsRange, nsIDOMRange)
nsrefcnt GetRefCount() const
{
return mRefCnt;
@@ -156,17 +156,17 @@ public:
* SetStartAndEnd() works similar to call both SetStart() and SetEnd().
* Different from calls them separately, this does nothing if either
* the start point or the end point is invalid point.
* If the specified start point is after the end point, the range will be
* collapsed at the end point. Similarly, if they are in different root,
* the range will be collapsed at the end point.
*/
nsresult SetStartAndEnd(nsINode* aStartContainer, int32_t aStartOffset,
- nsINode* aEndParent, int32_t aEndOffset);
+ nsINode* aEndContainer, int32_t aEndOffset);
/**
* CollapseTo() works similar to call both SetStart() and SetEnd() with
* same node and offset. This just calls SetStartAndParent() to set
* collapsed range at aContainer and aOffset.
*/
nsresult CollapseTo(nsINode* aContainer, int32_t aOffset)
{
@@ -267,17 +267,17 @@ public:
void SetStart(nsINode& aNode, uint32_t aOffset, ErrorResult& aErr);
void SetStartAfter(nsINode& aNode, ErrorResult& aErr);
void SetStartBefore(nsINode& aNode, ErrorResult& aErr);
static void GetInnerTextNoFlush(mozilla::dom::DOMString& aValue,
mozilla::ErrorResult& aError,
nsIContent* aStartContainer,
uint32_t aStartOffset,
- nsIContent* aEndParent,
+ nsIContent* aEndContainer,
uint32_t aEndOffset);
nsINode* GetParentObject() const { return mOwner; }
virtual JSObject* WrapObject(JSContext* cx, JS::Handle<JSObject*> aGivenProto) override final;
private:
// no copy's or assigns
nsRange(const nsRange&);
@@ -323,17 +323,18 @@ public:
* This helper function gets rects and correlated text for the given range.
* @param aTextList optional where nullptr = don't retrieve text
*/
static void CollectClientRectsAndText(nsLayoutUtils::RectCallback* aCollector,
mozilla::dom::Sequence<nsString>* aTextList,
nsRange* aRange,
nsINode* aStartContainer,
int32_t aStartOffset,
- nsINode* aEndParent, int32_t aEndOffset,
+ nsINode* aEndContainer,
+ int32_t aEndOffset,
bool aClampToEdge, bool aFlushLayout);
/**
* Scan this range for -moz-user-select:none nodes and split it up into
* multiple ranges to exclude those nodes. The resulting ranges are put
* in aOutRanges. If no -moz-user-select:none node is found in the range
* then |this| is unmodified and is the only range in aOutRanges.
* Otherwise, |this| will be modified so that it ends before the first
--- a/editor/libeditor/EditorBase.cpp
+++ b/editor/libeditor/EditorBase.cpp
@@ -3857,34 +3857,34 @@ EditorBase::GetEndNodeAndOffset(Selectio
} else {
*outEndNode = nullptr;
}
return NS_OK;
}
nsresult
EditorBase::GetEndNodeAndOffset(Selection* aSelection,
- nsINode** aEndNode,
+ nsINode** aEndContainer,
int32_t* aEndOffset)
{
MOZ_ASSERT(aSelection);
- MOZ_ASSERT(aEndNode);
+ MOZ_ASSERT(aEndContainer);
MOZ_ASSERT(aEndOffset);
- *aEndNode = nullptr;
+ *aEndContainer = nullptr;
*aEndOffset = 0;
NS_ENSURE_TRUE(aSelection->RangeCount(), NS_ERROR_FAILURE);
const nsRange* range = aSelection->GetRangeAt(0);
NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
NS_ENSURE_TRUE(range->IsPositioned(), NS_ERROR_FAILURE);
- NS_IF_ADDREF(*aEndNode = range->GetEndContainer());
+ NS_IF_ADDREF(*aEndContainer = range->GetEndContainer());
*aEndOffset = range->EndOffset();
return NS_OK;
}
/**
* IsPreformatted() checks the style info for the node for the preformatted
* text style.
*/
@@ -4659,22 +4659,22 @@ EditorBase::CreateTxnForDeleteRange(nsRa
}
selectedNode.forget(aRemovingNode);
return deleteNodeTransaction.forget();
}
nsresult
EditorBase::CreateRange(nsIDOMNode* aStartContainer,
int32_t aStartOffset,
- nsIDOMNode* aEndParent,
+ nsIDOMNode* aEndContainer,
int32_t aEndOffset,
nsRange** aRange)
{
return nsRange::CreateRange(aStartContainer, aStartOffset,
- aEndParent, aEndOffset, aRange);
+ aEndContainer, aEndOffset, aRange);
}
nsresult
EditorBase::AppendNodeToSelectionAsRange(nsIDOMNode* aNode)
{
NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
RefPtr<Selection> selection = GetSelection();
NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
@@ -4813,24 +4813,24 @@ EditorBase::HandleKeyPressEvent(WidgetKe
nsresult
EditorBase::HandleInlineSpellCheck(EditAction action,
Selection* aSelection,
nsIDOMNode* previousSelectedNode,
int32_t previousSelectedOffset,
nsIDOMNode* aStartContainer,
int32_t aStartOffset,
- nsIDOMNode* aEndNode,
+ nsIDOMNode* aEndContainer,
int32_t aEndOffset)
{
// Have to cast action here because this method is from an IDL
return mInlineSpellChecker ? mInlineSpellChecker->SpellCheckAfterEditorChange(
(int32_t)action, aSelection,
previousSelectedNode, previousSelectedOffset,
- aStartContainer, aStartOffset, aEndNode,
+ aStartContainer, aStartOffset, aEndContainer,
aEndOffset)
: NS_OK;
}
already_AddRefed<nsIContent>
EditorBase::FindSelectionRoot(nsINode* aNode)
{
nsCOMPtr<nsIContent> rootContent = GetRoot();
--- a/editor/libeditor/EditorBase.h
+++ b/editor/libeditor/EditorBase.h
@@ -807,30 +807,30 @@ public:
int32_t* outStartOffset);
static nsresult GetStartNodeAndOffset(Selection* aSelection,
nsINode** aStartContainer,
int32_t* aStartOffset);
static nsresult GetEndNodeAndOffset(Selection* aSelection,
nsIDOMNode** outEndNode,
int32_t* outEndOffset);
static nsresult GetEndNodeAndOffset(Selection* aSelection,
- nsINode** aEndNode,
+ nsINode** aEndContainer,
int32_t* aEndOffset);
#if DEBUG_JOE
static void DumpNode(nsIDOMNode* aNode, int32_t indent = 0);
#endif
Selection* GetSelection(SelectionType aSelectionType =
SelectionType::eNormal);
/**
* Helpers to add a node to the selection.
* Used by table cell selection methods.
*/
nsresult CreateRange(nsIDOMNode* aStartContainer, int32_t aStartOffset,
- nsIDOMNode* aEndParent, int32_t aEndOffset,
+ nsIDOMNode* aEndContainer, int32_t aEndOffset,
nsRange** aRange);
/**
* Creates a range with just the supplied node and appends that to the
* selection.
*/
nsresult AppendNodeToSelectionAsRange(nsIDOMNode *aNode);
@@ -862,17 +862,17 @@ public:
virtual nsresult HandleKeyPressEvent(WidgetKeyboardEvent* aKeyboardEvent);
nsresult HandleInlineSpellCheck(EditAction action,
Selection* aSelection,
nsIDOMNode* previousSelectedNode,
int32_t previousSelectedOffset,
nsIDOMNode* aStartContainer,
int32_t aStartOffset,
- nsIDOMNode* aEndNode,
+ nsIDOMNode* aEndContainer,
int32_t aEndOffset);
virtual already_AddRefed<dom::EventTarget> GetDOMEventTarget() = 0;
/**
* Fast non-refcounting editor root element accessor
*/
Element* GetRoot();
--- a/editor/libeditor/HTMLEditor.h
+++ b/editor/libeditor/HTMLEditor.h
@@ -645,17 +645,17 @@ protected:
bool aTrustedInput);
nsresult ParseFragment(const nsAString& aStr, nsIAtom* aContextLocalName,
nsIDocument* aTargetDoc,
dom::DocumentFragment** aFragment, bool aTrustedInput);
void CreateListOfNodesToPaste(dom::DocumentFragment& aFragment,
nsTArray<OwningNonNull<nsINode>>& outNodeList,
nsINode* aStartContainer,
int32_t aStartOffset,
- nsINode* aEndNode,
+ nsINode* aEndContainer,
int32_t aEndOffset);
nsresult CreateTagStack(nsTArray<nsString>& aTagStack,
nsIDOMNode* aNode);
enum class StartOrEnd { start, end };
void GetListAndTableParents(StartOrEnd aStartOrEnd,
nsTArray<OwningNonNull<nsINode>>& aNodeList,
nsTArray<OwningNonNull<Element>>& outArray);
int32_t DiscoverPartialListsAndTables(
--- a/editor/libeditor/HTMLEditorDataTransfer.cpp
+++ b/editor/libeditor/HTMLEditorDataTransfer.cpp
@@ -2224,31 +2224,31 @@ HTMLEditor::ParseFragment(const nsAStrin
}
void
HTMLEditor::CreateListOfNodesToPaste(
DocumentFragment& aFragment,
nsTArray<OwningNonNull<nsINode>>& outNodeList,
nsINode* aStartContainer,
int32_t aStartOffset,
- nsINode* aEndNode,
+ nsINode* aEndContainer,
int32_t aEndOffset)
{
// If no info was provided about the boundary between context and stream,
// then assume all is stream.
if (!aStartContainer) {
aStartContainer = &aFragment;
aStartOffset = 0;
- aEndNode = &aFragment;
+ aEndContainer = &aFragment;
aEndOffset = aFragment.Length();
}
RefPtr<nsRange> docFragRange;
nsresult rv = nsRange::CreateRange(aStartContainer, aStartOffset,
- aEndNode, aEndOffset,
+ aEndContainer, aEndOffset,
getter_AddRefs(docFragRange));
MOZ_ASSERT(NS_SUCCEEDED(rv));
NS_ENSURE_SUCCESS(rv, );
// Now use a subtree iterator over the range to create a list of nodes
TrivialFunctor functor;
DOMSubtreeIterator iter;
rv = iter.Init(*docFragRange);
--- a/editor/txtsvc/nsFilteredContentIterator.cpp
+++ b/editor/txtsvc/nsFilteredContentIterator.cpp
@@ -206,34 +206,34 @@ ContentToParentOffset(nsIContent *aConte
///////////////////////////////////////////////////////////////////////////
// ContentIsInTraversalRange: returns true if content is visited during
// the traversal of the range in the specified mode.
//
static bool
ContentIsInTraversalRange(nsIContent *aContent, bool aIsPreMode,
nsIDOMNode *aStartContainer, int32_t aStartOffset,
- nsIDOMNode *aEndNode, int32_t aEndOffset)
+ nsIDOMNode *aEndContainer, int32_t aEndOffset)
{
- NS_ENSURE_TRUE(aStartContainer && aEndNode && aContent, false);
+ NS_ENSURE_TRUE(aStartContainer && aEndContainer && aContent, false);
nsCOMPtr<nsIDOMNode> parentNode;
int32_t indx = 0;
ContentToParentOffset(aContent, getter_AddRefs(parentNode), &indx);
NS_ENSURE_TRUE(parentNode, false);
if (!aIsPreMode)
++indx;
int32_t startRes =
nsContentUtils::ComparePoints(aStartContainer, aStartOffset,
parentNode, indx);
- int32_t endRes = nsContentUtils::ComparePoints(aEndNode, aEndOffset,
+ int32_t endRes = nsContentUtils::ComparePoints(aEndContainer, aEndOffset,
parentNode, indx);
return (startRes <= 0) && (endRes >= 0);
}
static bool
ContentIsInTraversalRange(nsRange* aRange, nsIDOMNode* aNextNode, bool aIsPreMode)
{
nsCOMPtr<nsIContent> content(do_QueryInterface(aNextNode));
--- a/editor/txtsvc/nsTextServicesDocument.cpp
+++ b/editor/txtsvc/nsTextServicesDocument.cpp
@@ -2803,49 +2803,49 @@ nsTextServicesDocument::SelectionIsValid
{
return(mSelStartIndex >= 0);
}
nsresult
nsTextServicesDocument::GetRangeEndPoints(nsRange* aRange,
nsIDOMNode** aStartContainer,
int32_t* aStartOffset,
- nsIDOMNode** aEndParent,
+ nsIDOMNode** aEndContainer,
int32_t* aEndOffset)
{
NS_ENSURE_TRUE(aRange && aStartContainer && aStartOffset &&
- aEndParent && aEndOffset, NS_ERROR_NULL_POINTER);
+ aEndContainer && aEndOffset, NS_ERROR_NULL_POINTER);
nsresult rv = aRange->GetStartContainer(aStartContainer);
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(aStartContainer, NS_ERROR_FAILURE);
rv = aRange->GetStartOffset(aStartOffset);
NS_ENSURE_SUCCESS(rv, rv);
- rv = aRange->GetEndContainer(aEndParent);
+ rv = aRange->GetEndContainer(aEndContainer);
NS_ENSURE_SUCCESS(rv, rv);
- NS_ENSURE_TRUE(aEndParent, NS_ERROR_FAILURE);
+ NS_ENSURE_TRUE(aEndContainer, NS_ERROR_FAILURE);
return aRange->GetEndOffset(aEndOffset);
}
nsresult
nsTextServicesDocument::CreateRange(nsIDOMNode* aStartContainer,
int32_t aStartOffset,
- nsIDOMNode* aEndParent,
+ nsIDOMNode* aEndContainer,
int32_t aEndOffset,
nsRange** aRange)
{
- return nsRange::CreateRange(aStartContainer, aStartOffset, aEndParent,
+ return nsRange::CreateRange(aStartContainer, aStartOffset, aEndContainer,
aEndOffset, aRange);
}
nsresult
nsTextServicesDocument::FirstTextNode(nsIContentIterator *aIterator,
TSDIteratorStatus *aIteratorStatus)
{
if (aIteratorStatus) {
--- a/editor/txtsvc/nsTextServicesDocument.h
+++ b/editor/txtsvc/nsTextServicesDocument.h
@@ -158,20 +158,20 @@ public:
NS_IMETHOD DidDeleteText(nsIDOMCharacterData *aTextNode, int32_t aOffset, int32_t aLength, nsresult aResult) override;
NS_IMETHOD WillDeleteSelection(nsISelection *aSelection) override;
NS_IMETHOD DidDeleteSelection(nsISelection *aSelection) override;
/* Helper functions */
static nsresult GetRangeEndPoints(nsRange* aRange,
nsIDOMNode** aStartContainer,
int32_t* aStartOffset,
- nsIDOMNode** aParent2,
- int32_t* aOffset2);
+ nsIDOMNode** aEndContainer,
+ int32_t* aEndOffset);
static nsresult CreateRange(nsIDOMNode* aStartContainer, int32_t aStartOffset,
- nsIDOMNode* aEndParent, int32_t aEndOffset,
+ nsIDOMNode* aEndContainer, int32_t aEndOffset,
nsRange** aRange);
private:
/* nsTextServicesDocument private methods. */
nsresult CreateContentIterator(nsRange* aRange,
nsIContentIterator** aIterator);
