Bug 1260651 part.11 Rename nsAutoSelectionReset to mozilla::AutoSelectionRestorer r=mccr8
authorMasayuki Nakano <masayuki@d-toybox.com>
Thu, 07 Jul 2016 13:27:31 +0900
changeset 304344 ad93b01c875aff3788caebbeb22fce748b1bf65f
parent 304343 47d665ff867e017d1ac97c0e44a3b714a49aad49
child 304345 e3e7b685a8e44db5123044907a24fcea1390a7d1
push id30423
push usercbook@mozilla.com
push dateMon, 11 Jul 2016 09:47:55 +0000
treeherdermozilla-central@1bee8d2da23e [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.11 Rename nsAutoSelectionReset to mozilla::AutoSelectionRestorer r=mccr8 MozReview-Commit-ID: LA4ou7vnVXG
editor/libeditor/EditorUtils.cpp
editor/libeditor/EditorUtils.h
editor/libeditor/nsEditor.cpp
editor/libeditor/nsEditor.h
editor/libeditor/nsHTMLDataTransfer.cpp
editor/libeditor/nsHTMLEditRules.cpp
editor/libeditor/nsHTMLEditor.cpp
editor/libeditor/nsHTMLEditorStyle.cpp
editor/libeditor/nsTableEditor.cpp
--- a/editor/libeditor/EditorUtils.cpp
+++ b/editor/libeditor/EditorUtils.cpp
@@ -19,57 +19,63 @@
 #include "nsIDocument.h"
 #include "nsIInterfaceRequestorUtils.h"
 #include "nsINode.h"
 #include "nsISimpleEnumerator.h"
 
 class nsISupports;
 class nsRange;
 
-using namespace mozilla;
-using namespace mozilla::dom;
+namespace mozilla {
+
+using namespace dom;
 
 /******************************************************************************
- * nsAutoSelectionReset
+ * AutoSelectionRestorer
  *****************************************************************************/
 
-nsAutoSelectionReset::nsAutoSelectionReset(Selection* aSel, nsEditor* aEd
-                                           MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)
-  : mSel(nullptr), mEd(nullptr)
+AutoSelectionRestorer::AutoSelectionRestorer(
+                         Selection* aSelection,
+                         nsEditor* aEditor
+                         MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)
+  : mEditor(nullptr)
 {
   MOZ_GUARD_OBJECT_NOTIFIER_INIT;
-  if (!aSel || !aEd) return;    // not much we can do, bail.
-  if (aEd->ArePreservingSelection()) return;   // we already have initted mSavedSel, so this must be nested call.
-  mSel = aSel;
-  mEd = aEd;
-  if (mSel)
-  {
-    mEd->PreserveSelectionAcrossActions(mSel);
+  if (NS_WARN_IF(!aSelection) || NS_WARN_IF(!aEditor)) {
+    return;
   }
+  if (aEditor->ArePreservingSelection()) {
+    // We already have initialized mSavedSel, so this must be nested call.
+    return;
+  }
+  mSelection = aSelection;
+  mEditor = aEditor;
+  mEditor->PreserveSelectionAcrossActions(mSelection);
 }
 
-nsAutoSelectionReset::~nsAutoSelectionReset()
+AutoSelectionRestorer::~AutoSelectionRestorer()
 {
-  NS_ASSERTION(!mSel || mEd, "mEd should be non-null when mSel is");
-  if (mSel && mEd->ArePreservingSelection())   // mSel will be null if this was nested call
-  {
-    mEd->RestorePreservedSelection(mSel);
+  NS_ASSERTION(!mSelection || mEditor,
+               "mEditor should be non-null when mSelection is");
+  // mSelection will be null if this was nested call.
+  if (mSelection && mEditor->ArePreservingSelection()) {
+    mEditor->RestorePreservedSelection(mSelection);
   }
 }
 
 void
-nsAutoSelectionReset::Abort()
+AutoSelectionRestorer::Abort()
 {
-  NS_ASSERTION(!mSel || mEd, "mEd should be non-null when mSel is");
-  if (mSel)
-    mEd->StopPreservingSelection();
+  NS_ASSERTION(!mSelection || mEditor,
+               "mEditor should be non-null when mSelection is");
+  if (mSelection) {
+    mEditor->StopPreservingSelection();
+  }
 }
 
-namespace mozilla {
-
 /******************************************************************************
  * some helper classes for iterating the dom tree
  *****************************************************************************/
 
 DOMIterator::DOMIterator(nsINode& aNode MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)
 {
   MOZ_GUARD_OBJECT_NOTIFIER_INIT;
   mIter = NS_NewContentIterator();
--- a/editor/libeditor/EditorUtils.h
+++ b/editor/libeditor/EditorUtils.h
@@ -67,41 +67,50 @@ class MOZ_RAII nsAutoEditBatch : public 
     explicit nsAutoEditBatch(nsIEditor *aEd MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
       : nsAutoPlaceHolderBatch(aEd, nullptr)
     {
       MOZ_GUARD_OBJECT_NOTIFIER_INIT;
     }
     ~nsAutoEditBatch() {}
 };
 
+namespace mozilla {
+
 /***************************************************************************
  * stack based helper class for saving/restoring selection.  Note that this
  * assumes that the nodes involved are still around afterwards!
  */
-class MOZ_RAII nsAutoSelectionReset
+class MOZ_RAII AutoSelectionRestorer final
 {
-  private:
-    /** ref-counted reference to the selection that we are supposed to restore */
-    RefPtr<mozilla::dom::Selection> mSel;
-    nsEditor *mEd;  // non-owning ref to nsEditor
-    MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
+private:
+  // Ref-counted reference to the selection that we are supposed to restore.
+  RefPtr<dom::Selection> mSelection;
+  nsEditor* mEditor;  // Non-owning ref to nsEditor.
+  MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
-  public:
-    /** constructor responsible for remembering all state needed to restore aSel */
-    nsAutoSelectionReset(mozilla::dom::Selection* aSel, nsEditor* aEd MOZ_GUARD_OBJECT_NOTIFIER_PARAM);
+public:
+  /**
+   * Constructor responsible for remembering all state needed to restore
+   * aSelection.
+   */
+  AutoSelectionRestorer(dom::Selection* aSelection,
+                        nsEditor* aEditor
+                        MOZ_GUARD_OBJECT_NOTIFIER_PARAM);
 
-    /** destructor restores mSel to its former state */
-    ~nsAutoSelectionReset();
+  /**
+   * Destructor restores mSelection to its former state
+   */
+  ~AutoSelectionRestorer();
 
-    /** Abort: cancel selection saver */
-    void Abort();
+  /**
+   * Abort() cancels to restore the selection.
+   */
+  void Abort();
 };
 
-namespace mozilla {
-
 /***************************************************************************
  * stack based helper class for StartOperation()/EndOperation() sandwich
  */
 class MOZ_RAII AutoRules final
 {
 public:
   AutoRules(nsEditor* aEditor, EditAction aAction,
             nsIEditor::EDirection aDirection
--- a/editor/libeditor/nsEditor.cpp
+++ b/editor/libeditor/nsEditor.cpp
@@ -1563,17 +1563,17 @@ nsEditor::ReplaceContainer(Element* aOld
     res = ret->SetAttr(kNameSpaceID_None, aAttribute, *aValue, true);
     NS_ENSURE_SUCCESS(res, nullptr);
   }
   if (aCloneAttributes == eCloneAttributes) {
     CloneAttributes(ret, aOldContainer);
   }
 
   // notify our internal selection state listener
-  // (Note: A nsAutoSelectionReset object must be created
+  // (Note: An AutoSelectionRestorer object must be created
   //  before calling this to initialize mRangeUpdater)
   AutoReplaceContainerSelNotify selStateNotify(mRangeUpdater, aOldContainer,
                                                ret);
   {
     AutoTransactionsConserveSelection conserveSelection(this);
     while (aOldContainer->HasChildren()) {
       nsCOMPtr<nsIContent> child = aOldContainer->GetFirstChild();
 
--- a/editor/libeditor/nsEditor.h
+++ b/editor/libeditor/nsEditor.h
@@ -50,16 +50,17 @@ class nsISupports;
 class nsITransaction;
 class nsIWidget;
 class nsRange;
 class nsString;
 class nsTransactionManager;
 
 namespace mozilla {
 class AutoRules;
+class AutoSelectionRestorer;
 class AutoTransactionsConserveSelection;
 class ErrorResult;
 class TextComposition;
 struct EditorDOMPoint;
 
 namespace dom {
 class ChangeAttributeTxn;
 class CreateElementTxn;
@@ -853,17 +854,18 @@ protected:
   // various listeners
   // Listens to all low level actions on the doc
   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;
 
-  nsSelectionState  mSavedSel;           // cached selection for nsAutoSelectionReset
+  // cached selection for AutoSelectionRestorer
+  nsSelectionState  mSavedSel;
   nsRangeUpdater    mRangeUpdater;       // utility class object for maintaining preserved ranges
 
   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
@@ -882,15 +884,15 @@ protected:
   bool mDidPreDestroy;    // whether PreDestroy has been called
   bool mDidPostCreate;    // whether PostCreate has been called
   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 nsAutoSelectionReset;
   friend class nsRangeUpdater;
 };
 
 
 #endif
--- a/editor/libeditor/nsHTMLDataTransfer.cpp
+++ b/editor/libeditor/nsHTMLDataTransfer.cpp
@@ -347,20 +347,22 @@ nsHTMLEditor::DoInsertHTMLWithContext(co
       nsCOMPtr<nsINode> tmpNode = selection->GetAnchorNode();
       int32_t tmpOffset = static_cast<int32_t>(selection->AnchorOffset());
       rv = ClearStyle(address_of(tmpNode), &tmpOffset, nullptr, nullptr);
       NS_ENSURE_SUCCESS(rv, rv);
     }
   }
   else
   {
-    // delete whole cells: we will replace with new table content
-    { // Braces for artificial block to scope nsAutoSelectionReset.
-      // Save current selection since DeleteTableCell perturbs it
-      nsAutoSelectionReset selectionResetter(selection, this);
+    // Delete whole cells: we will replace with new table content.
+
+    // Braces for artificial block to scope AutoSelectionRestorer.
+    // Save current selection since DeleteTableCell() perturbs it.
+    {
+      AutoSelectionRestorer selectionRestorer(selection, this);
       rv = DeleteTableCell(1);
       NS_ENSURE_SUCCESS(rv, rv);
     }
     // collapse selection to beginning of deleted table content
     selection->CollapseToStart();
   }
 
   // give rules a chance to handle or cancel
--- a/editor/libeditor/nsHTMLEditRules.cpp
+++ b/editor/libeditor/nsHTMLEditRules.cpp
@@ -2991,17 +2991,17 @@ nsHTMLEditRules::WillMakeList(Selection*
   // block parent, and then further expands to include any ancestors
   // whose children are all in the range
 
   *aHandled = true;
 
   nsresult res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
-  nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
+  AutoSelectionRestorer selectionRestorer(aSelection, mHTMLEditor);
 
   nsTArray<OwningNonNull<nsINode>> arrayOfNodes;
   res = GetListActionNodes(arrayOfNodes,
                            aEntireList ? EntireList::yes : EntireList::no);
   NS_ENSURE_SUCCESS(res, res);
 
   // check if all our nodes are <br>s, or empty inlines
   bool bOnlyBreaks = true;
@@ -3049,18 +3049,18 @@ nsHTMLEditRules::WillMakeList(Selection*
     nsCOMPtr<Element> theListItem =
       mHTMLEditor->CreateNode(itemType, theList, 0);
     NS_ENSURE_STATE(theListItem);
 
     // remember our new block for postprocessing
     mNewBlock = theListItem;
     // put selection in new list item
     res = aSelection->Collapse(theListItem, 0);
-    // to prevent selection resetter from overriding us
-    selectionResetter.Abort();
+    // Don't restore the selection
+    selectionRestorer.Abort();
     *aHandled = true;
     return res;
   }
 
   // if there is only one node in the array, and it is a list, div, or
   // blockquote, then look inside of it until we find inner list or content.
 
   LookInsideDivBQandList(arrayOfNodes);
@@ -3271,17 +3271,17 @@ nsHTMLEditRules::WillRemoveList(Selectio
   if (!aSelection || !aCancel || !aHandled) { return NS_ERROR_NULL_POINTER; }
   // initialize out param
   *aCancel = false;
   *aHandled = true;
 
   nsresult res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
-  nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
+  AutoSelectionRestorer selectionRestorer(aSelection, mHTMLEditor);
 
   nsTArray<RefPtr<nsRange>> arrayOfRanges;
   GetPromotedRanges(*aSelection, arrayOfRanges, EditAction::makeList);
 
   // use these ranges to contruct a list of nodes to act on.
   nsTArray<OwningNonNull<nsINode>> arrayOfNodes;
   res = GetListActionNodes(arrayOfNodes, EntireList::no);
   NS_ENSURE_SUCCESS(res, res);
@@ -3351,17 +3351,17 @@ nsHTMLEditRules::WillMakeBasicBlock(Sele
 
   WillInsert(aSelection, aCancel);
   // We want to ignore result of WillInsert()
   *aCancel = false;
   *aHandled = false;
 
   nsresult res = NormalizeSelection(&aSelection);
   NS_ENSURE_SUCCESS(res, res);
-  nsAutoSelectionReset selectionResetter(&aSelection, mHTMLEditor);
+  AutoSelectionRestorer selectionRestorer(&aSelection, mHTMLEditor);
   AutoTransactionsConserveSelection dontSpazMySelection(mHTMLEditor);
   *aHandled = true;
 
   // Contruct a list of nodes to act on.
   nsTArray<OwningNonNull<nsINode>> arrayOfNodes;
   res = GetNodesFromSelection(aSelection, EditAction::makeBasicBlock,
                               arrayOfNodes);
   NS_ENSURE_SUCCESS(res, res);
@@ -3402,18 +3402,18 @@ nsHTMLEditRules::WillMakeBasicBlock(Sele
                                             offset,
                                             nsHTMLEditor::EmptyContainers::no);
         NS_ENSURE_STATE(offset != -1);
         // Put a br at the split point
         brNode = mHTMLEditor->CreateBR(curBlock->GetParentNode(), offset);
         NS_ENSURE_STATE(brNode);
         // Put selection at the split point
         res = aSelection.Collapse(curBlock->GetParentNode(), offset);
-        // To prevent selection resetter from overriding us.
-        selectionResetter.Abort();
+        // Don't restore the selection
+        selectionRestorer.Abort();
         *aHandled = true;
         NS_ENSURE_SUCCESS(res, res);
       }
       // Else nothing to do!
     } else {
       // We are making a block.  Consume a br, if needed.
       nsCOMPtr<nsIContent> brNode =
         mHTMLEditor->GetNextHTMLNode(parent, offset, true);
@@ -3435,18 +3435,18 @@ nsHTMLEditRules::WillMakeBasicBlock(Sele
       while (!arrayOfNodes.IsEmpty()) {
         OwningNonNull<nsINode> curNode = arrayOfNodes[0];
         res = mHTMLEditor->DeleteNode(curNode);
         NS_ENSURE_SUCCESS(res, res);
         arrayOfNodes.RemoveElementAt(0);
       }
       // Put selection in new block
       res = aSelection.Collapse(block, 0);
-      // To prevent selection resetter from overriding us.
-      selectionResetter.Abort();
+      // Don't restore the selection
+      selectionRestorer.Abort();
       *aHandled = true;
       NS_ENSURE_SUCCESS(res, res);
     }
     return NS_OK;
   }
   // Okay, now go through all the nodes and make the right kind of blocks, or
   // whatever is approriate.  Woohoo!  Note: blockquote is handled a little
   // differently.
@@ -3508,17 +3508,17 @@ nsHTMLEditRules::WillCSSIndent(Selection
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
   *aHandled = true;
 
   nsresult res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
-  nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
+  AutoSelectionRestorer selectionRestorer(aSelection, mHTMLEditor);
   nsTArray<OwningNonNull<nsRange>> arrayOfRanges;
   nsTArray<OwningNonNull<nsINode>> arrayOfNodes;
 
   // short circuit: detect case of collapsed selection inside an <li>.
   // just sublist that <li>.  This prevents bug 97797.
 
   nsCOMPtr<Element> liNode;
   if (aSelection->Collapsed()) {
@@ -3570,17 +3570,18 @@ nsHTMLEditRules::WillCSSIndent(Selection
       OwningNonNull<nsINode> curNode = arrayOfNodes[0];
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(curNode);
       NS_ENSURE_SUCCESS(res, res);
       arrayOfNodes.RemoveElementAt(0);
     }
     // put selection in new block
     res = aSelection->Collapse(theBlock,0);
-    selectionResetter.Abort();  // to prevent selection reseter from overriding us.
+    // Don't restore the selection
+    selectionRestorer.Abort();
     *aHandled = true;
     return res;
   }
 
   // Ok, now go through all the nodes and put them in a blockquote,
   // or whatever is appropriate.  Wohoo!
   int32_t i;
   nsCOMPtr<nsINode> curParent;
@@ -3711,17 +3712,17 @@ nsHTMLEditRules::WillHTMLIndent(Selectio
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
   *aHandled = true;
 
   nsresult res = NormalizeSelection(aSelection);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_STATE(mHTMLEditor);
-  nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
+  AutoSelectionRestorer selectionRestorer(aSelection, mHTMLEditor);
 
   // convert the selection ranges into "promoted" selection ranges:
   // this basically just expands the range to include the immediate
   // block parent, and then further expands to include any ancestors
   // whose children are all in the range
 
   nsTArray<RefPtr<nsRange>> arrayOfRanges;
   GetPromotedRanges(*aSelection, arrayOfRanges, EditAction::indent);
@@ -3754,17 +3755,18 @@ nsHTMLEditRules::WillHTMLIndent(Selectio
       OwningNonNull<nsINode> curNode = arrayOfNodes[0];
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(curNode);
       NS_ENSURE_SUCCESS(res, res);
       arrayOfNodes.RemoveElementAt(0);
     }
     // put selection in new block
     res = aSelection->Collapse(theBlock,0);
-    selectionResetter.Abort();  // to prevent selection reseter from overriding us.
+    // Don't restore the selection
+    selectionRestorer.Abort();
     *aHandled = true;
     return res;
   }
 
   // Ok, now go through all the nodes and put them in a blockquote,
   // or whatever is appropriate.  Wohoo!
   int32_t i;
   nsCOMPtr<nsINode> curParent;
@@ -3944,17 +3946,17 @@ nsHTMLEditRules::WillOutdent(Selection& 
   nsCOMPtr<nsIEditor> kungFuDeathGrip(mHTMLEditor);
   bool useCSS = mHTMLEditor->IsCSSEnabled();
 
   nsresult res = NormalizeSelection(&aSelection);
   NS_ENSURE_SUCCESS(res, res);
 
   // Some scoping for selection resetting - we may need to tweak it
   {
-    nsAutoSelectionReset selectionResetter(&aSelection, mHTMLEditor);
+    AutoSelectionRestorer selectionRestorer(&aSelection, mHTMLEditor);
 
     // Convert the selection ranges into "promoted" selection ranges: this
     // basically just expands the range to include the immediate block parent,
     // and then further expands to include any ancestors whose children are all
     // in the range
     nsTArray<OwningNonNull<nsINode>> arrayOfNodes;
     res = GetNodesFromSelection(aSelection, EditAction::outdent,
                                 arrayOfNodes);
@@ -4481,17 +4483,17 @@ nsHTMLEditRules::WillAlign(Selection& aS
   WillInsert(aSelection, aCancel);
 
   // Initialize out param.  We want to ignore result of WillInsert().
   *aCancel = false;
   *aHandled = false;
 
   nsresult rv = NormalizeSelection(&aSelection);
   NS_ENSURE_SUCCESS(rv, rv);
-  nsAutoSelectionReset selectionResetter(&aSelection, mHTMLEditor);
+  AutoSelectionRestorer selectionRestorer(&aSelection, mHTMLEditor);
 
   // Convert the selection ranges into "promoted" selection ranges: This
   // basically just expands the range to include the immediate block parent,
   // and then further expands to include any ancestors whose children are all
   // in the range
   *aHandled = true;
   nsTArray<OwningNonNull<nsINode>> nodeArray;
   rv = GetNodesFromSelection(aSelection, EditAction::align, nodeArray);
@@ -4568,18 +4570,18 @@ nsHTMLEditRules::WillAlign(Selection& aS
     // Set up the alignment on the div, using HTML or CSS
     rv = AlignBlock(*div, aAlignType, ContentsOnly::yes);
     NS_ENSURE_SUCCESS(rv, rv);
     *aHandled = true;
     // Put in a moz-br so that it won't get deleted
     rv = CreateMozBR(div->AsDOMNode(), 0);
     NS_ENSURE_SUCCESS(rv, rv);
     rv = aSelection.Collapse(div, 0);
-    // Don't reset our selection in this case.
-    selectionResetter.Abort();
+    // Don't restore the selection
+    selectionRestorer.Abort();
     NS_ENSURE_SUCCESS(rv, rv);
     return NS_OK;
   }
 
   // Next we detect all the transitions in the array, where a transition
   // means that adjacent nodes in the array don't have the same parent.
 
   nsTArray<bool> transitionList;
@@ -8502,17 +8504,17 @@ nsHTMLEditRules::WillAbsolutePosition(Se
   nsCOMPtr<Element> focusElement = mHTMLEditor->GetSelectionContainer();
   if (focusElement && nsHTMLEditUtils::IsImage(focusElement)) {
     mNewBlock = focusElement;
     return NS_OK;
   }
 
   nsresult res = NormalizeSelection(&aSelection);
   NS_ENSURE_SUCCESS(res, res);
-  nsAutoSelectionReset selectionResetter(&aSelection, mHTMLEditor);
+  AutoSelectionRestorer selectionRestorer(&aSelection, mHTMLEditor);
 
   // Convert the selection ranges into "promoted" selection ranges: this
   // basically just expands the range to include the immediate block parent,
   // and then further expands to include any ancestors whose children are all
   // in the range.
 
   nsTArray<RefPtr<nsRange>> arrayOfRanges;
   GetPromotedRanges(aSelection, arrayOfRanges,
@@ -8545,18 +8547,18 @@ nsHTMLEditRules::WillAbsolutePosition(Se
     while (!arrayOfNodes.IsEmpty()) {
       OwningNonNull<nsINode> curNode = arrayOfNodes[0];
       res = mHTMLEditor->DeleteNode(curNode);
       NS_ENSURE_SUCCESS(res, res);
       arrayOfNodes.RemoveElementAt(0);
     }
     // Put selection in new block
     res = aSelection.Collapse(positionedDiv, 0);
-    // Prevent selection resetter from overriding us.
-    selectionResetter.Abort();
+    // Don't restore the selection
+    selectionRestorer.Abort();
     *aHandled = true;
     NS_ENSURE_SUCCESS(res, res);
     return NS_OK;
   }
 
   // Okay, now go through all the nodes and put them in a blockquote, or
   // whatever is appropriate.  Woohoo!
   nsCOMPtr<Element> curList, curPositionedDiv, indentedLI;
@@ -8702,17 +8704,17 @@ nsHTMLEditRules::WillRemoveAbsolutePosit
 
   nsCOMPtr<nsIDOMElement>  elt;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res =
     mHTMLEditor->GetAbsolutelyPositionedSelectionContainer(getter_AddRefs(elt));
   NS_ENSURE_SUCCESS(res, res);
 
   NS_ENSURE_STATE(mHTMLEditor);
-  nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
+  AutoSelectionRestorer selectionRestorer(aSelection, mHTMLEditor);
 
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIHTMLAbsPosEditor> absPosHTMLEditor = mHTMLEditor;
   return absPosHTMLEditor->AbsolutelyPositionElement(elt, false);
 }
 
 nsresult
 nsHTMLEditRules::WillRelativeChangeZIndex(Selection* aSelection,
@@ -8730,17 +8732,17 @@ nsHTMLEditRules::WillRelativeChangeZInde
 
   nsCOMPtr<nsIDOMElement>  elt;
   NS_ENSURE_STATE(mHTMLEditor);
   nsresult res =
     mHTMLEditor->GetAbsolutelyPositionedSelectionContainer(getter_AddRefs(elt));
   NS_ENSURE_SUCCESS(res, res);
 
   NS_ENSURE_STATE(mHTMLEditor);
-  nsAutoSelectionReset selectionResetter(aSelection, mHTMLEditor);
+  AutoSelectionRestorer selectionRestorer(aSelection, mHTMLEditor);
 
   NS_ENSURE_STATE(mHTMLEditor);
   nsCOMPtr<nsIHTMLAbsPosEditor> absPosHTMLEditor = mHTMLEditor;
   int32_t zIndex;
   return absPosHTMLEditor->RelativeChangeElementZIndex(elt, aChange, &zIndex);
 }
 
 NS_IMETHODIMP
--- a/editor/libeditor/nsHTMLEditor.cpp
+++ b/editor/libeditor/nsHTMLEditor.cpp
@@ -3329,17 +3329,17 @@ SetSelectionAroundHeadChildren(Selection
 
 NS_IMETHODIMP
 nsHTMLEditor::GetHeadContentsAsHTML(nsAString& aOutputString)
 {
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
   // Save current selection
-  nsAutoSelectionReset selectionResetter(selection, this);
+  AutoSelectionRestorer selectionRestorer(selection, this);
 
   nsresult res = SetSelectionAroundHeadChildren(selection, mDocWeak);
   NS_ENSURE_SUCCESS(res, res);
 
   res = OutputToString(NS_LITERAL_STRING("text/html"),
                        nsIDocumentEncoder::OutputSelectionOnly,
                        aOutputString);
   if (NS_SUCCEEDED(res))
@@ -4529,17 +4529,17 @@ nsHTMLEditor::SetCSSBackgroundColor(cons
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_STATE(selection);
 
   bool isCollapsed = selection->Collapsed();
 
   nsAutoEditBatch batchIt(this);
   AutoRules beginRulesSniffing(this, EditAction::insertElement,
                                nsIEditor::eNext);
-  nsAutoSelectionReset selectionResetter(selection, this);
+  AutoSelectionRestorer selectionRestorer(selection, this);
   AutoTransactionsConserveSelection dontSpazMySelection(this);
 
   bool cancel, handled;
   nsTextRulesInfo ruleInfo(EditAction::setTextProperty);
   nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
   NS_ENSURE_SUCCESS(res, res);
   if (!cancel && !handled) {
     // Loop through the ranges in the selection
--- a/editor/libeditor/nsHTMLEditorStyle.cpp
+++ b/editor/libeditor/nsHTMLEditorStyle.cpp
@@ -122,17 +122,17 @@ nsHTMLEditor::SetInlineProperty(nsIAtom*
     // for the next text insertion
     mTypeInState->SetProp(aProperty, aAttribute, aValue);
     return NS_OK;
   }
 
   nsAutoEditBatch batchIt(this);
   AutoRules beginRulesSniffing(this, EditAction::insertElement,
                                nsIEditor::eNext);
-  nsAutoSelectionReset selectionResetter(selection, this);
+  AutoSelectionRestorer selectionRestorer(selection, this);
   AutoTransactionsConserveSelection dontSpazMySelection(this);
 
   bool cancel, handled;
   nsTextRulesInfo ruleInfo(EditAction::setTextProperty);
   // Protect the edit rules object from dying
   nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
   NS_ENSURE_SUCCESS(res, res);
   if (!cancel && !handled) {
@@ -1209,17 +1209,17 @@ nsHTMLEditor::RemoveInlinePropertyImpl(n
       mTypeInState->ClearAllProps();
     }
     return NS_OK;
   }
 
   nsAutoEditBatch batchIt(this);
   AutoRules beginRulesSniffing(this, EditAction::removeTextProperty,
                                nsIEditor::eNext);
-  nsAutoSelectionReset selectionResetter(selection, this);
+  AutoSelectionRestorer selectionRestorer(selection, this);
   AutoTransactionsConserveSelection dontSpazMySelection(this);
 
   bool cancel, handled;
   nsTextRulesInfo ruleInfo(EditAction::removeTextProperty);
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
   nsresult res = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
   NS_ENSURE_SUCCESS(res, res);
@@ -1358,17 +1358,17 @@ nsHTMLEditor::RelativeFontChange(FontSiz
     mTypeInState->SetProp(&atom, EmptyString(), EmptyString());
     return NS_OK;
   }
 
   // Wrap with txn batching, rules sniffing, and selection preservation code
   nsAutoEditBatch batchIt(this);
   AutoRules beginRulesSniffing(this, EditAction::setTextProperty,
                                nsIEditor::eNext);
-  nsAutoSelectionReset selectionResetter(selection, this);
+  AutoSelectionRestorer selectionRestorer(selection, this);
   AutoTransactionsConserveSelection dontSpazMySelection(this);
 
   // Loop through the ranges in the selection
   uint32_t rangeCount = selection->RangeCount();
   for (uint32_t rangeIdx = 0; rangeIdx < rangeCount; ++rangeIdx) {
     RefPtr<nsRange> range = selection->GetRangeAt(rangeIdx);
 
     // Adjust range to include any ancestors with entirely selected children
--- a/editor/libeditor/nsTableEditor.cpp
+++ b/editor/libeditor/nsTableEditor.cpp
@@ -1922,17 +1922,17 @@ nsHTMLEditor::SwitchTableCellHeaderType(
   // Prevent auto insertion of BR in new cell created by ReplaceContainer
   AutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
 
   // Save current selection to restore when done
   // This is needed so ReplaceContainer can monitor selection
   //  when replacing nodes
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
-  nsAutoSelectionReset selectionResetter(selection, this);
+  AutoSelectionRestorer selectionRestorer(selection, this);
 
   // Set to the opposite of current type
   nsCOMPtr<nsIAtom> atom = nsEditor::GetTag(aSourceCell);
   nsIAtom* newCellType = atom == nsGkAtoms::td ? nsGkAtoms::th : nsGkAtoms::td;
 
   // This creates new node, moves children, copies attributes (true)
   //   and manages the selection!
   nsCOMPtr<Element> newNode = ReplaceContainer(sourceCell, newCellType,
@@ -2469,17 +2469,17 @@ nsHTMLEditor::NormalizeTable(nsIDOMEleme
   // Don't fail if we didn't find a table
   NS_ENSURE_TRUE(table, NS_OK);
 
   int32_t rowCount, colCount, rowIndex, colIndex;
   res = GetTableSize(table, &rowCount, &colCount);
   NS_ENSURE_SUCCESS(res, res);
 
   // Save current selection
-  nsAutoSelectionReset selectionResetter(selection, this);
+  AutoSelectionRestorer selectionRestorer(selection, this);
 
   nsAutoEditBatch beginBatching(this);
   // Prevent auto insertion of BR in new cell until we're done
   AutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
 
   nsCOMPtr<nsIDOMElement> cell;
   int32_t startRowIndex, startColIndex, rowSpan, colSpan, actualRowSpan, actualColSpan;
   bool    isSelected;