Bug 1260651 part.39 Rename nsRangeUpdater to mozilla::RangeUpdater r=mccr8
authorMasayuki Nakano <masayuki@d-toybox.com>
Fri, 24 Jun 2016 15:01:40 +0900
changeset 304334 a5c1fd72f8037da86551856cd409e35a78ae6149
parent 304333 1a86560aea6ead8331c170cda41b1d114e03d1d7
child 304335 116492eeee2b32705ddb4f350ffd815d0886d936
push id79299
push usermasayuki@d-toybox.com
push dateSat, 09 Jul 2016 08:01:22 +0000
treeherdermozilla-inbound@942dac383054 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmccr8
bugs1260651
milestone50.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1260651 part.39 Rename nsRangeUpdater to mozilla::RangeUpdater r=mccr8 MozReview-Commit-ID: 8xPhGbSSOjx
editor/libeditor/DeleteNodeTransaction.cpp
editor/libeditor/DeleteNodeTransaction.h
editor/libeditor/DeleteRangeTransaction.cpp
editor/libeditor/DeleteRangeTransaction.h
editor/libeditor/DeleteTextTransaction.cpp
editor/libeditor/DeleteTextTransaction.h
editor/libeditor/SelectionState.cpp
editor/libeditor/SelectionState.h
editor/libeditor/nsEditor.h
--- a/editor/libeditor/DeleteNodeTransaction.cpp
+++ b/editor/libeditor/DeleteNodeTransaction.cpp
@@ -1,15 +1,15 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "DeleteNodeTransaction.h"
-#include "SelectionState.h" // nsRangeUpdater
+#include "SelectionState.h" // RangeUpdater
 #include "nsDebug.h"
 #include "nsEditor.h"
 #include "nsError.h"
 #include "nsAString.h"
 
 namespace mozilla {
 
 DeleteNodeTransaction::DeleteNodeTransaction()
@@ -30,17 +30,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(Delet
 NS_IMPL_ADDREF_INHERITED(DeleteNodeTransaction, EditTransactionBase)
 NS_IMPL_RELEASE_INHERITED(DeleteNodeTransaction, EditTransactionBase)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeleteNodeTransaction)
 NS_INTERFACE_MAP_END_INHERITING(EditTransactionBase)
 
 nsresult
 DeleteNodeTransaction::Init(nsEditor* aEditor,
                             nsINode* aNode,
-                            nsRangeUpdater* aRangeUpdater)
+                            RangeUpdater* aRangeUpdater)
 {
   NS_ENSURE_TRUE(aEditor && aNode, NS_ERROR_NULL_POINTER);
   mEditor = aEditor;
   mNode = aNode;
   mParent = aNode->GetParentNode();
 
   // do nothing if the node has a parent and it's read-only
   NS_ENSURE_TRUE(!mParent || mEditor->IsModifiableNode(mParent),
--- a/editor/libeditor/DeleteNodeTransaction.h
+++ b/editor/libeditor/DeleteNodeTransaction.h
@@ -10,32 +10,33 @@
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsIContent.h"
 #include "nsINode.h"
 #include "nsISupportsImpl.h"
 #include "nscore.h"
 
 class nsEditor;
-class nsRangeUpdater;
 
 namespace mozilla {
 
+class RangeUpdater;
+
 /**
  * A transaction that deletes a single element
  */
 class DeleteNodeTransaction final : public EditTransactionBase
 {
 public:
   /**
    * Initialize the transaction.
    * @param aElement        The node to delete.
    */
   nsresult Init(nsEditor* aEditor, nsINode* aNode,
-                nsRangeUpdater* aRangeUpdater);
+                RangeUpdater* aRangeUpdater);
 
   DeleteNodeTransaction();
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DeleteNodeTransaction,
                                            EditTransactionBase)
 
   NS_DECL_EDITTRANSACTIONBASE
@@ -53,14 +54,14 @@ protected:
 
   // Next sibling to remember for undo/redo purposes.
   nsCOMPtr<nsIContent> mRefNode;
 
   // The editor for this transaction.
   nsEditor* mEditor;
 
   // Range updater object.
-  nsRangeUpdater* mRangeUpdater;
+  RangeUpdater* mRangeUpdater;
 };
 
 } // namespace mozilla
 
 #endif // #ifndef DeleteNodeTransaction_h
--- a/editor/libeditor/DeleteRangeTransaction.cpp
+++ b/editor/libeditor/DeleteRangeTransaction.cpp
@@ -36,17 +36,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(Delet
                                    mRange)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeleteRangeTransaction)
 NS_INTERFACE_MAP_END_INHERITING(EditAggregateTransaction)
 
 nsresult
 DeleteRangeTransaction::Init(nsEditor* aEditor,
                              nsRange* aRange,
-                             nsRangeUpdater* aRangeUpdater)
+                             RangeUpdater* aRangeUpdater)
 {
   MOZ_ASSERT(aEditor && aRange);
 
   mEditor = aEditor;
   mRange = aRange->CloneRange();
   mRangeUpdater = aRangeUpdater;
 
   NS_ENSURE_TRUE(mEditor->IsModifiableNode(mRange->GetStartParent()),
--- a/editor/libeditor/DeleteRangeTransaction.h
+++ b/editor/libeditor/DeleteRangeTransaction.h
@@ -11,34 +11,35 @@
 #include "nsID.h"
 #include "nsIEditor.h"
 #include "nsISupportsImpl.h"
 #include "nsRange.h"
 #include "nscore.h"
 
 class nsEditor;
 class nsINode;
-class nsRangeUpdater;
 
 namespace mozilla {
 
+class RangeUpdater;
+
 /**
  * A transaction that deletes an entire range in the content tree
  */
 class DeleteRangeTransaction final : public EditAggregateTransaction
 {
 public:
   /**
    * Initialize the transaction.
    * @param aEditor     The object providing basic editing operations.
    * @param aRange      The range to delete.
    */
   nsresult Init(nsEditor* aEditor,
                 nsRange* aRange,
-                nsRangeUpdater* aRangeUpdater);
+                RangeUpdater* aRangeUpdater);
 
   DeleteRangeTransaction();
 
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DeleteRangeTransaction,
                                            EditAggregateTransaction)
   NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
 
   NS_DECL_EDITTRANSACTIONBASE
@@ -64,14 +65,14 @@ protected:
 
   // P1 in the range.
   RefPtr<nsRange> mRange;
 
   // The editor for this transaction.
   nsEditor* mEditor;
 
   // Range updater object.
-  nsRangeUpdater* mRangeUpdater;
+  RangeUpdater* mRangeUpdater;
 };
 
 } // namespace mozilla
 
 #endif // #ifndef DeleteRangeTransaction_h
--- a/editor/libeditor/DeleteTextTransaction.cpp
+++ b/editor/libeditor/DeleteTextTransaction.cpp
@@ -18,17 +18,17 @@ namespace mozilla {
 
 using namespace dom;
 
 DeleteTextTransaction::DeleteTextTransaction(
                          nsEditor& aEditor,
                          nsGenericDOMDataNode& aCharData,
                          uint32_t aOffset,
                          uint32_t aNumCharsToDelete,
-                         nsRangeUpdater* aRangeUpdater)
+                         RangeUpdater* aRangeUpdater)
   : mEditor(aEditor)
   , mCharData(&aCharData)
   , mOffset(aOffset)
   , mNumCharsToDelete(aNumCharsToDelete)
   , mRangeUpdater(aRangeUpdater)
 {
   NS_ASSERTION(mCharData->Length() >= aOffset + aNumCharsToDelete,
                "Trying to delete more characters than in node");
--- a/editor/libeditor/DeleteTextTransaction.h
+++ b/editor/libeditor/DeleteTextTransaction.h
@@ -10,20 +10,21 @@
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsGenericDOMDataNode.h"
 #include "nsID.h"
 #include "nsString.h"
 #include "nscore.h"
 
 class nsEditor;
-class nsRangeUpdater;
 
 namespace mozilla {
 
+class RangeUpdater;
+
 /**
  * A transaction that removes text from a content node.
  */
 class DeleteTextTransaction final : public EditTransactionBase
 {
 public:
   /**
    * Initialize the transaction.
@@ -32,17 +33,17 @@ public:
    * @param aOffset             The location in aElement to begin the deletion.
    * @param aNumCharsToDelete   The number of characters to delete.  Not the
    *                            number of bytes!
    */
   DeleteTextTransaction(nsEditor& aEditor,
                         nsGenericDOMDataNode& aCharData,
                         uint32_t aOffset,
                         uint32_t aNumCharsToDelete,
-                        nsRangeUpdater* aRangeUpdater);
+                        RangeUpdater* aRangeUpdater);
 
   nsresult Init();
 
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DeleteTextTransaction,
                                            EditTransactionBase)
   NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
 
   NS_DECL_EDITTRANSACTIONBASE
@@ -63,14 +64,14 @@ protected:
 
   // The number of characters to delete.
   uint32_t mNumCharsToDelete;
 
   // The text that was deleted.
   nsString mDeletedText;
 
   // Range updater object.
-  nsRangeUpdater* mRangeUpdater;
+  RangeUpdater* mRangeUpdater;
 };
 
 } // namespace mozilla
 
 #endif // #ifndef DeleteTextTransaction_h
--- a/editor/libeditor/SelectionState.cpp
+++ b/editor/libeditor/SelectionState.cpp
@@ -132,83 +132,84 @@ SelectionState::MakeEmpty()
 }
 
 bool
 SelectionState::IsEmpty()
 {
   return mArray.IsEmpty();
 }
 
-} // namespace mozilla
-
-using namespace mozilla;
-using namespace mozilla::dom;
+/******************************************************************************
+ * mozilla::RangeUpdater
+ *
+ * Class for updating nsRanges in response to editor actions.
+ ******************************************************************************/
 
-/***************************************************************************
- * nsRangeUpdater:  class for updating nsRanges in response to editor actions.
- */
+RangeUpdater::RangeUpdater()
+  : mLock(false)
+{
+}
 
-nsRangeUpdater::nsRangeUpdater() : mArray(), mLock(false) {}
-
-nsRangeUpdater::~nsRangeUpdater()
+RangeUpdater::~RangeUpdater()
 {
   // nothing to do, we don't own the items in our array.
 }
 
 void
-nsRangeUpdater::RegisterRangeItem(RangeItem* aRangeItem)
+RangeUpdater::RegisterRangeItem(RangeItem* aRangeItem)
 {
   if (!aRangeItem) return;
   if (mArray.Contains(aRangeItem))
   {
     NS_ERROR("tried to register an already registered range");
     return;  // don't register it again.  It would get doubly adjusted.
   }
   mArray.AppendElement(aRangeItem);
 }
 
 void
-nsRangeUpdater::DropRangeItem(RangeItem* aRangeItem)
+RangeUpdater::DropRangeItem(RangeItem* aRangeItem)
 {
   if (!aRangeItem) return;
   mArray.RemoveElement(aRangeItem);
 }
 
 nsresult
-nsRangeUpdater::RegisterSelectionState(SelectionState& aSelState)
+RangeUpdater::RegisterSelectionState(SelectionState& aSelState)
 {
   uint32_t i, theCount = aSelState.mArray.Length();
   if (theCount < 1) return NS_ERROR_FAILURE;
 
   for (i=0; i<theCount; i++)
   {
     RegisterRangeItem(aSelState.mArray[i]);
   }
 
   return NS_OK;
 }
 
 nsresult
-nsRangeUpdater::DropSelectionState(SelectionState& aSelState)
+RangeUpdater::DropSelectionState(SelectionState& aSelState)
 {
   uint32_t i, theCount = aSelState.mArray.Length();
   if (theCount < 1) return NS_ERROR_FAILURE;
 
   for (i=0; i<theCount; i++)
   {
     DropRangeItem(aSelState.mArray[i]);
   }
 
   return NS_OK;
 }
 
 // gravity methods:
 
 nsresult
-nsRangeUpdater::SelAdjCreateNode(nsINode* aParent, int32_t aPosition)
+RangeUpdater::SelAdjCreateNode(nsINode* aParent,
+                               int32_t aPosition)
 {
   if (mLock) {
     // lock set by Will/DidReplaceParent, etc...
     return NS_OK;
   }
   NS_ENSURE_TRUE(aParent, NS_ERROR_NULL_POINTER);
   uint32_t count = mArray.Length();
   if (!count) {
@@ -225,36 +226,39 @@ nsRangeUpdater::SelAdjCreateNode(nsINode
     if (item->endNode == aParent && item->endOffset > aPosition) {
       item->endOffset++;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsRangeUpdater::SelAdjCreateNode(nsIDOMNode* aParent, int32_t aPosition)
+RangeUpdater::SelAdjCreateNode(nsIDOMNode* aParent,
+                               int32_t aPosition)
 {
   nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
   return SelAdjCreateNode(parent, aPosition);
 }
 
 nsresult
-nsRangeUpdater::SelAdjInsertNode(nsINode* aParent, int32_t aPosition)
+RangeUpdater::SelAdjInsertNode(nsINode* aParent,
+                               int32_t aPosition)
 {
   return SelAdjCreateNode(aParent, aPosition);
 }
 
 nsresult
-nsRangeUpdater::SelAdjInsertNode(nsIDOMNode *aParent, int32_t aPosition)
+RangeUpdater::SelAdjInsertNode(nsIDOMNode* aParent,
+                               int32_t aPosition)
 {
   return SelAdjCreateNode(aParent, aPosition);
 }
 
 void
-nsRangeUpdater::SelAdjDeleteNode(nsINode* aNode)
+RangeUpdater::SelAdjDeleteNode(nsINode* aNode)
 {
   if (mLock) {
     // lock set by Will/DidReplaceParent, etc...
     return;
   }
   MOZ_ASSERT(aNode);
   uint32_t count = mArray.Length();
   if (!count) {
@@ -300,27 +304,27 @@ nsRangeUpdater::SelAdjDeleteNode(nsINode
     {
       item->endNode   = parent;
       item->endOffset = offset;
     }
   }
 }
 
 void
-nsRangeUpdater::SelAdjDeleteNode(nsIDOMNode *aNode)
+RangeUpdater::SelAdjDeleteNode(nsIDOMNode* aNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_TRUE(node, );
   return SelAdjDeleteNode(node);
 }
 
-
 nsresult
-nsRangeUpdater::SelAdjSplitNode(nsIContent& aOldRightNode, int32_t aOffset,
-                                nsIContent* aNewLeftNode)
+RangeUpdater::SelAdjSplitNode(nsIContent& aOldRightNode,
+                              int32_t aOffset,
+                              nsIContent* aNewLeftNode)
 {
   if (mLock) {
     // lock set by Will/DidReplaceParent, etc...
     return NS_OK;
   }
   NS_ENSURE_TRUE(aNewLeftNode, NS_ERROR_NULL_POINTER);
   uint32_t count = mArray.Length();
   if (!count) {
@@ -353,21 +357,21 @@ nsRangeUpdater::SelAdjSplitNode(nsIConte
         item->endNode = aNewLeftNode;
       }
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsRangeUpdater::SelAdjJoinNodes(nsINode& aLeftNode,
-                                nsINode& aRightNode,
-                                nsINode& aParent,
-                                int32_t aOffset,
-                                int32_t aOldLeftNodeLength)
+RangeUpdater::SelAdjJoinNodes(nsINode& aLeftNode,
+                              nsINode& aRightNode,
+                              nsINode& aParent,
+                              int32_t aOffset,
+                              int32_t aOldLeftNodeLength)
 {
   if (mLock) {
     // lock set by Will/DidReplaceParent, etc...
     return NS_OK;
   }
   uint32_t count = mArray.Length();
   if (!count) {
     return NS_OK;
@@ -410,20 +414,20 @@ nsRangeUpdater::SelAdjJoinNodes(nsINode&
       // adjust end point in aLeftNode
       item->endNode = &aRightNode;
     }
   }
 
   return NS_OK;
 }
 
-
 void
-nsRangeUpdater::SelAdjInsertText(Text& aTextNode, int32_t aOffset,
-                                 const nsAString& aString)
+RangeUpdater::SelAdjInsertText(Text& aTextNode,
+                               int32_t aOffset,
+                               const nsAString& aString)
 {
   if (mLock) {
     // lock set by Will/DidReplaceParent, etc...
     return;
   }
 
   uint32_t count = mArray.Length();
   if (!count) {
@@ -441,18 +445,19 @@ nsRangeUpdater::SelAdjInsertText(Text& a
     if (item->endNode == &aTextNode && item->endOffset > aOffset) {
       item->endOffset += len;
     }
   }
   return;
 }
 
 nsresult
-nsRangeUpdater::SelAdjDeleteText(nsIContent* aTextNode, int32_t aOffset,
-                                 int32_t aLength)
+RangeUpdater::SelAdjDeleteText(nsIContent* aTextNode,
+                               int32_t aOffset,
+                               int32_t aLength)
 {
   if (mLock) {
     // lock set by Will/DidReplaceParent, etc...
     return NS_OK;
   }
 
   uint32_t count = mArray.Length();
   if (!count) {
@@ -476,35 +481,35 @@ nsRangeUpdater::SelAdjDeleteText(nsICont
         item->endOffset = 0;
       }
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsRangeUpdater::SelAdjDeleteText(nsIDOMCharacterData* aTextNode,
-                                 int32_t aOffset, int32_t aLength)
+RangeUpdater::SelAdjDeleteText(nsIDOMCharacterData* aTextNode,
+                               int32_t aOffset,
+                               int32_t aLength)
 {
   nsCOMPtr<nsIContent> textNode = do_QueryInterface(aTextNode);
   return SelAdjDeleteText(textNode, aOffset, aLength);
 }
 
-
 nsresult
-nsRangeUpdater::WillReplaceContainer()
+RangeUpdater::WillReplaceContainer()
 {
   if (mLock) return NS_ERROR_UNEXPECTED;
   mLock = true;
   return NS_OK;
 }
 
-
 nsresult
-nsRangeUpdater::DidReplaceContainer(Element* aOriginalNode, Element* aNewNode)
+RangeUpdater::DidReplaceContainer(Element* aOriginalNode,
+                                  Element* aNewNode)
 {
   NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
   mLock = false;
 
   NS_ENSURE_TRUE(aOriginalNode && aNewNode, NS_ERROR_NULL_POINTER);
   uint32_t count = mArray.Length();
   if (!count) {
     return NS_OK;
@@ -519,29 +524,29 @@ nsRangeUpdater::DidReplaceContainer(Elem
     }
     if (item->endNode == aOriginalNode) {
       item->endNode = aNewNode;
     }
   }
   return NS_OK;
 }
 
-
 nsresult
-nsRangeUpdater::WillRemoveContainer()
+RangeUpdater::WillRemoveContainer()
 {
   if (mLock) return NS_ERROR_UNEXPECTED;
   mLock = true;
   return NS_OK;
 }
 
-
 nsresult
-nsRangeUpdater::DidRemoveContainer(nsINode* aNode, nsINode* aParent,
-                                   int32_t aOffset, uint32_t aNodeOrigLen)
+RangeUpdater::DidRemoveContainer(nsINode* aNode,
+                                 nsINode* aParent,
+                                 int32_t aOffset,
+                                 uint32_t aNodeOrigLen)
 {
   NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
   mLock = false;
 
   NS_ENSURE_TRUE(aNode && aParent, NS_ERROR_NULL_POINTER);
   uint32_t count = mArray.Length();
   if (!count) {
     return NS_OK;
@@ -564,52 +569,50 @@ nsRangeUpdater::DidRemoveContainer(nsINo
     } else if (item->endNode == aParent && item->endOffset > aOffset) {
       item->endOffset += (int32_t)aNodeOrigLen - 1;
     }
   }
   return NS_OK;
 }
 
 nsresult
-nsRangeUpdater::DidRemoveContainer(nsIDOMNode* aNode, nsIDOMNode* aParent,
-                                   int32_t aOffset, uint32_t aNodeOrigLen)
+RangeUpdater::DidRemoveContainer(nsIDOMNode* aNode,
+                                 nsIDOMNode* aParent,
+                                 int32_t aOffset,
+                                 uint32_t aNodeOrigLen)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
   return DidRemoveContainer(node, parent, aOffset, aNodeOrigLen);
 }
 
-
 nsresult
-nsRangeUpdater::WillInsertContainer()
+RangeUpdater::WillInsertContainer()
 {
   if (mLock) return NS_ERROR_UNEXPECTED;
   mLock = true;
   return NS_OK;
 }
 
-
 nsresult
-nsRangeUpdater::DidInsertContainer()
+RangeUpdater::DidInsertContainer()
 {
   NS_ENSURE_TRUE(mLock, NS_ERROR_UNEXPECTED);
   mLock = false;
   return NS_OK;
 }
 
-
 void
-nsRangeUpdater::WillMoveNode()
+RangeUpdater::WillMoveNode()
 {
   mLock = true;
 }
 
-
 void
-nsRangeUpdater::DidMoveNode(nsINode* aOldParent, int32_t aOldOffset,
+RangeUpdater::DidMoveNode(nsINode* aOldParent, int32_t aOldOffset,
                             nsINode* aNewParent, int32_t aNewOffset)
 {
   MOZ_ASSERT(aOldParent);
   MOZ_ASSERT(aNewParent);
   NS_ENSURE_TRUE_VOID(mLock);
   mLock = false;
 
   for (uint32_t i = 0, count = mArray.Length(); i < count; ++i) {
@@ -629,18 +632,16 @@ nsRangeUpdater::DidMoveNode(nsINode* aOl
       item->startOffset++;
     }
     if (item->endNode == aNewParent && item->endOffset > aNewOffset) {
       item->endOffset++;
     }
   }
 }
 
-namespace mozilla {
-
 /******************************************************************************
  * mozilla::RangeItem
  *
  * Helper struct for SelectionState.  This stores range endpoints.
  ******************************************************************************/
 
 RangeItem::RangeItem()
 {
--- a/editor/libeditor/SelectionState.h
+++ b/editor/libeditor/SelectionState.h
@@ -10,18 +10,18 @@
 #include "nsIDOMNode.h"
 #include "nsINode.h"
 #include "nsTArray.h"
 #include "nscore.h"
 
 class nsCycleCollectionTraversalCallback;
 class nsIDOMCharacterData;
 class nsRange;
-class nsRangeUpdater;
 namespace mozilla {
+class RangeUpdater;
 namespace dom {
 class Selection;
 class Text;
 } // namespace dom
 
 /**
  * A helper struct for saving/setting ranges.
  */
@@ -64,17 +64,17 @@ public:
   nsresult RestoreSelection(dom::Selection* aSel);
   bool IsCollapsed();
   bool IsEqual(SelectionState *aSelState);
   void MakeEmpty();
   bool IsEmpty();
 private:
   nsTArray<RefPtr<RangeItem>> mArray;
 
-  friend class nsRangeUpdater;
+  friend class RangeUpdater;
   friend void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback&,
                                           SelectionState&,
                                           const char*,
                                           uint32_t);
   friend void ImplCycleCollectionUnlink(SelectionState&);
 };
 
 inline void
@@ -87,124 +87,127 @@ ImplCycleCollectionTraverse(nsCycleColle
 }
 
 inline void
 ImplCycleCollectionUnlink(SelectionState& aField)
 {
   ImplCycleCollectionUnlink(aField.mArray);
 }
 
-} // namespace mozilla
-
-class nsRangeUpdater
+class RangeUpdater final
 {
-  public:
+public:
+  RangeUpdater();
+  ~RangeUpdater();
 
-    nsRangeUpdater();
-    ~nsRangeUpdater();
-
-    void RegisterRangeItem(mozilla::RangeItem* aRangeItem);
-    void DropRangeItem(mozilla::RangeItem* aRangeItem);
-    nsresult RegisterSelectionState(mozilla::SelectionState& aSelState);
-    nsresult DropSelectionState(mozilla::SelectionState& aSelState);
+  void RegisterRangeItem(RangeItem* aRangeItem);
+  void DropRangeItem(RangeItem* aRangeItem);
+  nsresult RegisterSelectionState(SelectionState& aSelState);
+  nsresult DropSelectionState(SelectionState& aSelState);
 
-    // editor selection gravity routines.  Note that we can't always depend on
-    // DOM Range gravity to do what we want to the "real" selection.  For instance,
-    // if you move a node, that corresponds to deleting it and reinserting it.
-    // DOM Range gravity will promote the selection out of the node on deletion,
-    // which is not what you want if you know you are reinserting it.
-    nsresult SelAdjCreateNode(nsINode* aParent, int32_t aPosition);
-    nsresult SelAdjCreateNode(nsIDOMNode *aParent, int32_t aPosition);
-    nsresult SelAdjInsertNode(nsINode* aParent, int32_t aPosition);
-    nsresult SelAdjInsertNode(nsIDOMNode *aParent, int32_t aPosition);
-    void     SelAdjDeleteNode(nsINode* aNode);
-    void     SelAdjDeleteNode(nsIDOMNode *aNode);
-    nsresult SelAdjSplitNode(nsIContent& aOldRightNode, int32_t aOffset,
-                             nsIContent* aNewLeftNode);
-    nsresult SelAdjJoinNodes(nsINode& aLeftNode,
-                             nsINode& aRightNode,
-                             nsINode& aParent,
-                             int32_t aOffset,
-                             int32_t aOldLeftNodeLength);
-    void     SelAdjInsertText(mozilla::dom::Text& aTextNode, int32_t aOffset,
-                              const nsAString &aString);
-    nsresult SelAdjDeleteText(nsIContent* aTextNode, int32_t aOffset,
-                              int32_t aLength);
-    nsresult SelAdjDeleteText(nsIDOMCharacterData *aTextNode, int32_t aOffset, int32_t aLength);
-    // the following gravity routines need will/did sandwiches, because the other gravity
-    // routines will be called inside of these sandwiches, but should be ignored.
-    nsresult WillReplaceContainer();
-    nsresult DidReplaceContainer(mozilla::dom::Element* aOriginalNode,
-                                 mozilla::dom::Element* aNewNode);
-    nsresult WillRemoveContainer();
-    nsresult DidRemoveContainer(nsINode* aNode, nsINode* aParent,
-                                int32_t aOffset, uint32_t aNodeOrigLen);
-    nsresult DidRemoveContainer(nsIDOMNode *aNode, nsIDOMNode *aParent, int32_t aOffset, uint32_t aNodeOrigLen);
-    nsresult WillInsertContainer();
-    nsresult DidInsertContainer();
-    void WillMoveNode();
-    void DidMoveNode(nsINode* aOldParent, int32_t aOldOffset,
-                     nsINode* aNewParent, int32_t aNewOffset);
-  private:
-    friend void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback&,
-                                            nsRangeUpdater&,
-                                            const char*,
-                                            uint32_t);
-    friend void ImplCycleCollectionUnlink(nsRangeUpdater& aField);
+  // editor selection gravity routines.  Note that we can't always depend on
+  // DOM Range gravity to do what we want to the "real" selection.  For instance,
+  // if you move a node, that corresponds to deleting it and reinserting it.
+  // DOM Range gravity will promote the selection out of the node on deletion,
+  // which is not what you want if you know you are reinserting it.
+  nsresult SelAdjCreateNode(nsINode* aParent, int32_t aPosition);
+  nsresult SelAdjCreateNode(nsIDOMNode* aParent, int32_t aPosition);
+  nsresult SelAdjInsertNode(nsINode* aParent, int32_t aPosition);
+  nsresult SelAdjInsertNode(nsIDOMNode* aParent, int32_t aPosition);
+  void SelAdjDeleteNode(nsINode* aNode);
+  void SelAdjDeleteNode(nsIDOMNode* aNode);
+  nsresult SelAdjSplitNode(nsIContent& aOldRightNode, int32_t aOffset,
+                           nsIContent* aNewLeftNode);
+  nsresult SelAdjJoinNodes(nsINode& aLeftNode,
+                           nsINode& aRightNode,
+                           nsINode& aParent,
+                           int32_t aOffset,
+                           int32_t aOldLeftNodeLength);
+  void SelAdjInsertText(dom::Text& aTextNode, int32_t aOffset,
+                        const nsAString &aString);
+  nsresult SelAdjDeleteText(nsIContent* aTextNode, int32_t aOffset,
+                            int32_t aLength);
+  nsresult SelAdjDeleteText(nsIDOMCharacterData* aTextNode,
+                            int32_t aOffset, int32_t aLength);
+  // the following gravity routines need will/did sandwiches, because the other
+  // gravity routines will be called inside of these sandwiches, but should be
+  // ignored.
+  nsresult WillReplaceContainer();
+  nsresult DidReplaceContainer(dom::Element* aOriginalNode,
+                               dom::Element* aNewNode);
+  nsresult WillRemoveContainer();
+  nsresult DidRemoveContainer(nsINode* aNode, nsINode* aParent,
+                              int32_t aOffset, uint32_t aNodeOrigLen);
+  nsresult DidRemoveContainer(nsIDOMNode* aNode, nsIDOMNode* aParent,
+                              int32_t aOffset, uint32_t aNodeOrigLen);
+  nsresult WillInsertContainer();
+  nsresult DidInsertContainer();
+  void WillMoveNode();
+  void DidMoveNode(nsINode* aOldParent, int32_t aOldOffset,
+                   nsINode* aNewParent, int32_t aNewOffset);
 
-    nsTArray<RefPtr<mozilla::RangeItem>> mArray;
-    bool mLock;
+private:
+  friend void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback&,
+                                          RangeUpdater&,
+                                          const char*,
+                                          uint32_t);
+  friend void ImplCycleCollectionUnlink(RangeUpdater& aField);
+
+  nsTArray<RefPtr<RangeItem>> mArray;
+  bool mLock;
 };
 
 inline void
 ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            nsRangeUpdater& aField,
+                            RangeUpdater& aField,
                             const char* aName,
                             uint32_t aFlags = 0)
 {
   ImplCycleCollectionTraverse(aCallback, aField.mArray, aName, aFlags);
 }
 
 inline void
-ImplCycleCollectionUnlink(nsRangeUpdater& aField)
+ImplCycleCollectionUnlink(RangeUpdater& aField)
 {
   ImplCycleCollectionUnlink(aField.mArray);
 }
 
+} // namespace mozilla
+
 /***************************************************************************
  * helper class for using SelectionState.  stack based class for doing
  * preservation of dom points across editor actions
  */
 
 class MOZ_STACK_CLASS nsAutoTrackDOMPoint
 {
   private:
-    nsRangeUpdater &mRU;
+    mozilla::RangeUpdater& mRU;
     // Allow tracking either nsIDOMNode or nsINode until nsIDOMNode is gone
     nsCOMPtr<nsINode>* mNode;
     nsCOMPtr<nsIDOMNode>* mDOMNode;
     int32_t* mOffset;
     RefPtr<mozilla::RangeItem> mRangeItem;
   public:
-    nsAutoTrackDOMPoint(nsRangeUpdater &aRangeUpdater,
+    nsAutoTrackDOMPoint(mozilla::RangeUpdater& aRangeUpdater,
                         nsCOMPtr<nsINode>* aNode, int32_t* aOffset)
       : mRU(aRangeUpdater)
       , mNode(aNode)
       , mDOMNode(nullptr)
       , mOffset(aOffset)
     {
       mRangeItem = new mozilla::RangeItem();
       mRangeItem->startNode = *mNode;
       mRangeItem->endNode = *mNode;
       mRangeItem->startOffset = *mOffset;
       mRangeItem->endOffset = *mOffset;
       mRU.RegisterRangeItem(mRangeItem);
     }
 
-    nsAutoTrackDOMPoint(nsRangeUpdater &aRangeUpdater,
+    nsAutoTrackDOMPoint(mozilla::RangeUpdater& aRangeUpdater,
                         nsCOMPtr<nsIDOMNode>* aNode, int32_t* aOffset)
       : mRU(aRangeUpdater)
       , mNode(nullptr)
       , mDOMNode(aNode)
       , mOffset(aOffset)
     {
       mRangeItem = new mozilla::RangeItem();
       mRangeItem->startNode = do_QueryInterface(*mDOMNode);
@@ -233,22 +236,22 @@ class MOZ_STACK_CLASS nsAutoTrackDOMPoin
  * Will/DidReplaceContainer()
  */
 
 namespace mozilla {
 namespace dom {
 class MOZ_STACK_CLASS AutoReplaceContainerSelNotify
 {
   private:
-    nsRangeUpdater &mRU;
+    RangeUpdater& mRU;
     Element* mOriginalElement;
     Element* mNewElement;
 
   public:
-    AutoReplaceContainerSelNotify(nsRangeUpdater& aRangeUpdater,
+    AutoReplaceContainerSelNotify(RangeUpdater& aRangeUpdater,
                                   Element* aOriginalElement,
                                   Element* aNewElement)
       : mRU(aRangeUpdater)
       , mOriginalElement(aOriginalElement)
       , mNewElement(aNewElement)
     {
       mRU.WillReplaceContainer();
     }
@@ -266,24 +269,24 @@ class MOZ_STACK_CLASS AutoReplaceContain
 /***************************************************************************
  * another helper class for SelectionState.  stack based class for doing
  * Will/DidRemoveContainer()
  */
 
 class MOZ_STACK_CLASS nsAutoRemoveContainerSelNotify
 {
   private:
-    nsRangeUpdater &mRU;
+    mozilla::RangeUpdater& mRU;
     nsIDOMNode *mNode;
     nsIDOMNode *mParent;
     int32_t    mOffset;
     uint32_t   mNodeOrigLen;
 
   public:
-    nsAutoRemoveContainerSelNotify(nsRangeUpdater& aRangeUpdater,
+    nsAutoRemoveContainerSelNotify(mozilla::RangeUpdater& aRangeUpdater,
                                    nsINode* aNode,
                                    nsINode* aParent,
                                    int32_t aOffset,
                                    uint32_t aNodeOrigLen)
       : mRU(aRangeUpdater)
       , mNode(aNode->AsDOMNode())
       , mParent(aParent->AsDOMNode())
       , mOffset(aOffset)
@@ -301,20 +304,21 @@ class MOZ_STACK_CLASS nsAutoRemoveContai
 /***************************************************************************
  * another helper class for SelectionState.  stack based class for doing
  * Will/DidInsertContainer()
  */
 
 class MOZ_STACK_CLASS nsAutoInsertContainerSelNotify
 {
   private:
-    nsRangeUpdater &mRU;
+    mozilla::RangeUpdater& mRU;
 
   public:
-    explicit nsAutoInsertContainerSelNotify(nsRangeUpdater &aRangeUpdater) :
+    explicit nsAutoInsertContainerSelNotify(
+               mozilla::RangeUpdater& aRangeUpdater) :
     mRU(aRangeUpdater)
     {
       mRU.WillInsertContainer();
     }
 
     ~nsAutoInsertContainerSelNotify()
     {
       mRU.DidInsertContainer();
@@ -325,24 +329,24 @@ class MOZ_STACK_CLASS nsAutoInsertContai
 /***************************************************************************
  * another helper class for SelectionState.  stack based class for doing
  * Will/DidMoveNode()
  */
 
 class MOZ_STACK_CLASS nsAutoMoveNodeSelNotify
 {
   private:
-    nsRangeUpdater &mRU;
+    mozilla::RangeUpdater& mRU;
     nsINode* mOldParent;
     nsINode* mNewParent;
     int32_t    mOldOffset;
     int32_t    mNewOffset;
 
   public:
-    nsAutoMoveNodeSelNotify(nsRangeUpdater &aRangeUpdater,
+    nsAutoMoveNodeSelNotify(mozilla::RangeUpdater& aRangeUpdater,
                             nsINode* aOldParent,
                             int32_t aOldOffset,
                             nsINode* aNewParent,
                             int32_t aNewOffset)
       : mRU(aRangeUpdater)
       , mOldParent(aOldParent)
       , mNewParent(aNewParent)
       , mOldOffset(aOldOffset)
--- a/editor/libeditor/nsEditor.h
+++ b/editor/libeditor/nsEditor.h
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef __editor_h__
 #define __editor_h__
 
-#include "SelectionState.h"             // for nsRangeUpdater, etc
+#include "SelectionState.h"             // for RangeUpdater, etc
 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc.
 #include "mozilla/OwningNonNull.h"      // for OwningNonNull
 #include "mozilla/StyleSheetHandle.h"   // for StyleSheetHandle
 #include "mozilla/dom/Text.h"
 #include "nsCOMPtr.h"                   // for already_AddRefed, nsCOMPtr
 #include "nsCycleCollectionParticipant.h"
 #include "nsGkAtoms.h"
 #include "nsIEditor.h"                  // for nsIEditor::EDirection, etc
@@ -862,17 +862,18 @@ protected:
   nsTArray<OwningNonNull<nsIEditActionListener>> mActionListeners;
   // Just notify once per high level change
   nsTArray<OwningNonNull<nsIEditorObserver>> mEditorObservers;
   // Listen to overall doc state (dirty or not, just created, etc)
   nsTArray<OwningNonNull<nsIDocumentStateListener>> mDocStateListeners;
 
   // Cached selection for AutoSelectionRestorer.
   mozilla::SelectionState mSavedSel;
-  nsRangeUpdater    mRangeUpdater;       // utility class object for maintaining preserved ranges
+  // Utility class object for maintaining preserved ranges.
+  mozilla::RangeUpdater mRangeUpdater;
 
   uint32_t          mModCount;     // number of modifications (for undo/redo stack)
   uint32_t          mFlags;        // behavior flags. See nsIPlaintextEditor.idl for the flags we use.
 
   int32_t           mUpdateCount;
 
   int32_t           mPlaceHolderBatch;   // nesting count for batching
   EditAction        mAction;             // the current editor action
@@ -892,13 +893,13 @@ protected:
   bool mDispatchInputEvent;
   bool mIsInEditAction;   // true while the instance is handling an edit action
   bool mHidingCaret;      // whether caret is hidden forcibly.
 
   friend bool NSCanUnload(nsISupports* serviceMgr);
   friend class mozilla::AutoRules;
   friend class mozilla::AutoSelectionRestorer;
   friend class mozilla::AutoTransactionsConserveSelection;
-  friend class nsRangeUpdater;
+  friend class mozilla::RangeUpdater;
 };
 
 
 #endif