--- a/dom/base/SelectionChangeListener.cpp
+++ b/dom/base/SelectionChangeListener.cpp
@@ -16,48 +16,49 @@
 #include "Selection.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
 SelectionChangeListener::RawRangeData::RawRangeData(const nsRange* aRange)
 {
   mozilla::ErrorResult rv;
-  mStartParent = aRange->GetStartContainer(rv);
+  mStartContainer = aRange->GetStartContainer(rv);
   rv.SuppressException();
   mEndParent = aRange->GetEndContainer(rv);
   rv.SuppressException();
   mStartOffset = aRange->GetStartOffset(rv);
   rv.SuppressException();
   mEndOffset = aRange->GetEndOffset(rv);
   rv.SuppressException();
 }
 
 bool
 SelectionChangeListener::RawRangeData::Equals(const nsRange* aRange)
 {
   mozilla::ErrorResult rv;
-  bool eq = mStartParent == aRange->GetStartContainer(rv);
+  bool eq = mStartContainer == aRange->GetStartContainer(rv);
   rv.SuppressException();
   eq = eq && mEndParent == aRange->GetEndContainer(rv);
   rv.SuppressException();
   eq = eq && mStartOffset == aRange->GetStartOffset(rv);
   rv.SuppressException();
   eq = eq && mEndOffset == aRange->GetEndOffset(rv);
   rv.SuppressException();
   return eq;
 }
 
 inline void
 ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
                             SelectionChangeListener::RawRangeData& aField,
                             const char* aName,
                             uint32_t aFlags = 0)
 {
-  ImplCycleCollectionTraverse(aCallback, aField.mStartParent, "mStartParent", aFlags);
+  ImplCycleCollectionTraverse(aCallback, aField.mStartContainer,
+                              "mStartContainer", aFlags);
   ImplCycleCollectionTraverse(aCallback, aField.mEndParent, "mEndParent", aFlags);
 }
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(SelectionChangeListener)
 
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(SelectionChangeListener)
   tmp->mOldRanges.Clear();
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END

--- a/dom/base/SelectionChangeListener.h
+++ b/dom/base/SelectionChangeListener.h
@@ -28,17 +28,17 @@ public:
   // changed.
   struct RawRangeData
   {
     // These properties are not void*s to avoid the potential situation where the
     // nsINode is freed, and a new nsINode is allocated with the same address, which
     // could potentially break the comparison logic. In reality, this is extremely
     // unlikely to occur (potentially impossible), but these nsCOMPtrs are safer.
     // They are never dereferenced.
-    nsCOMPtr<nsINode> mStartParent;
+    nsCOMPtr<nsINode> mStartContainer;
     nsCOMPtr<nsINode> mEndParent;
 
     // XXX These are int32_ts on nsRange, but uint32_ts in the return value
     // of GetStart_, so I use uint32_ts here. See bug 1194256.
     uint32_t mStartOffset;
     uint32_t mEndOffset;
 
     explicit RawRangeData(const nsRange* aRange);

--- a/dom/base/nsRange.cpp
+++ b/dom/base/nsRange.cpp
@@ -332,17 +332,17 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ns
 
   // This needs to be unlinked after Reset() is called, as it controls
   // the result of IsInSelection() which is used by tmp->Reset().
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mSelection);
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsRange)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwner)
-  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStartParent)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStartContainer)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEndParent)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRoot)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSelection)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(nsRange)
   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
 NS_IMPL_CYCLE_COLLECTION_TRACE_END
@@ -455,53 +455,53 @@ nsRange::CharacterDataChanged(nsIDocumen
     // again (when the new text node is notified).
     nsINode* parentNode = aContent->GetParentNode();
     int32_t index = -1;
     if (parentNode == mEndParent && mEndOffset > 0 &&
         (index = parentNode->IndexOf(aContent)) + 1 == mEndOffset) {
       ++mEndOffset;
       mEndOffsetWasIncremented = true;
     }
-    if (parentNode == mStartParent && mStartOffset > 0 &&
+    if (parentNode == mStartContainer && mStartOffset > 0 &&
         (index != -1 ? index : parentNode->IndexOf(aContent)) + 1 == mStartOffset) {
       ++mStartOffset;
       mStartOffsetWasIncremented = true;
     }
 #ifdef DEBUG
     if (mStartOffsetWasIncremented || mEndOffsetWasIncremented) {
       mAssertNextInsertOrAppendIndex =
         (mStartOffsetWasIncremented ? mStartOffset : mEndOffset) - 1;
       mAssertNextInsertOrAppendNode = aInfo->mDetails->mNextSibling;
     }
 #endif
   }
 
   // If the changed node contains our start boundary and the change starts
   // before the boundary we'll need to adjust the offset.
-  if (aContent == mStartParent &&
+  if (aContent == mStartContainer &&
       aInfo->mChangeStart < static_cast<uint32_t>(mStartOffset)) {
     if (aInfo->mDetails) {
       // splitText(), aInfo->mDetails->mNextSibling is the new text node
       NS_ASSERTION(aInfo->mDetails->mType ==
                    CharacterDataChangeInfo::Details::eSplit,
                    "only a split can start before the end");
       NS_ASSERTION(static_cast<uint32_t>(mStartOffset) <= aInfo->mChangeEnd + 1,
                    "mStartOffset is beyond the end of this node");
       newStartOffset = static_cast<uint32_t>(mStartOffset) - aInfo->mChangeStart;
       newStartNode = aInfo->mDetails->mNextSibling;
       if (MOZ_UNLIKELY(aContent == mRoot)) {
         newRoot = IsValidBoundary(newStartNode);
       }
 
-      bool isCommonAncestor = IsInSelection() && mStartParent == mEndParent;
+      bool isCommonAncestor = IsInSelection() && mStartContainer == mEndParent;
       if (isCommonAncestor) {
-        UnregisterCommonAncestor(mStartParent);
+        UnregisterCommonAncestor(mStartContainer);
         RegisterCommonAncestor(newStartNode);
       }
-      if (mStartParent->IsDescendantOfCommonAncestorForRangeInSelection()) {
+      if (mStartContainer->IsDescendantOfCommonAncestorForRangeInSelection()) {
         newStartNode->SetDescendantOfCommonAncestorForRangeInSelection();
       }
     } else {
       // If boundary is inside changed text, position it before change
       // else adjust start offset for the change in length.
       mStartOffset = static_cast<uint32_t>(mStartOffset) <= aInfo->mChangeEnd ?
         aInfo->mChangeStart :
         mStartOffset + aInfo->mChangeStart - aInfo->mChangeEnd +
@@ -519,21 +519,21 @@ nsRange::CharacterDataChanged(nsIDocumen
       NS_ASSERTION(aInfo->mDetails->mType ==
                    CharacterDataChangeInfo::Details::eSplit,
                    "only a split can start before the end");
       NS_ASSERTION(static_cast<uint32_t>(mEndOffset) <= aInfo->mChangeEnd + 1,
                    "mEndOffset is beyond the end of this node");
       newEndOffset = static_cast<uint32_t>(mEndOffset) - aInfo->mChangeStart;
       newEndNode = aInfo->mDetails->mNextSibling;
 
-      bool isCommonAncestor = IsInSelection() && mStartParent == mEndParent;
+      bool isCommonAncestor = IsInSelection() && mStartContainer == mEndParent;
       if (isCommonAncestor && !newStartNode) {
         // The split occurs inside the range.
-        UnregisterCommonAncestor(mStartParent);
-        RegisterCommonAncestor(mStartParent->GetParentNode());
+        UnregisterCommonAncestor(mStartContainer);
+        RegisterCommonAncestor(mStartContainer->GetParentNode());
         newEndNode->SetDescendantOfCommonAncestorForRangeInSelection();
       } else if (mEndParent->IsDescendantOfCommonAncestorForRangeInSelection()) {
         newEndNode->SetDescendantOfCommonAncestorForRangeInSelection();
       }
     } else {
       mEndOffset = static_cast<uint32_t>(mEndOffset) <= aInfo->mChangeEnd ?
         aInfo->mChangeStart :
         mEndOffset + aInfo->mChangeStart - aInfo->mChangeEnd +
@@ -541,17 +541,17 @@ nsRange::CharacterDataChanged(nsIDocumen
     }
   }
 
   if (aInfo->mDetails &&
       aInfo->mDetails->mType == CharacterDataChangeInfo::Details::eMerge) {
     // normalize(), aInfo->mDetails->mNextSibling is the merged text node
     // that will be removed
     nsIContent* removed = aInfo->mDetails->mNextSibling;
-    if (removed == mStartParent) {
+    if (removed == mStartContainer) {
       newStartOffset = static_cast<uint32_t>(mStartOffset) + aInfo->mChangeStart;
       newStartNode = aContent;
       if (MOZ_UNLIKELY(removed == mRoot)) {
         newRoot = IsValidBoundary(newStartNode);
       }
     }
     if (removed == mEndParent) {
       newEndOffset = static_cast<uint32_t>(mEndOffset) + aInfo->mChangeStart;
@@ -562,33 +562,33 @@ nsRange::CharacterDataChanged(nsIDocumen
     }
     // When the removed text node's parent is one of our boundary nodes we may
     // need to adjust the offset to account for the removed node. However,
     // there will also be a ContentRemoved notification later so the only cases
     // we need to handle here is when the removed node is the text node after
     // the boundary.  (The m*Offset > 0 check is an optimization - a boundary
     // point before the first child is never affected by normalize().)
     nsINode* parentNode = aContent->GetParentNode();
-    if (parentNode == mStartParent && mStartOffset > 0 &&
+    if (parentNode == mStartContainer && mStartOffset > 0 &&
         uint32_t(mStartOffset) < parentNode->GetChildCount() &&
         removed == parentNode->GetChildAt(mStartOffset)) {
       newStartNode = aContent;
       newStartOffset = aInfo->mChangeStart;
     }
     if (parentNode == mEndParent && mEndOffset > 0 &&
         uint32_t(mEndOffset) < parentNode->GetChildCount() &&
         removed == parentNode->GetChildAt(mEndOffset)) {
       newEndNode = aContent;
       newEndOffset = aInfo->mChangeEnd;
     }
   }
 
   if (newStartNode || newEndNode) {
     if (!newStartNode) {
-      newStartNode = mStartParent;
+      newStartNode = mStartContainer;
       newStartOffset = mStartOffset;
     }
     if (!newEndNode) {
       newEndNode = mEndParent;
       newEndOffset = mEndOffset;
     }
     DoSetRange(newStartNode, newStartOffset, newEndNode, newEndOffset,
                newRoot ? newRoot : mRoot.get(),
@@ -634,17 +634,17 @@ nsRange::ContentInserted(nsIDocument* aD
                          nsIContent* aChild,
                          int32_t aIndexInContainer)
 {
   NS_ASSERTION(mIsPositioned, "shouldn't be notified if not positioned");
 
   nsINode* container = NODE_FROM(aContainer, aDocument);
 
   // Adjust position if a sibling was inserted.
-  if (container == mStartParent && aIndexInContainer < mStartOffset &&
+  if (container == mStartContainer && aIndexInContainer < mStartOffset &&
       !mStartOffsetWasIncremented) {
     ++mStartOffset;
   }
   if (container == mEndParent && aIndexInContainer < mEndOffset &&
       !mEndOffsetWasIncremented) {
     ++mEndOffset;
   }
   if (container->IsSelectionDescendant() &&
@@ -678,38 +678,39 @@ nsRange::ContentRemoved(nsIDocument* aDo
              "splitText failed to notify insert/append?");
 
   nsINode* container = NODE_FROM(aContainer, aDocument);
   bool gravitateStart = false;
   bool gravitateEnd = false;
   bool didCheckStartParentDescendant = false;
 
   // Adjust position if a sibling was removed...
-  if (container == mStartParent) {
+  if (container == mStartContainer) {
     if (aIndexInContainer < mStartOffset) {
       --mStartOffset;
     }
   } else { // ...or gravitate if an ancestor was removed.
     didCheckStartParentDescendant = true;
-    gravitateStart = nsContentUtils::ContentIsDescendantOf(mStartParent, aChild);
+    gravitateStart =
+      nsContentUtils::ContentIsDescendantOf(mStartContainer, aChild);
   }
 
   // Do same thing for end boundry.
   if (container == mEndParent) {
     if (aIndexInContainer < mEndOffset) {
       --mEndOffset;
     }
-  } else if (didCheckStartParentDescendant && mStartParent == mEndParent) {
+  } else if (didCheckStartParentDescendant && mStartContainer == mEndParent) {
     gravitateEnd = gravitateStart;
   } else {
     gravitateEnd = nsContentUtils::ContentIsDescendantOf(mEndParent, aChild);
   }
 
   if (gravitateStart || gravitateEnd) {
-    DoSetRange(gravitateStart ? container : mStartParent.get(),
+    DoSetRange(gravitateStart ? container : mStartContainer.get(),
                gravitateStart ? aIndexInContainer : mStartOffset,
                gravitateEnd ? container : mEndParent.get(),
                gravitateEnd ? aIndexInContainer : mEndOffset,
                mRoot);
   }
   if (container->IsSelectionDescendant() &&
       aChild->IsDescendantOfCommonAncestorForRangeInSelection()) {
     aChild->ClearDescendantOfCommonAncestorForRangeInSelection();
@@ -719,34 +720,34 @@ nsRange::ContentRemoved(nsIDocument* aDo
 
 void
 nsRange::ParentChainChanged(nsIContent *aContent)
 {
   MOZ_ASSERT(!mStartOffsetWasIncremented && !mEndOffsetWasIncremented &&
              mAssertNextInsertOrAppendIndex == -1,
              "splitText failed to notify insert/append?");
   NS_ASSERTION(mRoot == aContent, "Wrong ParentChainChanged notification?");
-  nsINode* newRoot = IsValidBoundary(mStartParent);
+  nsINode* newRoot = IsValidBoundary(mStartContainer);
   NS_ASSERTION(newRoot, "No valid boundary or root found!");
   if (newRoot != IsValidBoundary(mEndParent)) {
     // Sometimes ordering involved in cycle collection can lead to our
     // start parent and/or end parent being disconnected from our root
     // without our getting a ContentRemoved notification.
     // See bug 846096 for more details.
     NS_ASSERTION(mEndParent->IsInNativeAnonymousSubtree(),
                  "This special case should happen only with "
                  "native-anonymous content");
     // When that happens, bail out and set pointers to null; since we're
     // in cycle collection and unreachable it shouldn't matter.
     Reset();
     return;
   }
   // This is safe without holding a strong ref to self as long as the change
   // of mRoot is the last thing in DoSetRange.
-  DoSetRange(mStartParent, mStartOffset, mEndParent, mEndOffset, newRoot);
+  DoSetRange(mStartContainer, mStartOffset, mEndParent, mEndOffset, newRoot);
 }
 
 /******************************************************
  * Utilities for comparing points: API from nsIDOMRange
  ******************************************************/
 NS_IMETHODIMP
 nsRange::IsPointInRange(nsIDOMNode* aParent, int32_t aOffset, bool* aResult)
 {
@@ -807,17 +808,18 @@ nsRange::ComparePoint(nsINode& aParent, 
 
   if (aOffset > aParent.Length()) {
     aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
     return 0;
   }
 
   int32_t cmp;
   if ((cmp = nsContentUtils::ComparePoints(&aParent, aOffset,
-                                           mStartParent, mStartOffset)) <= 0) {
+                                           mStartContainer,
+                                           mStartOffset)) <= 0) {
 
     return cmp;
   }
   if (nsContentUtils::ComparePoints(mEndParent, mEndOffset,
                                     &aParent, aOffset) == -1) {
     return 1;
   }
 
@@ -855,17 +857,17 @@ nsRange::IntersectsNode(nsINode& aNode, 
   }
 
   // Step 5.
   int32_t nodeIndex = parent->IndexOf(&aNode);
 
   // Steps 6-7.
   // Note: if disconnected is true, ComparePoints returns 1.
   bool disconnected = false;
-  bool result = nsContentUtils::ComparePoints(mStartParent, mStartOffset,
+  bool result = nsContentUtils::ComparePoints(mStartContainer, mStartOffset,
                                              parent, nodeIndex + 1,
                                              &disconnected) < 0 &&
                nsContentUtils::ComparePoints(parent, nodeIndex,
                                              mEndParent, mEndOffset,
                                              &disconnected) < 0;
 
   // Step 2.
   if (disconnected) {
@@ -915,24 +917,25 @@ nsRange::DoSetRange(nsINode* aStartN, in
   if (mRoot != aRoot) {
     if (mRoot) {
       mRoot->RemoveMutationObserver(this);
     }
     if (aRoot) {
       aRoot->AddMutationObserver(this);
     }
   }
-  bool checkCommonAncestor = (mStartParent != aStartN || mEndParent != aEndN) &&
-                             IsInSelection() && !aNotInsertedYet;
+  bool checkCommonAncestor =
+    (mStartContainer != aStartN || mEndParent != aEndN) &&
+    IsInSelection() && !aNotInsertedYet;
   nsINode* oldCommonAncestor = checkCommonAncestor ? GetCommonAncestor() : nullptr;
-  mStartParent = aStartN;
+  mStartContainer = aStartN;
   mStartOffset = aStartOffset;
   mEndParent = aEndN;
   mEndOffset = aEndOffset;
-  mIsPositioned = !!mStartParent;
+  mIsPositioned = !!mStartContainer;
   if (checkCommonAncestor) {
     nsINode* newCommonAncestor = GetCommonAncestor();
     if (newCommonAncestor != oldCommonAncestor) {
       if (oldCommonAncestor) {
         UnregisterCommonAncestor(oldCommonAncestor);
       }
       if (newCommonAncestor) {
         RegisterCommonAncestor(newCommonAncestor);
@@ -992,17 +995,17 @@ nsRange::SetSelection(mozilla::dom::Sele
     UnregisterCommonAncestor(commonAncestor);
   }
 }
 
 nsINode*
 nsRange::GetCommonAncestor() const
 {
   return mIsPositioned ?
-    nsContentUtils::GetCommonAncestor(mStartParent, mEndParent) :
+    nsContentUtils::GetCommonAncestor(mStartContainer, mEndParent) :
     nullptr;
 }
 
 void
 nsRange::Reset()
 {
   DoSetRange(nullptr, 0, nullptr, 0, nullptr);
 }
@@ -1012,28 +1015,28 @@ nsRange::Reset()
  ******************************************************/
 
 NS_IMETHODIMP
 nsRange::GetStartContainer(nsIDOMNode** aStartParent)
 {
   if (!mIsPositioned)
     return NS_ERROR_NOT_INITIALIZED;
 
-  return CallQueryInterface(mStartParent, aStartParent);
+  return CallQueryInterface(mStartContainer, aStartParent);
 }
 
 nsINode*
 nsRange::GetStartContainer(ErrorResult& aRv) const
 {
   if (!mIsPositioned) {
     aRv.Throw(NS_ERROR_NOT_INITIALIZED);
     return nullptr;
   }
 
-  return mStartParent;
+  return mStartContainer;
 }
 
 NS_IMETHODIMP
 nsRange::GetStartOffset(int32_t* aStartOffset)
 {
   if (!mIsPositioned)
     return NS_ERROR_NOT_INITIALIZED;
 
@@ -1109,17 +1112,17 @@ nsRange::GetCollapsed(bool* aIsCollapsed
 nsINode*
 nsRange::GetCommonAncestorContainer(ErrorResult& aRv) const
 {
   if (!mIsPositioned) {
     aRv.Throw(NS_ERROR_NOT_INITIALIZED);
     return nullptr;
   }
 
-  return nsContentUtils::GetCommonAncestor(mStartParent, mEndParent);
+  return nsContentUtils::GetCommonAncestor(mStartContainer, mEndParent);
 }
 
 NS_IMETHODIMP
 nsRange::GetCommonAncestorContainer(nsIDOMNode** aCommonParent)
 {
   ErrorResult rv;
   nsINode* commonAncestor = GetCommonAncestorContainer(rv);
   if (commonAncestor) {
@@ -1362,24 +1365,24 @@ nsRange::SetEnd(nsINode* aParent, int32_
 
   if (!IsValidOffset(aParent, aOffset)) {
     return NS_ERROR_DOM_INDEX_SIZE_ERR;
   }
 
   // Collapse if not positioned yet, if positioned in another doc or
   // if the new end is before start.
   if (!mIsPositioned || newRoot != mRoot ||
-      nsContentUtils::ComparePoints(mStartParent, mStartOffset,
+      nsContentUtils::ComparePoints(mStartContainer, mStartOffset,
                                     aParent, aOffset) == 1) {
     DoSetRange(aParent, aOffset, aParent, aOffset, newRoot);
 
     return NS_OK;
   }
 
-  DoSetRange(mStartParent, mStartOffset, aParent, aOffset, mRoot);
+  DoSetRange(mStartContainer, mStartOffset, aParent, aOffset, mRoot);
 
   return NS_OK;
 }
 
 nsresult
 nsRange::SetStartAndEnd(nsINode* aStartParent, int32_t aStartOffset,
                         nsINode* aEndParent, int32_t aEndOffset)
 {
@@ -1511,20 +1514,22 @@ nsRange::SetEndAfter(nsIDOMNode* aSiblin
 
 NS_IMETHODIMP
 nsRange::Collapse(bool aToStart)
 {
   if (!mIsPositioned)
     return NS_ERROR_NOT_INITIALIZED;
 
   AutoInvalidateSelection atEndOfBlock(this);
-  if (aToStart)
-    DoSetRange(mStartParent, mStartOffset, mStartParent, mStartOffset, mRoot);
-  else
+  if (aToStart) {
+    DoSetRange(mStartContainer, mStartOffset,
+               mStartContainer, mStartOffset, mRoot);
+  } else {
     DoSetRange(mEndParent, mEndOffset, mEndParent, mEndOffset, mRoot);
+  }
 
   return NS_OK;
 }
 
 void
 nsRange::CollapseJS(bool aToStart)
 {
   AutoCalledByJSRestore calledByJSRestorer(*this);
@@ -2000,17 +2005,17 @@ ValidateCurrentNode(nsRange* aRange, Ran
 
 nsresult
 nsRange::CutContents(DocumentFragment** aFragment)
 {
   if (aFragment) {
     *aFragment = nullptr;
   }
 
-  nsCOMPtr<nsIDocument> doc = mStartParent->OwnerDoc();
+  nsCOMPtr<nsIDocument> doc = mStartContainer->OwnerDoc();
 
   ErrorResult res;
   nsCOMPtr<nsINode> commonAncestor = GetCommonAncestorContainer(res);
   NS_ENSURE_TRUE(!res.Failed(), res.StealNSResult());
 
   // If aFragment isn't null, create a temporary fragment to hold our return.
   RefPtr<DocumentFragment> retval;
   if (aFragment) {
@@ -2019,17 +2024,17 @@ nsRange::CutContents(DocumentFragment** 
   nsCOMPtr<nsINode> commonCloneAncestor = retval.get();
 
   // Batch possible DOMSubtreeModified events.
   mozAutoSubtreeModified subtree(mRoot ? mRoot->OwnerDoc(): nullptr, nullptr);
 
   // Save the range end points locally to avoid interference
   // of Range gravity during our edits!
 
-  nsCOMPtr<nsINode> startContainer = mStartParent;
+  nsCOMPtr<nsINode> startContainer = mStartContainer;
   int32_t              startOffset = mStartOffset;
   nsCOMPtr<nsINode> endContainer = mEndParent;
   int32_t              endOffset = mEndOffset;
 
   if (retval) {
     // For extractContents(), abort early if there's a doctype (bug 719533).
     // This can happen only if the common ancestor is a document, in which case
     // we just need to find its doctype child and check if that's in the range.
@@ -2323,29 +2328,29 @@ nsRange::CompareBoundaryPoints(uint16_t 
     return 0;
   }
 
   nsINode *ourNode, *otherNode;
   int32_t ourOffset, otherOffset;
 
   switch (aHow) {
     case nsIDOMRange::START_TO_START:
-      ourNode = mStartParent;
+      ourNode = mStartContainer;
       ourOffset = mStartOffset;
       otherNode = aOtherRange.GetStartContainer();
       otherOffset = aOtherRange.StartOffset();
       break;
     case nsIDOMRange::START_TO_END:
       ourNode = mEndParent;
       ourOffset = mEndOffset;
       otherNode = aOtherRange.GetStartContainer();
       otherOffset = aOtherRange.StartOffset();
       break;
     case nsIDOMRange::END_TO_START:
-      ourNode = mStartParent;
+      ourNode = mStartContainer;
       ourOffset = mStartOffset;
       otherNode = aOtherRange.GetEndContainer();
       otherOffset = aOtherRange.EndOffset();
       break;
     case nsIDOMRange::END_TO_END:
       ourNode = mEndParent;
       ourOffset = mEndOffset;
       otherNode = aOtherRange.GetEndContainer();
@@ -2425,17 +2430,17 @@ nsRange::CloneContents(nsIDOMDocumentFra
 }
 
 already_AddRefed<DocumentFragment>
 nsRange::CloneContents(ErrorResult& aRv)
 {
   nsCOMPtr<nsINode> commonAncestor = GetCommonAncestorContainer(aRv);
   MOZ_ASSERT(!aRv.Failed(), "GetCommonAncestorContainer() shouldn't fail!");
 
-  nsCOMPtr<nsIDocument> doc = mStartParent->OwnerDoc();
+  nsCOMPtr<nsIDocument> doc = mStartContainer->OwnerDoc();
   NS_ASSERTION(doc, "CloneContents needs a document to continue.");
   if (!doc) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
 
   // Create a new document fragment in the context of this document,
   // which might be null
@@ -2474,17 +2479,17 @@ nsRange::CloneContents(ErrorResult& aRv)
   // parent hierarchy, adds a cloned version of the subtree, to it, then
   // correctly places this new subtree into the doc fragment.
 
   while (!iter.IsDone())
   {
     nsCOMPtr<nsINode> node = iter.GetCurrentNode();
     bool deepClone = !node->IsElement() ||
                        (!(node == mEndParent && mEndOffset == 0) &&
-                        !(node == mStartParent &&
+                        !(node == mStartContainer &&
                           mStartOffset ==
                             int32_t(node->AsElement()->GetChildCount())));
 
     // Clone the current subtree!
 
     nsCOMPtr<nsINode> clone = node->CloneNode(deepClone, aRv);
     if (aRv.Failed()) {
       return nullptr;
@@ -2515,18 +2520,17 @@ nsRange::CloneContents(ErrorResult& aRv)
         {
           aRv = charData->DeleteData(mEndOffset, dataLength - mEndOffset);
           if (aRv.Failed()) {
             return nullptr;
           }
         }
       }
 
-      if (node == mStartParent)
-      {
+      if (node == mStartContainer) {
         // We don't need any data before mStartOffset, so just
         // delete it!
 
         if (mStartOffset > 0)
         {
           aRv = charData->DeleteData(0, mStartOffset);
           if (aRv.Failed()) {
             return nullptr;
@@ -2630,17 +2634,18 @@ nsRange::CloneContents(ErrorResult& aRv)
 
 already_AddRefed<nsRange>
 nsRange::CloneRange() const
 {
   RefPtr<nsRange> range = new nsRange(mOwner);
 
   range->SetMaySpanAnonymousSubtrees(mMaySpanAnonymousSubtrees);
 
-  range->DoSetRange(mStartParent, mStartOffset, mEndParent, mEndOffset, mRoot);
+  range->DoSetRange(mStartContainer, mStartOffset,
+                    mEndParent, mEndOffset, mRoot);
 
   return range.forget();
 }
 
 NS_IMETHODIMP
 nsRange::CloneRange(nsIDOMRange** aReturn)
 {
   *aReturn = CloneRange().take();
@@ -2784,30 +2789,30 @@ nsRange::SurroundContents(nsINode& aNewP
   }
 
   if (!mRoot) {
     aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
     return;
   }
   // INVALID_STATE_ERROR: Raised if the Range partially selects a non-text
   // node.
-  if (mStartParent != mEndParent) {
-    bool startIsText = mStartParent->IsNodeOfType(nsINode::eTEXT);
+  if (mStartContainer != mEndParent) {
+    bool startIsText = mStartContainer->IsNodeOfType(nsINode::eTEXT);
     bool endIsText = mEndParent->IsNodeOfType(nsINode::eTEXT);
-    nsINode* startGrandParent = mStartParent->GetParentNode();
+    nsINode* startGrandParent = mStartContainer->GetParentNode();
     nsINode* endGrandParent = mEndParent->GetParentNode();
     if (!((startIsText && endIsText &&
            startGrandParent &&
            startGrandParent == endGrandParent) ||
           (startIsText &&
            startGrandParent &&
            startGrandParent == mEndParent) ||
           (endIsText &&
            endGrandParent &&
-           endGrandParent == mStartParent))) {
+           endGrandParent == mStartContainer))) {
       aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
       return;
     }
   }
 
   // INVALID_NODE_TYPE_ERROR if aNewParent is something that can't be inserted
   // (Document, DocumentType, DocumentFragment)
   uint16_t nodeType = aNewParent.NodeType();
@@ -2885,38 +2890,37 @@ nsRange::ToString(nsAString& aReturn)
     return NS_OK;
   }
 
 #ifdef DEBUG_range
       printf("Range dump: -----------------------\n");
 #endif /* DEBUG */
 
   // effeciency hack for simple case
-  if (mStartParent == mEndParent)
-  {
-    nsCOMPtr<nsIDOMText> textNode( do_QueryInterface(mStartParent) );
+  if (mStartContainer == mEndParent) {
+    nsCOMPtr<nsIDOMText> textNode = do_QueryInterface(mStartContainer);
 
     if (textNode)
     {
 #ifdef DEBUG_range
       // If debug, dump it:
-      nsCOMPtr<nsIContent> cN (do_QueryInterface(mStartParent));
+      nsCOMPtr<nsIContent> cN = do_QueryInterface(mStartContainer);
       if (cN) cN->List(stdout);
       printf("End Range dump: -----------------------\n");
 #endif /* DEBUG */
 
       // grab the text
       if (NS_FAILED(textNode->SubstringData(mStartOffset,mEndOffset-mStartOffset,aReturn)))
         return NS_ERROR_UNEXPECTED;
       return NS_OK;
     }
   }
 
-  /* complex case: mStartParent != mEndParent, or mStartParent not a text node
-     revisit - there are potential optimizations here and also tradeoffs.
+  /* complex case: mStartContainer != mEndParent, or mStartParent not a text
+     node revisit - there are potential optimizations here and also tradeoffs.
   */
 
   nsCOMPtr<nsIContentIterator> iter = NS_NewContentIterator();
   nsresult rv = iter->Init(this);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString tempString;
 
@@ -2928,18 +2932,17 @@ nsRange::ToString(nsAString& aReturn)
 
 #ifdef DEBUG_range
     // If debug, dump it:
     n->List(stdout);
 #endif /* DEBUG */
     nsCOMPtr<nsIDOMText> textNode(do_QueryInterface(n));
     if (textNode) // if it's a text node, get the text
     {
-      if (n == mStartParent) // only include text past start offset
-      {
+      if (n == mStartContainer) { // only include text past start offset
         uint32_t strLength;
         textNode->GetLength(&strLength);
         textNode->SubstringData(mStartOffset,strLength-mStartOffset,tempString);
         aReturn += tempString;
       }
       else if (n == mEndParent)  // only include text before end offset
       {
         textNode->SubstringData(0,mEndOffset,tempString);
@@ -2969,31 +2972,31 @@ nsRange::Detach()
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsRange::CreateContextualFragment(const nsAString& aFragment,
                                   nsIDOMDocumentFragment** aReturn)
 {
   if (mIsPositioned) {
-    return nsContentUtils::CreateContextualFragment(mStartParent, aFragment,
+    return nsContentUtils::CreateContextualFragment(mStartContainer, aFragment,
                                                     false, aReturn);
   }
   return NS_ERROR_FAILURE;
 }
 
 already_AddRefed<DocumentFragment>
 nsRange::CreateContextualFragment(const nsAString& aFragment, ErrorResult& aRv)
 {
   if (!mIsPositioned) {
     aRv.Throw(NS_ERROR_FAILURE);
     return nullptr;
   }
 
-  return nsContentUtils::CreateContextualFragment(mStartParent, aFragment,
+  return nsContentUtils::CreateContextualFragment(mStartContainer, aFragment,
                                                   false, aRv);
 }
 
 static void ExtractRectFromOffset(nsIFrame* aFrame,
                                   const int32_t aOffset, nsRect* aR, bool aKeepLeft,
                                   bool aClampToEdge)
 {
   nsPoint point;
@@ -3178,22 +3181,22 @@ nsRange::GetBoundingClientRect(nsIDOMCli
   *aResult = GetBoundingClientRect(true).take();
   return NS_OK;
 }
 
 already_AddRefed<DOMRect>
 nsRange::GetBoundingClientRect(bool aClampToEdge, bool aFlushLayout)
 {
   RefPtr<DOMRect> rect = new DOMRect(ToSupports(this));
-  if (!mStartParent) {
+  if (!mStartContainer) {
     return rect.forget();
   }
 
   nsLayoutUtils::RectAccumulator accumulator;
-  CollectClientRectsAndText(&accumulator, nullptr, this, mStartParent,
+  CollectClientRectsAndText(&accumulator, nullptr, this, mStartContainer,
     mStartOffset, mEndParent, mEndOffset, aClampToEdge, aFlushLayout);
 
   nsRect r = accumulator.mResultRect.IsEmpty() ? accumulator.mFirstRect :
     accumulator.mResultRect;
   rect->SetLayoutRect(r);
   return rect.forget();
 }
 
@@ -3202,64 +3205,64 @@ nsRange::GetClientRects(nsIDOMClientRect
 {
   *aResult = GetClientRects(true).take();
   return NS_OK;
 }
 
 already_AddRefed<DOMRectList>
 nsRange::GetClientRects(bool aClampToEdge, bool aFlushLayout)
 {
-  if (!mStartParent) {
+  if (!mStartContainer) {
     return nullptr;
   }
 
   RefPtr<DOMRectList> rectList =
     new DOMRectList(static_cast<nsIDOMRange*>(this));
 
   nsLayoutUtils::RectListBuilder builder(rectList);
 
-  CollectClientRectsAndText(&builder, nullptr, this, mStartParent,
+  CollectClientRectsAndText(&builder, nullptr, this, mStartContainer,
     mStartOffset, mEndParent, mEndOffset, aClampToEdge, aFlushLayout);
   return rectList.forget();
 }
 
 void
 nsRange::GetClientRectsAndTexts(
   mozilla::dom::ClientRectsAndTexts& aResult,
   ErrorResult& aErr)
 {
-  if (!mStartParent) {
+  if (!mStartContainer) {
     return;
   }
 
   aResult.mRectList = new DOMRectList(static_cast<nsIDOMRange*>(this));
 
   nsLayoutUtils::RectListBuilder builder(aResult.mRectList);
 
   CollectClientRectsAndText(&builder, &aResult.mTextList, this,
-    mStartParent, mStartOffset, mEndParent, mEndOffset, true, true);
+    mStartContainer, mStartOffset, mEndParent, mEndOffset, true, true);
 }
 
 NS_IMETHODIMP
 nsRange::GetUsedFontFaces(nsIDOMFontFaceList** aResult)
 {
   *aResult = nullptr;
 
-  NS_ENSURE_TRUE(mStartParent, NS_ERROR_UNEXPECTED);
-
-  nsCOMPtr<nsINode> startContainer = do_QueryInterface(mStartParent);
+  NS_ENSURE_TRUE(mStartContainer, NS_ERROR_UNEXPECTED);
+
+  nsCOMPtr<nsINode> startContainer = do_QueryInterface(mStartContainer);
   nsCOMPtr<nsINode> endContainer = do_QueryInterface(mEndParent);
 
   // Flush out layout so our frames are up to date.
-  nsIDocument* doc = mStartParent->OwnerDoc();
+  nsIDocument* doc = mStartContainer->OwnerDoc();
   NS_ENSURE_TRUE(doc, NS_ERROR_UNEXPECTED);
   doc->FlushPendingNotifications(FlushType::Frames);
 
   // Recheck whether we're still in the document
-  NS_ENSURE_TRUE(mStartParent->IsInUncomposedDoc(), NS_ERROR_UNEXPECTED);
+  NS_ENSURE_TRUE(mStartContainer->IsInUncomposedDoc(), NS_ERROR_UNEXPECTED);
 
   RefPtr<nsFontFaceList> fontFaceList = new nsFontFaceList();
 
   RangeSubtreeIterator iter;
   nsresult rv = iter.Init(this);
   NS_ENSURE_SUCCESS(rv, rv);
 
   while (!iter.IsDone()) {
@@ -3298,17 +3301,17 @@ nsRange::GetUsedFontFaces(nsIDOMFontFace
   return NS_OK;
 }
 
 nsINode*
 nsRange::GetRegisteredCommonAncestor()
 {
   NS_ASSERTION(IsInSelection(),
                "GetRegisteredCommonAncestor only valid for range in selection");
-  nsINode* ancestor = GetNextRangeCommonAncestor(mStartParent);
+  nsINode* ancestor = GetNextRangeCommonAncestor(mStartContainer);
   while (ancestor) {
     RangeHashTable* ranges =
       static_cast<RangeHashTable*>(ancestor->GetProperty(nsGkAtoms::range));
     if (ranges->GetEntry(this)) {
       break;
     }
     ancestor = GetNextRangeCommonAncestor(ancestor->GetParentNode());
   }
@@ -3352,17 +3355,17 @@ static bool ExcludeIfNextToNonSelectable
     aContent->HasFlag(NS_CREATE_FRAME_IF_NON_WHITESPACE);
 }
 
 void
 nsRange::ExcludeNonSelectableNodes(nsTArray<RefPtr<nsRange>>* aOutRanges)
 {
   MOZ_ASSERT(mIsPositioned);
   MOZ_ASSERT(mEndParent);
-  MOZ_ASSERT(mStartParent);
+  MOZ_ASSERT(mStartContainer);
 
   nsRange* range = this;
   RefPtr<nsRange> newRange;
   while (range) {
     nsCOMPtr<nsIContentIterator> iter = NS_NewPreContentIterator();
     nsresult rv = iter->Init(range);
     if (NS_FAILED(rv)) {
       return;

--- a/dom/base/nsRange.h
+++ b/dom/base/nsRange.h
@@ -70,17 +70,17 @@ public:
 
   nsINode* GetRoot() const
   {
     return mRoot;
   }
 
   nsINode* GetStartContainer() const
   {
-    return mStartParent;
+    return mStartContainer;
   }
 
   nsINode* GetEndContainer() const
   {
     return mEndParent;
   }
 
   int32_t StartOffset() const
@@ -208,17 +208,17 @@ public:
 
   // WebIDL
   static already_AddRefed<nsRange>
   Constructor(const mozilla::dom::GlobalObject& global,
               mozilla::ErrorResult& aRv);
 
   bool Collapsed() const
   {
-    return mIsPositioned && mStartParent == mEndParent &&
+    return mIsPositioned && mStartContainer == mEndParent &&
            mStartOffset == mEndOffset;
   }
   already_AddRefed<mozilla::dom::DocumentFragment>
   CreateContextualFragment(const nsAString& aString, ErrorResult& aError);
   already_AddRefed<mozilla::dom::DocumentFragment>
   CloneContents(ErrorResult& aErr);
   int16_t CompareBoundaryPoints(uint16_t aHow, nsRange& aOther,
                                 ErrorResult& aErr);
@@ -419,17 +419,17 @@ protected:
 #ifdef DEBUG
     bool mWasInSelection;
 #endif
     static bool mIsNested;
   };
 
   nsCOMPtr<nsIDocument> mOwner;
   nsCOMPtr<nsINode> mRoot;
-  nsCOMPtr<nsINode> mStartParent;
+  nsCOMPtr<nsINode> mStartContainer;
   nsCOMPtr<nsINode> mEndParent;
   RefPtr<mozilla::dom::Selection> mSelection;
   int32_t mStartOffset;
   int32_t mEndOffset;
 
   bool mIsPositioned : 1;
   bool mMaySpanAnonymousSubtrees : 1;
   bool mIsGenerated : 1;

--- a/editor/libeditor/EditorBase.cpp
+++ b/editor/libeditor/EditorBase.cpp
@@ -2862,17 +2862,17 @@ EditorBase::CreateTxnForJoinNode(nsINode
     return nullptr;
   }
   return joinNodeTransaction.forget();
 }
 
 struct SavedRange final
 {
   RefPtr<Selection> mSelection;
-  nsCOMPtr<nsINode> mStartNode;
+  nsCOMPtr<nsINode> mStartContainer;
   nsCOMPtr<nsINode> mEndNode;
   int32_t mStartOffset;
   int32_t mEndOffset;
 };
 
 nsresult
 EditorBase::SplitNodeImpl(nsIContent& aExistingRightNode,
                           int32_t aOffset,
@@ -2889,17 +2889,17 @@ EditorBase::SplitNodeImpl(nsIContent& aE
     } else if (!range.mSelection) {
       // For non-normal selections, skip over the non-existing ones.
       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.mStartContainer = r->GetStartContainer();
       range.mStartOffset = r->StartOffset();
       range.mEndNode = r->GetEndContainer();
       range.mEndOffset = r->EndOffset();
 
       savedRanges.AppendElement(range);
     }
   }
 
@@ -2969,34 +2969,35 @@ EditorBase::SplitNodeImpl(nsIContent& aE
     if (shouldSetSelection &&
         range.mSelection->Type() == SelectionType::eNormal) {
       // If the editor should adjust the selection, don't bother restoring
       // the ranges for the normal selection here.
       continue;
     }
 
     // Split the selection into existing node and new node.
-    if (range.mStartNode == &aExistingRightNode) {
+    if (range.mStartContainer == &aExistingRightNode) {
       if (range.mStartOffset < aOffset) {
-        range.mStartNode = &aNewLeftNode;
+        range.mStartContainer = &aNewLeftNode;
       } else {
         range.mStartOffset -= aOffset;
       }
     }
 
     if (range.mEndNode == &aExistingRightNode) {
       if (range.mEndOffset < aOffset) {
         range.mEndNode = &aNewLeftNode;
       } else {
         range.mEndOffset -= aOffset;
       }
     }
 
     RefPtr<nsRange> newRange;
-    nsresult rv = nsRange::CreateRange(range.mStartNode, range.mStartOffset,
+    nsresult rv = nsRange::CreateRange(range.mStartContainer,
+                                       range.mStartOffset,
                                        range.mEndNode, range.mEndOffset,
                                        getter_AddRefs(newRange));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = range.mSelection->AddRange(newRange);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   if (shouldSetSelection) {
@@ -3036,29 +3037,29 @@ EditorBase::JoinNodesImpl(nsINode* aNode
     } else if (!range.mSelection) {
       // For non-normal selections, skip over the non-existing ones.
       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.mStartContainer = r->GetStartContainer();
       range.mStartOffset = r->StartOffset();
       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 &&
+      if (range.mStartContainer) {
+        if (range.mStartContainer == parent &&
             joinOffset < range.mStartOffset &&
             range.mStartOffset <= keepOffset) {
-          range.mStartNode = aNodeToJoin;
+          range.mStartContainer = aNodeToJoin;
           range.mStartOffset = firstNodeLength;
         }
         if (range.mEndNode == parent &&
             joinOffset < range.mEndOffset &&
             range.mEndOffset <= keepOffset) {
           range.mEndNode = aNodeToJoin;
           range.mEndOffset = firstNodeLength;
         }
@@ -3120,31 +3121,32 @@ EditorBase::JoinNodesImpl(nsINode* aNode
     if (shouldSetSelection &&
         range.mSelection->Type() == SelectionType::eNormal) {
       // If the editor should adjust the selection, don't bother restoring
       // the ranges for the normal selection here.
       continue;
     }
 
     // Check to see if we joined nodes where selection starts.
-    if (range.mStartNode == aNodeToJoin) {
-      range.mStartNode = aNodeToKeep;
-    } else if (range.mStartNode == aNodeToKeep) {
+    if (range.mStartContainer == aNodeToJoin) {
+      range.mStartContainer = aNodeToKeep;
+    } else if (range.mStartContainer == aNodeToKeep) {
       range.mStartOffset += firstNodeLength;
     }
 
     // Check to see if we joined nodes where selection ends.
     if (range.mEndNode == aNodeToJoin) {
       range.mEndNode = aNodeToKeep;
     } else if (range.mEndNode == aNodeToKeep) {
       range.mEndOffset += firstNodeLength;
     }
 
     RefPtr<nsRange> newRange;
-    nsresult rv = nsRange::CreateRange(range.mStartNode, range.mStartOffset,
+    nsresult rv = nsRange::CreateRange(range.mStartContainer,
+                                       range.mStartOffset,
                                        range.mEndNode, range.mEndOffset,
                                        getter_AddRefs(newRange));
     NS_ENSURE_SUCCESS(rv, rv);
     rv = range.mSelection->AddRange(newRange);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   if (shouldSetSelection) {

--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -345,21 +345,21 @@ HTMLEditRules::BeforeEdit(EditAction act
 
     // Get selection
     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->mStartContainer = selection->GetRangeAt(0)->GetStartContainer();
+    mRangeItem->mStartOffset = selection->GetRangeAt(0)->StartOffset();
     mRangeItem->endNode = selection->GetRangeAt(0)->GetEndContainer();
     mRangeItem->endOffset = selection->GetRangeAt(0)->EndOffset();
-    nsCOMPtr<nsINode> selStartNode = mRangeItem->startNode;
+    nsCOMPtr<nsINode> selStartNode = mRangeItem->mStartContainer;
     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
     mDidDeleteSelection = false;
 
@@ -512,23 +512,23 @@ HTMLEditRules::AfterEditInner(EditAction
         action == EditAction::insertBreak ||
         action == EditAction::htmlPaste ||
         action == EditAction::loadHTML) {
       rv = AdjustWhitespace(selection);
       NS_ENSURE_SUCCESS(rv, rv);
 
       // also do this for original selection endpoints.
       NS_ENSURE_STATE(mHTMLEditor);
-      NS_ENSURE_STATE(mRangeItem->startNode);
+      NS_ENSURE_STATE(mRangeItem->mStartContainer);
       NS_ENSURE_STATE(mRangeItem->endNode);
-      WSRunObject(mHTMLEditor, mRangeItem->startNode,
-                  mRangeItem->startOffset).AdjustWhitespace();
+      WSRunObject(mHTMLEditor, mRangeItem->mStartContainer,
+                  mRangeItem->mStartOffset).AdjustWhitespace();
       // we only need to handle old selection endpoint if it was different from start
-      if (mRangeItem->startNode != mRangeItem->endNode ||
-          mRangeItem->startOffset != mRangeItem->endOffset) {
+      if (mRangeItem->mStartContainer != mRangeItem->endNode ||
+          mRangeItem->mStartOffset != mRangeItem->endOffset) {
         NS_ENSURE_STATE(mHTMLEditor);
         WSRunObject(mHTMLEditor, mRangeItem->endNode,
                     mRangeItem->endOffset).AdjustWhitespace();
       }
     }
 
     // if we created a new block, make sure selection lands in it
     if (mNewBlock) {
@@ -558,21 +558,22 @@ HTMLEditRules::AfterEditInner(EditAction
       NS_ENSURE_SUCCESS(rv, rv);
       ClearCachedStyles();
     }
   }
 
   NS_ENSURE_STATE(mHTMLEditor);
 
   nsresult rv =
-    mHTMLEditor->HandleInlineSpellCheck(action, selection,
-                                        GetAsDOMNode(mRangeItem->startNode),
-                                        mRangeItem->startOffset,
-                                        rangeStartParent, rangeStartOffset,
-                                        rangeEndParent, rangeEndOffset);
+    mHTMLEditor->HandleInlineSpellCheck(
+                   action, selection,
+                   GetAsDOMNode(mRangeItem->mStartContainer),
+                   mRangeItem->mStartOffset,
+                   rangeStartParent, rangeStartOffset,
+                   rangeEndParent, rangeEndOffset);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // detect empty doc
   rv = CreateBogusNodeIfNeeded(selection);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // adjust selection HINT if needed
   if (!mDidExplicitlySetInterline) {
@@ -6109,17 +6110,18 @@ HTMLEditRules::GetParagraphFormatNodes(
     }
   }
   return NS_OK;
 }
 
 nsresult
 HTMLEditRules::BustUpInlinesAtRangeEndpoints(RangeItem& item)
 {
-  bool isCollapsed = ((item.startNode == item.endNode) && (item.startOffset == item.endOffset));
+  bool isCollapsed = item.mStartContainer == item.endNode &&
+                     item.mStartOffset == item.endOffset;
 
   nsCOMPtr<nsIContent> endInline = GetHighestInlineParent(*item.endNode);
 
   // if we have inline parents above range endpoints, split them
   if (endInline && !isCollapsed) {
     nsCOMPtr<nsINode> resultEndNode = endInline->GetParentNode();
     NS_ENSURE_STATE(mHTMLEditor);
     // item.endNode must be content if endInline isn't null
@@ -6128,29 +6130,31 @@ HTMLEditRules::BustUpInlinesAtRangeEndpo
                                  item.endOffset,
                                  EditorBase::EmptyContainers::no);
     NS_ENSURE_TRUE(resultEndOffset != -1, NS_ERROR_FAILURE);
     // reset range
     item.endNode = resultEndNode;
     item.endOffset = resultEndOffset;
   }
 
-  nsCOMPtr<nsIContent> startInline = GetHighestInlineParent(*item.startNode);
+  nsCOMPtr<nsIContent> startInline =
+    GetHighestInlineParent(*item.mStartContainer);
 
   if (startInline) {
     nsCOMPtr<nsINode> resultStartNode = startInline->GetParentNode();
     NS_ENSURE_STATE(mHTMLEditor);
     int32_t resultStartOffset =
-      mHTMLEditor->SplitNodeDeep(*startInline, *item.startNode->AsContent(),
-                                 item.startOffset,
+      mHTMLEditor->SplitNodeDeep(*startInline,
+                                 *item.mStartContainer->AsContent(),
+                                 item.mStartOffset,
                                  EditorBase::EmptyContainers::no);
     NS_ENSURE_TRUE(resultStartOffset != -1, NS_ERROR_FAILURE);
     // reset range
-    item.startNode = resultStartNode;
-    item.startOffset = resultStartOffset;
+    item.mStartContainer = resultStartNode;
+    item.mStartOffset = resultStartOffset;
   }
 
   return NS_OK;
 }
 
 nsresult
 HTMLEditRules::BustUpInlinesAtBRs(
                  nsIContent& aNode,

--- a/editor/libeditor/SelectionState.cpp
+++ b/editor/libeditor/SelectionState.cpp
@@ -227,18 +227,18 @@ RangeUpdater::SelAdjCreateNode(nsINode* 
   if (!count) {
     return NS_OK;
   }
 
   for (size_t i = 0; i < count; i++) {
     RangeItem* item = mArray[i];
     NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
 
-    if (item->startNode == aParent && item->startOffset > aPosition) {
-      item->startOffset++;
+    if (item->mStartContainer == aParent && item->mStartOffset > aPosition) {
+      item->mStartOffset++;
     }
     if (item->endNode == aParent && item->endOffset > aPosition) {
       item->endOffset++;
     }
   }
   return NS_OK;
 }
 
@@ -265,39 +265,39 @@ RangeUpdater::SelAdjDeleteNode(nsINode* 
   nsCOMPtr<nsINode> parent = aNode->GetParentNode();
   int32_t offset = parent ? parent->IndexOf(aNode) : -1;
 
   // check for range endpoints that are after aNode and in the same parent
   for (size_t i = 0; i < count; i++) {
     RangeItem* item = mArray[i];
     MOZ_ASSERT(item);
 
-    if (item->startNode == parent && item->startOffset > offset) {
-      item->startOffset--;
+    if (item->mStartContainer == parent && item->mStartOffset > offset) {
+      item->mStartOffset--;
     }
     if (item->endNode == parent && item->endOffset > offset) {
       item->endOffset--;
     }
 
     // check for range endpoints that are in aNode
-    if (item->startNode == aNode) {
-      item->startNode   = parent;
-      item->startOffset = offset;
+    if (item->mStartContainer == aNode) {
+      item->mStartContainer = parent;
+      item->mStartOffset = offset;
     }
     if (item->endNode == aNode) {
       item->endNode   = parent;
       item->endOffset = offset;
     }
 
     // check for range endpoints that are in descendants of aNode
     nsCOMPtr<nsINode> oldStart;
-    if (EditorUtils::IsDescendantOf(item->startNode, aNode)) {
-      oldStart = item->startNode;  // save for efficiency hack below.
-      item->startNode   = parent;
-      item->startOffset = offset;
+    if (EditorUtils::IsDescendantOf(item->mStartContainer, aNode)) {
+      oldStart = item->mStartContainer;  // save for efficiency hack below.
+      item->mStartContainer = parent;
+      item->mStartOffset = offset;
     }
 
     // avoid having to call IsDescendantOf() for common case of range startnode == range endnode.
     if (item->endNode == oldStart ||
         EditorUtils::IsDescendantOf(item->endNode, aNode)) {
       item->endNode   = parent;
       item->endOffset = offset;
     }
@@ -326,21 +326,21 @@ RangeUpdater::SelAdjSplitNode(nsIContent
   nsresult rv = SelAdjInsertNode(parent, offset - 1);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // next step is to check for range enpoints inside aOldRightNode
   for (size_t i = 0; i < count; i++) {
     RangeItem* item = mArray[i];
     NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
 
-    if (item->startNode == &aOldRightNode) {
-      if (item->startOffset > aOffset) {
-        item->startOffset -= aOffset;
+    if (item->mStartContainer == &aOldRightNode) {
+      if (item->mStartOffset > aOffset) {
+        item->mStartOffset -= aOffset;
       } else {
-        item->startNode = aNewLeftNode;
+        item->mStartContainer = aNewLeftNode;
       }
     }
     if (item->endNode == &aOldRightNode) {
       if (item->endOffset > aOffset) {
         item->endOffset -= aOffset;
       } else {
         item->endNode = aNewLeftNode;
       }
@@ -364,31 +364,31 @@ RangeUpdater::SelAdjJoinNodes(nsINode& a
   if (!count) {
     return NS_OK;
   }
 
   for (size_t i = 0; i < count; i++) {
     RangeItem* item = mArray[i];
     NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
 
-    if (item->startNode == &aParent) {
+    if (item->mStartContainer == &aParent) {
       // adjust start point in aParent
-      if (item->startOffset > aOffset) {
-        item->startOffset--;
-      } else if (item->startOffset == aOffset) {
+      if (item->mStartOffset > aOffset) {
+        item->mStartOffset--;
+      } else if (item->mStartOffset == aOffset) {
         // join keeps right hand node
-        item->startNode = &aRightNode;
-        item->startOffset = aOldLeftNodeLength;
+        item->mStartContainer = &aRightNode;
+        item->mStartOffset = aOldLeftNodeLength;
       }
-    } else if (item->startNode == &aRightNode) {
+    } else if (item->mStartContainer == &aRightNode) {
       // adjust start point in aRightNode
-      item->startOffset += aOldLeftNodeLength;
-    } else if (item->startNode == &aLeftNode) {
+      item->mStartOffset += aOldLeftNodeLength;
+    } else if (item->mStartContainer == &aLeftNode) {
       // adjust start point in aLeftNode
-      item->startNode = &aRightNode;
+      item->mStartContainer = &aRightNode;
     }
 
     if (item->endNode == &aParent) {
       // adjust end point in aParent
       if (item->endOffset > aOffset) {
         item->endOffset--;
       } else if (item->endOffset == aOffset) {
         // join keeps right hand node
@@ -422,18 +422,18 @@ RangeUpdater::SelAdjInsertText(Text& aTe
     return;
   }
 
   size_t len = aString.Length();
   for (size_t i = 0; i < count; i++) {
     RangeItem* item = mArray[i];
     MOZ_ASSERT(item);
 
-    if (item->startNode == &aTextNode && item->startOffset > aOffset) {
-      item->startOffset += len;
+    if (item->mStartContainer == &aTextNode && item->mStartOffset > aOffset) {
+      item->mStartOffset += len;
     }
     if (item->endNode == &aTextNode && item->endOffset > aOffset) {
       item->endOffset += len;
     }
   }
   return;
 }
 
@@ -452,20 +452,20 @@ RangeUpdater::SelAdjDeleteText(nsIConten
     return NS_OK;
   }
   NS_ENSURE_TRUE(aTextNode, NS_ERROR_NULL_POINTER);
 
   for (size_t i = 0; i < count; i++) {
     RangeItem* item = mArray[i];
     NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
 
-    if (item->startNode == aTextNode && item->startOffset > aOffset) {
-      item->startOffset -= aLength;
-      if (item->startOffset < 0) {
-        item->startOffset = 0;
+    if (item->mStartContainer == aTextNode && item->mStartOffset > aOffset) {
+      item->mStartOffset -= aLength;
+      if (item->mStartOffset < 0) {
+        item->mStartOffset = 0;
       }
     }
     if (item->endNode == aTextNode && item->endOffset > aOffset) {
       item->endOffset -= aLength;
       if (item->endOffset < 0) {
         item->endOffset = 0;
       }
     }
@@ -504,18 +504,18 @@ RangeUpdater::DidReplaceContainer(Elemen
   if (!count) {
     return NS_OK;
   }
 
   for (size_t i = 0; i < count; i++) {
     RangeItem* item = mArray[i];
     NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
 
-    if (item->startNode == aOriginalNode) {
-      item->startNode = aNewNode;
+    if (item->mStartContainer == aOriginalNode) {
+      item->mStartContainer = aNewNode;
     }
     if (item->endNode == aOriginalNode) {
       item->endNode = aNewNode;
     }
   }
   return NS_OK;
 }
 
@@ -543,21 +543,22 @@ RangeUpdater::DidRemoveContainer(nsINode
   if (!count) {
     return NS_OK;
   }
 
   for (size_t i = 0; i < count; i++) {
     RangeItem* item = mArray[i];
     NS_ENSURE_TRUE(item, NS_ERROR_NULL_POINTER);
 
-    if (item->startNode == aNode) {
-      item->startNode = aParent;
-      item->startOffset += aOffset;
-    } else if (item->startNode == aParent && item->startOffset > aOffset) {
-      item->startOffset += (int32_t)aNodeOrigLen - 1;
+    if (item->mStartContainer == aNode) {
+      item->mStartContainer = aParent;
+      item->mStartOffset += aOffset;
+    } else if (item->mStartContainer == aParent &&
+               item->mStartOffset > aOffset) {
+      item->mStartOffset += (int32_t)aNodeOrigLen - 1;
     }
 
     if (item->endNode == aNode) {
       item->endNode = aParent;
       item->endOffset += aOffset;
     } else if (item->endNode == aParent && item->endOffset > aOffset) {
       item->endOffset += (int32_t)aNodeOrigLen - 1;
     }
@@ -609,26 +610,28 @@ RangeUpdater::DidMoveNode(nsINode* aOldP
   NS_ENSURE_TRUE_VOID(mLock);
   mLock = false;
 
   for (size_t i = 0, count = mArray.Length(); i < count; ++i) {
     RangeItem* item = mArray[i];
     NS_ENSURE_TRUE_VOID(item);
 
     // like a delete in aOldParent
-    if (item->startNode == aOldParent && item->startOffset > aOldOffset) {
-      item->startOffset--;
+    if (item->mStartContainer == aOldParent &&
+        item->mStartOffset > aOldOffset) {
+      item->mStartOffset--;
     }
     if (item->endNode == aOldParent && item->endOffset > aOldOffset) {
       item->endOffset--;
     }
 
     // and like an insert in aNewParent
-    if (item->startNode == aNewParent && item->startOffset > aNewOffset) {
-      item->startOffset++;
+    if (item->mStartContainer == aNewParent &&
+        item->mStartOffset > aNewOffset) {
+      item->mStartOffset++;
     }
     if (item->endNode == aNewParent && item->endOffset > aNewOffset) {
       item->endOffset++;
     }
   }
 }
 
 /******************************************************************************
@@ -640,34 +643,34 @@ RangeUpdater::DidMoveNode(nsINode* aOldP
 RangeItem::RangeItem()
 {
 }
 
 RangeItem::~RangeItem()
 {
 }
 
-NS_IMPL_CYCLE_COLLECTION(RangeItem, startNode, endNode)
+NS_IMPL_CYCLE_COLLECTION(RangeItem, mStartContainer, endNode)
 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(RangeItem, AddRef)
 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(RangeItem, Release)
 
 void
 RangeItem::StoreRange(nsRange* aRange)
 {
   MOZ_ASSERT(aRange);
-  startNode = aRange->GetStartContainer();
-  startOffset = aRange->StartOffset();
+  mStartContainer = aRange->GetStartContainer();
+  mStartOffset = aRange->StartOffset();
   endNode = aRange->GetEndContainer();
   endOffset = aRange->EndOffset();
 }
 
 already_AddRefed<nsRange>
 RangeItem::GetRange()
 {
-  RefPtr<nsRange> range = new nsRange(startNode);
-  if (NS_FAILED(range->SetStartAndEnd(startNode, startOffset,
+  RefPtr<nsRange> range = new nsRange(mStartContainer);
+  if (NS_FAILED(range->SetStartAndEnd(mStartContainer, mStartOffset,
                                       endNode, endOffset))) {
     return nullptr;
   }
   return range.forget();
 }
 
 } // namespace mozilla

--- a/editor/libeditor/SelectionState.h
+++ b/editor/libeditor/SelectionState.h
@@ -35,18 +35,18 @@ private:
 
 public:
   void StoreRange(nsRange* aRange);
   already_AddRefed<nsRange> GetRange();
 
   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(RangeItem)
   NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(RangeItem)
 
-  nsCOMPtr<nsINode> startNode;
-  int32_t startOffset;
+  nsCOMPtr<nsINode> mStartContainer;
+  int32_t mStartOffset;
   nsCOMPtr<nsINode> endNode;
   int32_t endOffset;
 };
 
 /**
  * mozilla::SelectionState
  *
  * Class for recording selection info.  Stores selection as collection of
@@ -186,47 +186,47 @@ public:
   AutoTrackDOMPoint(RangeUpdater& aRangeUpdater,
                     nsCOMPtr<nsINode>* aNode, int32_t* aOffset)
     : mRangeUpdater(aRangeUpdater)
     , mNode(aNode)
     , mDOMNode(nullptr)
     , mOffset(aOffset)
   {
     mRangeItem = new RangeItem();
-    mRangeItem->startNode = *mNode;
+    mRangeItem->mStartContainer = *mNode;
     mRangeItem->endNode = *mNode;
-    mRangeItem->startOffset = *mOffset;
+    mRangeItem->mStartOffset = *mOffset;
     mRangeItem->endOffset = *mOffset;
     mRangeUpdater.RegisterRangeItem(mRangeItem);
   }
 
   AutoTrackDOMPoint(RangeUpdater& aRangeUpdater,
                     nsCOMPtr<nsIDOMNode>* aNode, int32_t* aOffset)
     : mRangeUpdater(aRangeUpdater)
     , mNode(nullptr)
     , mDOMNode(aNode)
     , mOffset(aOffset)
   {
     mRangeItem = new RangeItem();
-    mRangeItem->startNode = do_QueryInterface(*mDOMNode);
+    mRangeItem->mStartContainer = do_QueryInterface(*mDOMNode);
     mRangeItem->endNode = do_QueryInterface(*mDOMNode);
-    mRangeItem->startOffset = *mOffset;
+    mRangeItem->mStartOffset = *mOffset;
     mRangeItem->endOffset = *mOffset;
     mRangeUpdater.RegisterRangeItem(mRangeItem);
   }
 
   ~AutoTrackDOMPoint()
   {
     mRangeUpdater.DropRangeItem(mRangeItem);
     if (mNode) {
-      *mNode = mRangeItem->startNode;
+      *mNode = mRangeItem->mStartContainer;
     } else {
-      *mDOMNode = GetAsDOMNode(mRangeItem->startNode);
+      *mDOMNode = GetAsDOMNode(mRangeItem->mStartContainer);
     }
-    *mOffset = mRangeItem->startOffset;
+    *mOffset = mRangeItem->mStartOffset;
   }
 };
 
 /**
  * Another helper class for SelectionState.  Stack based class for doing
  * Will/DidReplaceContainer()
  */