--- a/accessible/generic/HyperTextAccessible.cpp
+++ b/accessible/generic/HyperTextAccessible.cpp
@@ -1607,17 +1607,17 @@ HyperTextAccessible::SelectionBoundsAt(i
   uint32_t rangeCount = ranges.Length();
   if (aSelectionNum < 0 || aSelectionNum >= static_cast<int32_t>(rangeCount))
     return false;
 
   nsRange* range = ranges[aSelectionNum];
 
   // Get start and end points.
   nsINode* startNode = range->GetStartContainer();
-  nsINode* endNode = range->GetEndParent();
+  nsINode* endNode = range->GetEndContainer();
   int32_t startOffset = range->StartOffset(), endOffset = range->EndOffset();
 
   // Make sure start is before end, by swapping DOM points.  This occurs when
   // the user selects backwards in the text.
   int32_t rangeCompare = nsContentUtils::ComparePoints(endNode, endOffset,
                                                        startNode, startOffset);
   if (rangeCompare < 0) {
     nsINode* tempNode = startNode;
@@ -1785,25 +1785,25 @@ HyperTextAccessible::SelectionRanges(nsT
 
   aRanges->SetCapacity(sel->RangeCount());
 
   for (uint32_t idx = 0; idx < sel->RangeCount(); idx++) {
     nsRange* DOMRange = sel->GetRangeAt(idx);
     HyperTextAccessible* startParent =
       nsAccUtils::GetTextContainer(DOMRange->GetStartContainer());
     HyperTextAccessible* endParent =
-      nsAccUtils::GetTextContainer(DOMRange->GetEndParent());
+      nsAccUtils::GetTextContainer(DOMRange->GetEndContainer());
     if (!startParent || !endParent)
       continue;
 
     int32_t startOffset =
       startParent->DOMPointToOffset(DOMRange->GetStartContainer(),
                                     DOMRange->StartOffset(), false);
     int32_t endOffset =
-      endParent->DOMPointToOffset(DOMRange->GetEndParent(),
+      endParent->DOMPointToOffset(DOMRange->GetEndContainer(),
                                   DOMRange->EndOffset(), true);
 
     TextRange tr(IsTextField() ? const_cast<HyperTextAccessible*>(this) : mDoc,
                     startParent, startOffset, endParent, endOffset);
     *(aRanges->AppendElement()) = Move(tr);
   }
 }
 
@@ -2145,17 +2145,17 @@ HyperTextAccessible::GetSpellTextAttr(ns
   uint32_t startOffset = 0, endOffset = 0;
   for (int32_t idx = 0; idx < rangeCount; idx++) {
     nsRange* range = domSel->GetRangeAt(idx);
     if (range->Collapsed())
       continue;
 
     // See if the point comes after the range in which case we must continue in
     // case there is another range after this one.
-    nsINode* endNode = range->GetEndParent();
+    nsINode* endNode = range->GetEndContainer();
     int32_t endNodeOffset = range->EndOffset();
     if (nsContentUtils::ComparePoints(aNode, aNodeOffset,
                                       endNode, endNodeOffset) >= 0)
       continue;
 
     // At this point our point is either in this range or before it but after
     // the previous range.  So we check to see if the range starts before the
     // point in which case the point is in the missspelled range, otherwise it
@@ -2182,17 +2182,17 @@ HyperTextAccessible::GetSpellTextAttr(ns
       return;
     }
 
     // This range came after the point.
     endOffset = DOMPointToOffset(startNode, startNodeOffset);
 
     if (idx > 0) {
       nsRange* prevRange = domSel->GetRangeAt(idx - 1);
-      startOffset = DOMPointToOffset(prevRange->GetEndParent(),
+      startOffset = DOMPointToOffset(prevRange->GetEndContainer(),
                                      prevRange->EndOffset());
     }
 
     if (startOffset > *aStartOffset)
       *aStartOffset = startOffset;
 
     if (endOffset < *aEndOffset)
       *aEndOffset = endOffset;
@@ -2200,17 +2200,17 @@ HyperTextAccessible::GetSpellTextAttr(ns
     return;
   }
 
   // We never found a range that ended after the point, therefore we know that
   // the point is not in a range, that we do not need to compute an end offset,
   // and that we should use the end offset of the last range to compute the
   // start offset of the text attribute range.
   nsRange* prevRange = domSel->GetRangeAt(rangeCount - 1);
-  startOffset = DOMPointToOffset(prevRange->GetEndParent(),
+  startOffset = DOMPointToOffset(prevRange->GetEndContainer(),
                                  prevRange->EndOffset());
 
   if (startOffset > *aStartOffset)
     *aStartOffset = startOffset;
 }
 
 bool
 HyperTextAccessible::IsTextRole()

--- a/dom/base/Selection.cpp
+++ b/dom/base/Selection.cpp
@@ -439,17 +439,17 @@ struct MOZ_RAII AutoPrepareFocusRange
 #ifdef PRINT_RANGE
 void printRange(nsRange *aDomRange)
 {
   if (!aDomRange)
   {
     printf("NULL nsIDOMRange\n");
   }
   nsINode* startNode = aDomRange->GetStartContainer();
-  nsINode* endNode = aDomRange->GetEndParent();
+  nsINode* endNode = aDomRange->GetEndContainer();
   int32_t startOffset = aDomRange->StartOffset();
   int32_t endOffset = aDomRange->EndOffset();
 
   printf("range: 0x%lx\t start: 0x%lx %ld, \t end: 0x%lx,%ld\n",
          (unsigned long)aDomRange,
          (unsigned long)startNode, (long)startOffset,
          (unsigned long)endNode, (long)endOffset);
 
@@ -705,17 +705,17 @@ Selection::GetTableSelectionType(nsIDOMR
   *aTableSelectionType = nsISelectionPrivate::TABLESELECTION_NONE;
 
   // Must have access to frame selection to get cell info
   if(!mFrameSelection) return NS_OK;
 
   nsINode* startNode = range->GetStartContainer();
   if (!startNode) return NS_ERROR_FAILURE;
 
-  nsINode* endNode = range->GetEndParent();
+  nsINode* endNode = range->GetEndContainer();
   if (!endNode) return NS_ERROR_FAILURE;
 
   // Not a single selected node
   if (startNode != endNode) return NS_OK;
 
   int32_t startOffset = range->StartOffset();
   int32_t endOffset = range->EndOffset();
 
@@ -858,17 +858,17 @@ Selection::GetAnchorNode()
 {
   if (!mAnchorFocusRange)
     return nullptr;
 
   if (GetDirection() == eDirNext) {
     return mAnchorFocusRange->GetStartContainer();
   }
 
-  return mAnchorFocusRange->GetEndParent();
+  return mAnchorFocusRange->GetEndContainer();
 }
 
 NS_IMETHODIMP
 Selection::GetAnchorOffset(int32_t* aAnchorOffset)
 {
   *aAnchorOffset = static_cast<int32_t>(AnchorOffset());
   return NS_OK;
 }
@@ -888,17 +888,17 @@ Selection::GetFocusNode(nsIDOMNode** aFo
 
 nsINode*
 Selection::GetFocusNode()
 {
   if (!mAnchorFocusRange)
     return nullptr;
 
   if (GetDirection() == eDirNext){
-    return mAnchorFocusRange->GetEndParent();
+    return mAnchorFocusRange->GetEndContainer();
   }
 
   return mAnchorFocusRange->GetStartContainer();
 }
 
 NS_IMETHODIMP
 Selection::GetFocusOffset(int32_t* aFocusOffset)
 {
@@ -963,17 +963,17 @@ CompareToRangeStart(nsINode* aCompareNod
   }
   return NS_OK;
 }
 
 static nsresult
 CompareToRangeEnd(nsINode* aCompareNode, int32_t aCompareOffset,
                   nsRange* aRange, int32_t* aCmp)
 {
-  nsINode* end = aRange->GetEndParent();
+  nsINode* end = aRange->GetEndContainer();
   NS_ENSURE_STATE(aCompareNode && end);
   // If the nodes that we're comparing are not in the same document,
   // assume that aCompareNode will fall at the end of the ranges.
   if (aCompareNode->GetComposedDoc() != end->GetComposedDoc() ||
       !end->GetComposedDoc()) {
     *aCmp = 1;
   } else {
     *aCmp = nsContentUtils::ComparePoints(aCompareNode, aCompareOffset,
@@ -1044,33 +1044,33 @@ Selection::SubtractRange(RangeData* aRan
   int32_t cmp;
   nsresult rv = CompareToRangeStart(range->GetStartContainer(),
                                     range->StartOffset(),
                                     aSubtract, &cmp);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Also, make a comparison to the range end
   int32_t cmp2;
-  rv = CompareToRangeEnd(range->GetEndParent(),
+  rv = CompareToRangeEnd(range->GetEndContainer(),
                          range->EndOffset(),
                          aSubtract, &cmp2);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // If the existing range left overlaps the new range (aSubtract) then
   // cmp < 0, and cmp2 < 0
   // If it right overlaps the new range then cmp > 0 and cmp2 > 0
   // If it fully contains the new range, then cmp < 0 and cmp2 > 0
 
   if (cmp2 > 0) {
     // We need to add a new RangeData to the output, running from
     // the end of aSubtract to the end of range
-    RefPtr<nsRange> postOverlap = new nsRange(aSubtract->GetEndParent());
+    RefPtr<nsRange> postOverlap = new nsRange(aSubtract->GetEndContainer());
     rv = postOverlap->SetStartAndEnd(
-                        aSubtract->GetEndParent(), aSubtract->EndOffset(),
-                        range->GetEndParent(), range->EndOffset());
+                        aSubtract->GetEndContainer(), aSubtract->EndOffset(),
+                        range->GetEndContainer(), range->EndOffset());
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
     if (!postOverlap->Collapsed()) {
       if (!aOutput->InsertElementAt(0, RangeData(postOverlap)))
         return NS_ERROR_OUT_OF_MEMORY;
       (*aOutput)[0].mTextRangeStyle = aRange->mTextRangeStyle;
     }
@@ -1230,17 +1230,17 @@ Selection::AddItemInternal(nsRange* aIte
 
     *aOutIndex = 0;
     return NS_OK;
   }
 
   int32_t startIndex, endIndex;
   nsresult rv = GetIndicesForInterval(aItem->GetStartContainer(),
                                       aItem->StartOffset(),
-                                      aItem->GetEndParent(),
+                                      aItem->GetEndContainer(),
                                       aItem->EndOffset(), false,
                                       &startIndex, &endIndex);
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (endIndex == -1) {
     // All ranges start after the given range. We can insert our range at
     // position 0, knowing there are no overlaps (handled below)
     startIndex = 0;
@@ -1250,17 +1250,17 @@ Selection::AddItemInternal(nsRange* aIte
     // the end of the array, knowing there are no overlaps (handled below)
     startIndex = mRanges.Length();
     endIndex = startIndex;
   }
 
   // If the range is already contained in mRanges, silently succeed
   bool sameRange = EqualsRangeAtPoint(aItem->GetStartContainer(),
                                       aItem->StartOffset(),
-                                      aItem->GetEndParent(),
+                                      aItem->GetEndContainer(),
                                       aItem->EndOffset(), startIndex);
   if (sameRange) {
     *aOutIndex = startIndex;
     return NS_OK;
   }
 
   if (startIndex == endIndex) {
     // The new range doesn't overlap any existing ranges
@@ -1403,17 +1403,17 @@ RangeMatchesBeginPoint(nsRange* aRange, 
 {
   return aRange->GetStartContainer() == aNode &&
          aRange->StartOffset() == aOffset;
 }
 
 static inline bool
 RangeMatchesEndPoint(nsRange* aRange, nsINode* aNode, int32_t aOffset)
 {
-  return aRange->GetEndParent() == aNode && aRange->EndOffset() == aOffset;
+  return aRange->GetEndContainer() == aNode && aRange->EndOffset() == aOffset;
 }
 
 // Selection::EqualsRangeAtPoint
 //
 //    Utility method for checking equivalence of two ranges.
 
 bool
 Selection::EqualsRangeAtPoint(
@@ -1807,17 +1807,17 @@ Selection::SelectFrames(nsPresContext* a
     // XXX The range can start from a document node and such range can be
     //     added to Selection with JS.  Therefore, even in such cases,
     //     shouldn't we handle selection in the range?
     return NS_ERROR_UNEXPECTED;
   }
 
   // We must call first one explicitly
   bool isFirstContentTextNode = startContent->IsNodeOfType(nsINode::eTEXT);
-  nsINode* endNode = aRange->GetEndParent();
+  nsINode* endNode = aRange->GetEndContainer();
   if (isFirstContentTextNode) {
     nsIFrame* frame = startContent->GetPrimaryFrame();
     // The frame could be an SVG text frame, in which case we don't treat it
     // as a text frame.
     if (frame) {
       if (frame->IsTextFrame()) {
         nsTextFrame* textFrame = static_cast<nsTextFrame*>(frame);
         uint32_t startOffset = aRange->StartOffset();
@@ -1936,17 +1936,17 @@ Selection::LookUpSelection(nsIContent* a
     return aDetailsHead;
   }
 
   UniquePtr<SelectionDetails> detailsHead = Move(aDetailsHead);
 
   for (uint32_t i = 0; i < overlappingRanges.Length(); i++) {
     nsRange* range = overlappingRanges[i];
     nsINode* startNode = range->GetStartContainer();
-    nsINode* endNode = range->GetEndParent();
+    nsINode* endNode = range->GetEndContainer();
     int32_t startOffset = range->StartOffset();
     int32_t endOffset = range->EndOffset();
 
     int32_t start = -1, end = -1;
     if (startNode == aContent && endNode == aContent) {
       if (startOffset < (aContentOffset + aContentLength)  &&
           endOffset > aContentOffset) {
         // this range is totally inside the requested content range
@@ -2382,17 +2382,17 @@ Selection::RemoveRange(nsRange& aRange, 
 {
   nsresult rv = RemoveItem(&aRange);
   if (NS_FAILED(rv)) {
     aRv.Throw(rv);
     return;
   }
 
   nsINode* beginNode = aRange.GetStartContainer();
-  nsINode* endNode = aRange.GetEndParent();
+  nsINode* endNode = aRange.GetEndContainer();
 
   if (!beginNode || !endNode) {
     // Detached range; nothing else to do here.
     return;
   }
 
   // find out the length of the end node, so we can select all of it
   int32_t beginOffset, endOffset;
@@ -2667,17 +2667,17 @@ Selection::CollapseToEnd(ErrorResult& aR
     aRv.Throw(NS_ERROR_FAILURE);
     return;
   }
 
   if (mFrameSelection) {
     int16_t reason = mFrameSelection->PopReason() | nsISelectionListener::COLLAPSETOEND_REASON;
     mFrameSelection->PostReason(reason);
   }
-  nsINode* parent = lastRange->GetEndParent();
+  nsINode* parent = lastRange->GetEndContainer();
   if (!parent) {
     aRv.Throw(NS_ERROR_FAILURE);
     return;
   }
   Collapse(*parent, lastRange->EndOffset(), aRv);
 }
 
 /*
@@ -2904,17 +2904,17 @@ Selection::Extend(nsINode& aParentNode, 
   nsINode* anchorNode = GetAnchorNode();
   nsINode* focusNode = GetFocusNode();
   uint32_t anchorOffset = AnchorOffset();
   uint32_t focusOffset = FocusOffset();
 
   RefPtr<nsRange> range = mAnchorFocusRange->CloneRange();
 
   nsINode* startNode = range->GetStartContainer();
-  nsINode* endNode = range->GetEndParent();
+  nsINode* endNode = range->GetEndContainer();
   int32_t startOffset = range->StartOffset();
   int32_t endOffset = range->EndOffset();
 
   //compare anchor to old cursor.
 
   // We pass |disconnected| to the following ComparePoints calls in order
   // to avoid assertions. ComparePoints returns 1 in the disconnected case
   // and we can end up in various cases below, but it is assumed that in
@@ -2949,17 +2949,18 @@ Selection::Extend(nsINode& aParentNode, 
   if ((result1 == 0 && result3 < 0) || (result1 <= 0 && result2 < 0)){//a1,2  a,1,2
     //select from 1 to 2 unless they are collapsed
     range->SetEnd(aParentNode, aOffset, aRv);
     if (aRv.Failed()) {
       return;
     }
     SetDirection(eDirNext);
     res = difRange->SetStartAndEnd(focusNode, focusOffset,
-                                   range->GetEndParent(), range->EndOffset());
+                                   range->GetEndContainer(),
+                                   range->EndOffset());
     if (NS_FAILED(res)) {
       aRv.Throw(res);
       return;
     }
     SelectFrames(presContext, difRange , true);
     res = SetAnchorFocusToRange(range);
     if (NS_FAILED(res)) {
       aRv.Throw(res);
@@ -2994,17 +2995,17 @@ Selection::Extend(nsINode& aParentNode, 
       return;
     }
     res = SetAnchorFocusToRange(range);
     if (NS_FAILED(res)) {
       aRv.Throw(res);
       return;
     }
     SelectFrames(presContext, difRange, false); // deselect now
-    difRange->SetEnd(range->GetEndParent(), range->EndOffset());
+    difRange->SetEnd(range->GetEndContainer(), range->EndOffset());
     SelectFrames(presContext, difRange, true); // must reselect last node
                                                // maybe more
   }
   else if (result1 >= 0 && result3 <= 0) {//1,a,2 or 1a,2 or 1,a2 or 1a2
     if (GetDirection() == eDirPrevious){
       res = range->SetStart(endNode, endOffset);
       if (NS_FAILED(res)) {
         aRv.Throw(res);
@@ -3286,17 +3287,17 @@ Selection::ContainsPoint(const nsPoint& 
     return false;
   }
   PointInRectChecker checker(aPoint);
   for (uint32_t i = 0; i < RangeCount(); i++) {
     nsRange* range = GetRangeAt(i);
     nsRange::CollectClientRectsAndText(&checker, nullptr, range,
                                        range->GetStartContainer(),
                                        range->StartOffset(),
-                                       range->GetEndParent(),
+                                       range->GetEndContainer(),
                                        range->EndOffset(),
                                        true, false);
     if (checker.MatchFound()) {
       return true;
     }
   }
   return false;
 }

--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/nsContentIterator.cpp
@@ -312,17 +312,17 @@ nsContentIterator::Init(nsIDOMRange* aDO
   nsINode* startNode = range->GetStartContainer();
   if (NS_WARN_IF(!startNode)) {
     return NS_ERROR_FAILURE;
   }
 
   // get the end node and offset
   int32_t endIndx = range->EndOffset();
   NS_WARNING_ASSERTION(endIndx >= 0, "bad endIndx");
-  nsINode* endNode = range->GetEndParent();
+  nsINode* endNode = range->GetEndContainer();
   if (NS_WARN_IF(!endNode)) {
     return NS_ERROR_FAILURE;
   }
 
   bool startIsData = startNode->IsNodeOfType(nsINode::eDATA_NODE);
 
   // short circuit when start node == end node
   if (startNode == endNode) {
@@ -1280,17 +1280,17 @@ nsContentSubtreeIterator::Init(nsIDOMRan
   mIsDone = false;
 
   mRange = static_cast<nsRange*>(aRange);
 
   // get the start node and offset, convert to nsINode
   mCommonParent = mRange->GetCommonAncestor();
   nsINode* startParent = mRange->GetStartContainer();
   int32_t startOffset = mRange->StartOffset();
-  nsINode* endParent = mRange->GetEndParent();
+  nsINode* endParent = mRange->GetEndContainer();
   int32_t endOffset = mRange->EndOffset();
   MOZ_ASSERT(mCommonParent && startParent && endParent);
   // Bug 767169
   MOZ_ASSERT(uint32_t(startOffset) <= startParent->Length() &&
              uint32_t(endOffset) <= endParent->Length());
 
   // short circuit when start node == end node
   if (startParent == endParent) {

--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -7455,17 +7455,17 @@ nsContentUtils::GetSelectionInTextContro
     aOutStartOffset = aOutEndOffset = 0;
     return;
   }
 
   // All the node pointers here are raw pointers for performance.  We shouldn't
   // be doing anything in this function that invalidates the node tree.
   nsINode* startParent = range->GetStartContainer();
   uint32_t startOffset = range->StartOffset();
-  nsINode* endParent = range->GetEndParent();
+  nsINode* endParent = range->GetEndContainer();
   uint32_t endOffset = range->EndOffset();
 
   // We have at most two children, consisting of an optional text node followed
   // by an optional <br>.
   NS_ASSERTION(aRoot->GetChildCount() <= 2, "Unexpected children");
   nsIContent* firstChild = aRoot->GetFirstChild();
 #ifdef DEBUG
   nsCOMPtr<nsIContent> lastChild = aRoot->GetLastChild();

--- a/dom/base/nsDocumentEncoder.cpp
+++ b/dom/base/nsDocumentEncoder.cpp
@@ -834,17 +834,17 @@ nsDocumentEncoder::SerializeRangeNodes(n
       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 GetAncestorsAndOffsets().  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.
-        if (aNode != aRange->GetEndParent())
+        if (aNode != aRange->GetEndContainer())
         {
           endOffset++;
         }
       }
       // serialize the children of this node that are in the range
       for (j=startOffset; j<endOffset; j++)
       {
         childAsNode = content->GetChildAt(j);
@@ -942,17 +942,17 @@ nsDocumentEncoder::SerializeRangeToStrin
 
   if (!mCommonParent)
     return NS_OK;
 
   nsINode* startParent = aRange->GetStartContainer();
   NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE);
   int32_t startOffset = aRange->StartOffset();
 
-  nsINode* endParent = aRange->GetEndParent();
+  nsINode* endParent = aRange->GetEndContainer();
   NS_ENSURE_TRUE(endParent, NS_ERROR_FAILURE);
   int32_t endOffset = aRange->EndOffset();
 
   mStartDepth = mEndDepth = 0;
   mCommonAncestors.Clear();
   mStartNodes.Clear();
   mStartOffsets.Clear();
   mEndNodes.Clear();

--- a/dom/base/nsRange.cpp
+++ b/dom/base/nsRange.cpp
@@ -114,17 +114,17 @@ nsRange::CompareNodeToRange(nsINode* aNo
     nodeEnd = aNode->GetChildCount();
   }
   else {
     nodeStart = parent->IndexOf(aNode);
     nodeEnd = nodeStart + 1;
   }
 
   nsINode* rangeStartParent = aRange->GetStartContainer();
-  nsINode* rangeEndParent = aRange->GetEndParent();
+  nsINode* rangeEndParent = aRange->GetEndContainer();
   int32_t rangeStartOffset = aRange->StartOffset();
   int32_t rangeEndOffset = aRange->EndOffset();
 
   // is RANGE(start) <= NODE(start) ?
   bool disconnected = false;
   *outNodeBefore = nsContentUtils::ComparePoints(rangeStartParent,
                                                  rangeStartOffset,
                                                  parent, nodeStart,
@@ -164,17 +164,17 @@ struct IsItemInRangeComparator
 
   int operator()(const nsRange* const aRange) const
   {
     int32_t cmp = nsContentUtils::ComparePoints(mNode, mEndOffset,
                                                 aRange->GetStartContainer(),
                                                 aRange->StartOffset());
     if (cmp == 1) {
       cmp = nsContentUtils::ComparePoints(mNode, mStartOffset,
-                                          aRange->GetEndParent(),
+                                          aRange->GetEndContainer(),
                                           aRange->EndOffset());
       if (cmp == -1) {
         return 0;
       }
       return 1;
     }
     return -1;
   }
@@ -1984,17 +1984,17 @@ ValidateCurrentNode(nsRange* aRange, Ran
   if (before || after) {
     nsCOMPtr<nsIDOMCharacterData> charData = do_QueryInterface(node);
     if (charData) {
       // If we're dealing with the start/end container which is a character
       // node, pretend that the node is in the range.
       if (before && node == aRange->GetStartContainer()) {
         before = false;
       }
-      if (after && node == aRange->GetEndParent()) {
+      if (after && node == aRange->GetEndContainer()) {
         after = false;
       }
     }
   }
 
   return !before && !after;
 }
 
@@ -2337,23 +2337,23 @@ nsRange::CompareBoundaryPoints(uint16_t 
       ourNode = mEndParent;
       ourOffset = mEndOffset;
       otherNode = aOtherRange.GetStartContainer();
       otherOffset = aOtherRange.StartOffset();
       break;
     case nsIDOMRange::END_TO_START:
       ourNode = mStartParent;
       ourOffset = mStartOffset;
-      otherNode = aOtherRange.GetEndParent();
+      otherNode = aOtherRange.GetEndContainer();
       otherOffset = aOtherRange.EndOffset();
       break;
     case nsIDOMRange::END_TO_END:
       ourNode = mEndParent;
       ourOffset = mEndOffset;
-      otherNode = aOtherRange.GetEndParent();
+      otherNode = aOtherRange.GetEndContainer();
       otherOffset = aOtherRange.EndOffset();
       break;
     default:
       // We were passed an illegal value
       rv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
       return 0;
   }
 

--- a/dom/base/nsRange.h
+++ b/dom/base/nsRange.h
@@ -73,17 +73,17 @@ public:
     return mRoot;
   }
 
   nsINode* GetStartContainer() const
   {
     return mStartParent;
   }
 
-  nsINode* GetEndParent() const
+  nsINode* GetEndContainer() const
   {
     return mEndParent;
   }
 
   int32_t StartOffset() const
   {
     return mStartOffset;
   }

--- a/dom/events/ContentEventHandler.cpp
+++ b/dom/events/ContentEventHandler.cpp
@@ -160,17 +160,17 @@ ContentEventHandler::InitRootContent(Sel
 
   // If there is a selection, we should retrieve the selection root from
   // the range since when the window is inactivated, the ancestor limiter
   // of selection was cleared by blur event handler of EditorBase but the
   // selection range still keeps storing the nodes.  If the active element of
   // the deactive window is <input> or <textarea>, we can compute the
   // selection root from them.
   nsINode* startNode = range->GetStartContainer();
-  nsINode* endNode = range->GetEndParent();
+  nsINode* endNode = range->GetEndContainer();
   if (NS_WARN_IF(!startNode) || NS_WARN_IF(!endNode)) {
     return NS_ERROR_FAILURE;
   }
 
   // See bug 537041 comment 5, the range could have removed node.
   if (NS_WARN_IF(startNode->GetUncomposedDoc() != mPresShell->GetDocument())) {
     return NS_ERROR_FAILURE;
   }
@@ -685,17 +685,17 @@ ContentEventHandler::GenerateFlatTextCon
 {
   MOZ_ASSERT(aString.IsEmpty());
 
   if (aRange->Collapsed()) {
     return NS_OK;
   }
 
   nsINode* startNode = aRange->GetStartContainer();
-  nsINode* endNode = aRange->GetEndParent();
+  nsINode* endNode = aRange->GetEndContainer();
   if (NS_WARN_IF(!startNode) || NS_WARN_IF(!endNode)) {
     return NS_ERROR_FAILURE;
   }
 
   if (startNode == endNode && startNode->IsNodeOfType(nsINode::eTEXT)) {
     nsIContent* content = startNode->AsContent();
     AppendSubString(aString, content, aRange->StartOffset(),
                     aRange->EndOffset() - aRange->StartOffset());
@@ -859,17 +859,17 @@ ContentEventHandler::GenerateFlatFontRan
 {
   MOZ_ASSERT(aFontRanges.IsEmpty(), "aRanges must be empty array");
 
   if (aRange->Collapsed()) {
     return NS_OK;
   }
 
   nsINode* startNode = aRange->GetStartContainer();
-  nsINode* endNode = aRange->GetEndParent();
+  nsINode* endNode = aRange->GetEndContainer();
   if (NS_WARN_IF(!startNode) || NS_WARN_IF(!endNode)) {
     return NS_ERROR_FAILURE;
   }
 
   // baseOffset is the flattened offset of each content node.
   int32_t baseOffset = 0;
   nsCOMPtr<nsIContentIterator> iter = NS_NewPreContentIterator();
   nsresult rv = iter->Init(aRange);
@@ -1302,17 +1302,17 @@ ContentEventHandler::OnQuerySelectedText
     MOZ_ASSERT(aEvent->mReply.mOffset == WidgetQueryContentEvent::NOT_FOUND);
     MOZ_ASSERT(aEvent->mReply.mString.IsEmpty());
     MOZ_ASSERT(!aEvent->mReply.mHasSelection);
     aEvent->mSucceeded = true;
     return NS_OK;
   }
 
   nsINode* const startNode = mFirstSelectedRange->GetStartContainer();
-  nsINode* const endNode = mFirstSelectedRange->GetEndParent();
+  nsINode* const endNode = mFirstSelectedRange->GetEndContainer();
 
   // Make sure the selection is within the root content range.
   if (!nsContentUtils::ContentIsDescendantOf(startNode, mRootContent) ||
       !nsContentUtils::ContentIsDescendantOf(endNode, mRootContent)) {
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   NS_ASSERTION(aEvent->mReply.mString.IsEmpty(),
@@ -1538,17 +1538,17 @@ ContentEventHandler::GetFirstFrameInRang
 
 ContentEventHandler::FrameAndNodeOffset
 ContentEventHandler::GetLastFrameInRangeForTextRect(nsRange* aRange)
 {
   NodePosition nodePosition;
   nsCOMPtr<nsIContentIterator> iter = NS_NewPreContentIterator();
   iter->Init(aRange);
 
-  nsINode* endNode = aRange->GetEndParent();
+  nsINode* endNode = aRange->GetEndContainer();
   uint32_t endOffset = static_cast<uint32_t>(aRange->EndOffset());
   // If the end point is start of a text node or specified by its parent and
   // index, the node shouldn't be included into the range.  For example,
   // with this case, |<p>abc[<br>]def</p>|, the range ends at 3rd children of
   // <p> (see the range creation rules, "2.4. Cases: <element/>]"). This causes
   // following frames:
   // +----+-----+
   // | abc|[<br>|
@@ -1581,17 +1581,17 @@ ContentEventHandler::GetLastFrameInRange
     }
 
     if (!node->IsContent() || node == nextNodeOfRangeEnd) {
       continue;
     }
 
     if (node->IsNodeOfType(nsINode::eTEXT)) {
       nodePosition.mNode = node;
-      if (node == aRange->GetEndParent()) {
+      if (node == aRange->GetEndContainer()) {
         nodePosition.mOffset = aRange->EndOffset();
       } else {
         nodePosition.mOffset = node->Length();
       }
       // If the text node is empty or the last node of the range but the index
       // is 0, we should store current position but continue looking for
       // previous node (If there are no nodes before it, we should use current
       // node position for returning its frame).
@@ -3010,17 +3010,17 @@ ContentEventHandler::OnSelectionEvent(Wi
   // Get range from offset and length
   RefPtr<nsRange> range = new nsRange(mRootContent);
   rv = SetRangeFromFlatTextOffset(range, aEvent->mOffset, aEvent->mLength,
                                   GetLineBreakType(aEvent),
                                   aEvent->mExpandToClusterBoundary);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsINode* startNode = range->GetStartContainer();
-  nsINode* endNode = range->GetEndParent();
+  nsINode* endNode = range->GetEndContainer();
   int32_t startNodeOffset = range->StartOffset();
   int32_t endNodeOffset = range->EndOffset();
   AdjustRangeForSelection(mRootContent, &startNode, &startNodeOffset);
   AdjustRangeForSelection(mRootContent, &endNode, &endNodeOffset);
   if (NS_WARN_IF(!startNode) || NS_WARN_IF(!endNode) ||
       NS_WARN_IF(startNodeOffset < 0) || NS_WARN_IF(endNodeOffset < 0)) {
     return NS_ERROR_UNEXPECTED;
   }

--- a/editor/libeditor/DeleteRangeTransaction.cpp
+++ b/editor/libeditor/DeleteRangeTransaction.cpp
@@ -53,17 +53,17 @@ DeleteRangeTransaction::DoTransaction()
   // need mRangeToDelete, and keeping it alive in the long term slows down all
   // DOM mutations because it's observing them.
   RefPtr<nsRange> rangeToDelete;
   rangeToDelete.swap(mRangeToDelete);
 
   // build the child transactions
   nsCOMPtr<nsINode> startParent = rangeToDelete->GetStartContainer();
   int32_t startOffset = rangeToDelete->StartOffset();
-  nsCOMPtr<nsINode> endParent = rangeToDelete->GetEndParent();
+  nsCOMPtr<nsINode> endParent = rangeToDelete->GetEndContainer();
   int32_t endOffset = rangeToDelete->EndOffset();
   MOZ_ASSERT(startParent && endParent);
 
   if (startParent == endParent) {
     // the selection begins and ends in the same node
     nsresult rv =
       CreateTxnsToDeleteBetween(startParent, startOffset, endOffset);
     NS_ENSURE_SUCCESS(rv, rv);

--- a/editor/libeditor/EditorBase.cpp
+++ b/editor/libeditor/EditorBase.cpp
@@ -2891,17 +2891,17 @@ EditorBase::SplitNodeImpl(nsIContent& aE
       continue;
     }
 
     for (uint32_t j = 0; j < range.mSelection->RangeCount(); ++j) {
       RefPtr<nsRange> r = range.mSelection->GetRangeAt(j);
       MOZ_ASSERT(r->IsPositioned());
       range.mStartNode = r->GetStartContainer();
       range.mStartOffset = r->StartOffset();
-      range.mEndNode = r->GetEndParent();
+      range.mEndNode = r->GetEndContainer();
       range.mEndOffset = r->EndOffset();
 
       savedRanges.AppendElement(range);
     }
   }
 
   nsCOMPtr<nsINode> parent = aExistingRightNode.GetParentNode();
   NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
@@ -3038,17 +3038,17 @@ EditorBase::JoinNodesImpl(nsINode* aNode
       continue;
     }
 
     for (uint32_t j = 0; j < range.mSelection->RangeCount(); ++j) {
       RefPtr<nsRange> r = range.mSelection->GetRangeAt(j);
       MOZ_ASSERT(r->IsPositioned());
       range.mStartNode = r->GetStartContainer();
       range.mStartOffset = r->StartOffset();
-      range.mEndNode = r->GetEndParent();
+      range.mEndNode = r->GetEndContainer();
       range.mEndOffset = r->EndOffset();
 
       // If selection endpoint is between the nodes, remember it as being
       // in the one that is going away instead.  This simplifies later selection
       // adjustment logic at end of this method.
       if (range.mStartNode) {
         if (range.mStartNode == parent &&
             joinOffset < range.mStartOffset &&
@@ -3870,17 +3870,17 @@ EditorBase::GetEndNodeAndOffset(Selectio
 
   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->GetEndParent());
+  NS_IF_ADDREF(*aEndNode = range->GetEndContainer());
   *aEndOffset = range->EndOffset();
   return NS_OK;
 }
 
 /**
  * IsPreformatted() checks the style info for the node for the preformatted
  * text style.
  */
@@ -5334,17 +5334,17 @@ EditorBase::GetIMESelectionStartOffsetIn
       }
       if (NS_WARN_IF(range->GetStartContainer() != aTextNode)) {
         // ignore the start offset...
       } else {
         MOZ_ASSERT(range->StartOffset() >= 0,
                    "start offset shouldn't be negative");
         minOffset = std::min(minOffset, range->StartOffset());
       }
-      if (NS_WARN_IF(range->GetEndParent() != aTextNode)) {
+      if (NS_WARN_IF(range->GetEndContainer() != aTextNode)) {
         // ignore the end offset...
       } else {
         MOZ_ASSERT(range->EndOffset() >= 0,
                    "start offset shouldn't be negative");
         minOffset = std::min(minOffset, range->EndOffset());
       }
     }
   }

--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -347,17 +347,17 @@ HTMLEditRules::BeforeEdit(EditAction act
     RefPtr<Selection> selection = htmlEditor->GetSelection();
 
     // Get the selection location
     if (NS_WARN_IF(!selection) || !selection->RangeCount()) {
       return NS_ERROR_UNEXPECTED;
     }
     mRangeItem->startNode = selection->GetRangeAt(0)->GetStartContainer();
     mRangeItem->startOffset = selection->GetRangeAt(0)->StartOffset();
-    mRangeItem->endNode = selection->GetRangeAt(0)->GetEndParent();
+    mRangeItem->endNode = selection->GetRangeAt(0)->GetEndContainer();
     mRangeItem->endOffset = selection->GetRangeAt(0)->EndOffset();
     nsCOMPtr<nsINode> selStartNode = mRangeItem->startNode;
     nsCOMPtr<nsINode> selEndNode = mRangeItem->endNode;
 
     // Register with range updater to track this as we perturb the doc
     htmlEditor->mRangeUpdater.RegisterRangeItem(mRangeItem);
 
     // Clear deletion state bool
@@ -614,17 +614,17 @@ HTMLEditRules::WillDoAction(Selection* a
   nsCOMPtr<nsINode> selStartNode = range->GetStartContainer();
 
   NS_ENSURE_STATE(mHTMLEditor);
   if (!mHTMLEditor->IsModifiableNode(selStartNode)) {
     *aCancel = true;
     return NS_OK;
   }
 
-  nsCOMPtr<nsINode> selEndNode = range->GetEndParent();
+  nsCOMPtr<nsINode> selEndNode = range->GetEndContainer();
 
   if (selStartNode != selEndNode) {
     NS_ENSURE_STATE(mHTMLEditor);
     if (!mHTMLEditor->IsModifiableNode(selEndNode)) {
       *aCancel = true;
       return NS_OK;
     }
 
@@ -2038,17 +2038,17 @@ HTMLEditRules::WillDeleteSelection(Selec
           }
         }
       } else {
         RefPtr<nsRange> range = aSelection->GetRangeAt(0);
         NS_ENSURE_STATE(range);
 
         NS_ASSERTION(range->GetStartContainer() == visNode,
                      "selection start not in visNode");
-        NS_ASSERTION(range->GetEndParent() == visNode,
+        NS_ASSERTION(range->GetEndContainer() == visNode,
                      "selection end not in visNode");
 
         so = range->StartOffset();
         eo = range->EndOffset();
       }
       NS_ENSURE_STATE(mHTMLEditor);
       rv = WSRunObject::PrepareToDeleteRange(mHTMLEditor, address_of(visNode),
                                              &so, address_of(visNode), &eo);
@@ -2367,17 +2367,17 @@ HTMLEditRules::WillDeleteSelection(Selec
   // Remember that we did a ranged delete for the benefit of AfterEditInner().
   mDidRangedDelete = true;
 
   // Refresh start and end points
   NS_ENSURE_STATE(aSelection->GetRangeAt(0));
   startNode = aSelection->GetRangeAt(0)->GetStartContainer();
   startOffset = aSelection->GetRangeAt(0)->StartOffset();
   NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);
-  nsCOMPtr<nsINode> endNode = aSelection->GetRangeAt(0)->GetEndParent();
+  nsCOMPtr<nsINode> endNode = aSelection->GetRangeAt(0)->GetEndContainer();
   int32_t endOffset = aSelection->GetRangeAt(0)->EndOffset();
   NS_ENSURE_TRUE(endNode, NS_ERROR_FAILURE);
 
   // Figure out if the endpoints are in nodes that can be merged.  Adjust
   // surrounding whitespace in preparation to delete selection.
   if (!IsPlaintextEditor()) {
     NS_ENSURE_STATE(mHTMLEditor);
     AutoTransactionsConserveSelection dontSpazMySelection(mHTMLEditor);
@@ -5168,17 +5168,17 @@ HTMLEditRules::ExpandSelectionForDeletio
   }
 
   // Find current sel start and end
   NS_ENSURE_TRUE(aSelection.GetRangeAt(0), NS_ERROR_NULL_POINTER);
   OwningNonNull<nsRange> range = *aSelection.GetRangeAt(0);
 
   nsCOMPtr<nsINode> selStartNode = range->GetStartContainer();
   int32_t selStartOffset = range->StartOffset();
-  nsCOMPtr<nsINode> selEndNode = range->GetEndParent();
+  nsCOMPtr<nsINode> selEndNode = range->GetEndContainer();
   int32_t selEndOffset = range->EndOffset();
 
   // Find current selection common block parent
   nsCOMPtr<Element> selCommon =
     HTMLEditor::GetBlock(*range->GetCommonAncestor());
   NS_ENSURE_STATE(selCommon);
 
   // Set up for loops and cache our root element
@@ -5669,17 +5669,17 @@ HTMLEditRules::PromoteRange(nsRange& aRa
   NS_ENSURE_TRUE(mHTMLEditor, );
   RefPtr<HTMLEditor> htmlEditor(mHTMLEditor);
 
   if (!aRange.IsPositioned()) {
     return;
   }
 
   nsCOMPtr<nsINode> startNode = aRange.GetStartContainer();
-  nsCOMPtr<nsINode> endNode = aRange.GetEndParent();
+  nsCOMPtr<nsINode> endNode = aRange.GetEndContainer();
   int32_t startOffset = aRange.StartOffset();
   int32_t endOffset = aRange.EndOffset();
 
   // MOOSE major hack:
   // GetPromotedPoint doesn't really do the right thing for collapsed ranges
   // inside block elements that contain nothing but a solo <br>.  It's easier
   // to put a workaround here than to revamp GetPromotedPoint.  :-(
   if (startNode == endNode && startOffset == endOffset) {
@@ -5770,17 +5770,17 @@ HTMLEditRules::GetNodesForOperation(
 
   int32_t rangeCount = aArrayOfRanges.Length();
   if (aTouchContent == TouchContent::yes) {
     // Split text nodes. This is necessary, since GetPromotedPoint() may return a
     // range ending in a text node in case where part of a pre-formatted
     // elements needs to be moved.
     for (int32_t i = 0; i < rangeCount; i++) {
       RefPtr<nsRange> r = aArrayOfRanges[i];
-      nsCOMPtr<nsINode> endParent = r->GetEndParent();
+      nsCOMPtr<nsINode> endParent = r->GetEndContainer();
       if (!endParent->IsNodeOfType(nsINode::eTEXT)) {
         continue;
       }
       int32_t offset = r->EndOffset();
 
       if (0 < offset &&
           offset < static_cast<int32_t>(endParent->Length())) {
         // Split the text node.

--- a/editor/libeditor/HTMLEditor.cpp
+++ b/editor/libeditor/HTMLEditor.cpp
@@ -4570,17 +4570,17 @@ HTMLEditor::SetCSSBackgroundColor(const 
       RefPtr<nsRange> range = selection->GetRangeAt(i);
       NS_ENSURE_TRUE(range, NS_ERROR_FAILURE);
 
       nsCOMPtr<Element> cachedBlockParent;
 
       // Check for easy case: both range endpoints in same text node
       nsCOMPtr<nsINode> startNode = range->GetStartContainer();
       int32_t startOffset = range->StartOffset();
-      nsCOMPtr<nsINode> endNode = range->GetEndParent();
+      nsCOMPtr<nsINode> endNode = range->GetEndContainer();
       int32_t endOffset = range->EndOffset();
       if (startNode == endNode && IsTextNode(startNode)) {
         // Let's find the block container of the text node
         nsCOMPtr<Element> blockParent = GetBlockNodeParent(startNode);
         // And apply the background color to that block container
         if (blockParent && cachedBlockParent != blockParent) {
           cachedBlockParent = blockParent;
           mCSSEditUtils->SetCSSEquivalentToHTMLStyle(blockParent, nullptr,
@@ -4862,17 +4862,17 @@ HTMLEditor::GetSelectionContainer()
   } else {
     int32_t rangeCount = selection->RangeCount();
 
     if (rangeCount == 1) {
       RefPtr<nsRange> range = selection->GetRangeAt(0);
 
       nsCOMPtr<nsINode> startContainer = range->GetStartContainer();
       int32_t startOffset = range->StartOffset();
-      nsCOMPtr<nsINode> endContainer = range->GetEndParent();
+      nsCOMPtr<nsINode> endContainer = range->GetEndContainer();
       int32_t endOffset = range->EndOffset();
 
       if (startContainer == endContainer && startOffset + 1 == endOffset) {
         nsCOMPtr<nsIDOMElement> focusElement;
         nsresult rv = GetSelectedElement(EmptyString(),
                                          getter_AddRefs(focusElement));
         NS_ENSURE_SUCCESS(rv, nullptr);
         if (focusElement) {

--- a/editor/libeditor/HTMLStyleEditor.cpp
+++ b/editor/libeditor/HTMLStyleEditor.cpp
@@ -139,17 +139,17 @@ HTMLEditor::SetInlineProperty(nsIAtom* a
     for (auto& range : arrayOfRanges.mRanges) {
       // Adjust range to include any ancestors whose children are entirely
       // selected
       rv = PromoteInlineRange(*range);
       NS_ENSURE_SUCCESS(rv, rv);
 
       // Check for easy case: both range endpoints in same text node
       nsCOMPtr<nsINode> startNode = range->GetStartContainer();
-      nsCOMPtr<nsINode> endNode = range->GetEndParent();
+      nsCOMPtr<nsINode> endNode = range->GetEndContainer();
       if (startNode && startNode == endNode && startNode->GetAsText()) {
         rv = SetInlinePropertyOnTextNode(*startNode->GetAsText(),
                                          range->StartOffset(),
                                          range->EndOffset(),
                                          *aProperty, &aAttribute, aValue);
         NS_ENSURE_SUCCESS(rv, rv);
         continue;
       }
@@ -507,17 +507,17 @@ nsresult
 HTMLEditor::SplitStyleAboveRange(nsRange* inRange,
                                  nsIAtom* aProperty,
                                  const nsAString* aAttribute)
 {
   NS_ENSURE_TRUE(inRange, NS_ERROR_NULL_POINTER);
 
   nsCOMPtr<nsINode> startNode = inRange->GetStartContainer();
   int32_t startOffset = inRange->StartOffset();
-  nsCOMPtr<nsINode> endNode = inRange->GetEndParent();
+  nsCOMPtr<nsINode> endNode = inRange->GetEndContainer();
   int32_t endOffset = inRange->EndOffset();
 
   nsCOMPtr<nsINode> origStartNode = startNode;
 
   // split any matching style nodes above the start of range
   {
     AutoTrackDOMPoint tracker(mRangeUpdater, address_of(endNode), &endOffset);
     nsresult rv =
@@ -849,17 +849,17 @@ HTMLEditor::IsOnlyAttribute(const nsICon
 }
 
 nsresult
 HTMLEditor::PromoteRangeIfStartsOrEndsInNamedAnchor(nsRange& aRange)
 {
   // We assume that <a> is not nested.
   nsCOMPtr<nsINode> startNode = aRange.GetStartContainer();
   int32_t startOffset = aRange.StartOffset();
-  nsCOMPtr<nsINode> endNode = aRange.GetEndParent();
+  nsCOMPtr<nsINode> endNode = aRange.GetEndContainer();
   int32_t endOffset = aRange.EndOffset();
 
   nsCOMPtr<nsINode> parent = startNode;
 
   while (parent && !parent->IsHTMLElement(nsGkAtoms::body) &&
          !HTMLEditUtils::IsNamedAnchor(parent)) {
     parent = parent->GetParentNode();
   }
@@ -891,17 +891,17 @@ HTMLEditor::PromoteRangeIfStartsOrEndsIn
   return NS_OK;
 }
 
 nsresult
 HTMLEditor::PromoteInlineRange(nsRange& aRange)
 {
   nsCOMPtr<nsINode> startNode = aRange.GetStartContainer();
   int32_t startOffset = aRange.StartOffset();
-  nsCOMPtr<nsINode> endNode = aRange.GetEndParent();
+  nsCOMPtr<nsINode> endNode = aRange.GetEndContainer();
   int32_t endOffset = aRange.EndOffset();
 
   while (startNode && !startNode->IsHTMLElement(nsGkAtoms::body) &&
          IsEditable(startNode) && IsAtFrontOfNode(*startNode, startOffset)) {
     nsCOMPtr<nsINode> parent = startNode->GetParentNode();
     NS_ENSURE_TRUE(parent, NS_ERROR_NULL_POINTER);
     startOffset = parent->IndexOf(startNode);
     startNode = parent;
@@ -1047,17 +1047,17 @@ HTMLEditor::GetInlinePropertyBase(nsIAto
       return NS_OK;
     }
 
     // Non-collapsed selection
     nsCOMPtr<nsIContentIterator> iter = NS_NewContentIterator();
 
     nsAutoString firstValue, theValue;
 
-    nsCOMPtr<nsINode> endNode = range->GetEndParent();
+    nsCOMPtr<nsINode> endNode = range->GetEndContainer();
     int32_t endOffset = range->EndOffset();
 
     for (iter->Init(range); !iter->IsDone(); iter->Next()) {
       if (!iter->GetCurrentNode()->IsContent()) {
         continue;
       }
       nsCOMPtr<nsIContent> content = iter->GetCurrentNode()->AsContent();
 
@@ -1260,17 +1260,17 @@ HTMLEditor::RemoveInlinePropertyImpl(nsI
 
       // Remove this style from ancestors of our range endpoints, splitting
       // them as appropriate
       rv = SplitStyleAboveRange(range, aProperty, aAttribute);
       NS_ENSURE_SUCCESS(rv, rv);
 
       // Check for easy case: both range endpoints in same text node
       nsCOMPtr<nsINode> startNode = range->GetStartContainer();
-      nsCOMPtr<nsINode> endNode = range->GetEndParent();
+      nsCOMPtr<nsINode> endNode = range->GetEndContainer();
       if (startNode && startNode == endNode && startNode->GetAsText()) {
         // We're done with this range!
         if (IsCSSEnabled() &&
             mCSSEditUtils->IsCSSEditableProperty(startNode, aProperty,
                                                  aAttribute)) {
           // The HTML style defined by aProperty/aAttribute has a CSS
           // equivalence in this implementation for startNode
           if (mCSSEditUtils->IsCSSEquivalentToHTMLInlineStyleSet(startNode,
@@ -1391,17 +1391,17 @@ HTMLEditor::RelativeFontChange(FontSize 
   AutoRangeArray arrayOfRanges(selection);
   for (auto& range : arrayOfRanges.mRanges) {
     // Adjust range to include any ancestors with entirely selected children
     nsresult rv = PromoteInlineRange(*range);
     NS_ENSURE_SUCCESS(rv, rv);
 
     // Check for easy case: both range endpoints in same text node
     nsCOMPtr<nsINode> startNode = range->GetStartContainer();
-    nsCOMPtr<nsINode> endNode = range->GetEndParent();
+    nsCOMPtr<nsINode> endNode = range->GetEndContainer();
     if (startNode == endNode && IsTextNode(startNode)) {
       rv = RelativeFontChangeOnTextNode(aDir, *startNode->GetAsText(),
                                         range->StartOffset(),
                                         range->EndOffset());
       NS_ENSURE_SUCCESS(rv, rv);
     } else {
       // Not the easy case.  Range not contained in single text node.  There
       // are up to three phases here.  There are all the nodes reported by the

--- a/editor/libeditor/SelectionState.cpp
+++ b/editor/libeditor/SelectionState.cpp
@@ -650,17 +650,17 @@ NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(Ran
 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(RangeItem, Release)
 
 void
 RangeItem::StoreRange(nsRange* aRange)
 {
   MOZ_ASSERT(aRange);
   startNode = aRange->GetStartContainer();
   startOffset = aRange->StartOffset();
-  endNode = aRange->GetEndParent();
+  endNode = aRange->GetEndContainer();
   endOffset = aRange->EndOffset();
 }
 
 already_AddRefed<nsRange>
 RangeItem::GetRange()
 {
   RefPtr<nsRange> range = new nsRange(startNode);
   if (NS_FAILED(range->SetStartAndEnd(startNode, startOffset,

--- a/extensions/spellcheck/src/mozInlineSpellChecker.cpp
+++ b/extensions/spellcheck/src/mozInlineSpellChecker.cpp
@@ -1479,17 +1479,17 @@ nsresult mozInlineSpellChecker::DoSpellC
   int32_t originalRangeCount = aSpellCheckSelection->RangeCount();
 
   // set the starting DOM position to be the beginning of our range
   {
     // Scope for the node/offset pairs here so they don't get
     // accidentally used later
     nsINode* beginNode = aStatus->mRange->GetStartContainer();
     int32_t beginOffset = aStatus->mRange->StartOffset();
-    nsINode* endNode = aStatus->mRange->GetEndParent();
+    nsINode* endNode = aStatus->mRange->GetEndContainer();
     int32_t endOffset = aStatus->mRange->EndOffset();
 
     // Now check that we're still looking at a range that's under
     // aWordUtil.GetRootNode()
     nsINode* rootNode = aWordUtil.GetRootNode();
     if (!nsContentUtils::ContentIsDescendantOf(beginNode, rootNode) ||
         !nsContentUtils::ContentIsDescendantOf(endNode, rootNode)) {
       // Just bail out and don't try to spell-check this

--- a/layout/base/AccessibleCaretManager.cpp
+++ b/layout/base/AccessibleCaretManager.cpp
@@ -1051,22 +1051,22 @@ AccessibleCaretManager::GetFrameForFirst
   CaretAssociationHint hint;
 
   RefPtr<Selection> selection = GetSelection();
   bool findInFirstRangeStart = aDirection == eDirNext;
 
   if (findInFirstRangeStart) {
     range = selection->GetRangeAt(0);
     startNode = range->GetStartContainer();
-    endNode = range->GetEndParent();
+    endNode = range->GetEndContainer();
     nodeOffset = range->StartOffset();
     hint = CARET_ASSOCIATE_AFTER;
   } else {
     range = selection->GetRangeAt(selection->RangeCount() - 1);
-    startNode = range->GetEndParent();
+    startNode = range->GetEndContainer();
     endNode = range->GetStartContainer();
     nodeOffset = range->EndOffset();
     hint = CARET_ASSOCIATE_BEFORE;
   }
 
   nsCOMPtr<nsIContent> startContent = do_QueryInterface(startNode);
   RefPtr<nsFrameSelection> fs = GetFrameSelection();
   nsIFrame* startFrame =

--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -4782,17 +4782,17 @@ PresShell::ClipListToRange(nsDisplayList
   while ((i = aList->RemoveBottom())) {
     // itemToInsert indiciates the item that should be inserted into the
     // temporary list. If null, no item should be inserted.
     nsDisplayItem* itemToInsert = nullptr;
     nsIFrame* frame = i->Frame();
     nsIContent* content = frame->GetContent();
     if (content) {
       bool atStart = (content == aRange->GetStartContainer());
-      bool atEnd = (content == aRange->GetEndParent());
+      bool atEnd = (content == aRange->GetEndContainer());
       if ((atStart || atEnd) && frame->IsTextFrame()) {
         int32_t frameStartOffset, frameEndOffset;
         frame->GetOffsets(frameStartOffset, frameEndOffset);
 
         int32_t hilightStart =
           atStart ? std::max(aRange->StartOffset(), frameStartOffset) : frameStartOffset;
         int32_t hilightEnd =
           atEnd ? std::min(aRange->EndOffset(), frameEndOffset) : frameEndOffset;
@@ -4879,17 +4879,17 @@ PresShell::CreateRangePaintInfo(nsIDOMRa
   nsRange* range = static_cast<nsRange*>(aRange);
   nsIFrame* ancestorFrame;
   nsIFrame* rootFrame = GetRootFrame();
 
   // If the start or end of the range is the document, just use the root
   // frame, otherwise get the common ancestor of the two endpoints of the
   // range.
   nsINode* startParent = range->GetStartContainer();
-  nsINode* endParent = range->GetEndParent();
+  nsINode* endParent = range->GetEndContainer();
   nsIDocument* doc = startParent->GetComposedDoc();
   if (startParent == doc || endParent == doc) {
     ancestorFrame = rootFrame;
   } else {
     nsINode* ancestor = nsContentUtils::GetCommonAncestor(startParent, endParent);
     NS_ASSERTION(!ancestor || ancestor->IsNodeOfType(nsINode::eCONTENT),
                  "common ancestor is not content");
     if (!ancestor || !ancestor->IsNodeOfType(nsINode::eCONTENT))

--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -9149,17 +9149,17 @@ nsLayoutUtils::GetSelectionBoundingRect(
   } else {
     int32_t rangeCount = aSel->RangeCount();
     RectAccumulator accumulator;
     for (int32_t idx = 0; idx < rangeCount; ++idx) {
       nsRange* range = aSel->GetRangeAt(idx);
       nsRange::CollectClientRectsAndText(&accumulator, nullptr, range,
                                          range->GetStartContainer(),
                                          range->StartOffset(),
-                                         range->GetEndParent(),
+                                         range->GetEndContainer(),
                                          range->EndOffset(),
                                          true, false);
     }
     res = accumulator.mResultRect.IsEmpty() ? accumulator.mFirstRect :
       accumulator.mResultRect;
   }
 
   return res;

--- a/layout/generic/nsFrameSelection.cpp
+++ b/layout/generic/nsFrameSelection.cpp
@@ -636,17 +636,17 @@ nsFrameSelection::UndefineCaretBidiLevel
 #ifdef PRINT_RANGE
 void printRange(nsRange *aDomRange)
 {
   if (!aDomRange)
   {
     printf("NULL nsIDOMRange\n");
   }
   nsINode* startNode = aDomRange->GetStartContainer();
-  nsINode* endNode = aDomRange->GetEndParent();
+  nsINode* endNode = aDomRange->GetEndContainer();
   int32_t startOffset = aDomRange->StartOffset();
   int32_t endOffset = aDomRange->EndOffset();
 
   printf("range: 0x%lx\t start: 0x%lx %ld, \t end: 0x%lx,%ld\n",
          (unsigned long)aDomRange,
          (unsigned long)startNode, (long)startOffset,
          (unsigned long)endNode, (long)endOffset);
 
@@ -833,17 +833,17 @@ nsFrameSelection::MoveCaret(nsDirection 
     const nsRange* anchorFocusRange = sel->GetAnchorFocusRange();
     if (anchorFocusRange) {
       nsINode* node;
       int32_t offset;
       if (aDirection == eDirPrevious) {
         node =  anchorFocusRange->GetStartContainer();
         offset = anchorFocusRange->StartOffset();
       } else {
-        node = anchorFocusRange->GetEndParent();
+        node = anchorFocusRange->GetEndContainer();
         offset = anchorFocusRange->EndOffset();
       }
       sel->Collapse(node, offset);
     }
     sel->ScrollIntoView(nsISelectionController::SELECTION_FOCUS_REGION,
                         nsIPresShell::ScrollAxis(),
                         nsIPresShell::ScrollAxis(), scrollFlags);
     return NS_OK;
@@ -1207,17 +1207,17 @@ nsFrameSelection::AdjustForMaintainedSel
     return false;
   }
 
   int8_t index = GetIndexFromSelectionType(SelectionType::eNormal);
   if (!mDomSelections[index])
     return false;
 
   nsINode* rangeStartNode = mMaintainRange->GetStartContainer();
-  nsINode* rangeEndNode = mMaintainRange->GetEndParent();
+  nsINode* rangeEndNode = mMaintainRange->GetEndContainer();
   int32_t rangeStartOffset = mMaintainRange->StartOffset();
   int32_t rangeEndOffset = mMaintainRange->EndOffset();
 
   int32_t relToStart =
     nsContentUtils::ComparePoints(rangeStartNode, rangeStartOffset,
                                   aContent, aOffset);
   int32_t relToEnd =
     nsContentUtils::ComparePoints(rangeEndNode, rangeEndOffset,