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

--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/nsContentIterator.cpp
@@ -1279,28 +1279,28 @@ nsContentSubtreeIterator::Init(nsIDOMRan
   MOZ_ASSERT(aRange);
 
   mIsDone = false;
 
   mRange = static_cast<nsRange*>(aRange);
 
   // get the start node and offset, convert to nsINode
   mCommonParent = mRange->GetCommonAncestor();
-  nsINode* startParent = mRange->GetStartContainer();
+  nsINode* startContainer = mRange->GetStartContainer();
   int32_t startOffset = mRange->StartOffset();
   nsINode* endParent = mRange->GetEndContainer();
   int32_t endOffset = mRange->EndOffset();
-  MOZ_ASSERT(mCommonParent && startParent && endParent);
+  MOZ_ASSERT(mCommonParent && startContainer && endParent);
   // Bug 767169
-  MOZ_ASSERT(uint32_t(startOffset) <= startParent->Length() &&
+  MOZ_ASSERT(uint32_t(startOffset) <= startContainer->Length() &&
              uint32_t(endOffset) <= endParent->Length());
 
   // short circuit when start node == end node
-  if (startParent == endParent) {
-    nsINode* child = startParent->GetFirstChild();
+  if (startContainer == endParent) {
+    nsINode* child = startContainer->GetFirstChild();
 
     if (!child || startOffset == endOffset) {
       // Text node, empty container, or collapsed
       MakeEmpty();
       return NS_OK;
     }
   }
 
@@ -1310,24 +1310,24 @@ nsContentSubtreeIterator::Init(nsIDOMRan
 
   nsIContent* firstCandidate = nullptr;
   nsIContent* lastCandidate = nullptr;
 
   // find first node in range
   int32_t offset = mRange->StartOffset();
 
   nsINode* node = nullptr;
-  if (!startParent->GetChildCount()) {
+  if (!startContainer->GetChildCount()) {
     // no children, start at the node itself
-    node = startParent;
+    node = startContainer;
   } else {
-    nsIContent* child = startParent->GetChildAt(offset);
+    nsIContent* child = startContainer->GetChildAt(offset);
     if (!child) {
       // offset after last child
-      node = startParent;
+      node = startContainer;
     } else {
       firstCandidate = child;
     }
   }
 
   if (!firstCandidate) {
     // then firstCandidate is next node after node
     firstCandidate = GetNextSibling(node);

--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -7453,47 +7453,47 @@ nsContentUtils::GetSelectionInTextContro
   if (!range) {
     // Nothing selected
     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();
+  nsINode* startContainer = range->GetStartContainer();
   uint32_t startOffset = range->StartOffset();
   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();
-  NS_ASSERTION(startParent == aRoot || startParent == firstChild ||
-               startParent == lastChild, "Unexpected startParent");
+  NS_ASSERTION(startContainer == aRoot || startContainer == firstChild ||
+               startContainer == lastChild, "Unexpected startContainer");
   NS_ASSERTION(endParent == aRoot || endParent == firstChild ||
                endParent == lastChild, "Unexpected endParent");
   // 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
     startOffset = endOffset = 0;
   } else {
     // 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 ((startParent == aRoot && startOffset != 0) ||
-        (startParent != aRoot && startParent != firstChild)) {
+    if ((startContainer == aRoot && startOffset != 0) ||
+        (startContainer != aRoot && startContainer != firstChild)) {
       startOffset = firstChild->Length();
     }
     if ((endParent == aRoot && endOffset != 0) ||
         (endParent != aRoot && endParent != firstChild)) {
       endOffset = firstChild->Length();
     }
   }
 

--- a/dom/base/nsDocumentEncoder.cpp
+++ b/dom/base/nsDocumentEncoder.cpp
@@ -938,65 +938,63 @@ nsDocumentEncoder::SerializeRangeToStrin
   if (!aRange || aRange->Collapsed())
     return NS_OK;
 
   mCommonParent = aRange->GetCommonAncestor();
 
   if (!mCommonParent)
     return NS_OK;
 
-  nsINode* startParent = aRange->GetStartContainer();
-  NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE);
+  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);
   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(startParent);
+  nsCOMPtr<nsIDOMNode> sp = do_QueryInterface(startContainer);
   nsContentUtils::GetAncestorsAndOffsets(sp, startOffset,
                                          &mStartNodes, &mStartOffsets);
   nsCOMPtr<nsIDOMNode> ep = do_QueryInterface(endParent);
   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 ((startParent == endParent) && IsTextNode(startParent))
-  {
+  if ((startContainer == endParent) && 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(startParent);
+      nsCOMPtr<nsIContent> content = do_QueryInterface(startContainer);
       if (content && !content->GetPrimaryFrame()) {
         nsIContent* parent = content->GetParent();
         if (!parent || !IsVisibleNode(parent))
           return NS_OK;
       }
     }
-    rv = SerializeNodeStart(startParent, startOffset, endOffset, aOutputString);
+    rv = SerializeNodeStart(startContainer, startOffset, endOffset,
+                            aOutputString);
     NS_ENSURE_SUCCESS(rv, rv);
-  }
-  else
-  {
+  } else {
     rv = SerializeRangeNodes(aRange, mCommonParent, aOutputString, 0);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   rv = SerializeRangeContextEnd(mCommonAncestors, aOutputString);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return rv;
 }

--- a/dom/base/nsRange.cpp
+++ b/dom/base/nsRange.cpp
@@ -113,24 +113,24 @@ nsRange::CompareNodeToRange(nsINode* aNo
     nodeStart = 0;
     nodeEnd = aNode->GetChildCount();
   }
   else {
     nodeStart = parent->IndexOf(aNode);
     nodeEnd = nodeStart + 1;
   }
 
-  nsINode* rangeStartParent = aRange->GetStartContainer();
+  nsINode* rangeStartContainer = aRange->GetStartContainer();
   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,
+  *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,
                                                 rangeEndOffset,
@@ -284,19 +284,20 @@ nsRange::CreateRange(nsINode* aStartCont
 }
 
 /* static */
 nsresult
 nsRange::CreateRange(nsIDOMNode* aStartContainer, int32_t aStartOffset,
                      nsIDOMNode* aEndParent, int32_t aEndOffset,
                      nsRange** aRange)
 {
-  nsCOMPtr<nsINode> startParent = do_QueryInterface(aStartContainer);
+  nsCOMPtr<nsINode> startContainer = do_QueryInterface(aStartContainer);
   nsCOMPtr<nsINode> endParent = do_QueryInterface(aEndParent);
-  return CreateRange(startParent, aStartOffset, endParent, aEndOffset, aRange);
+  return CreateRange(startContainer, aStartOffset,
+                     endParent, aEndOffset, aRange);
 }
 
 /* static */
 nsresult
 nsRange::CreateRange(nsIDOMNode* aStartContainer, int32_t aStartOffset,
                      nsIDOMNode* aEndParent, int32_t aEndOffset,
                      nsIDOMRange** aRange)
 {
@@ -3437,28 +3438,28 @@ nsRange::ExcludeNonSelectableNodes(nsTAr
           // 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.
           if (!added && !err.Failed()) {
             aOutRanges->AppendElement(range);
           }
 
           // Create a new range for the remainder.
-          nsINode* startParent = node;
+          nsINode* startContainer = node;
           int32_t startOffset = 0;
           // Don't start *inside* a node with independent selection though
           // (e.g. <input>).
           if (content && content->HasIndependentSelection()) {
-            nsINode* parent = startParent->GetParent();
+            nsINode* parent = startContainer->GetParent();
             if (parent) {
-              startOffset = parent->IndexOf(startParent);
-              startParent = parent;
+              startOffset = parent->IndexOf(startContainer);
+              startContainer = parent;
             }
           }
-          rv = CreateRange(startParent, startOffset, endParent, endOffset,
+          rv = CreateRange(startContainer, startOffset, endParent, 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
@@ -51,32 +51,32 @@ DeleteRangeTransaction::DoTransaction()
   // Swap mRangeToDelete out into a stack variable, so we make sure to null it
   // out on return from this function.  Once this function returns, we no longer
   // 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();
+  nsCOMPtr<nsINode> startContainer = rangeToDelete->GetStartContainer();
   int32_t startOffset = rangeToDelete->StartOffset();
   nsCOMPtr<nsINode> endParent = rangeToDelete->GetEndContainer();
   int32_t endOffset = rangeToDelete->EndOffset();
-  MOZ_ASSERT(startParent && endParent);
+  MOZ_ASSERT(startContainer && endParent);
 
-  if (startParent == endParent) {
+  if (startContainer == endParent) {
     // the selection begins and ends in the same node
     nsresult rv =
-      CreateTxnsToDeleteBetween(startParent, startOffset, endOffset);
+      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(startParent, startOffset, nsIEditor::eNext);
+      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);
     NS_ENSURE_SUCCESS(rv, rv);
   }
@@ -86,17 +86,17 @@ DeleteRangeTransaction::DoTransaction()
   NS_ENSURE_SUCCESS(rv, rv);
 
   // only set selection to deletion point if editor gives permission
   bool bAdjustSelection;
   mEditorBase->ShouldTxnSetSelection(&bAdjustSelection);
   if (bAdjustSelection) {
     RefPtr<Selection> selection = mEditorBase->GetSelection();
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
-    rv = selection->Collapse(startParent, startOffset);
+    rv = selection->Collapse(startContainer, startOffset);
     NS_ENSURE_SUCCESS(rv, rv);
   }
   // else do nothing - dom range gravity will adjust selection
 
   return NS_OK;
 }
 
 NS_IMETHODIMP

--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -452,27 +452,28 @@ 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> rangeStartParent, rangeEndParent;
+  nsCOMPtr<nsIDOMNode> rangeStartContainer, rangeEndParent;
   int32_t rangeStartOffset = 0, rangeEndOffset = 0;
   // do we have a real range to act on?
   bool bDamagedRange = false;
   if (mDocChangeRange) {
-    mDocChangeRange->GetStartContainer(getter_AddRefs(rangeStartParent));
+    mDocChangeRange->GetStartContainer(getter_AddRefs(rangeStartContainer));
     mDocChangeRange->GetEndContainer(getter_AddRefs(rangeEndParent));
     mDocChangeRange->GetStartOffset(&rangeStartOffset);
     mDocChangeRange->GetEndOffset(&rangeEndOffset);
-    if (rangeStartParent && rangeEndParent)
+    if (rangeStartContainer && rangeEndParent) {
       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.
     NS_ENSURE_STATE(mHTMLEditor);
     AutoTransactionsConserveSelection dontSpazMySelection(mHTMLEditor);
@@ -562,17 +563,17 @@ HTMLEditRules::AfterEditInner(EditAction
 
   NS_ENSURE_STATE(mHTMLEditor);
 
   nsresult rv =
     mHTMLEditor->HandleInlineSpellCheck(
                    action, selection,
                    GetAsDOMNode(mRangeItem->mStartContainer),
                    mRangeItem->mStartOffset,
-                   rangeStartParent, rangeStartOffset,
+                   rangeStartContainer, rangeStartOffset,
                    rangeEndParent, rangeEndOffset);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // detect empty doc
   rv = CreateBogusNodeIfNeeded(selection);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // adjust selection HINT if needed
@@ -7911,30 +7912,30 @@ 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> startParent, endParent;
-    range->GetStartContainer(getter_AddRefs(startParent));
-    if (startParent) {
-      if (node == startParent) {
+    nsCOMPtr<nsIDOMNode> startContainer, endParent;
+    range->GetStartContainer(getter_AddRefs(startContainer));
+    if (startContainer) {
+      if (node == startContainer) {
         *aResult = true;
         return NS_OK;
       }
-      if (EditorUtils::IsDescendantOf(startParent, node)) {
+      if (EditorUtils::IsDescendantOf(startContainer, node)) {
         *aResult = true;
         return NS_OK;
       }
     }
     range->GetEndContainer(getter_AddRefs(endParent));
-    if (startParent == endParent) {
+    if (startContainer == endParent) {
       continue;
     }
     if (endParent) {
       if (node == endParent) {
         *aResult = true;
         return NS_OK;
       }
       if (EditorUtils::IsDescendantOf(endParent, node)) {

--- a/editor/libeditor/HTMLEditor.cpp
+++ b/editor/libeditor/HTMLEditor.cpp
@@ -2412,32 +2412,33 @@ HTMLEditor::GetSelectedElement(const nsA
   bool anyTag = (TagName.IsEmpty());
   bool isLinkTag = IsLinkTag(TagName);
   bool isNamedAnchorTag = IsNamedAnchorTag(TagName);
 
   nsCOMPtr<nsIDOMElement> selectedElement;
   RefPtr<nsRange> range = selection->GetRangeAt(0);
   NS_ENSURE_STATE(range);
 
-  nsCOMPtr<nsIDOMNode> startParent;
+  nsCOMPtr<nsIDOMNode> startContainer;
   int32_t startOffset, endOffset;
-  nsresult rv = range->GetStartContainer(getter_AddRefs(startParent));
+  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));
   NS_ENSURE_SUCCESS(rv, rv);
   rv = range->GetEndOffset(&endOffset);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Optimization for a single selected element
-  if (startParent && startParent == endParent && endOffset - startOffset == 1) {
-    nsCOMPtr<nsIDOMNode> selectedNode = GetChildAt(startParent, startOffset);
+  if (startContainer && startContainer == endParent &&
+      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
       if (anyTag || (TagName == domTagName) ||
           (isLinkTag && HTMLEditUtils::IsLink(selectedNode)) ||

--- a/editor/libeditor/HTMLTableEditor.cpp
+++ b/editor/libeditor/HTMLTableEditor.cpp
@@ -2917,44 +2917,44 @@ HTMLEditor::GetCellFromRange(nsRange* aR
                              nsIDOMElement** aCell)
 {
   // Note: this might return a node that is outside of the range.
   // Use carefully.
   NS_ENSURE_TRUE(aRange && aCell, NS_ERROR_NULL_POINTER);
 
   *aCell = nullptr;
 
-  nsCOMPtr<nsIDOMNode> startParent;
-  nsresult rv = aRange->GetStartContainer(getter_AddRefs(startParent));
+  nsCOMPtr<nsIDOMNode> startContainer;
+  nsresult rv = aRange->GetStartContainer(getter_AddRefs(startContainer));
   NS_ENSURE_SUCCESS(rv, rv);
-  NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE);
+  NS_ENSURE_TRUE(startContainer, NS_ERROR_FAILURE);
 
   int32_t startOffset;
   rv = aRange->GetStartOffset(&startOffset);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  nsCOMPtr<nsIDOMNode> childNode = GetChildAt(startParent, startOffset);
+  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));
   NS_ENSURE_SUCCESS(rv, rv);
-  NS_ENSURE_TRUE(startParent, NS_ERROR_FAILURE);
+  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 (startParent == endParent &&
+  if (startContainer == endParent &&
       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> startParent, endParent;
+  nsCOMPtr<nsIDOMNode> startContainer, endParent;
   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();
@@ -2594,25 +2594,25 @@ nsTextServicesDocument::GetUncollapsedSe
   // Find the first range in the selection that intersects
   // 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(startParent), &startOffset,
+                           getter_AddRefs(startContainer), &startOffset,
                            getter_AddRefs(endParent), &endOffset);
 
     NS_ENSURE_SUCCESS(rv, rv);
 
     e1s2 = nsContentUtils::ComparePoints(eStart->mNode, eStartOffset,
                                          endParent, endOffset);
     e2s1 = nsContentUtils::ComparePoints(eEnd->mNode, eEndOffset,
-                                         startParent, startOffset);
+                                         startContainer, startOffset);
 
     // Break out of the loop if the text block intersects the current range.
 
     if (e1s2 <= 0 && e2s1 >= 0) {
       break;
     }
   }
 
@@ -2622,17 +2622,17 @@ nsTextServicesDocument::GetUncollapsedSe
     *aSelStatus = nsITextServicesDocument::eBlockOutside;
     *aSelOffset = *aSelLength = -1;
     return NS_OK;
   }
 
   // Now that we have an intersecting range, find out more info:
 
   e1s1 = nsContentUtils::ComparePoints(eStart->mNode, eStartOffset,
-                                       startParent, startOffset);
+                                       startContainer, startOffset);
   e2s2 = nsContentUtils::ComparePoints(eEnd->mNode, eEndOffset,
                                        endParent, 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;
@@ -2657,17 +2657,17 @@ nsTextServicesDocument::GetUncollapsedSe
 
   // The start of the range will be the rightmost
   // start node.
 
   if (e1s1 >= 0) {
     p1 = do_QueryInterface(eStart->mNode);
     o1 = eStartOffset;
   } else {
-    p1 = startParent;
+    p1 = startContainer;
     o1 = startOffset;
   }
 
   // The end of the range will be the leftmost
   // end node.
 
   if (e2s2 <= 0) {
     p2 = do_QueryInterface(eEnd->mNode);

--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -4878,23 +4878,24 @@ 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* startContainer = range->GetStartContainer();
   nsINode* endParent = range->GetEndContainer();
-  nsIDocument* doc = startParent->GetComposedDoc();
-  if (startParent == doc || endParent == doc) {
+  nsIDocument* doc = startContainer->GetComposedDoc();
+  if (startContainer == doc || endParent == doc) {
     ancestorFrame = rootFrame;
   } else {
-    nsINode* ancestor = nsContentUtils::GetCommonAncestor(startParent, endParent);
+    nsINode* ancestor =
+      nsContentUtils::GetCommonAncestor(startContainer, endParent);
     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();
 
@@ -4931,24 +4932,24 @@ PresShell::CreateRangePaintInfo(nsIDOMRa
     }
     nsIFrame* frame = aNode->AsContent()->GetPrimaryFrame();
     // XXX deal with frame being null due to display:contents
     for (; frame; frame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(frame)) {
       frame->BuildDisplayListForStackingContext(&info->mBuilder,
                frame->GetVisualOverflowRect(), &info->mList);
     }
   };
-  if (startParent->NodeType() == nsIDOMNode::TEXT_NODE) {
-    BuildDisplayListForNode(startParent);
+  if (startContainer->NodeType() == nsIDOMNode::TEXT_NODE) {
+    BuildDisplayListForNode(startContainer);
   }
   for (; !iter->IsDone(); iter->Next()) {
     nsCOMPtr<nsINode> node = iter->GetCurrentNode();
     BuildDisplayListForNode(node);
   }
-  if (endParent != startParent &&
+  if (endParent != startContainer &&
       endParent->NodeType() == nsIDOMNode::TEXT_NODE) {
     BuildDisplayListForNode(endParent);
   }
 
 #ifdef DEBUG
   if (gDumpRangePaintList) {
     fprintf(stderr, "CreateRangePaintInfo --- before ClipListToRange:\n");
     nsFrame::PrintDisplayList(&(info->mBuilder), info->mList);

--- a/layout/generic/nsFrameSelection.cpp
+++ b/layout/generic/nsFrameSelection.cpp
@@ -2735,23 +2735,24 @@ nsFrameSelection::SelectRowOrColumn(nsIC
   return NS_OK;
 }
 
 nsIContent*
 nsFrameSelection::GetFirstCellNodeInRange(nsRange *aRange) const
 {
   if (!aRange) return nullptr;
 
-  nsINode* startParent = aRange->GetStartContainer();
-  if (!startParent)
+  nsINode* startContainer = aRange->GetStartContainer();
+  if (!startContainer) {
     return nullptr;
+  }
 
   int32_t offset = aRange->StartOffset();
 
-  nsIContent* childContent = startParent->GetChildAt(offset);
+  nsIContent* childContent = startContainer->GetChildAt(offset);
   if (!childContent)
     return nullptr;
   // Don't return node if not a cell
   if (!IsCell(childContent))
     return nullptr;
 
   return childContent;
 }