--- a/accessible/generic/HyperTextAccessible.cpp
+++ b/accessible/generic/HyperTextAccessible.cpp
@@ -1784,31 +1784,31 @@ HyperTextAccessible::SelectionRanges(nsT
     return;
 
   aRanges->SetCapacity(sel->RangeCount());
 
   for (uint32_t idx = 0; idx < sel->RangeCount(); idx++) {
     nsRange* DOMRange = sel->GetRangeAt(idx);
     HyperTextAccessible* startContainer =
       nsAccUtils::GetTextContainer(DOMRange->GetStartContainer());
-    HyperTextAccessible* endParent =
+    HyperTextAccessible* endContainer =
       nsAccUtils::GetTextContainer(DOMRange->GetEndContainer());
-    if (!startContainer || !endParent) {
+    if (!startContainer || !endContainer) {
       continue;
     }
 
     int32_t startOffset =
       startContainer->DOMPointToOffset(DOMRange->GetStartContainer(),
                                        DOMRange->StartOffset(), false);
     int32_t endOffset =
-      endParent->DOMPointToOffset(DOMRange->GetEndContainer(),
-                                  DOMRange->EndOffset(), true);
+      endContainer->DOMPointToOffset(DOMRange->GetEndContainer(),
+                                     DOMRange->EndOffset(), true);
 
     TextRange tr(IsTextField() ? const_cast<HyperTextAccessible*>(this) : mDoc,
-                    startContainer, startOffset, endParent, endOffset);
+                    startContainer, startOffset, endContainer, endOffset);
     *(aRanges->AppendElement()) = Move(tr);
   }
 }
 
 void
 HyperTextAccessible::VisibleRanges(nsTArray<a11y::TextRange>* aRanges) const
 {
 }

--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/nsContentIterator.cpp
@@ -1281,36 +1281,36 @@ nsContentSubtreeIterator::Init(nsIDOMRan
   mIsDone = false;
 
   mRange = static_cast<nsRange*>(aRange);
 
   // get the start node and offset, convert to nsINode
   mCommonParent = mRange->GetCommonAncestor();
   nsINode* startContainer = mRange->GetStartContainer();
   int32_t startOffset = mRange->StartOffset();
-  nsINode* endParent = mRange->GetEndContainer();
+  nsINode* endContainer = mRange->GetEndContainer();
   int32_t endOffset = mRange->EndOffset();
-  MOZ_ASSERT(mCommonParent && startContainer && endParent);
+  MOZ_ASSERT(mCommonParent && startContainer && endContainer);
   // Bug 767169
   MOZ_ASSERT(uint32_t(startOffset) <= startContainer->Length() &&
-             uint32_t(endOffset) <= endParent->Length());
+             uint32_t(endOffset) <= endContainer->Length());
 
   // short circuit when start node == end node
-  if (startContainer == endParent) {
+  if (startContainer == endContainer) {
     nsINode* child = startContainer->GetFirstChild();
 
     if (!child || startOffset == endOffset) {
       // Text node, empty container, or collapsed
       MakeEmpty();
       return NS_OK;
     }
   }
 
   // cache ancestors
-  nsContentUtils::GetAncestorsAndOffsets(endParent->AsDOMNode(), endOffset,
+  nsContentUtils::GetAncestorsAndOffsets(endContainer->AsDOMNode(), endOffset,
                                          &mEndNodes, &mEndOffsets);
 
   nsIContent* firstCandidate = nullptr;
   nsIContent* lastCandidate = nullptr;
 
   // find first node in range
   int32_t offset = mRange->StartOffset();
 
@@ -1354,26 +1354,26 @@ nsContentSubtreeIterator::Init(nsIDOMRan
 
   // cool, we have the first node in the range.  Now we walk up its ancestors
   // to find the most senior that is still in the range.  That's the real first
   // node.
   mFirst = GetTopAncestorInRange(firstCandidate);
 
   // now to find the last node
   offset = mRange->EndOffset();
-  int32_t numChildren = endParent->GetChildCount();
+  int32_t numChildren = endContainer->GetChildCount();
 
   if (offset > numChildren) {
     // Can happen for text nodes
     offset = numChildren;
   }
   if (!offset || !numChildren) {
-    node = endParent;
+    node = endContainer;
   } else {
-    lastCandidate = endParent->GetChildAt(--offset);
+    lastCandidate = endContainer->GetChildAt(--offset);
     NS_ASSERTION(lastCandidate,
                  "tree traversal trouble in nsContentSubtreeIterator::Init");
   }
 
   if (!lastCandidate) {
     // then lastCandidate is prev node before node
     lastCandidate = GetPrevSibling(node);
   }

--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -7455,29 +7455,29 @@ 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* startContainer = range->GetStartContainer();
   uint32_t startOffset = range->StartOffset();
-  nsINode* endParent = range->GetEndContainer();
+  nsINode* endContainer = 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();
   NS_ASSERTION(startContainer == aRoot || startContainer == firstChild ||
                startContainer == lastChild, "Unexpected startContainer");
-  NS_ASSERTION(endParent == aRoot || endParent == firstChild ||
-               endParent == lastChild, "Unexpected endParent");
+  NS_ASSERTION(endContainer == aRoot || endContainer == firstChild ||
+               endContainer == lastChild, "Unexpected endContainer");
   // firstChild is either text or a <br> (hence an element).
   MOZ_ASSERT_IF(firstChild,
                 firstChild->IsNodeOfType(nsINode::eTEXT) || firstChild->IsElement());
 #endif
   // Testing IsElement() is faster than testing IsNodeOfType(), since it's
   // non-virtual.
   if (!firstChild || firstChild->IsElement()) {
     // No text node, so everything is 0
@@ -7486,18 +7486,18 @@ nsContentUtils::GetSelectionInTextContro
     // First child is text.  If the start/end is already in the text node,
     // or the start of the root node, no change needed.  If it's in the root
     // node but not the start, or in the trailing <br>, we need to set the
     // offset to the end.
     if ((startContainer == aRoot && startOffset != 0) ||
         (startContainer != aRoot && startContainer != firstChild)) {
       startOffset = firstChild->Length();
     }
-    if ((endParent == aRoot && endOffset != 0) ||
-        (endParent != aRoot && endParent != firstChild)) {
+    if ((endContainer == aRoot && endOffset != 0) ||
+        (endContainer != aRoot && endContainer != firstChild)) {
       endOffset = firstChild->Length();
     }
   }
 
   MOZ_ASSERT(startOffset <= endOffset);
   aOutStartOffset = startOffset;
   aOutEndOffset = endOffset;
 }

--- a/dom/base/nsDocumentEncoder.cpp
+++ b/dom/base/nsDocumentEncoder.cpp
@@ -942,45 +942,45 @@ nsDocumentEncoder::SerializeRangeToStrin
 
   if (!mCommonParent)
     return NS_OK;
 
   nsINode* startContainer = aRange->GetStartContainer();
   NS_ENSURE_TRUE(startContainer, NS_ERROR_FAILURE);
   int32_t startOffset = aRange->StartOffset();
 
-  nsINode* endParent = aRange->GetEndContainer();
-  NS_ENSURE_TRUE(endParent, NS_ERROR_FAILURE);
+  nsINode* endContainer = aRange->GetEndContainer();
+  NS_ENSURE_TRUE(endContainer, NS_ERROR_FAILURE);
   int32_t endOffset = aRange->EndOffset();
 
   mStartDepth = mEndDepth = 0;
   mCommonAncestors.Clear();
   mStartNodes.Clear();
   mStartOffsets.Clear();
   mEndNodes.Clear();
   mEndOffsets.Clear();
 
   nsContentUtils::GetAncestors(mCommonParent, mCommonAncestors);
   nsCOMPtr<nsIDOMNode> sp = do_QueryInterface(startContainer);
   nsContentUtils::GetAncestorsAndOffsets(sp, startOffset,
                                          &mStartNodes, &mStartOffsets);
-  nsCOMPtr<nsIDOMNode> ep = do_QueryInterface(endParent);
+  nsCOMPtr<nsIDOMNode> ep = do_QueryInterface(endContainer);
   nsContentUtils::GetAncestorsAndOffsets(ep, endOffset,
                                          &mEndNodes, &mEndOffsets);
 
   nsCOMPtr<nsIContent> commonContent = do_QueryInterface(mCommonParent);
   mStartRootIndex = mStartNodes.IndexOf(commonContent);
   mEndRootIndex = mEndNodes.IndexOf(commonContent);
 
   nsresult rv = NS_OK;
 
   rv = SerializeRangeContextStart(mCommonAncestors, aOutputString);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  if ((startContainer == endParent) && IsTextNode(startContainer)) {
+  if (startContainer == endContainer && IsTextNode(startContainer)) {
     if (mFlags & SkipInvisibleContent) {
       // Check that the parent is visible if we don't a frame.
       // IsVisibleNode() will do it when there's a frame.
       nsCOMPtr<nsIContent> content = do_QueryInterface(startContainer);
       if (content && !content->GetPrimaryFrame()) {
         nsIContent* parent = content->GetParent();
         if (!parent || !IsVisibleNode(parent))
           return NS_OK;

--- a/dom/base/nsRange.cpp
+++ b/dom/base/nsRange.cpp
@@ -114,30 +114,30 @@ nsRange::CompareNodeToRange(nsINode* aNo
     nodeEnd = aNode->GetChildCount();
   }
   else {
     nodeStart = parent->IndexOf(aNode);
     nodeEnd = nodeStart + 1;
   }
 
   nsINode* rangeStartContainer = aRange->GetStartContainer();
-  nsINode* rangeEndParent = aRange->GetEndContainer();
+  nsINode* rangeEndContainer = aRange->GetEndContainer();
   int32_t rangeStartOffset = aRange->StartOffset();
   int32_t rangeEndOffset = aRange->EndOffset();
 
   // is RANGE(start) <= NODE(start) ?
   bool disconnected = false;
   *outNodeBefore = nsContentUtils::ComparePoints(rangeStartContainer,
                                                  rangeStartOffset,
                                                  parent, nodeStart,
                                                  &disconnected) > 0;
   NS_ENSURE_TRUE(!disconnected, NS_ERROR_DOM_WRONG_DOCUMENT_ERR);
 
   // is RANGE(end) >= NODE(end) ?
-  *outNodeAfter = nsContentUtils::ComparePoints(rangeEndParent,
+  *outNodeAfter = nsContentUtils::ComparePoints(rangeEndContainer,
                                                 rangeEndOffset,
                                                 parent, nodeEnd,
                                                 &disconnected) < 0;
   NS_ENSURE_TRUE(!disconnected, NS_ERROR_DOM_WRONG_DOCUMENT_ERR);
   return NS_OK;
 }
 
 static nsINode*
@@ -285,19 +285,19 @@ nsRange::CreateRange(nsINode* aStartCont
 
 /* static */
 nsresult
 nsRange::CreateRange(nsIDOMNode* aStartContainer, int32_t aStartOffset,
                      nsIDOMNode* aEndParent, int32_t aEndOffset,
                      nsRange** aRange)
 {
   nsCOMPtr<nsINode> startContainer = do_QueryInterface(aStartContainer);
-  nsCOMPtr<nsINode> endParent = do_QueryInterface(aEndParent);
+  nsCOMPtr<nsINode> endContainer = do_QueryInterface(aEndParent);
   return CreateRange(startContainer, aStartOffset,
-                     endParent, aEndOffset, aRange);
+                     endContainer, aEndOffset, aRange);
 }
 
 /* static */
 nsresult
 nsRange::CreateRange(nsIDOMNode* aStartContainer, int32_t aStartOffset,
                      nsIDOMNode* aEndParent, int32_t aEndOffset,
                      nsIDOMRange** aRange)
 {
@@ -3424,17 +3424,17 @@ nsRange::ExcludeNonSelectableNodes(nsTAr
           // non-selectable so just trim them from the start.
           range->SetStartBefore(*node, err);
           if (err.Failed()) {
             return;
           }
           break; // restart the same range with a new iterator
         } else {
           // Save the end point before truncating the range.
-          nsINode* endParent = range->mEndContainer;
+          nsINode* endContainer = range->mEndContainer;
           int32_t endOffset = range->mEndOffset;
 
           // Truncate the current range before the first non-selectable node.
           range->SetEndBefore(*firstNonSelectableContent, err);
 
           // Store it in the result (strong ref) - do this before creating
           // a new range in |newRange| below so we don't drop the last ref
           // to the range created in the previous iteration.
@@ -3449,17 +3449,17 @@ nsRange::ExcludeNonSelectableNodes(nsTAr
           // (e.g. <input>).
           if (content && content->HasIndependentSelection()) {
             nsINode* parent = startContainer->GetParent();
             if (parent) {
               startOffset = parent->IndexOf(startContainer);
               startContainer = parent;
             }
           }
-          rv = CreateRange(startContainer, startOffset, endParent, endOffset,
+          rv = CreateRange(startContainer, startOffset, endContainer, endOffset,
                            getter_AddRefs(newRange));
           if (NS_FAILED(rv) || newRange->Collapsed()) {
             newRange = nullptr;
           }
           range = newRange;
           break; // create a new iterator for the new range, if any
         }
       } else {

--- a/editor/libeditor/DeleteRangeTransaction.cpp
+++ b/editor/libeditor/DeleteRangeTransaction.cpp
@@ -53,36 +53,37 @@ 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> startContainer = rangeToDelete->GetStartContainer();
   int32_t startOffset = rangeToDelete->StartOffset();
-  nsCOMPtr<nsINode> endParent = rangeToDelete->GetEndContainer();
+  nsCOMPtr<nsINode> endContainer = rangeToDelete->GetEndContainer();
   int32_t endOffset = rangeToDelete->EndOffset();
-  MOZ_ASSERT(startContainer && endParent);
+  MOZ_ASSERT(startContainer && endContainer);
 
-  if (startContainer == endParent) {
+  if (startContainer == endContainer) {
     // the selection begins and ends in the same node
     nsresult rv =
       CreateTxnsToDeleteBetween(startContainer, startOffset, endOffset);
     NS_ENSURE_SUCCESS(rv, rv);
   } else {
     // the selection ends in a different node from where it started.  delete
     // the relevant content in the start node
     nsresult rv =
       CreateTxnsToDeleteContent(startContainer, startOffset, nsIEditor::eNext);
     NS_ENSURE_SUCCESS(rv, rv);
     // delete the intervening nodes
     rv = CreateTxnsToDeleteNodesBetween(rangeToDelete);
     NS_ENSURE_SUCCESS(rv, rv);
     // delete the relevant content in the end node
-    rv = CreateTxnsToDeleteContent(endParent, endOffset, nsIEditor::ePrevious);
+    rv = CreateTxnsToDeleteContent(endContainer, endOffset,
+                                   nsIEditor::ePrevious);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   // if we've successfully built this aggregate transaction, then do it.
   nsresult rv = EditAggregateTransaction::DoTransaction();
   NS_ENSURE_SUCCESS(rv, rv);
 
   // only set selection to deletion point if editor gives permission

--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -452,26 +452,26 @@ HTMLEditRules::AfterEditInner(EditAction
   if (action == EditAction::ignore) {
     return NS_OK;
   }
 
   NS_ENSURE_STATE(mHTMLEditor);
   RefPtr<Selection> selection = mHTMLEditor->GetSelection();
   NS_ENSURE_STATE(selection);
 
-  nsCOMPtr<nsIDOMNode> rangeStartContainer, rangeEndParent;
+  nsCOMPtr<nsIDOMNode> rangeStartContainer, rangeEndContainer;
   int32_t rangeStartOffset = 0, rangeEndOffset = 0;
   // do we have a real range to act on?
   bool bDamagedRange = false;
   if (mDocChangeRange) {
     mDocChangeRange->GetStartContainer(getter_AddRefs(rangeStartContainer));
-    mDocChangeRange->GetEndContainer(getter_AddRefs(rangeEndParent));
+    mDocChangeRange->GetEndContainer(getter_AddRefs(rangeEndContainer));
     mDocChangeRange->GetStartOffset(&rangeStartOffset);
     mDocChangeRange->GetEndOffset(&rangeEndOffset);
-    if (rangeStartContainer && rangeEndParent) {
+    if (rangeStartContainer && rangeEndContainer) {
       bDamagedRange = true;
     }
   }
 
   if (bDamagedRange && !((action == EditAction::undo) ||
                          (action == EditAction::redo))) {
     // don't let any txns in here move the selection around behind our back.
     // Note that this won't prevent explicit selection setting from working.
@@ -564,17 +564,17 @@ HTMLEditRules::AfterEditInner(EditAction
   NS_ENSURE_STATE(mHTMLEditor);
 
   nsresult rv =
     mHTMLEditor->HandleInlineSpellCheck(
                    action, selection,
                    GetAsDOMNode(mRangeItem->mStartContainer),
                    mRangeItem->mStartOffset,
                    rangeStartContainer, rangeStartOffset,
-                   rangeEndParent, rangeEndOffset);
+                   rangeEndContainer, rangeEndOffset);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // detect empty doc
   rv = CreateBogusNodeIfNeeded(selection);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // adjust selection HINT if needed
   if (!mDidExplicitlySetInterline) {
@@ -5774,34 +5774,34 @@ 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->GetEndContainer();
-      if (!endParent->IsNodeOfType(nsINode::eTEXT)) {
+      nsCOMPtr<nsINode> endContainer = r->GetEndContainer();
+      if (!endContainer->IsNodeOfType(nsINode::eTEXT)) {
         continue;
       }
       int32_t offset = r->EndOffset();
 
       if (0 < offset &&
-          offset < static_cast<int32_t>(endParent->Length())) {
+          offset < static_cast<int32_t>(endContainer->Length())) {
         // Split the text node.
         nsCOMPtr<nsIDOMNode> tempNode;
-        nsresult rv = htmlEditor->SplitNode(endParent->AsDOMNode(), offset,
+        nsresult rv = htmlEditor->SplitNode(endContainer->AsDOMNode(), offset,
                                             getter_AddRefs(tempNode));
         NS_ENSURE_SUCCESS(rv, rv);
 
         // Correct the range.
         // The new end parent becomes the parent node of the text.
-        nsCOMPtr<nsIContent> newParent = endParent->GetParent();
-        r->SetEnd(newParent, newParent->IndexOf(endParent));
+        nsCOMPtr<nsIContent> newParent = endContainer->GetParent();
+        r->SetEnd(newParent, newParent->IndexOf(endContainer));
       }
     }
   }
 
   // Bust up any inlines that cross our range endpoints, but only if we are
   // allowed to touch content.
 
   if (aTouchContent == TouchContent::yes) {
@@ -7912,38 +7912,38 @@ HTMLEditRules::SelectionEndpointInNode(n
 
   NS_ENSURE_STATE(mHTMLEditor);
   RefPtr<Selection> selection = mHTMLEditor->GetSelection();
   NS_ENSURE_STATE(selection);
 
   uint32_t rangeCount = selection->RangeCount();
   for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; ++rangeIdx) {
     RefPtr<nsRange> range = selection->GetRangeAt(rangeIdx);
-    nsCOMPtr<nsIDOMNode> startContainer, endParent;
+    nsCOMPtr<nsIDOMNode> startContainer, endContainer;
     range->GetStartContainer(getter_AddRefs(startContainer));
     if (startContainer) {
       if (node == startContainer) {
         *aResult = true;
         return NS_OK;
       }
       if (EditorUtils::IsDescendantOf(startContainer, node)) {
         *aResult = true;
         return NS_OK;
       }
     }
-    range->GetEndContainer(getter_AddRefs(endParent));
-    if (startContainer == endParent) {
+    range->GetEndContainer(getter_AddRefs(endContainer));
+    if (startContainer == endContainer) {
       continue;
     }
-    if (endParent) {
-      if (node == endParent) {
+    if (endContainer) {
+      if (node == endContainer) {
         *aResult = true;
         return NS_OK;
       }
-      if (EditorUtils::IsDescendantOf(endParent, node)) {
+      if (EditorUtils::IsDescendantOf(endContainer, node)) {
         *aResult = true;
         return NS_OK;
       }
     }
   }
   return NS_OK;
 }
 

--- a/editor/libeditor/HTMLEditor.cpp
+++ b/editor/libeditor/HTMLEditor.cpp
@@ -2419,24 +2419,24 @@ HTMLEditor::GetSelectedElement(const nsA
 
   nsCOMPtr<nsIDOMNode> startContainer;
   int32_t startOffset, endOffset;
   nsresult rv = range->GetStartContainer(getter_AddRefs(startContainer));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = range->GetStartOffset(&startOffset);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  nsCOMPtr<nsIDOMNode> endParent;
-  rv = range->GetEndContainer(getter_AddRefs(endParent));
+  nsCOMPtr<nsIDOMNode> endContainer;
+  rv = range->GetEndContainer(getter_AddRefs(endContainer));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = range->GetEndOffset(&endOffset);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Optimization for a single selected element
-  if (startContainer && startContainer == endParent &&
+  if (startContainer && startContainer == endContainer &&
       endOffset - startOffset == 1) {
     nsCOMPtr<nsIDOMNode> selectedNode = GetChildAt(startContainer, startOffset);
     NS_ENSURE_SUCCESS(rv, NS_OK);
     if (selectedNode) {
       selectedNode->GetNodeName(domTagName);
       ToLowerCase(domTagName);
 
       // Test for appropriate node type requested

--- a/editor/libeditor/HTMLTableEditor.cpp
+++ b/editor/libeditor/HTMLTableEditor.cpp
@@ -2932,29 +2932,29 @@ HTMLEditor::GetCellFromRange(nsRange* aR
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIDOMNode> childNode = GetChildAt(startContainer, startOffset);
   // This means selection is probably at a text node (or end of doc?)
   if (!childNode) {
     return NS_ERROR_FAILURE;
   }
 
-  nsCOMPtr<nsIDOMNode> endParent;
-  rv = aRange->GetEndContainer(getter_AddRefs(endParent));
+  nsCOMPtr<nsIDOMNode> endContainer;
+  rv = aRange->GetEndContainer(getter_AddRefs(endContainer));
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ENSURE_TRUE(startContainer, NS_ERROR_FAILURE);
 
   int32_t endOffset;
   rv = aRange->GetEndOffset(&endOffset);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // If a cell is deleted, the range is collapse
   //   (startOffset == endOffset)
   //   so tell caller the cell wasn't found
-  if (startContainer == endParent &&
+  if (startContainer == endContainer &&
       endOffset == startOffset+1 &&
       HTMLEditUtils::IsTableCell(childNode)) {
     // Should we also test if frame is selected? (Use GetCellDataAt())
     // (Let's not for now -- more efficient)
     nsCOMPtr<nsIDOMElement> cellElement = do_QueryInterface(childNode);
     *aCell = cellElement.get();
     NS_ADDREF(*aCell);
     return NS_OK;

--- a/editor/txtsvc/nsTextServicesDocument.cpp
+++ b/editor/txtsvc/nsTextServicesDocument.cpp
@@ -2558,17 +2558,17 @@ nsTextServicesDocument::GetUncollapsedSe
   NS_ENSURE_TRUE(domSelection, NS_ERROR_FAILURE);
 
   RefPtr<Selection> selection = domSelection->AsSelection();
 
   // It is assumed that the calling function has made sure that the
   // selection is not collapsed, and that the input params to this
   // method are initialized to some defaults.
 
-  nsCOMPtr<nsIDOMNode> startContainer, endParent;
+  nsCOMPtr<nsIDOMNode> startContainer, endContainer;
   int32_t startOffset, endOffset;
   int32_t rangeCount, tableCount;
   int32_t e1s1 = 0, e1s2 = 0, e2s1 = 0, e2s2 = 0;
 
   OffsetEntry *eStart, *eEnd;
   int32_t eStartOffset, eEndOffset;
 
   tableCount = mOffsetTable.Length();
@@ -2595,22 +2595,22 @@ nsTextServicesDocument::GetUncollapsedSe
   // the current text block.
 
   for (int32_t i = 0; i < rangeCount; i++) {
     range = selection->GetRangeAt(i);
     NS_ENSURE_STATE(range);
 
     rv = GetRangeEndPoints(range,
                            getter_AddRefs(startContainer), &startOffset,
-                           getter_AddRefs(endParent), &endOffset);
+                           getter_AddRefs(endContainer), &endOffset);
 
     NS_ENSURE_SUCCESS(rv, rv);
 
     e1s2 = nsContentUtils::ComparePoints(eStart->mNode, eStartOffset,
-                                         endParent, endOffset);
+                                         endContainer, endOffset);
     e2s1 = nsContentUtils::ComparePoints(eEnd->mNode, eEndOffset,
                                          startContainer, startOffset);
 
     // Break out of the loop if the text block intersects the current range.
 
     if (e1s2 <= 0 && e2s1 >= 0) {
       break;
     }
@@ -2624,17 +2624,17 @@ nsTextServicesDocument::GetUncollapsedSe
     return NS_OK;
   }
 
   // Now that we have an intersecting range, find out more info:
 
   e1s1 = nsContentUtils::ComparePoints(eStart->mNode, eStartOffset,
                                        startContainer, startOffset);
   e2s2 = nsContentUtils::ComparePoints(eEnd->mNode, eEndOffset,
-                                       endParent, endOffset);
+                                       endContainer, endOffset);
 
   if (rangeCount > 1) {
     // There are multiple selection ranges, we only deal
     // with the first one that intersects the current,
     // text block, so mark this a as a partial.
     *aSelStatus = nsITextServicesDocument::eBlockPartial;
   } else if (e1s1 > 0 && e2s2 < 0) {
     // The range extends beyond the start and
@@ -2668,17 +2668,17 @@ nsTextServicesDocument::GetUncollapsedSe
 
   // The end of the range will be the leftmost
   // end node.
 
   if (e2s2 <= 0) {
     p2 = do_QueryInterface(eEnd->mNode);
     o2 = eEndOffset;
   } else {
-    p2 = endParent;
+    p2 = endContainer;
     o2 = endOffset;
   }
 
   rv = CreateRange(p1, o1, p2, o2, getter_AddRefs(range));
 
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Now iterate over this range to figure out the selection's

--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -4879,23 +4879,23 @@ 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* startContainer = range->GetStartContainer();
-  nsINode* endParent = range->GetEndContainer();
+  nsINode* endContainer = range->GetEndContainer();
   nsIDocument* doc = startContainer->GetComposedDoc();
-  if (startContainer == doc || endParent == doc) {
+  if (startContainer == doc || endContainer == doc) {
     ancestorFrame = rootFrame;
   } else {
     nsINode* ancestor =
-      nsContentUtils::GetCommonAncestor(startContainer, endParent);
+      nsContentUtils::GetCommonAncestor(startContainer, endContainer);
     NS_ASSERTION(!ancestor || ancestor->IsNodeOfType(nsINode::eCONTENT),
                  "common ancestor is not content");
     if (!ancestor || !ancestor->IsNodeOfType(nsINode::eCONTENT))
       return nullptr;
 
     nsIContent* ancestorContent = static_cast<nsIContent*>(ancestor);
     ancestorFrame = ancestorContent->GetPrimaryFrame();
 
@@ -4939,19 +4939,19 @@ PresShell::CreateRangePaintInfo(nsIDOMRa
   };
   if (startContainer->NodeType() == nsIDOMNode::TEXT_NODE) {
     BuildDisplayListForNode(startContainer);
   }
   for (; !iter->IsDone(); iter->Next()) {
     nsCOMPtr<nsINode> node = iter->GetCurrentNode();
     BuildDisplayListForNode(node);
   }
-  if (endParent != startContainer &&
-      endParent->NodeType() == nsIDOMNode::TEXT_NODE) {
-    BuildDisplayListForNode(endParent);
+  if (endContainer != startContainer &&
+      endContainer->NodeType() == nsIDOMNode::TEXT_NODE) {
+    BuildDisplayListForNode(endContainer);
   }
 
 #ifdef DEBUG
   if (gDumpRangePaintList) {
     fprintf(stderr, "CreateRangePaintInfo --- before ClipListToRange:\n");
     nsFrame::PrintDisplayList(&(info->mBuilder), info->mList);
   }
 #endif