Bug 1260651 part.59 Rename nsEditor to mozilla::EditorBase (and also their file names) r?ehsan draft
authorMasayuki Nakano <masayuki@d-toybox.com>
Sat, 25 Jun 2016 15:06:25 +0900
changeset 381310 03f5f1561c98458fd3d8f400d54c64e07ea106c8
parent 381309 637060de3a6a90711ad741f48f40a41a7546ee8e
child 381311 de220811f04de0e9013997c1c7c3f3f601b3c0fa
push id21453
push usermasayuki@d-toybox.com
push dateSat, 25 Jun 2016 10:50:45 +0000
reviewersehsan
bugs1260651
milestone50.0a1
Bug 1260651 part.59 Rename nsEditor to mozilla::EditorBase (and also their file names) r?ehsan This patch also renames: EditorInputEventDispatcher -> mozilla::EditorInputEventDispatcher And some variable names are renamed from aEditor or mEditor to aEditorBase or mEditorBase for making their types clearer. MozReview-Commit-ID: 2FCXWpLMn8e
dom/events/ContentEventHandler.cpp
dom/events/EventNameList.h
dom/events/IMEContentObserver.cpp
dom/events/IMEStateManager.cpp
editor/libeditor/CompositionTransaction.cpp
editor/libeditor/CompositionTransaction.h
editor/libeditor/CreateElementTransaction.cpp
editor/libeditor/CreateElementTransaction.h
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/EditorBase.cpp
editor/libeditor/EditorBase.h
editor/libeditor/EditorEventListener.cpp
editor/libeditor/EditorEventListener.h
editor/libeditor/EditorUtils.cpp
editor/libeditor/EditorUtils.h
editor/libeditor/HTMLAbsPositionEditor.cpp
editor/libeditor/HTMLEditRules.cpp
editor/libeditor/HTMLEditRules.h
editor/libeditor/HTMLEditUtils.cpp
editor/libeditor/HTMLEditor.cpp
editor/libeditor/HTMLEditor.h
editor/libeditor/HTMLEditorDataTransfer.cpp
editor/libeditor/HTMLEditorEventListener.cpp
editor/libeditor/HTMLEditorEventListener.h
editor/libeditor/HTMLStyleEditor.cpp
editor/libeditor/HTMLTableEditor.cpp
editor/libeditor/InsertNodeTransaction.cpp
editor/libeditor/InsertNodeTransaction.h
editor/libeditor/InsertTextTransaction.cpp
editor/libeditor/InsertTextTransaction.h
editor/libeditor/JoinNodeTransaction.cpp
editor/libeditor/JoinNodeTransaction.h
editor/libeditor/PlaceholderTransaction.cpp
editor/libeditor/PlaceholderTransaction.h
editor/libeditor/SelectionState.cpp
editor/libeditor/SplitNodeTransaction.cpp
editor/libeditor/SplitNodeTransaction.h
editor/libeditor/TextEditRules.cpp
editor/libeditor/TextEditRules.h
editor/libeditor/TextEditUtils.cpp
editor/libeditor/TextEditor.cpp
editor/libeditor/TextEditor.h
editor/libeditor/TextEditorDataTransfer.cpp
editor/libeditor/TypeInState.cpp
editor/libeditor/moz.build
editor/libeditor/nsEditor.cpp
editor/libeditor/nsEditor.h
editor/libeditor/nsIAbsorbingTransaction.h
editor/libeditor/nsIEditRules.h
extensions/spellcheck/src/mozInlineSpellChecker.cpp
extensions/spellcheck/src/mozInlineSpellChecker.h
layout/base/nsLayoutUtils.cpp
layout/build/nsLayoutModule.cpp
widget/windows/KeyboardLayout.cpp
--- a/dom/events/ContentEventHandler.cpp
+++ b/dom/events/ContentEventHandler.cpp
@@ -155,17 +155,17 @@ ContentEventHandler::InitRootContent(Sel
 
   RefPtr<nsRange> range(aNormalSelection->GetRangeAt(0));
   if (NS_WARN_IF(!range)) {
     return NS_ERROR_UNEXPECTED;
   }
 
   // If there is a selection, we should retrieve the selection root from
   // the range since when the window is inactivated, the ancestor limiter
-  // of selection was cleared by blur event handler of nsEditor but the
+  // of selection was cleared by blur event handler of EditorBase but the
   // selection range still keeps storing the nodes.  If the active element of
   // the deactive window is <input> or <textarea>, we can compute the
   // selection root from them.
   nsINode* startNode = range->GetStartParent();
   nsINode* endNode = range->GetEndParent();
   if (NS_WARN_IF(!startNode) || NS_WARN_IF(!endNode)) {
     return NS_ERROR_FAILURE;
   }
@@ -1968,17 +1968,17 @@ ContentEventHandler::AdjustCollapsedRang
 
   // If the node is text node, we don't need to modify aRange.
   if (parentNode->IsNodeOfType(nsINode::eTEXT)) {
     return NS_OK;
   }
 
   // If the parent is not a text node but it has a text node at the offset,
   // we should adjust the range into the text node.
-  // NOTE: This is emulating similar situation of nsEditor.
+  // NOTE: This is emulating similar situation of EditorBase.
   nsINode* childNode = nullptr;
   int32_t offsetInChildNode = -1;
   if (!offsetInParentNode && parentNode->HasChildren()) {
     // If the range is the start of the parent, adjusted the range to the
     // start of the first child.
     childNode = parentNode->GetFirstChild();
     offsetInChildNode = 0;
   } else if (static_cast<uint32_t>(offsetInParentNode) <
--- a/dom/events/EventNameList.h
+++ b/dom/events/EventNameList.h
@@ -714,17 +714,17 @@ NON_IDL_EVENT(warning,
 
 NON_IDL_EVENT(speakerforcedchange,
               eSpeakerForcedChange,
               EventNameType_None,
               eBasicEventClass)
 
 // Events that only have on* attributes on XUL elements
 
- // "text" event is legacy event for modifying composition string in nsEditor.
+ // "text" event is legacy event for modifying composition string in EditorBase.
  // This shouldn't be used by web/xul apps.  "compositionupdate" should be
  // used instead.
 NON_IDL_EVENT(text,
               eCompositionChange,
               EventNameType_XUL,
               eCompositionEventClass)
 NON_IDL_EVENT(compositionstart,
               eCompositionStart,
--- a/dom/events/IMEContentObserver.cpp
+++ b/dom/events/IMEContentObserver.cpp
@@ -624,17 +624,17 @@ IMEContentObserver::IsEditorHandlingEven
 }
 
 bool
 IMEContentObserver::IsEditorComposing() const
 {
   // Note that don't use TextComposition here. The important thing is,
   // whether the editor already started to handle composition because
   // web contents can change selection, text content and/or something from
-  // compositionstart event listener which is run before nsEditor handles it.
+  // compositionstart event listener which is run before EditorBase handles it.
   nsCOMPtr<nsIEditorIMESupport> editorIMESupport = do_QueryInterface(mEditor);
   if (NS_WARN_IF(!editorIMESupport)) {
     return false;
   }
   bool isComposing = false;
   nsresult rv = editorIMESupport->GetComposing(&isComposing);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return false;
--- a/dom/events/IMEStateManager.cpp
+++ b/dom/events/IMEStateManager.cpp
@@ -880,18 +880,18 @@ IMEStateManager::GetNewIMEState(nsPresCo
     }
     MOZ_LOG(sISMLog, LogLevel::Debug,
       ("ISM:   IMEStateManager::GetNewIMEState() returns DISABLED because "
        "no content has focus"));
     return IMEState(IMEState::DISABLED);
   }
 
   // nsIContent::GetDesiredIMEState() may cause a call of UpdateIMEState()
-  // from nsEditor::PostCreate() because GetDesiredIMEState() needs to retrieve
-  // an editor instance for the element if it's editable element.
+  // from EditorBase::PostCreate() because GetDesiredIMEState() needs to
+  // retrieve an editor instance for the element if it's editable element.
   // For avoiding such nested IME state updates, we should set
   // sIsGettingNewIMEState here and UpdateIMEState() should check it.
   GettingNewIMEStateBlocker blocker;
 
   IMEState newIMEState = aContent->GetDesiredIMEState();
   MOZ_LOG(sISMLog, LogLevel::Debug,
     ("ISM:   IMEStateManager::GetNewIMEState() returns { mEnabled=%s, "
      "mOpen=%s }",
--- a/editor/libeditor/CompositionTransaction.cpp
+++ b/editor/libeditor/CompositionTransaction.cpp
@@ -1,43 +1,43 @@
 /* -*- 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 "CompositionTransaction.h"
 
+#include "EditorBase.h"                 // mEditorBase
 #include "mozilla/dom/Selection.h"      // local var
 #include "mozilla/dom/Text.h"           // mTextNode
 #include "nsAString.h"                  // params
 #include "nsDebug.h"                    // for NS_ASSERTION, etc
-#include "nsEditor.h"                   // mEditor
 #include "nsError.h"                    // for NS_SUCCEEDED, NS_FAILED, etc
 #include "nsIPresShell.h"               // nsISelectionController constants
 #include "nsRange.h"                    // local var
 #include "nsQueryObject.h"              // for do_QueryObject
 
 namespace mozilla {
 
 using namespace dom;
 
 CompositionTransaction::CompositionTransaction(
                           Text& aTextNode,
                           uint32_t aOffset,
                           uint32_t aReplaceLength,
                           TextRangeArray* aTextRangeArray,
                           const nsAString& aStringToInsert,
-                          nsEditor& aEditor)
+                          EditorBase& aEditorBase)
   : EditTransactionBase()
   , mTextNode(&aTextNode)
   , mOffset(aOffset)
   , mReplaceLength(aReplaceLength)
   , mRanges(aTextRangeArray)
   , mStringToInsert(aStringToInsert)
-  , mEditor(aEditor)
+  , mEditorBase(aEditorBase)
   , mFixed(false)
 {
 }
 
 CompositionTransaction::~CompositionTransaction()
 {
 }
 
@@ -54,17 +54,17 @@ NS_INTERFACE_MAP_END_INHERITING(EditTran
 NS_IMPL_ADDREF_INHERITED(CompositionTransaction, EditTransactionBase)
 NS_IMPL_RELEASE_INHERITED(CompositionTransaction, EditTransactionBase)
 
 NS_IMETHODIMP
 CompositionTransaction::DoTransaction()
 {
   // Fail before making any changes if there's no selection controller
   nsCOMPtr<nsISelectionController> selCon;
-  mEditor.GetSelectionController(getter_AddRefs(selCon));
+  mEditorBase.GetSelectionController(getter_AddRefs(selCon));
   NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
 
   // Advance caret: This requires the presentation shell to get the selection.
   nsresult res;
   if (mReplaceLength == 0) {
     res = mTextNode->InsertData(mOffset, mStringToInsert);
   } else {
     res = mTextNode->ReplaceData(mOffset, mReplaceLength, mStringToInsert);
@@ -77,17 +77,17 @@ CompositionTransaction::DoTransaction()
   return NS_OK;
 }
 
 NS_IMETHODIMP
 CompositionTransaction::UndoTransaction()
 {
   // Get the selection first so we'll fail before making any changes if we
   // can't get it
-  RefPtr<Selection> selection = mEditor.GetSelection();
+  RefPtr<Selection> selection = mEditorBase.GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);
 
   nsresult res = mTextNode->DeleteData(mOffset, mStringToInsert.Length());
   NS_ENSURE_SUCCESS(res, res);
 
   // set the selection to the insertion point where the string was removed
   res = selection->Collapse(mTextNode, mOffset);
   NS_ASSERTION(NS_SUCCEEDED(res),
@@ -138,44 +138,44 @@ CompositionTransaction::GetTxnDescriptio
   return NS_OK;
 }
 
 /* ============ private methods ================== */
 
 nsresult
 CompositionTransaction::SetSelectionForRanges()
 {
-  return SetIMESelection(mEditor, mTextNode, mOffset,
+  return SetIMESelection(mEditorBase, mTextNode, mOffset,
                          mStringToInsert.Length(), mRanges);
 }
 
 // static
 nsresult
-CompositionTransaction::SetIMESelection(nsEditor& aEditor,
+CompositionTransaction::SetIMESelection(EditorBase& aEditorBase,
                                         Text* aTextNode,
                                         uint32_t aOffsetInNode,
                                         uint32_t aLengthOfCompositionString,
                                         const TextRangeArray* aRanges)
 {
-  RefPtr<Selection> selection = aEditor.GetSelection();
+  RefPtr<Selection> selection = aEditorBase.GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);
 
   nsresult rv = selection->StartBatchChanges();
   NS_ENSURE_SUCCESS(rv, rv);
 
   // First, remove all selections of IME composition.
   static const RawSelectionType kIMESelections[] = {
     nsISelectionController::SELECTION_IME_RAWINPUT,
     nsISelectionController::SELECTION_IME_SELECTEDRAWTEXT,
     nsISelectionController::SELECTION_IME_CONVERTEDTEXT,
     nsISelectionController::SELECTION_IME_SELECTEDCONVERTEDTEXT
   };
 
   nsCOMPtr<nsISelectionController> selCon;
-  aEditor.GetSelectionController(getter_AddRefs(selCon));
+  aEditorBase.GetSelectionController(getter_AddRefs(selCon));
   NS_ENSURE_TRUE(selCon, NS_ERROR_NOT_INITIALIZED);
 
   for (uint32_t i = 0; i < ArrayLength(kIMESelections); ++i) {
     nsCOMPtr<nsISelection> selectionOfIME;
     if (NS_FAILED(selCon->GetSelection(kIMESelections[i],
                                        getter_AddRefs(selectionOfIME)))) {
       continue;
     }
@@ -198,30 +198,31 @@ CompositionTransaction::SetIMESelection(
   //       composition.
   for (uint32_t i = 0; i < countOfRanges; ++i) {
     const TextRange& textRange = aRanges->ElementAt(i);
 
     // Caret needs special handling since its length may be 0 and if it's not
     // specified explicitly, we need to handle it ourselves later.
     if (textRange.mRangeType == TextRangeType::eCaret) {
       NS_ASSERTION(!setCaret, "The ranges already has caret position");
-      NS_ASSERTION(!textRange.Length(), "nsEditor doesn't support wide caret");
+      NS_ASSERTION(!textRange.Length(),
+                   "EditorBase doesn't support wide caret");
       int32_t caretOffset = static_cast<int32_t>(
         aOffsetInNode +
           std::min(textRange.mStartOffset, aLengthOfCompositionString));
       MOZ_ASSERT(caretOffset >= 0 &&
                  static_cast<uint32_t>(caretOffset) <= maxOffset);
       rv = selection->Collapse(aTextNode, caretOffset);
       setCaret = setCaret || NS_SUCCEEDED(rv);
       if (NS_WARN_IF(!setCaret)) {
         continue;
       }
       // If caret range is specified explicitly, we should show the caret if
       // it should be so.
-      aEditor.HideCaret(false);
+      aEditorBase.HideCaret(false);
       continue;
     }
 
     // If the clause length is 0, it should be a bug.
     if (!textRange.Length()) {
       NS_WARNING("Any clauses must not be empty");
       continue;
     }
@@ -283,17 +284,17 @@ CompositionTransaction::SetIMESelection(
     MOZ_ASSERT(caretOffset >= 0 &&
                static_cast<uint32_t>(caretOffset) <= maxOffset);
     rv = selection->Collapse(aTextNode, caretOffset);
     NS_ASSERTION(NS_SUCCEEDED(rv),
                  "Failed to set caret at the end of composition string");
 
     // If caret range isn't specified explicitly, we should hide the caret.
     // Hiding the caret benefits a Windows build (see bug 555642 comment #6).
-    aEditor.HideCaret(true);
+    aEditorBase.HideCaret(true);
   }
 
   rv = selection->EndBatchChangesInternal();
   NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to end batch changes");
 
   return rv;
 }
 
--- a/editor/libeditor/CompositionTransaction.h
+++ b/editor/libeditor/CompositionTransaction.h
@@ -5,24 +5,23 @@
 
 #ifndef CompositionTransaction_h_
 #define CompositionTransaction_h_
 
 #include "EditTransactionBase.h"          // base class
 #include "nsCycleCollectionParticipant.h" // various macros
 #include "nsString.h"                     // mStringToInsert
 
-class nsEditor;
-
 #define NS_IMETEXTTXN_IID \
   { 0xb391355d, 0x346c, 0x43d1, \
     { 0x85, 0xed, 0x9e, 0x65, 0xbe, 0xe7, 0x7e, 0x48 } }
 
 namespace mozilla {
 
+class EditorBase;
 class TextRangeArray;
 
 namespace dom {
 class Text;
 } // namespace dom
 
 /**
  * A transaction that inserts or modifies composition string into a content
@@ -36,36 +35,36 @@ public:
   /**
    * @param aTextNode           The text content node.
    * @param aOffset             The location in aTextNode to do the insertion.
    * @param aReplaceLength      The length of text to replace. 0 means not
    *                            replacing existing text.
    * @param aTextRangeArray     Clauses and/or caret information. This may be
    *                            null.
    * @param aString             The new text to insert.
-   * @param aEditor             Used to get and set the selection.
+   * @param aEditorBase         Used to get and set the selection.
    */
   CompositionTransaction(dom::Text& aTextNode,
                          uint32_t aOffset, uint32_t aReplaceLength,
                          TextRangeArray* aTextRangeArray,
                          const nsAString& aString,
-                         nsEditor& aEditor);
+                         EditorBase& aEditorBase);
 
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(CompositionTransaction,
                                            EditTransactionBase)
 
   NS_DECL_ISUPPORTS_INHERITED
 
   NS_DECL_EDITTRANSACTIONBASE
 
   NS_IMETHOD Merge(nsITransaction* aTransaction, bool* aDidMerge) override;
 
   void MarkFixed();
 
-  static nsresult SetIMESelection(nsEditor& aEditor,
+  static nsresult SetIMESelection(EditorBase& aEditorBase,
                                   dom::Text* aTextNode,
                                   uint32_t aOffsetInNode,
                                   uint32_t aLengthOfCompositionString,
                                   const TextRangeArray* aRanges);
 
 private:
   ~CompositionTransaction();
 
@@ -81,17 +80,17 @@ private:
 
   // The range list.
   RefPtr<TextRangeArray> mRanges;
 
   // The text to insert into mTextNode at mOffset.
   nsString mStringToInsert;
 
   // The editor, which is used to get the selection controller.
-  nsEditor& mEditor;
+  EditorBase& mEditorBase;
 
   bool mFixed;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(CompositionTransaction, NS_IMETEXTTXN_IID)
 
 } // namespace mozilla
 
--- a/editor/libeditor/CreateElementTransaction.cpp
+++ b/editor/libeditor/CreateElementTransaction.cpp
@@ -3,46 +3,47 @@
  * 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 "CreateElementTransaction.h"
 
 #include <algorithm>
 #include <stdio.h>
 
+#include "EditorBase.h"
+
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/Selection.h"
 
 #include "mozilla/Casting.h"
 
 #include "nsAlgorithm.h"
 #include "nsAString.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsIContent.h"
 #include "nsIDOMCharacterData.h"
 #include "nsIEditor.h"
 #include "nsINode.h"
 #include "nsISupportsUtils.h"
 #include "nsMemory.h"
 #include "nsReadableUtils.h"
 #include "nsStringFwd.h"
 #include "nsString.h"
 
 namespace mozilla {
 
 using namespace dom;
 
-CreateElementTransaction::CreateElementTransaction(nsEditor& aEditor,
+CreateElementTransaction::CreateElementTransaction(EditorBase& aEditorBase,
                                                    nsIAtom& aTag,
                                                    nsINode& aParent,
                                                    int32_t aOffsetInParent)
   : EditTransactionBase()
-  , mEditor(&aEditor)
+  , mEditorBase(&aEditorBase)
   , mTag(&aTag)
   , mParent(&aParent)
   , mOffsetInParent(aOffsetInParent)
 {
 }
 
 CreateElementTransaction::~CreateElementTransaction()
 {
@@ -58,23 +59,23 @@ NS_IMPL_ADDREF_INHERITED(CreateElementTr
 NS_IMPL_RELEASE_INHERITED(CreateElementTransaction, EditTransactionBase)
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(CreateElementTransaction)
 NS_INTERFACE_MAP_END_INHERITING(EditTransactionBase)
 
 
 NS_IMETHODIMP
 CreateElementTransaction::DoTransaction()
 {
-  MOZ_ASSERT(mEditor && mTag && mParent);
+  MOZ_ASSERT(mEditorBase && mTag && mParent);
 
-  mNewNode = mEditor->CreateHTMLContent(mTag);
+  mNewNode = mEditorBase->CreateHTMLContent(mTag);
   NS_ENSURE_STATE(mNewNode);
 
   // Try to insert formatting whitespace for the new node:
-  mEditor->MarkNodeDirty(GetAsDOMNode(mNewNode));
+  mEditorBase->MarkNodeDirty(GetAsDOMNode(mNewNode));
 
   // Insert the new node
   ErrorResult rv;
   if (mOffsetInParent == -1) {
     mParent->AppendChild(*mNewNode, rv);
     return rv.StealNSResult();
   }
 
@@ -83,45 +84,45 @@ CreateElementTransaction::DoTransaction(
 
   // Note, it's ok for mRefNode to be null. That means append
   mRefNode = mParent->GetChildAt(mOffsetInParent);
 
   mParent->InsertBefore(*mNewNode, mRefNode, rv);
   NS_ENSURE_TRUE(!rv.Failed(), rv.StealNSResult());
 
   // Only set selection to insertion point if editor gives permission
-  if (!mEditor->GetShouldTxnSetSelection()) {
+  if (!mEditorBase->GetShouldTxnSetSelection()) {
     // Do nothing - DOM range gravity will adjust selection
     return NS_OK;
   }
 
-  RefPtr<Selection> selection = mEditor->GetSelection();
+  RefPtr<Selection> selection = mEditorBase->GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
   rv = selection->CollapseNative(mParent, mParent->IndexOf(mNewNode) + 1);
   NS_ASSERTION(!rv.Failed(),
                "selection could not be collapsed after insert");
   return NS_OK;
 }
 
 NS_IMETHODIMP
 CreateElementTransaction::UndoTransaction()
 {
-  MOZ_ASSERT(mEditor && mParent);
+  MOZ_ASSERT(mEditorBase && mParent);
 
   ErrorResult rv;
   mParent->RemoveChild(*mNewNode, rv);
 
   return rv.StealNSResult();
 }
 
 NS_IMETHODIMP
 CreateElementTransaction::RedoTransaction()
 {
-  MOZ_ASSERT(mEditor && mParent);
+  MOZ_ASSERT(mEditorBase && mParent);
 
   // First, reset mNewNode so it has no attributes or content
   // XXX We never actually did this, we only cleared mNewNode's contents if it
   // was a CharacterData node (which it's not, it's an Element)
 
   // Now, reinsert mNewNode
   ErrorResult rv;
   mParent->InsertBefore(*mNewNode, mRefNode, rv);
--- a/editor/libeditor/CreateElementTransaction.h
+++ b/editor/libeditor/CreateElementTransaction.h
@@ -6,44 +6,44 @@
 #ifndef CreateElementTransaction_h_
 #define CreateElementTransaction_h_
 
 #include "EditTransactionBase.h"
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsISupportsImpl.h"
 
-class nsEditor;
 class nsIAtom;
 class nsIContent;
 class nsINode;
 
 /**
  * A transaction that creates a new node in the content tree.
  */
 namespace mozilla {
 
+class EditorBase;
 namespace dom {
 class Element;
 } // namespace dom
 
 class CreateElementTransaction final : public EditTransactionBase
 {
 public:
   /**
    * Initialize the transaction.
-   * @param aEditor         The provider of basic editing functionality.
+   * @param aEditorBase     The provider of basic editing functionality.
    * @param aTag            The tag (P, HR, TABLE, etc.) for the new element.
    * @param aParent         The node into which the new element will be
    *                        inserted.
    * @param aOffsetInParent The location in aParent to insert the new element.
    *                        If eAppend, the new element is appended as the last
    *                        child.
    */
-  CreateElementTransaction(nsEditor& aEditor,
+  CreateElementTransaction(EditorBase& aEditorBase,
                            nsIAtom& aTag,
                            nsINode& aParent,
                            int32_t aOffsetInParent);
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(CreateElementTransaction,
                                            EditTransactionBase)
 
@@ -52,17 +52,17 @@ public:
   NS_IMETHOD RedoTransaction() override;
 
   already_AddRefed<dom::Element> GetNewNode();
 
 protected:
   virtual ~CreateElementTransaction();
 
   // The document into which the new node will be inserted.
-  nsEditor* mEditor;
+  EditorBase* mEditorBase;
 
   // The tag (mapping to object type) for the new element.
   nsCOMPtr<nsIAtom> mTag;
 
   // The node into which the new node will be inserted.
   nsCOMPtr<nsINode> mParent;
 
   // The index in mParent for the new node.
--- a/editor/libeditor/DeleteNodeTransaction.cpp
+++ b/editor/libeditor/DeleteNodeTransaction.cpp
@@ -1,17 +1,18 @@
 /* -*- 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 "EditorBase.h"
 #include "SelectionState.h" // RangeUpdater
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsAString.h"
 
 namespace mozilla {
 
 DeleteNodeTransaction::DeleteNodeTransaction()
   : EditTransactionBase()
   , mRangeUpdater(nullptr)
@@ -28,27 +29,27 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(Delet
                                    mRefNode)
 
 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,
+DeleteNodeTransaction::Init(EditorBase* aEditorBase,
                             nsINode* aNode,
                             RangeUpdater* aRangeUpdater)
 {
-  NS_ENSURE_TRUE(aEditor && aNode, NS_ERROR_NULL_POINTER);
-  mEditor = aEditor;
+  NS_ENSURE_TRUE(aEditorBase && aNode, NS_ERROR_NULL_POINTER);
+  mEditorBase = aEditorBase;
   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),
+  NS_ENSURE_TRUE(!mParent || mEditorBase->IsModifiableNode(mParent),
                  NS_ERROR_FAILURE);
 
   mRangeUpdater = aRangeUpdater;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 DeleteNodeTransaction::DoTransaction()
--- a/editor/libeditor/DeleteNodeTransaction.h
+++ b/editor/libeditor/DeleteNodeTransaction.h
@@ -9,33 +9,32 @@
 #include "EditTransactionBase.h"
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsIContent.h"
 #include "nsINode.h"
 #include "nsISupportsImpl.h"
 #include "nscore.h"
 
-class nsEditor;
-
 namespace mozilla {
 
+class EditorBase;
 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,
+  nsresult Init(EditorBase* aEditorBase, nsINode* aNode,
                 RangeUpdater* aRangeUpdater);
 
   DeleteNodeTransaction();
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DeleteNodeTransaction,
                                            EditTransactionBase)
 
@@ -51,17 +50,17 @@ protected:
 
   // Parent of node to delete.
   nsCOMPtr<nsINode> mParent;
 
   // Next sibling to remember for undo/redo purposes.
   nsCOMPtr<nsIContent> mRefNode;
 
   // The editor for this transaction.
-  nsEditor* mEditor;
+  EditorBase* mEditorBase;
 
   // Range updater object.
   RangeUpdater* mRangeUpdater;
 };
 
 } // namespace mozilla
 
 #endif // #ifndef DeleteNodeTransaction_h_
--- a/editor/libeditor/DeleteRangeTransaction.cpp
+++ b/editor/libeditor/DeleteRangeTransaction.cpp
@@ -2,73 +2,73 @@
 /* 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 "DeleteRangeTransaction.h"
 
 #include "DeleteNodeTransaction.h"
 #include "DeleteTextTransaction.h"
+#include "EditorBase.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/dom/Selection.h"
 #include "mozilla/mozalloc.h"
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsIContent.h"
 #include "nsIContentIterator.h"
 #include "nsIDOMCharacterData.h"
 #include "nsINode.h"
 #include "nsAString.h"
 
 namespace mozilla {
 
 using namespace dom;
 
-// note that aEditor is not refcounted
+// note that aEditorBase is not refcounted
 DeleteRangeTransaction::DeleteRangeTransaction()
   : EditAggregateTransaction()
-  , mEditor(nullptr)
+  , mEditorBase(nullptr)
   , mRangeUpdater(nullptr)
 {
 }
 
 NS_IMPL_CYCLE_COLLECTION_INHERITED(DeleteRangeTransaction,
                                    EditAggregateTransaction,
                                    mRange)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeleteRangeTransaction)
 NS_INTERFACE_MAP_END_INHERITING(EditAggregateTransaction)
 
 nsresult
-DeleteRangeTransaction::Init(nsEditor* aEditor,
+DeleteRangeTransaction::Init(EditorBase* aEditorBase,
                              nsRange* aRange,
                              RangeUpdater* aRangeUpdater)
 {
-  MOZ_ASSERT(aEditor && aRange);
+  MOZ_ASSERT(aEditorBase && aRange);
 
-  mEditor = aEditor;
+  mEditorBase = aEditorBase;
   mRange = aRange->CloneRange();
   mRangeUpdater = aRangeUpdater;
 
-  NS_ENSURE_TRUE(mEditor->IsModifiableNode(mRange->GetStartParent()),
+  NS_ENSURE_TRUE(mEditorBase->IsModifiableNode(mRange->GetStartParent()),
                  NS_ERROR_FAILURE);
-  NS_ENSURE_TRUE(mEditor->IsModifiableNode(mRange->GetEndParent()),
+  NS_ENSURE_TRUE(mEditorBase->IsModifiableNode(mRange->GetEndParent()),
                  NS_ERROR_FAILURE);
-  NS_ENSURE_TRUE(mEditor->IsModifiableNode(mRange->GetCommonAncestor()),
+  NS_ENSURE_TRUE(mEditorBase->IsModifiableNode(mRange->GetCommonAncestor()),
                  NS_ERROR_FAILURE);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 DeleteRangeTransaction::DoTransaction()
 {
-  MOZ_ASSERT(mRange && mEditor);
+  MOZ_ASSERT(mRange && mEditorBase);
   nsresult res;
 
   // build the child transactions
   nsCOMPtr<nsINode> startParent = mRange->GetStartParent();
   int32_t startOffset = mRange->StartOffset();
   nsCOMPtr<nsINode> endParent = mRange->GetEndParent();
   int32_t endOffset = mRange->EndOffset();
   MOZ_ASSERT(startParent && endParent);
@@ -91,40 +91,40 @@ DeleteRangeTransaction::DoTransaction()
   }
 
   // if we've successfully built this aggregate transaction, then do it.
   res = EditAggregateTransaction::DoTransaction();
   NS_ENSURE_SUCCESS(res, res);
 
   // only set selection to deletion point if editor gives permission
   bool bAdjustSelection;
-  mEditor->ShouldTxnSetSelection(&bAdjustSelection);
+  mEditorBase->ShouldTxnSetSelection(&bAdjustSelection);
   if (bAdjustSelection) {
-    RefPtr<Selection> selection = mEditor->GetSelection();
+    RefPtr<Selection> selection = mEditorBase->GetSelection();
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     res = selection->Collapse(startParent, startOffset);
     NS_ENSURE_SUCCESS(res, res);
   }
   // else do nothing - dom range gravity will adjust selection
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 DeleteRangeTransaction::UndoTransaction()
 {
-  MOZ_ASSERT(mRange && mEditor);
+  MOZ_ASSERT(mRange && mEditorBase);
 
   return EditAggregateTransaction::UndoTransaction();
 }
 
 NS_IMETHODIMP
 DeleteRangeTransaction::RedoTransaction()
 {
-  MOZ_ASSERT(mRange && mEditor);
+  MOZ_ASSERT(mRange && mEditorBase);
 
   return EditAggregateTransaction::RedoTransaction();
 }
 
 NS_IMETHODIMP
 DeleteRangeTransaction::GetTxnDescription(nsAString& aString)
 {
   aString.AssignLiteral("DeleteRangeTransaction");
@@ -145,33 +145,33 @@ DeleteRangeTransaction::CreateTxnsToDele
     } else {
       numToDel = aEndOffset - aStartOffset;
     }
 
     RefPtr<nsGenericDOMDataNode> charDataNode =
       static_cast<nsGenericDOMDataNode*>(aNode);
 
     RefPtr<DeleteTextTransaction> transaction =
-      new DeleteTextTransaction(*mEditor, *charDataNode, aStartOffset, numToDel,
-                                mRangeUpdater);
+      new DeleteTextTransaction(*mEditorBase, *charDataNode, aStartOffset,
+                                numToDel, mRangeUpdater);
 
     nsresult res = transaction->Init();
     NS_ENSURE_SUCCESS(res, res);
 
     AppendChild(transaction);
     return NS_OK;
   }
 
   nsCOMPtr<nsIContent> child = aNode->GetChildAt(aStartOffset);
   NS_ENSURE_STATE(child);
 
   nsresult res = NS_OK;
   for (int32_t i = aStartOffset; i < aEndOffset; ++i) {
     RefPtr<DeleteNodeTransaction> transaction = new DeleteNodeTransaction();
-    res = transaction->Init(mEditor, child, mRangeUpdater);
+    res = transaction->Init(mEditorBase, child, mRangeUpdater);
     if (NS_SUCCEEDED(res)) {
       AppendChild(transaction);
     }
 
     child = child->GetNextSibling();
   }
 
   NS_ENSURE_SUCCESS(res, res);
@@ -194,17 +194,17 @@ DeleteRangeTransaction::CreateTxnsToDele
       start = 0;
       numToDelete = aOffset;
     }
 
     if (numToDelete) {
       RefPtr<nsGenericDOMDataNode> dataNode =
         static_cast<nsGenericDOMDataNode*>(aNode);
       RefPtr<DeleteTextTransaction> transaction =
-        new DeleteTextTransaction(*mEditor, *dataNode, start, numToDelete,
+        new DeleteTextTransaction(*mEditorBase, *dataNode, start, numToDelete,
                                   mRangeUpdater);
 
       nsresult res = transaction->Init();
       NS_ENSURE_SUCCESS(res, res);
 
       AppendChild(transaction);
     }
   }
@@ -220,17 +220,17 @@ DeleteRangeTransaction::CreateTxnsToDele
   nsresult res = iter->Init(mRange);
   NS_ENSURE_SUCCESS(res, res);
 
   while (!iter->IsDone()) {
     nsCOMPtr<nsINode> node = iter->GetCurrentNode();
     NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
 
     RefPtr<DeleteNodeTransaction> transaction = new DeleteNodeTransaction();
-    res = transaction->Init(mEditor, node, mRangeUpdater);
+    res = transaction->Init(mEditorBase, node, mRangeUpdater);
     NS_ENSURE_SUCCESS(res, res);
     AppendChild(transaction);
 
     iter->Next();
   }
   return NS_OK;
 }
 
--- a/editor/libeditor/DeleteRangeTransaction.h
+++ b/editor/libeditor/DeleteRangeTransaction.h
@@ -9,35 +9,35 @@
 #include "EditAggregateTransaction.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsID.h"
 #include "nsIEditor.h"
 #include "nsISupportsImpl.h"
 #include "nsRange.h"
 #include "nscore.h"
 
-class nsEditor;
 class nsINode;
 
 namespace mozilla {
 
+class EditorBase;
 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 aEditorBase The object providing basic editing operations.
    * @param aRange      The range to delete.
    */
-  nsresult Init(nsEditor* aEditor,
+  nsresult Init(EditorBase* aEditorBase,
                 nsRange* aRange,
                 RangeUpdater* aRangeUpdater);
 
   DeleteRangeTransaction();
 
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DeleteRangeTransaction,
                                            EditAggregateTransaction)
   NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
@@ -62,17 +62,17 @@ protected:
   nsresult CreateTxnsToDeleteContent(nsINode* aParent,
                                      int32_t aOffset,
                                      nsIEditor::EDirection aAction);
 
   // P1 in the range.
   RefPtr<nsRange> mRange;
 
   // The editor for this transaction.
-  nsEditor* mEditor;
+  EditorBase* mEditorBase;
 
   // Range updater object.
   RangeUpdater* mRangeUpdater;
 };
 
 } // namespace mozilla
 
 #endif // #ifndef DeleteRangeTransaction_h_
--- a/editor/libeditor/DeleteTextTransaction.cpp
+++ b/editor/libeditor/DeleteTextTransaction.cpp
@@ -1,36 +1,37 @@
 /* -*- 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 "DeleteTextTransaction.h"
+
+#include "EditorBase.h"
 #include "SelectionState.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/dom/Selection.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsIEditor.h"
 #include "nsISupportsImpl.h"
 #include "nsAString.h"
 
 namespace mozilla {
 
 using namespace dom;
 
 DeleteTextTransaction::DeleteTextTransaction(
-                         nsEditor& aEditor,
+                         EditorBase& aEditorBase,
                          nsGenericDOMDataNode& aCharData,
                          uint32_t aOffset,
                          uint32_t aNumCharsToDelete,
                          RangeUpdater* aRangeUpdater)
   : EditTransactionBase()
-  , mEditor(aEditor)
+  , mEditorBase(aEditorBase)
   , mCharData(&aCharData)
   , mOffset(aOffset)
   , mNumCharsToDelete(aNumCharsToDelete)
   , mRangeUpdater(aRangeUpdater)
 {
   NS_ASSERTION(mCharData->Length() >= aOffset + aNumCharsToDelete,
                "Trying to delete more characters than in node");
 }
@@ -40,17 +41,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(Delet
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DeleteTextTransaction)
 NS_INTERFACE_MAP_END_INHERITING(EditTransactionBase)
 
 nsresult
 DeleteTextTransaction::Init()
 {
   // Do nothing if the node is read-only
-  if (!mEditor.IsModifiableNode(mCharData)) {
+  if (!mEditorBase.IsModifiableNode(mCharData)) {
     return NS_ERROR_FAILURE;
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 DeleteTextTransaction::DoTransaction()
@@ -64,18 +65,18 @@ DeleteTextTransaction::DoTransaction()
   res = mCharData->DeleteData(mOffset, mNumCharsToDelete);
   NS_ENSURE_SUCCESS(res, res);
 
   if (mRangeUpdater) {
     mRangeUpdater->SelAdjDeleteText(mCharData, mOffset, mNumCharsToDelete);
   }
 
   // Only set selection to deletion point if editor gives permission
-  if (mEditor.GetShouldTxnSetSelection()) {
-    RefPtr<Selection> selection = mEditor.GetSelection();
+  if (mEditorBase.GetShouldTxnSetSelection()) {
+    RefPtr<Selection> selection = mEditorBase.GetSelection();
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     res = selection->Collapse(mCharData, mOffset);
     NS_ASSERTION(NS_SUCCEEDED(res),
                  "Selection could not be collapsed after undo of deletetext");
     NS_ENSURE_SUCCESS(res, res);
   }
   // Else do nothing - DOM Range gravity will adjust selection
   return NS_OK;
--- a/editor/libeditor/DeleteTextTransaction.h
+++ b/editor/libeditor/DeleteTextTransaction.h
@@ -9,37 +9,36 @@
 #include "EditTransactionBase.h"
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsGenericDOMDataNode.h"
 #include "nsID.h"
 #include "nsString.h"
 #include "nscore.h"
 
-class nsEditor;
-
 namespace mozilla {
 
+class EditorBase;
 class RangeUpdater;
 
 /**
  * A transaction that removes text from a content node.
  */
 class DeleteTextTransaction final : public EditTransactionBase
 {
 public:
   /**
    * Initialize the transaction.
-   * @param aEditor             The provider of basic editing operations.
+   * @param aEditorBase         The provider of basic editing operations.
    * @param aElement            The content node to remove text from.
    * @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,
+  DeleteTextTransaction(EditorBase& aEditorBase,
                         nsGenericDOMDataNode& aCharData,
                         uint32_t aOffset,
                         uint32_t aNumCharsToDelete,
                         RangeUpdater* aRangeUpdater);
 
   nsresult Init();
 
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DeleteTextTransaction,
@@ -49,17 +48,17 @@ public:
   NS_DECL_EDITTRANSACTIONBASE
 
   uint32_t GetOffset() { return mOffset; }
 
   uint32_t GetNumCharsToDelete() { return mNumCharsToDelete; }
 
 protected:
   // The provider of basic editing operations.
-  nsEditor& mEditor;
+  EditorBase& mEditorBase;
 
   // The CharacterData node to operate upon.
   RefPtr<nsGenericDOMDataNode> mCharData;
 
   // The offset into mCharData where the deletion is to take place.
   uint32_t mOffset;
 
   // The number of characters to delete.
rename from editor/libeditor/nsEditor.cpp
rename to editor/libeditor/EditorBase.cpp
--- a/editor/libeditor/nsEditor.cpp
+++ b/editor/libeditor/EditorBase.cpp
@@ -1,14 +1,14 @@
 /* -*- 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 "nsEditor.h"
+#include "EditorBase.h"
 
 #include "mozilla/DebugOnly.h"          // for DebugOnly
 
 #include <stdio.h>                      // for nullptr, stdout
 #include <string.h>                     // for strcmp
 
 #include "ChangeAttributeTransaction.h" // for ChangeAttributeTransaction
 #include "CompositionTransaction.h"     // for CompositionTransaction
@@ -109,84 +109,83 @@
 class nsIOutputStream;
 class nsIParserService;
 class nsITransferable;
 
 #ifdef DEBUG
 #include "nsIDOMHTMLDocument.h"         // for nsIDOMHTMLDocument
 #endif
 
-using namespace mozilla;
-using namespace mozilla::dom;
-using namespace mozilla::widget;
-
 // Defined in nsEditorRegistration.cpp
 extern nsIParserService *sParserService;
 
-//---------------------------------------------------------------------------
-//
-// nsEditor: base editor class implementation
-//
-//---------------------------------------------------------------------------
-
-nsEditor::nsEditor()
-:  mPlaceHolderName(nullptr)
-,  mSelState(nullptr)
-,  mPhonetic(nullptr)
-,  mModCount(0)
-,  mFlags(0)
-,  mUpdateCount(0)
-,  mPlaceHolderBatch(0)
-,  mAction(EditAction::none)
-,  mIMETextOffset(0)
-,  mIMETextLength(0)
-,  mDirection(eNone)
-,  mDocDirtyState(-1)
-,  mSpellcheckCheckboxState(eTriUnset)
-,  mShouldTxnSetSelection(true)
-,  mDidPreDestroy(false)
-,  mDidPostCreate(false)
-,  mDispatchInputEvent(true)
-,  mIsInEditAction(false)
-,  mHidingCaret(false)
-{
-}
-
-nsEditor::~nsEditor()
+namespace mozilla {
+
+using namespace dom;
+using namespace widget;
+
+/*****************************************************************************
+ * mozilla::EditorBase
+ *****************************************************************************/
+
+EditorBase::EditorBase()
+  : mPlaceHolderName(nullptr)
+  , mSelState(nullptr)
+  , mPhonetic(nullptr)
+  , mModCount(0)
+  , mFlags(0)
+  , mUpdateCount(0)
+  , mPlaceHolderBatch(0)
+  , mAction(EditAction::none)
+  , mIMETextOffset(0)
+  , mIMETextLength(0)
+  , mDirection(eNone)
+  , mDocDirtyState(-1)
+  , mSpellcheckCheckboxState(eTriUnset)
+  , mShouldTxnSetSelection(true)
+  , mDidPreDestroy(false)
+  , mDidPostCreate(false)
+  , mDispatchInputEvent(true)
+  , mIsInEditAction(false)
+  , mHidingCaret(false)
+{
+}
+
+EditorBase::~EditorBase()
 {
   NS_ASSERTION(!mDocWeak || mDidPreDestroy, "Why PreDestroy hasn't been called?");
 
   if (mComposition) {
     mComposition->OnEditorDestroyed();
     mComposition = nullptr;
   }
   // If this editor is still hiding the caret, we need to restore it.
   HideCaret(false);
   mTxnMgr = nullptr;
 
   delete mPhonetic;
 }
 
-NS_IMPL_CYCLE_COLLECTION_CLASS(nsEditor)
-
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsEditor)
+NS_IMPL_CYCLE_COLLECTION_CLASS(EditorBase)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(EditorBase)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mRootElement)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mInlineSpellChecker)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mTxnMgr)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mIMETextNode)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mActionListeners)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mEditorObservers)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mDocStateListeners)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mEventTarget)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mEventListener)
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mSavedSel);
  NS_IMPL_CYCLE_COLLECTION_UNLINK(mRangeUpdater);
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsEditor)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(EditorBase)
  nsIDocument* currentDoc =
    tmp->mRootElement ? tmp->mRootElement->GetUncomposedDoc() : nullptr;
  if (currentDoc &&
      nsCCUncollectableMarker::InGeneration(cb, currentDoc->GetMarkedCCGeneration())) {
    return NS_SUCCESS_INTERRUPTED_TRAVERSE;
  }
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRootElement)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mInlineSpellChecker)
@@ -196,32 +195,34 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEditorObservers)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDocStateListeners)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEventTarget)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mEventListener)
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSavedSel);
  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRangeUpdater);
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsEditor)
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(EditorBase)
  NS_INTERFACE_MAP_ENTRY(nsIPhonetic)
  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
  NS_INTERFACE_MAP_ENTRY(nsIEditorIMESupport)
  NS_INTERFACE_MAP_ENTRY(nsIEditor)
  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIEditor)
 NS_INTERFACE_MAP_END
 
-NS_IMPL_CYCLE_COLLECTING_ADDREF(nsEditor)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(nsEditor)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(EditorBase)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(EditorBase)
 
 
 NS_IMETHODIMP
-nsEditor::Init(nsIDOMDocument *aDoc, nsIContent *aRoot,
-               nsISelectionController *aSelCon, uint32_t aFlags,
-               const nsAString& aValue)
+EditorBase::Init(nsIDOMDocument* aDoc,
+                 nsIContent* aRoot,
+                 nsISelectionController* aSelCon,
+                 uint32_t aFlags,
+                 const nsAString& aValue)
 {
   NS_PRECONDITION(aDoc, "bad arg");
   if (!aDoc)
     return NS_ERROR_NULL_POINTER;
 
   // First only set flags, but other stuff shouldn't be initialized now.
   // Don't move this call after initializing mDocWeak.
   // SetFlags() can check whether it's called during initialization or not by
@@ -272,19 +273,18 @@ nsEditor::Init(nsIDOMDocument *aDoc, nsI
   // Make sure that the editor will be destroyed properly
   mDidPreDestroy = false;
   // Make sure that the ediotr will be created properly
   mDidPostCreate = false;
 
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::PostCreate()
+EditorBase::PostCreate()
 {
   // Synchronize some stuff for the flags.  SetFlags() will initialize
   // something by the flag difference.  This is first time of that, so, all
   // initializations must be run.  For such reason, we need to invert mFlags
   // value first.
   mFlags = ~mFlags;
   nsresult rv = SetFlags(~mFlags);
   NS_ENSURE_SUCCESS(rv, rv);
@@ -330,28 +330,27 @@ nsEditor::PostCreate()
   }
 
   // FYI: This call might cause destroying this editor.
   IMEStateManager::OnEditorInitialized(this);
 
   return NS_OK;
 }
 
-/* virtual */
 void
-nsEditor::CreateEventListeners()
+EditorBase::CreateEventListeners()
 {
   // Don't create the handler twice
   if (!mEventListener) {
     mEventListener = new EditorEventListener();
   }
 }
 
 nsresult
-nsEditor::InstallEventListeners()
+EditorBase::InstallEventListeners()
 {
   NS_ENSURE_TRUE(mDocWeak && mEventListener,
                  NS_ERROR_NOT_INITIALIZED);
 
   // Initialize the event target.
   nsCOMPtr<nsIContent> rootContent = GetRoot();
   NS_ENSURE_TRUE(rootContent, NS_ERROR_NOT_AVAILABLE);
   mEventTarget = do_QueryInterface(rootContent->GetParent());
@@ -363,32 +362,32 @@ nsEditor::InstallEventListeners()
   if (mComposition) {
     // Restart to handle composition with new editor contents.
     mComposition->StartHandlingComposition(this);
   }
   return rv;
 }
 
 void
-nsEditor::RemoveEventListeners()
+EditorBase::RemoveEventListeners()
 {
   if (!mDocWeak || !mEventListener) {
     return;
   }
   reinterpret_cast<EditorEventListener*>(mEventListener.get())->Disconnect();
   if (mComposition) {
     // Even if this is called, don't release mComposition because this is
     // may be reused after reframing.
     mComposition->EndHandlingComposition(this);
   }
   mEventTarget = nullptr;
 }
 
 bool
-nsEditor::GetDesiredSpellCheckState()
+EditorBase::GetDesiredSpellCheckState()
 {
   // Check user override on this element
   if (mSpellcheckCheckboxState != eTriUnset) {
     return (mSpellcheckCheckboxState == eTriTrue);
   }
 
   // Check user preferences
   int32_t spellcheckLevel = Preferences::GetInt("layout.spellcheckDefault", 1);
@@ -430,17 +429,17 @@ nsEditor::GetDesiredSpellCheckState()
 
   bool enable;
   element->GetSpellcheck(&enable);
 
   return enable;
 }
 
 NS_IMETHODIMP
-nsEditor::PreDestroy(bool aDestroyingFrames)
+EditorBase::PreDestroy(bool aDestroyingFrames)
 {
   if (mDidPreDestroy)
     return NS_OK;
 
   IMEStateManager::OnEditorDestroying(this);
 
   // Let spellchecker clean up its observers etc. It is important not to
   // actually free the spellchecker here, since the spellchecker could have
@@ -465,24 +464,24 @@ nsEditor::PreDestroy(bool aDestroyingFra
   mSpellcheckCheckboxState = eTriUnset;
   mRootElement = nullptr;
 
   mDidPreDestroy = true;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetFlags(uint32_t *aFlags)
+EditorBase::GetFlags(uint32_t* aFlags)
 {
   *aFlags = mFlags;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::SetFlags(uint32_t aFlags)
+EditorBase::SetFlags(uint32_t aFlags)
 {
   if (mFlags == aFlags) {
     return NS_OK;
   }
 
   bool spellcheckerWasEnabled = CanEnableSpellCheck();
   mFlags = aFlags;
 
@@ -518,104 +517,104 @@ nsEditor::SetFlags(uint32_t aFlags)
       IMEStateManager::UpdateIMEState(newState, content, this);
     }
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetIsSelectionEditable(bool *aIsSelectionEditable)
+EditorBase::GetIsSelectionEditable(bool* aIsSelectionEditable)
 {
   NS_ENSURE_ARG_POINTER(aIsSelectionEditable);
 
   // get current selection
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
   // XXX we just check that the anchor node is editable at the moment
   //     we should check that all nodes in the selection are editable
   nsCOMPtr<nsINode> anchorNode = selection->GetAnchorNode();
   *aIsSelectionEditable = anchorNode && IsEditable(anchorNode);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetIsDocumentEditable(bool *aIsDocumentEditable)
+EditorBase::GetIsDocumentEditable(bool* aIsDocumentEditable)
 {
   NS_ENSURE_ARG_POINTER(aIsDocumentEditable);
   nsCOMPtr<nsIDocument> doc = GetDocument();
   *aIsDocumentEditable = !!doc;
 
   return NS_OK;
 }
 
 already_AddRefed<nsIDocument>
-nsEditor::GetDocument()
+EditorBase::GetDocument()
 {
   NS_PRECONDITION(mDocWeak, "bad state, mDocWeak weak pointer not initialized");
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
   return doc.forget();
 }
 
 already_AddRefed<nsIDOMDocument>
-nsEditor::GetDOMDocument()
+EditorBase::GetDOMDocument()
 {
   NS_PRECONDITION(mDocWeak, "bad state, mDocWeak weak pointer not initialized");
   nsCOMPtr<nsIDOMDocument> doc = do_QueryReferent(mDocWeak);
   return doc.forget();
 }
 
 NS_IMETHODIMP
-nsEditor::GetDocument(nsIDOMDocument **aDoc)
+EditorBase::GetDocument(nsIDOMDocument** aDoc)
 {
   *aDoc = GetDOMDocument().take();
   return *aDoc ? NS_OK : NS_ERROR_NOT_INITIALIZED;
 }
 
 already_AddRefed<nsIPresShell>
-nsEditor::GetPresShell()
+EditorBase::GetPresShell()
 {
   NS_PRECONDITION(mDocWeak, "bad state, null mDocWeak");
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
   NS_ENSURE_TRUE(doc, nullptr);
   nsCOMPtr<nsIPresShell> ps = doc->GetShell();
   return ps.forget();
 }
 
 already_AddRefed<nsIWidget>
-nsEditor::GetWidget()
+EditorBase::GetWidget()
 {
   nsCOMPtr<nsIPresShell> ps = GetPresShell();
   NS_ENSURE_TRUE(ps, nullptr);
   nsPresContext* pc = ps->GetPresContext();
   NS_ENSURE_TRUE(pc, nullptr);
   nsCOMPtr<nsIWidget> widget = pc->GetRootWidget();
   NS_ENSURE_TRUE(widget.get(), nullptr);
   return widget.forget();
 }
 
 NS_IMETHODIMP
-nsEditor::GetContentsMIMEType(char * *aContentsMIMEType)
+EditorBase::GetContentsMIMEType(char** aContentsMIMEType)
 {
   NS_ENSURE_ARG_POINTER(aContentsMIMEType);
   *aContentsMIMEType = ToNewCString(mContentMIMEType);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::SetContentsMIMEType(const char * aContentsMIMEType)
+EditorBase::SetContentsMIMEType(const char* aContentsMIMEType)
 {
   mContentMIMEType.Assign(aContentsMIMEType ? aContentsMIMEType : "");
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetSelectionController(nsISelectionController **aSel)
+EditorBase::GetSelectionController(nsISelectionController** aSel)
 {
   NS_ENSURE_TRUE(aSel, NS_ERROR_NULL_POINTER);
   *aSel = nullptr; // init out param
   nsCOMPtr<nsISelectionController> selCon;
   if (mSelConWeak) {
     selCon = do_QueryReferent(mSelConWeak);
   } else {
     nsCOMPtr<nsIPresShell> presShell = GetPresShell();
@@ -623,58 +622,58 @@ nsEditor::GetSelectionController(nsISele
   }
   if (!selCon) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   NS_ADDREF(*aSel = selCon);
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::DeleteSelection(EDirection aAction, EStripWrappers aStripWrappers)
+EditorBase::DeleteSelection(EDirection aAction,
+                            EStripWrappers aStripWrappers)
 {
   MOZ_ASSERT(aStripWrappers == eStrip || aStripWrappers == eNoStrip);
   return DeleteSelectionImpl(aAction, aStripWrappers);
 }
 
-
 NS_IMETHODIMP
-nsEditor::GetSelection(nsISelection** aSelection)
+EditorBase::GetSelection(nsISelection** aSelection)
 {
   return GetSelection(SelectionType::eNormal, aSelection);
 }
 
 nsresult
-nsEditor::GetSelection(SelectionType aSelectionType, nsISelection** aSelection)
+EditorBase::GetSelection(SelectionType aSelectionType,
+                         nsISelection** aSelection)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
   *aSelection = nullptr;
   nsCOMPtr<nsISelectionController> selcon;
   GetSelectionController(getter_AddRefs(selcon));
   if (!selcon) {
     return NS_ERROR_NOT_INITIALIZED;
   }
   return selcon->GetSelection(ToRawSelectionType(aSelectionType), aSelection);
 }
 
 Selection*
-nsEditor::GetSelection(SelectionType aSelectionType)
+EditorBase::GetSelection(SelectionType aSelectionType)
 {
   nsCOMPtr<nsISelection> sel;
   nsresult res = GetSelection(aSelectionType, getter_AddRefs(sel));
   if (NS_WARN_IF(NS_FAILED(res)) || NS_WARN_IF(!sel)) {
     return nullptr;
   }
 
   return sel->AsSelection();
 }
 
 NS_IMETHODIMP
-nsEditor::DoTransaction(nsITransaction* aTxn)
+EditorBase::DoTransaction(nsITransaction* aTxn)
 {
   if (mPlaceHolderBatch && !mPlaceHolderTxn) {
     nsCOMPtr<nsIAbsorbingTransaction> placeholderTransaction =
       new PlaceholderTransaction();
 
     // Save off weak reference to placeholder transaction
     mPlaceHolderTxn = do_GetWeakReference(placeholderTransaction);
     placeholderTransaction->Init(mPlaceHolderName, mSelState, this);
@@ -742,72 +741,71 @@ nsEditor::DoTransaction(nsITransaction* 
     selection->EndBatchChanges();
 
     NS_ENSURE_SUCCESS(res, res);
   }
 
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::EnableUndo(bool aEnable)
+EditorBase::EnableUndo(bool aEnable)
 {
   if (aEnable) {
     if (!mTxnMgr) {
       mTxnMgr = new nsTransactionManager();
     }
     mTxnMgr->SetMaxTransactionCount(-1);
   } else if (mTxnMgr) {
     // disable the transaction manager if it is enabled
     mTxnMgr->Clear();
     mTxnMgr->SetMaxTransactionCount(0);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetNumberOfUndoItems(int32_t* aNumItems)
+EditorBase::GetNumberOfUndoItems(int32_t* aNumItems)
 {
   *aNumItems = 0;
   return mTxnMgr ? mTxnMgr->GetNumberOfUndoItems(aNumItems) : NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetNumberOfRedoItems(int32_t* aNumItems)
+EditorBase::GetNumberOfRedoItems(int32_t* aNumItems)
 {
   *aNumItems = 0;
   return mTxnMgr ? mTxnMgr->GetNumberOfRedoItems(aNumItems) : NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetTransactionManager(nsITransactionManager* *aTxnManager)
+EditorBase::GetTransactionManager(nsITransactionManager** aTxnManager)
 {
   NS_ENSURE_ARG_POINTER(aTxnManager);
 
   *aTxnManager = nullptr;
   NS_ENSURE_TRUE(mTxnMgr, NS_ERROR_FAILURE);
 
   NS_ADDREF(*aTxnManager = mTxnMgr);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::SetTransactionManager(nsITransactionManager *aTxnManager)
+EditorBase::SetTransactionManager(nsITransactionManager* aTxnManager)
 {
   NS_ENSURE_TRUE(aTxnManager, NS_ERROR_FAILURE);
 
   // nsITransactionManager is builtinclass, so this is safe
   mTxnMgr = static_cast<nsTransactionManager*>(aTxnManager);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::Undo(uint32_t aCount)
+EditorBase::Undo(uint32_t aCount)
 {
   ForceCompositionEnd();
 
   bool hasTxnMgr, hasTransaction = false;
   CanUndo(&hasTxnMgr, &hasTransaction);
   NS_ENSURE_TRUE(hasTransaction, NS_OK);
 
   AutoRules beginRulesSniffing(this, EditAction::undo, nsIEditor::eNone);
@@ -821,34 +819,34 @@ nsEditor::Undo(uint32_t aCount)
     NS_ENSURE_SUCCESS(rv, rv);
 
     DoAfterUndoTransaction();
   }
 
   return NS_OK;
 }
 
-
-NS_IMETHODIMP nsEditor::CanUndo(bool *aIsEnabled, bool *aCanUndo)
+NS_IMETHODIMP
+EditorBase::CanUndo(bool* aIsEnabled,
+                    bool* aCanUndo)
 {
   NS_ENSURE_TRUE(aIsEnabled && aCanUndo, NS_ERROR_NULL_POINTER);
   *aIsEnabled = !!mTxnMgr;
   if (*aIsEnabled) {
     int32_t numTxns = 0;
     mTxnMgr->GetNumberOfUndoItems(&numTxns);
     *aCanUndo = !!numTxns;
   } else {
     *aCanUndo = false;
   }
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::Redo(uint32_t aCount)
+EditorBase::Redo(uint32_t aCount)
 {
   bool hasTxnMgr, hasTransaction = false;
   CanRedo(&hasTxnMgr, &hasTransaction);
   NS_ENSURE_TRUE(hasTransaction, NS_OK);
 
   AutoRules beginRulesSniffing(this, EditAction::redo, nsIEditor::eNone);
 
   if (!mTxnMgr) {
@@ -860,47 +858,46 @@ nsEditor::Redo(uint32_t aCount)
     NS_ENSURE_SUCCESS(rv, rv);
 
     DoAfterRedoTransaction();
   }
 
   return NS_OK;
 }
 
-
-NS_IMETHODIMP nsEditor::CanRedo(bool *aIsEnabled, bool *aCanRedo)
+NS_IMETHODIMP
+EditorBase::CanRedo(bool* aIsEnabled, bool* aCanRedo)
 {
   NS_ENSURE_TRUE(aIsEnabled && aCanRedo, NS_ERROR_NULL_POINTER);
 
   *aIsEnabled = !!mTxnMgr;
   if (*aIsEnabled) {
     int32_t numTxns = 0;
     mTxnMgr->GetNumberOfRedoItems(&numTxns);
     *aCanRedo = !!numTxns;
   } else {
     *aCanRedo = false;
   }
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::BeginTransaction()
+EditorBase::BeginTransaction()
 {
   BeginUpdateViewBatch();
 
   if (mTxnMgr) {
     mTxnMgr->BeginBatch(nullptr);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::EndTransaction()
+EditorBase::EndTransaction()
 {
   if (mTxnMgr) {
     mTxnMgr->EndBatch(false);
   }
 
   EndUpdateViewBatch();
 
   return NS_OK;
@@ -910,17 +907,17 @@ nsEditor::EndTransaction()
 // These two routines are similar to the above, but do not use
 // the transaction managers batching feature.  Instead we use
 // a placeholder transaction to wrap up any further transaction
 // while the batch is open.  The advantage of this is that
 // placeholder transactions can later merge, if needed.  Merging
 // is unavailable between transaction manager batches.
 
 NS_IMETHODIMP
-nsEditor::BeginPlaceHolderTransaction(nsIAtom *aName)
+EditorBase::BeginPlaceHolderTransaction(nsIAtom* aName)
 {
   NS_PRECONDITION(mPlaceHolderBatch >= 0, "negative placeholder batch count!");
   if (!mPlaceHolderBatch)
   {
     NotifyEditorObservers(eNotifyEditorObserversOfBefore);
     // time to turn on the batch
     BeginUpdateViewBatch();
     mPlaceHolderTxn = nullptr;
@@ -932,17 +929,17 @@ nsEditor::BeginPlaceHolderTransaction(ns
     }
   }
   mPlaceHolderBatch++;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::EndPlaceHolderTransaction()
+EditorBase::EndPlaceHolderTransaction()
 {
   NS_PRECONDITION(mPlaceHolderBatch > 0, "zero or negative placeholder batch count when ending batch!");
   if (mPlaceHolderBatch == 1)
   {
     RefPtr<Selection> selection = GetSelection();
 
     // By making the assumption that no reflow happens during the calls
     // to EndUpdateViewBatch and ScrollSelectionIntoView, we are able to
@@ -1007,55 +1004,57 @@ nsEditor::EndPlaceHolderTransaction()
     }
   }
   mPlaceHolderBatch--;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::ShouldTxnSetSelection(bool *aResult)
+EditorBase::ShouldTxnSetSelection(bool* aResult)
 {
   NS_ENSURE_TRUE(aResult, NS_ERROR_NULL_POINTER);
   *aResult = mShouldTxnSetSelection;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::SetShouldTxnSetSelection(bool aShould)
+EditorBase::SetShouldTxnSetSelection(bool aShould)
 {
   mShouldTxnSetSelection = aShould;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetDocumentIsEmpty(bool *aDocumentIsEmpty)
+EditorBase::GetDocumentIsEmpty(bool* aDocumentIsEmpty)
 {
   *aDocumentIsEmpty = true;
 
   dom::Element* root = GetRoot();
   NS_ENSURE_TRUE(root, NS_ERROR_NULL_POINTER);
 
   *aDocumentIsEmpty = !root->HasChildren();
   return NS_OK;
 }
 
-
-// XXX: the rule system should tell us which node to select all on (ie, the root, or the body)
-NS_IMETHODIMP nsEditor::SelectAll()
+// XXX: The rule system should tell us which node to select all on (ie, the
+//      root, or the body)
+NS_IMETHODIMP
+EditorBase::SelectAll()
 {
   if (!mDocWeak) { return NS_ERROR_NOT_INITIALIZED; }
   ForceCompositionEnd();
 
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);
   return SelectEntireDocument(selection);
 }
 
-NS_IMETHODIMP nsEditor::BeginningOfDocument()
+NS_IMETHODIMP
+EditorBase::BeginningOfDocument()
 {
   if (!mDocWeak) { return NS_ERROR_NOT_INITIALIZED; }
 
   // get the selection
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);
 
   // get the root element
@@ -1080,17 +1079,17 @@ NS_IMETHODIMP nsEditor::BeginningOfDocum
     return NS_ERROR_NULL_POINTER;
   }
 
   int32_t offsetInParent = parent->IndexOf(firstNode);
   return selection->CollapseNative(parent, offsetInParent);
 }
 
 NS_IMETHODIMP
-nsEditor::EndOfDocument()
+EditorBase::EndOfDocument()
 {
   NS_ENSURE_TRUE(mDocWeak, NS_ERROR_NOT_INITIALIZED);
 
   // get selection
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
 
   // get the root element
@@ -1103,119 +1102,121 @@ nsEditor::EndOfDocument()
     child = node->GetLastChild();
   }
 
   uint32_t length = node->Length();
   return selection->CollapseNative(node, int32_t(length));
 }
 
 NS_IMETHODIMP
-nsEditor::GetDocumentModified(bool *outDocModified)
+EditorBase::GetDocumentModified(bool* outDocModified)
 {
   NS_ENSURE_TRUE(outDocModified, NS_ERROR_NULL_POINTER);
 
   int32_t  modCount = 0;
   GetModificationCount(&modCount);
 
   *outDocModified = (modCount != 0);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetDocumentCharacterSet(nsACString &characterSet)
+EditorBase::GetDocumentCharacterSet(nsACString& characterSet)
 {
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
   NS_ENSURE_TRUE(doc, NS_ERROR_UNEXPECTED);
 
   characterSet = doc->GetDocumentCharacterSet();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::SetDocumentCharacterSet(const nsACString& characterSet)
+EditorBase::SetDocumentCharacterSet(const nsACString& characterSet)
 {
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
   NS_ENSURE_TRUE(doc, NS_ERROR_UNEXPECTED);
 
   doc->SetDocumentCharacterSet(characterSet);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::Cut()
+EditorBase::Cut()
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::CanCut(bool *aCanCut)
+EditorBase::CanCut(bool* aCanCut)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::Copy()
+EditorBase::Copy()
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::CanCopy(bool *aCanCut)
+EditorBase::CanCopy(bool* aCanCut)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::CanDelete(bool *aCanDelete)
+EditorBase::CanDelete(bool* aCanDelete)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::Paste(int32_t aSelectionType)
+EditorBase::Paste(int32_t aSelectionType)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::PasteTransferable(nsITransferable *aTransferable)
+EditorBase::PasteTransferable(nsITransferable* aTransferable)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::CanPaste(int32_t aSelectionType, bool *aCanPaste)
+EditorBase::CanPaste(int32_t aSelectionType, bool* aCanPaste)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::CanPasteTransferable(nsITransferable *aTransferable, bool *aCanPaste)
+EditorBase::CanPasteTransferable(nsITransferable* aTransferable,
+                                 bool* aCanPaste)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::SetAttribute(nsIDOMElement* aElement, const nsAString& aAttribute,
-                       const nsAString& aValue)
+EditorBase::SetAttribute(nsIDOMElement* aElement,
+                         const nsAString& aAttribute,
+                         const nsAString& aValue)
 {
   nsCOMPtr<Element> element = do_QueryInterface(aElement);
   NS_ENSURE_TRUE(element, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIAtom> attribute = NS_Atomize(aAttribute);
 
   RefPtr<ChangeAttributeTransaction> transaction =
     CreateTxnForSetAttribute(*element, *attribute, aValue);
   return DoTransaction(transaction);
 }
 
 NS_IMETHODIMP
-nsEditor::GetAttributeValue(nsIDOMElement *aElement,
-                            const nsAString & aAttribute,
-                            nsAString & aResultValue,
-                            bool *aResultIsSet)
+EditorBase::GetAttributeValue(nsIDOMElement* aElement,
+                              const nsAString& aAttribute,
+                              nsAString& aResultValue,
+                              bool* aResultIsSet)
 {
   NS_ENSURE_TRUE(aResultIsSet, NS_ERROR_NULL_POINTER);
   *aResultIsSet = false;
   if (!aElement) {
     return NS_OK;
   }
   nsAutoString value;
   nsresult rv = aElement->GetAttribute(aAttribute, value);
@@ -1223,55 +1224,55 @@ nsEditor::GetAttributeValue(nsIDOMElemen
   if (!DOMStringIsNull(value)) {
     *aResultIsSet = true;
     aResultValue = value;
   }
   return rv;
 }
 
 NS_IMETHODIMP
-nsEditor::RemoveAttribute(nsIDOMElement* aElement, const nsAString& aAttribute)
+EditorBase::RemoveAttribute(nsIDOMElement* aElement,
+                            const nsAString& aAttribute)
 {
   nsCOMPtr<Element> element = do_QueryInterface(aElement);
   NS_ENSURE_TRUE(element, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIAtom> attribute = NS_Atomize(aAttribute);
 
   RefPtr<ChangeAttributeTransaction> transaction =
     CreateTxnForRemoveAttribute(*element, *attribute);
   return DoTransaction(transaction);
 }
 
-
 bool
-nsEditor::OutputsMozDirty()
+EditorBase::OutputsMozDirty()
 {
   // Return true for Composer (!eEditorAllowInteraction) or mail
   // (eEditorMailMask), but false for webpages.
   return !(mFlags & nsIPlaintextEditor::eEditorAllowInteraction) ||
           (mFlags & nsIPlaintextEditor::eEditorMailMask);
 }
 
-
 NS_IMETHODIMP
-nsEditor::MarkNodeDirty(nsIDOMNode* aNode)
+EditorBase::MarkNodeDirty(nsIDOMNode* aNode)
 {
   // Mark the node dirty, but not for webpages (bug 599983)
   if (!OutputsMozDirty()) {
     return NS_OK;
   }
   nsCOMPtr<dom::Element> element = do_QueryInterface(aNode);
   if (element) {
     element->SetAttr(kNameSpaceID_None, nsGkAtoms::mozdirty,
                      EmptyString(), false);
   }
   return NS_OK;
 }
 
-NS_IMETHODIMP nsEditor::GetInlineSpellChecker(bool autoCreate,
-                                              nsIInlineSpellChecker ** aInlineSpellChecker)
+NS_IMETHODIMP
+EditorBase::GetInlineSpellChecker(bool autoCreate,
+                                  nsIInlineSpellChecker** aInlineSpellChecker)
 {
   NS_ENSURE_ARG_POINTER(aInlineSpellChecker);
 
   if (mDidPreDestroy) {
     // Don't allow people to get or create the spell checker once the editor
     // is going away.
     *aInlineSpellChecker = nullptr;
     return autoCreate ? NS_ERROR_NOT_AVAILABLE : NS_OK;
@@ -1297,17 +1298,18 @@ NS_IMETHODIMP nsEditor::GetInlineSpellCh
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   NS_IF_ADDREF(*aInlineSpellChecker = mInlineSpellChecker);
 
   return NS_OK;
 }
 
-NS_IMETHODIMP nsEditor::SyncRealTimeSpell()
+NS_IMETHODIMP
+EditorBase::SyncRealTimeSpell()
 {
   bool enable = GetDesiredSpellCheckState();
 
   // Initializes mInlineSpellChecker
   nsCOMPtr<nsIInlineSpellChecker> spellChecker;
   GetInlineSpellChecker(enable, getter_AddRefs(spellChecker));
 
   if (mInlineSpellChecker) {
@@ -1315,41 +1317,42 @@ NS_IMETHODIMP nsEditor::SyncRealTimeSpel
     // available since we don't destroy the mInlineSpellChecker when the last
     // dictionariy is removed, but in that case spellChecker is null
     mInlineSpellChecker->SetEnableRealTimeSpell(enable && spellChecker);
   }
 
   return NS_OK;
 }
 
-NS_IMETHODIMP nsEditor::SetSpellcheckUserOverride(bool enable)
+NS_IMETHODIMP
+EditorBase::SetSpellcheckUserOverride(bool enable)
 {
   mSpellcheckCheckboxState = enable ? eTriTrue : eTriFalse;
 
   return SyncRealTimeSpell();
 }
 
 NS_IMETHODIMP
-nsEditor::CreateNode(const nsAString& aTag,
-                     nsIDOMNode* aParent,
-                     int32_t aPosition,
-                     nsIDOMNode** aNewNode)
+EditorBase::CreateNode(const nsAString& aTag,
+                       nsIDOMNode* aParent,
+                       int32_t aPosition,
+                       nsIDOMNode** aNewNode)
 {
   nsCOMPtr<nsIAtom> tag = NS_Atomize(aTag);
   nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
   NS_ENSURE_STATE(parent);
   *aNewNode = GetAsDOMNode(CreateNode(tag, parent, aPosition).take());
   NS_ENSURE_STATE(*aNewNode);
   return NS_OK;
 }
 
 already_AddRefed<Element>
-nsEditor::CreateNode(nsIAtom* aTag,
-                     nsINode* aParent,
-                     int32_t aPosition)
+EditorBase::CreateNode(nsIAtom* aTag,
+                       nsINode* aParent,
+                       int32_t aPosition)
 {
   MOZ_ASSERT(aTag && aParent);
 
   AutoRules beginRulesSniffing(this, EditAction::createNode, nsIEditor::eNext);
 
   for (auto& listener : mActionListeners) {
     listener->WillCreateNode(nsDependentAtomString(aTag),
                              GetAsDOMNode(aParent), aPosition);
@@ -1370,29 +1373,32 @@ nsEditor::CreateNode(nsIAtom* aTag,
   for (auto& listener : mActionListeners) {
     listener->DidCreateNode(nsDependentAtomString(aTag), GetAsDOMNode(ret),
                             GetAsDOMNode(aParent), aPosition, res);
   }
 
   return ret.forget();
 }
 
-
 NS_IMETHODIMP
-nsEditor::InsertNode(nsIDOMNode* aNode, nsIDOMNode* aParent, int32_t aPosition)
+EditorBase::InsertNode(nsIDOMNode* aNode,
+                       nsIDOMNode* aParent,
+                       int32_t aPosition)
 {
   nsCOMPtr<nsIContent> node = do_QueryInterface(aNode);
   nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
   NS_ENSURE_TRUE(node && parent, NS_ERROR_NULL_POINTER);
 
   return InsertNode(*node, *parent, aPosition);
 }
 
 nsresult
-nsEditor::InsertNode(nsIContent& aNode, nsINode& aParent, int32_t aPosition)
+EditorBase::InsertNode(nsIContent& aNode,
+                       nsINode& aParent,
+                       int32_t aPosition)
 {
   AutoRules beginRulesSniffing(this, EditAction::insertNode, nsIEditor::eNext);
 
   for (auto& listener : mActionListeners) {
     listener->WillInsertNode(aNode.AsDOMNode(), aParent.AsDOMNode(),
                              aPosition);
   }
 
@@ -1406,30 +1412,32 @@ nsEditor::InsertNode(nsIContent& aNode, 
     listener->DidInsertNode(aNode.AsDOMNode(), aParent.AsDOMNode(), aPosition,
                             rv);
   }
 
   return rv;
 }
 
 NS_IMETHODIMP
-nsEditor::SplitNode(nsIDOMNode* aNode,
-                    int32_t aOffset,
-                    nsIDOMNode** aNewLeftNode)
+EditorBase::SplitNode(nsIDOMNode* aNode,
+                      int32_t aOffset,
+                      nsIDOMNode** aNewLeftNode)
 {
   nsCOMPtr<nsIContent> node = do_QueryInterface(aNode);
   NS_ENSURE_STATE(node);
   ErrorResult rv;
   nsCOMPtr<nsIContent> newNode = SplitNode(*node, aOffset, rv);
   *aNewLeftNode = GetAsDOMNode(newNode.forget().take());
   return rv.StealNSResult();
 }
 
 nsIContent*
-nsEditor::SplitNode(nsIContent& aNode, int32_t aOffset, ErrorResult& aResult)
+EditorBase::SplitNode(nsIContent& aNode,
+                      int32_t aOffset,
+                      ErrorResult& aResult)
 {
   AutoRules beginRulesSniffing(this, EditAction::splitNode, nsIEditor::eNext);
 
   for (auto& listener : mActionListeners) {
     listener->WillSplitNode(aNode.AsDOMNode(), aOffset);
   }
 
   RefPtr<SplitNodeTransaction> transaction =
@@ -1448,30 +1456,30 @@ nsEditor::SplitNode(nsIContent& aNode, i
   }
   // Note: result might be a success code, so we can't use Throw() to
   // set it on aResult.
   aResult = result;
 
   return newNode;
 }
 
-
 NS_IMETHODIMP
-nsEditor::JoinNodes(nsIDOMNode* aLeftNode,
-                    nsIDOMNode* aRightNode,
-                    nsIDOMNode*)
+EditorBase::JoinNodes(nsIDOMNode* aLeftNode,
+                      nsIDOMNode* aRightNode,
+                      nsIDOMNode*)
 {
   nsCOMPtr<nsINode> leftNode = do_QueryInterface(aLeftNode);
   nsCOMPtr<nsINode> rightNode = do_QueryInterface(aRightNode);
   NS_ENSURE_STATE(leftNode && rightNode && leftNode->GetParentNode());
   return JoinNodes(*leftNode, *rightNode);
 }
 
 nsresult
-nsEditor::JoinNodes(nsINode& aLeftNode, nsINode& aRightNode)
+EditorBase::JoinNodes(nsINode& aLeftNode,
+                      nsINode& aRightNode)
 {
   nsCOMPtr<nsINode> parent = aLeftNode.GetParentNode();
   MOZ_ASSERT(parent);
 
   AutoRules beginRulesSniffing(this, EditAction::joinNode,
                                nsIEditor::ePrevious);
 
   // Remember some values; later used for saved selection updating.
@@ -1498,27 +1506,26 @@ nsEditor::JoinNodes(nsINode& aLeftNode, 
   for (auto& listener : mActionListeners) {
     listener->DidJoinNodes(aLeftNode.AsDOMNode(), aRightNode.AsDOMNode(),
                            parent->AsDOMNode(), result);
   }
 
   return result;
 }
 
-
 NS_IMETHODIMP
-nsEditor::DeleteNode(nsIDOMNode* aNode)
+EditorBase::DeleteNode(nsIDOMNode* aNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_STATE(node);
   return DeleteNode(node);
 }
 
 nsresult
-nsEditor::DeleteNode(nsINode* aNode)
+EditorBase::DeleteNode(nsINode* aNode)
 {
   AutoRules beginRulesSniffing(this, EditAction::createNode,
                                nsIEditor::ePrevious);
 
   // save node location for selection updating code.
   for (auto& listener : mActionListeners) {
     listener->WillDeleteNode(aNode->AsDOMNode());
   }
@@ -1532,27 +1539,27 @@ nsEditor::DeleteNode(nsINode* aNode)
   for (auto& listener : mActionListeners) {
     listener->DidDeleteNode(aNode->AsDOMNode(), rv);
   }
 
   NS_ENSURE_SUCCESS(rv, rv);
   return NS_OK;
 }
 
-///////////////////////////////////////////////////////////////////////////
-// ReplaceContainer: replace inNode with a new node (outNode) which is contructed
-//                   to be of type aNodeType.  Put inNodes children into outNode.
-//                   Callers responsibility to make sure inNode's children can
-//                   go in outNode.
+/**
+ * ReplaceContainer() replaces inNode with a new node (outNode) which is
+ * constructed to be of type aNodeType.  Put inNodes children into outNode.
+ * Callers responsibility to make sure inNode's children can go in outNode.
+ */
 already_AddRefed<Element>
-nsEditor::ReplaceContainer(Element* aOldContainer,
-                           nsIAtom* aNodeType,
-                           nsIAtom* aAttribute,
-                           const nsAString* aValue,
-                           ECloneAttributes aCloneAttributes)
+EditorBase::ReplaceContainer(Element* aOldContainer,
+                             nsIAtom* aNodeType,
+                             nsIAtom* aAttribute,
+                             const nsAString* aValue,
+                             ECloneAttributes aCloneAttributes)
 {
   MOZ_ASSERT(aOldContainer && aNodeType);
 
   nsCOMPtr<nsIContent> parent = aOldContainer->GetParent();
   NS_ENSURE_TRUE(parent, nullptr);
 
   int32_t offset = parent->IndexOf(aOldContainer);
 
@@ -1594,22 +1601,22 @@ nsEditor::ReplaceContainer(Element* aOld
 
   // delete old container
   res = DeleteNode(aOldContainer);
   NS_ENSURE_SUCCESS(res, nullptr);
 
   return ret.forget();
 }
 
-///////////////////////////////////////////////////////////////////////////////
-// RemoveContainer: remove inNode, reparenting its children (if any) into the
-//                  parent of inNode
-//
+/**
+ * RemoveContainer() removes inNode, reparenting its children (if any) into the
+ * parent of inNode.
+ */
 nsresult
-nsEditor::RemoveContainer(nsIContent* aNode)
+EditorBase::RemoveContainer(nsIContent* aNode)
 {
   MOZ_ASSERT(aNode);
 
   nsCOMPtr<nsINode> parent = aNode->GetParentNode();
   NS_ENSURE_STATE(parent);
 
   int32_t offset = parent->IndexOf(aNode);
 
@@ -1627,28 +1634,27 @@ nsEditor::RemoveContainer(nsIContent* aN
 
     rv = InsertNode(*child, *parent, offset);
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   return DeleteNode(aNode);
 }
 
-
-///////////////////////////////////////////////////////////////////////////////
-// InsertContainerAbove: Insert a new parent for inNode, which is contructed to
-//                       be of type aNodeType.  outNode becomes a child of
-//                       inNode's earlier parent.  Caller's responsibility to
-//                       make sure inNode's can be child of outNode, and
-//                       outNode can be child of old parent.
+/**
+ * InsertContainerAbove() inserts a new parent for inNode, which is contructed
+ * to be of type aNodeType.  outNode becomes a child of inNode's earlier
+ * parent.  Caller's responsibility to make sure inNode's can be child of
+ * outNode, and outNode can be child of old parent.
+ */
 already_AddRefed<Element>
-nsEditor::InsertContainerAbove(nsIContent* aNode,
-                               nsIAtom* aNodeType,
-                               nsIAtom* aAttribute,
-                               const nsAString* aValue)
+EditorBase::InsertContainerAbove(nsIContent* aNode,
+                                 nsIAtom* aNodeType,
+                                 nsIAtom* aAttribute,
+                                 const nsAString* aValue)
 {
   MOZ_ASSERT(aNode && aNodeType);
 
   nsCOMPtr<nsIContent> parent = aNode->GetParent();
   NS_ENSURE_TRUE(parent, nullptr);
   int32_t offset = parent->IndexOf(aNode);
 
   // Create new container
@@ -1677,20 +1683,23 @@ nsEditor::InsertContainerAbove(nsIConten
 
   // Put new parent in doc
   res = InsertNode(*newContent, *parent, offset);
   NS_ENSURE_SUCCESS(res, nullptr);
 
   return newContent.forget();
 }
 
-///////////////////////////////////////////////////////////////////////////
-// MoveNode:  move aNode to {aParent,aOffset}
+/**
+ * MoveNode() moves aNode to {aParent,aOffset}.
+ */
 nsresult
-nsEditor::MoveNode(nsIContent* aNode, nsINode* aParent, int32_t aOffset)
+EditorBase::MoveNode(nsIContent* aNode,
+                     nsINode* aParent,
+                     int32_t aOffset)
 {
   MOZ_ASSERT(aNode);
   MOZ_ASSERT(aParent);
   MOZ_ASSERT(aOffset == -1 ||
              (0 <= aOffset &&
               AssertedCast<uint32_t>(aOffset) <= aParent->Length()));
 
   nsCOMPtr<nsINode> oldParent = aNode->GetParentNode();
@@ -1720,71 +1729,69 @@ nsEditor::MoveNode(nsIContent* aNode, ns
   nsCOMPtr<nsINode> kungFuDeathGrip = aNode;
 
   nsresult rv = DeleteNode(aNode);
   NS_ENSURE_SUCCESS(rv, rv);
 
   return InsertNode(*aNode, *aParent, aOffset);
 }
 
-
 NS_IMETHODIMP
-nsEditor::AddEditorObserver(nsIEditorObserver *aObserver)
+EditorBase::AddEditorObserver(nsIEditorObserver* aObserver)
 {
   // we don't keep ownership of the observers.  They must
   // remove themselves as observers before they are destroyed.
 
   NS_ENSURE_TRUE(aObserver, NS_ERROR_NULL_POINTER);
 
   // Make sure the listener isn't already on the list
   if (!mEditorObservers.Contains(aObserver)) {
     mEditorObservers.AppendElement(*aObserver);
   }
 
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::RemoveEditorObserver(nsIEditorObserver *aObserver)
+EditorBase::RemoveEditorObserver(nsIEditorObserver* aObserver)
 {
   NS_ENSURE_TRUE(aObserver, NS_ERROR_FAILURE);
 
   mEditorObservers.RemoveElement(aObserver);
 
   return NS_OK;
 }
 
-class EditorInputEventDispatcher : public Runnable
+class EditorInputEventDispatcher final : public Runnable
 {
 public:
-  EditorInputEventDispatcher(nsEditor* aEditor,
+  EditorInputEventDispatcher(EditorBase* aEditorBase,
                              nsIContent* aTarget,
                              bool aIsComposing)
-    : mEditor(aEditor)
+    : mEditorBase(aEditorBase)
     , mTarget(aTarget)
     , mIsComposing(aIsComposing)
   {
   }
 
   NS_IMETHOD Run()
   {
     // Note that we don't need to check mDispatchInputEvent here.  We need
     // to check it only when the editor requests to dispatch the input event.
 
     if (!mTarget->IsInComposedDoc()) {
       return NS_OK;
     }
 
-    nsCOMPtr<nsIPresShell> ps = mEditor->GetPresShell();
+    nsCOMPtr<nsIPresShell> ps = mEditorBase->GetPresShell();
     if (!ps) {
       return NS_OK;
     }
 
-    nsCOMPtr<nsIWidget> widget = mEditor->GetWidget();
+    nsCOMPtr<nsIWidget> widget = mEditorBase->GetWidget();
     if (!widget) {
       return NS_OK;
     }
 
     // Even if the change is caused by untrusted event, we need to dispatch
     // trusted input event since it's a fact.
     InternalEditorInputEvent inputEvent(true, eEditorInput, widget);
     inputEvent.mTime = static_cast<uint64_t>(PR_Now() / 1000);
@@ -1792,23 +1799,23 @@ public:
     nsEventStatus status = nsEventStatus_eIgnore;
     nsresult rv =
       ps->HandleEventWithTarget(&inputEvent, nullptr, mTarget, &status);
     NS_ENSURE_SUCCESS(rv, NS_OK); // print the warning if error
     return NS_OK;
   }
 
 private:
-  RefPtr<nsEditor> mEditor;
+  RefPtr<EditorBase> mEditorBase;
   nsCOMPtr<nsIContent> mTarget;
   bool mIsComposing;
 };
 
 void
-nsEditor::NotifyEditorObservers(NotificationForEditorObservers aNotification)
+EditorBase::NotifyEditorObservers(NotificationForEditorObservers aNotification)
 {
   // Copy the observers since EditAction()s can modify mEditorObservers.
   nsTArray<mozilla::OwningNonNull<nsIEditorObserver>> observers(mEditorObservers);
   switch (aNotification) {
     case eNotifyEditorObserversOfEnd:
       mIsInEditAction = false;
       for (auto& observer : observers) {
         observer->EditAction();
@@ -1837,17 +1844,17 @@ nsEditor::NotifyEditorObservers(Notifica
       break;
     default:
       MOZ_CRASH("Handle all notifications here");
       break;
   }
 }
 
 void
-nsEditor::FireInputEvent()
+EditorBase::FireInputEvent()
 {
   // We don't need to dispatch multiple input events if there is a pending
   // input event.  However, it may have different event target.  If we resolved
   // this issue, we need to manage the pending events in an array.  But it's
   // overwork.  We don't need to do it for the very rare case.
 
   nsCOMPtr<nsIContent> target = GetInputEventTargetContent();
   NS_ENSURE_TRUE_VOID(target);
@@ -1855,178 +1862,173 @@ nsEditor::FireInputEvent()
   // NOTE: Don't refer IsIMEComposing() because it returns false even before
   //       compositionend.  However, DOM Level 3 Events defines it should be
   //       true after compositionstart and before compositionend.
   nsContentUtils::AddScriptRunner(
     new EditorInputEventDispatcher(this, target, !!GetComposition()));
 }
 
 NS_IMETHODIMP
-nsEditor::AddEditActionListener(nsIEditActionListener *aListener)
+EditorBase::AddEditActionListener(nsIEditActionListener* aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_NULL_POINTER);
 
   // Make sure the listener isn't already on the list
   if (!mActionListeners.Contains(aListener)) {
     mActionListeners.AppendElement(*aListener);
   }
 
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::RemoveEditActionListener(nsIEditActionListener *aListener)
+EditorBase::RemoveEditActionListener(nsIEditActionListener* aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_FAILURE);
 
   mActionListeners.RemoveElement(aListener);
 
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::AddDocumentStateListener(nsIDocumentStateListener *aListener)
+EditorBase::AddDocumentStateListener(nsIDocumentStateListener* aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_NULL_POINTER);
 
   if (!mDocStateListeners.Contains(aListener)) {
     mDocStateListeners.AppendElement(*aListener);
   }
 
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::RemoveDocumentStateListener(nsIDocumentStateListener *aListener)
+EditorBase::RemoveDocumentStateListener(nsIDocumentStateListener* aListener)
 {
   NS_ENSURE_TRUE(aListener, NS_ERROR_NULL_POINTER);
 
   mDocStateListeners.RemoveElement(aListener);
 
   return NS_OK;
 }
 
-
-NS_IMETHODIMP nsEditor::OutputToString(const nsAString& aFormatType,
-                                       uint32_t aFlags,
-                                       nsAString& aOutputString)
+NS_IMETHODIMP
+EditorBase::OutputToString(const nsAString& aFormatType,
+                           uint32_t aFlags,
+                           nsAString& aOutputString)
 {
   // these should be implemented by derived classes.
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::OutputToStream(nsIOutputStream* aOutputStream,
-                         const nsAString& aFormatType,
-                         const nsACString& aCharsetOverride,
-                         uint32_t aFlags)
+EditorBase::OutputToStream(nsIOutputStream* aOutputStream,
+                           const nsAString& aFormatType,
+                           const nsACString& aCharsetOverride,
+                           uint32_t aFlags)
 {
   // these should be implemented by derived classes.
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsEditor::DumpContentTree()
+EditorBase::DumpContentTree()
 {
 #ifdef DEBUG
   if (mRootElement) {
     mRootElement->List(stdout);
   }
 #endif
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::DebugDumpContent()
+EditorBase::DebugDumpContent()
 {
 #ifdef DEBUG
   nsCOMPtr<nsIDOMHTMLDocument> doc = do_QueryReferent(mDocWeak);
   NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
 
   nsCOMPtr<nsIDOMHTMLElement>bodyElem;
   doc->GetBody(getter_AddRefs(bodyElem));
   nsCOMPtr<nsIContent> content = do_QueryInterface(bodyElem);
   if (content)
     content->List();
 #endif
   return NS_OK;
 }
 
-
 NS_IMETHODIMP
-nsEditor::DebugUnitTests(int32_t *outNumTests, int32_t *outNumTestsFailed)
+EditorBase::DebugUnitTests(int32_t* outNumTests,
+                           int32_t* outNumTestsFailed)
 {
 #ifdef DEBUG
   NS_NOTREACHED("This should never get called. Overridden by subclasses");
 #endif
   return NS_OK;
 }
 
-
 bool
-nsEditor::ArePreservingSelection()
+EditorBase::ArePreservingSelection()
 {
   return !(mSavedSel.IsEmpty());
 }
 
 void
-nsEditor::PreserveSelectionAcrossActions(Selection* aSel)
+EditorBase::PreserveSelectionAcrossActions(Selection* aSel)
 {
   mSavedSel.SaveSelection(aSel);
   mRangeUpdater.RegisterSelectionState(mSavedSel);
 }
 
 nsresult
-nsEditor::RestorePreservedSelection(Selection* aSel)
+EditorBase::RestorePreservedSelection(Selection* aSel)
 {
   if (mSavedSel.IsEmpty()) return NS_ERROR_FAILURE;
   mSavedSel.RestoreSelection(aSel);
   StopPreservingSelection();
   return NS_OK;
 }
 
 void
-nsEditor::StopPreservingSelection()
+EditorBase::StopPreservingSelection()
 {
   mRangeUpdater.DropSelectionState(mSavedSel);
   mSavedSel.MakeEmpty();
 }
 
 void
-nsEditor::EnsureComposition(mozilla::WidgetCompositionEvent* aCompositionEvent)
+EditorBase::EnsureComposition(WidgetCompositionEvent* aCompositionEvent)
 {
   if (mComposition) {
     return;
   }
   // The compositionstart event must cause creating new TextComposition
   // instance at being dispatched by IMEStateManager.
   mComposition = IMEStateManager::GetTextCompositionFor(aCompositionEvent);
   if (!mComposition) {
     MOZ_CRASH("IMEStateManager doesn't return proper composition");
   }
   mComposition->StartHandlingComposition(this);
 }
 
 nsresult
-nsEditor::BeginIMEComposition(WidgetCompositionEvent* aCompositionEvent)
+EditorBase::BeginIMEComposition(WidgetCompositionEvent* aCompositionEvent)
 {
   MOZ_ASSERT(!mComposition, "There is composition already");
   EnsureComposition(aCompositionEvent);
   if (mPhonetic) {
     mPhonetic->Truncate(0);
   }
   return NS_OK;
 }
 
 void
-nsEditor::EndIMEComposition()
+EditorBase::EndIMEComposition()
 {
   NS_ENSURE_TRUE_VOID(mComposition); // nothing to do
 
   // commit the IME transaction..we can get at it via the transaction mgr.
   // Note that this means IME won't work without an undo stack!
   if (mTxnMgr) {
     nsCOMPtr<nsITransaction> txn = mTxnMgr->PeekUndoStack();
     nsCOMPtr<nsIAbsorbingTransaction> plcTxn = do_QueryInterface(txn);
@@ -2047,46 +2049,45 @@ nsEditor::EndIMEComposition()
   mIMETextLength = 0;
   mComposition->EndHandlingComposition(this);
   mComposition = nullptr;
 
   // notify editor observers of action
   NotifyEditorObservers(eNotifyEditorObserversOfEnd);
 }
 
-
 NS_IMETHODIMP
-nsEditor::GetPhonetic(nsAString& aPhonetic)
+EditorBase::GetPhonetic(nsAString& aPhonetic)
 {
   if (mPhonetic)
     aPhonetic = *mPhonetic;
   else
     aPhonetic.Truncate(0);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::ForceCompositionEnd()
+EditorBase::ForceCompositionEnd()
 {
   nsCOMPtr<nsIPresShell> ps = GetPresShell();
   if (!ps) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   nsPresContext* pc = ps->GetPresContext();
   if (!pc) {
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   return mComposition ?
     IMEStateManager::NotifyIME(REQUEST_TO_COMMIT_COMPOSITION, pc) : NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetPreferredIMEState(IMEState *aState)
+EditorBase::GetPreferredIMEState(IMEState* aState)
 {
   NS_ENSURE_ARG_POINTER(aState);
   aState->mEnabled = IMEState::ENABLED;
   aState->mOpen = IMEState::DONT_CHANGE_OPEN_STATE;
 
   if (IsReadonly() || IsDisabled()) {
     aState->mEnabled = IMEState::DISABLED;
     return NS_OK;
@@ -2114,61 +2115,62 @@ nsEditor::GetPreferredIMEState(IMEState 
       aState->mOpen = IMEState::CLOSED;
       break;
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetComposing(bool* aResult)
+EditorBase::GetComposing(bool* aResult)
 {
   NS_ENSURE_ARG_POINTER(aResult);
   *aResult = IsIMEComposing();
   return NS_OK;
 }
 
-
-/* Non-interface, public methods */
-
 NS_IMETHODIMP
-nsEditor::GetRootElement(nsIDOMElement **aRootElement)
+EditorBase::GetRootElement(nsIDOMElement** aRootElement)
 {
   NS_ENSURE_ARG_POINTER(aRootElement);
   NS_ENSURE_TRUE(mRootElement, NS_ERROR_NOT_AVAILABLE);
   nsCOMPtr<nsIDOMElement> rootElement = do_QueryInterface(mRootElement);
   rootElement.forget(aRootElement);
   return NS_OK;
 }
 
-
-/** All editor operations which alter the doc should be prefaced
- *  with a call to StartOperation, naming the action and direction */
+/**
+ * All editor operations which alter the doc should be prefaced
+ * with a call to StartOperation, naming the action and direction.
+ */
 NS_IMETHODIMP
-nsEditor::StartOperation(EditAction opID, nsIEditor::EDirection aDirection)
+EditorBase::StartOperation(EditAction opID,
+                           nsIEditor::EDirection aDirection)
 {
   mAction = opID;
   mDirection = aDirection;
   return NS_OK;
 }
 
-
-/** All editor operations which alter the doc should be followed
- *  with a call to EndOperation */
+/**
+ * All editor operations which alter the doc should be followed
+ * with a call to EndOperation.
+ */
 NS_IMETHODIMP
-nsEditor::EndOperation()
+EditorBase::EndOperation()
 {
   mAction = EditAction::none;
   mDirection = eNone;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::CloneAttribute(const nsAString & aAttribute,
-                         nsIDOMNode *aDestNode, nsIDOMNode *aSourceNode)
+EditorBase::CloneAttribute(const nsAString& aAttribute,
+                           nsIDOMNode* aDestNode,
+                           nsIDOMNode* aSourceNode)
 {
   NS_ENSURE_TRUE(aDestNode && aSourceNode, NS_ERROR_NULL_POINTER);
 
   nsCOMPtr<nsIDOMElement> destElement = do_QueryInterface(aDestNode);
   nsCOMPtr<nsIDOMElement> sourceElement = do_QueryInterface(aSourceNode);
   NS_ENSURE_TRUE(destElement && sourceElement, NS_ERROR_NO_INTERFACE);
 
   nsAutoString attrValue;
@@ -2181,33 +2183,38 @@ nsEditor::CloneAttribute(const nsAString
   if (isAttrSet)
     rv = SetAttribute(destElement, aAttribute, attrValue);
   else
     rv = RemoveAttribute(destElement, aAttribute);
 
   return rv;
 }
 
-// Objects must be DOM elements
+/**
+ * @param aDest     Must be a DOM element.
+ * @param aSource   Must be a DOM element.
+ */
 NS_IMETHODIMP
-nsEditor::CloneAttributes(nsIDOMNode* aDest, nsIDOMNode* aSource)
+EditorBase::CloneAttributes(nsIDOMNode* aDest,
+                            nsIDOMNode* aSource)
 {
   NS_ENSURE_TRUE(aDest && aSource, NS_ERROR_NULL_POINTER);
 
   nsCOMPtr<Element> dest = do_QueryInterface(aDest);
   nsCOMPtr<Element> source = do_QueryInterface(aSource);
   NS_ENSURE_TRUE(dest && source, NS_ERROR_NO_INTERFACE);
 
   CloneAttributes(dest, source);
 
   return NS_OK;
 }
 
 void
-nsEditor::CloneAttributes(Element* aDest, Element* aSource)
+EditorBase::CloneAttributes(Element* aDest,
+                            Element* aSource)
 {
   MOZ_ASSERT(aDest && aSource);
 
   AutoEditBatch beginBatching(this);
 
   // Use transaction system for undo only if destination is already in the
   // document
   NS_ENSURE_TRUE(GetRoot(), );
@@ -2239,18 +2246,18 @@ nsEditor::CloneAttributes(Element* aDest
       // The element is not inserted in the document yet, we don't want to put
       // a transaction on the UndoStack
       SetAttributeOrEquivalent(static_cast<nsIDOMElement*>(GetAsDOMNode(aDest)),
                                attr->NodeName(), value, true);
     }
   }
 }
 
-
-NS_IMETHODIMP nsEditor::ScrollSelectionIntoView(bool aScrollToAnchor)
+NS_IMETHODIMP
+EditorBase::ScrollSelectionIntoView(bool aScrollToAnchor)
 {
   nsCOMPtr<nsISelectionController> selCon;
   if (NS_SUCCEEDED(GetSelectionController(getter_AddRefs(selCon))) && selCon)
   {
     int16_t region = nsISelectionController::SELECTION_FOCUS_REGION;
 
     if (aScrollToAnchor)
       region = nsISelectionController::SELECTION_ANCHOR_REGION;
@@ -2258,18 +2265,18 @@ NS_IMETHODIMP nsEditor::ScrollSelectionI
     selCon->ScrollSelectionIntoView(nsISelectionController::SELECTION_NORMAL,
       region, nsISelectionController::SCROLL_OVERFLOW_HIDDEN);
   }
 
   return NS_OK;
 }
 
 void
-nsEditor::FindBetterInsertionPoint(nsCOMPtr<nsINode>& aNode,
-                                   int32_t& aOffset)
+EditorBase::FindBetterInsertionPoint(nsCOMPtr<nsINode>& aNode,
+                                     int32_t& aOffset)
 {
   if (aNode->IsNodeOfType(nsINode::eTEXT)) {
     // There is no "better" insertion point.
     return;
   }
 
   if (!IsPlaintextEditor()) {
     // We cannot find "better" insertion point in HTML editor.
@@ -2322,20 +2329,20 @@ nsEditor::FindBetterInsertionPoint(nsCOM
       aNode = node->GetParentNode();
       aOffset = 0;
       return;
     }
   }
 }
 
 nsresult
-nsEditor::InsertTextImpl(const nsAString& aStringToInsert,
-                         nsCOMPtr<nsINode>* aInOutNode,
-                         int32_t* aInOutOffset,
-                         nsIDocument* aDoc)
+EditorBase::InsertTextImpl(const nsAString& aStringToInsert,
+                           nsCOMPtr<nsINode>* aInOutNode,
+                           int32_t* aInOutOffset,
+                           nsIDocument* aDoc)
 {
   // NOTE: caller *must* have already used AutoTransactionsConserveSelection
   // stack-based class to turn off txn selection updating.  Caller also turned
   // on rules sniffing if desired.
 
   NS_ENSURE_TRUE(aInOutNode && *aInOutNode && aInOutOffset && aDoc,
                  NS_ERROR_NULL_POINTER);
 
@@ -2397,21 +2404,21 @@ nsEditor::InsertTextImpl(const nsAString
     }
   }
 
   *aInOutNode = node;
   *aInOutOffset = offset;
   return NS_OK;
 }
 
-
 nsresult
-nsEditor::InsertTextIntoTextNodeImpl(const nsAString& aStringToInsert,
-                                     Text& aTextNode,
-                                     int32_t aOffset, bool aSuppressIME)
+EditorBase::InsertTextIntoTextNodeImpl(const nsAString& aStringToInsert,
+                                       Text& aTextNode,
+                                       int32_t aOffset,
+                                       bool aSuppressIME)
 {
   RefPtr<EditTransactionBase> transaction;
   bool isIMETransaction = false;
   int32_t replacedOffset = 0;
   int32_t replacedLength = 0;
   // aSuppressIME is used when editor must insert text, yet this text is not
   // part of the current IME operation. Example: adjusting whitespace around an
   // IME insertion.
@@ -2492,45 +2499,43 @@ nsEditor::InsertTextIntoTextNodeImpl(con
       mIMETextNode = nullptr;
       static_cast<CompositionTransaction*>(transaction.get())->MarkFixed();
     }
   }
 
   return rv;
 }
 
-
 nsresult
-nsEditor::SelectEntireDocument(Selection* aSelection)
+EditorBase::SelectEntireDocument(Selection* aSelection)
 {
   if (!aSelection) { return NS_ERROR_NULL_POINTER; }
 
   nsCOMPtr<nsIDOMElement> rootElement = do_QueryInterface(GetRoot());
   if (!rootElement) { return NS_ERROR_NOT_INITIALIZED; }
 
   return aSelection->SelectAllChildren(rootElement);
 }
 
-
 nsINode*
-nsEditor::GetFirstEditableNode(nsINode* aRoot)
+EditorBase::GetFirstEditableNode(nsINode* aRoot)
 {
   MOZ_ASSERT(aRoot);
 
   nsIContent* node = GetLeftmostChild(aRoot);
   if (node && !IsEditable(node)) {
     node = GetNextNode(node, /* aEditableNode = */ true);
   }
 
   return (node != aRoot) ? node : nullptr;
 }
 
-
 NS_IMETHODIMP
-nsEditor::NotifyDocumentListeners(TDocumentListenerNotification aNotificationType)
+EditorBase::NotifyDocumentListeners(
+              TDocumentListenerNotification aNotificationType)
 {
   if (!mDocStateListeners.Length()) {
     // Maybe there just aren't any.
     return NS_OK;
   }
 
   nsTArray<OwningNonNull<nsIDocumentStateListener>>
     listeners(mDocStateListeners);
@@ -2575,29 +2580,30 @@ nsEditor::NotifyDocumentListeners(TDocum
 
     default:
       NS_NOTREACHED("Unknown notification");
   }
 
   return rv;
 }
 
-
 already_AddRefed<InsertTextTransaction>
-nsEditor::CreateTxnForInsertText(const nsAString& aStringToInsert,
-                                 Text& aTextNode, int32_t aOffset)
+EditorBase::CreateTxnForInsertText(const nsAString& aStringToInsert,
+                                   Text& aTextNode,
+                                   int32_t aOffset)
 {
   RefPtr<InsertTextTransaction> transaction =
     new InsertTextTransaction(aTextNode, aOffset, aStringToInsert, *this);
   return transaction.forget();
 }
 
 nsresult
-nsEditor::DeleteText(nsGenericDOMDataNode& aCharData, uint32_t aOffset,
-                     uint32_t aLength)
+EditorBase::DeleteText(nsGenericDOMDataNode& aCharData,
+                       uint32_t aOffset,
+                       uint32_t aLength)
 {
   RefPtr<DeleteTextTransaction> transaction =
     CreateTxnForDeleteText(aCharData, aOffset, aLength);
   NS_ENSURE_STATE(transaction);
 
   AutoRules beginRulesSniffing(this, EditAction::deleteText,
                                nsIEditor::ePrevious);
 
@@ -2616,64 +2622,63 @@ nsEditor::DeleteText(nsGenericDOMDataNod
         static_cast<nsIDOMCharacterData*>(GetAsDOMNode(&aCharData)), aOffset,
         aLength, rv);
   }
 
   return rv;
 }
 
 already_AddRefed<DeleteTextTransaction>
-nsEditor::CreateTxnForDeleteText(nsGenericDOMDataNode& aCharData,
-                                 uint32_t aOffset, uint32_t aLength)
+EditorBase::CreateTxnForDeleteText(nsGenericDOMDataNode& aCharData,
+                                   uint32_t aOffset,
+                                   uint32_t aLength)
 {
   RefPtr<DeleteTextTransaction> transaction =
     new DeleteTextTransaction(*this, aCharData, aOffset, aLength,
                               &mRangeUpdater);
   nsresult rv = transaction->Init();
   NS_ENSURE_SUCCESS(rv, nullptr);
 
   return transaction.forget();
 }
 
 already_AddRefed<SplitNodeTransaction>
-nsEditor::CreateTxnForSplitNode(nsIContent& aNode, uint32_t aOffset)
+EditorBase::CreateTxnForSplitNode(nsIContent& aNode,
+                                  uint32_t aOffset)
 {
   RefPtr<SplitNodeTransaction> transaction =
     new SplitNodeTransaction(*this, aNode, aOffset);
   return transaction.forget();
 }
 
 already_AddRefed<JoinNodeTransaction>
-nsEditor::CreateTxnForJoinNode(nsINode& aLeftNode, nsINode& aRightNode)
+EditorBase::CreateTxnForJoinNode(nsINode& aLeftNode,
+                                 nsINode& aRightNode)
 {
   RefPtr<JoinNodeTransaction> transaction =
     new JoinNodeTransaction(*this, aLeftNode, aRightNode);
 
   NS_ENSURE_SUCCESS(transaction->CheckValidity(), nullptr);
 
   return transaction.forget();
 }
 
-// END nsEditor core implementation
-
-
-// BEGIN nsEditor public helper methods
-
-struct SavedRange {
+struct SavedRange final
+{
   RefPtr<Selection> mSelection;
   nsCOMPtr<nsINode> mStartNode;
   nsCOMPtr<nsINode> mEndNode;
   int32_t mStartOffset;
   int32_t mEndOffset;
 };
 
 nsresult
-nsEditor::SplitNodeImpl(nsIContent& aExistingRightNode,
-                        int32_t aOffset,
-                        nsIContent& aNewLeftNode)
+EditorBase::SplitNodeImpl(nsIContent& aExistingRightNode,
+                          int32_t aOffset,
+                          nsIContent& aNewLeftNode)
 {
   // Remember all selection points.
   AutoTArray<SavedRange, 10> savedRanges;
   for (size_t i = 0; i < kPresentSelectionTypeCount; ++i) {
     SelectionType selectionType(ToSelectionType(1 << i));
     SavedRange range;
     range.mSelection = GetSelection(selectionType);
     if (selectionType == SelectionType::eNormal) {
@@ -2796,19 +2801,19 @@ nsEditor::SplitNodeImpl(nsIContent& aExi
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     selection->Collapse(&aNewLeftNode, aOffset);
   }
 
   return NS_OK;
 }
 
 nsresult
-nsEditor::JoinNodesImpl(nsINode* aNodeToKeep,
-                        nsINode* aNodeToJoin,
-                        nsINode* aParent)
+EditorBase::JoinNodesImpl(nsINode* aNodeToKeep,
+                          nsINode* aNodeToJoin,
+                          nsINode* aParent)
 {
   MOZ_ASSERT(aNodeToKeep);
   MOZ_ASSERT(aNodeToJoin);
   MOZ_ASSERT(aParent);
 
   uint32_t firstNodeLength = aNodeToJoin->Length();
 
   int32_t joinOffset;
@@ -2945,83 +2950,87 @@ nsEditor::JoinNodesImpl(nsINode* aNodeTo
     RefPtr<Selection> selection = GetSelection();
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     selection->Collapse(aNodeToKeep, AssertedCast<int32_t>(firstNodeLength));
   }
 
   return err.StealNSResult();
 }
 
-
 int32_t
-nsEditor::GetChildOffset(nsIDOMNode* aChild, nsIDOMNode* aParent)
+EditorBase::GetChildOffset(nsIDOMNode* aChild,
+                           nsIDOMNode* aParent)
 {
   MOZ_ASSERT(aChild && aParent);
 
   nsCOMPtr<nsINode> parent = do_QueryInterface(aParent);
   nsCOMPtr<nsINode> child = do_QueryInterface(aChild);
   MOZ_ASSERT(parent && child);
 
   int32_t idx = parent->IndexOf(child);
   MOZ_ASSERT(idx != -1);
   return idx;
 }
 
 // static
 already_AddRefed<nsIDOMNode>
-nsEditor::GetNodeLocation(nsIDOMNode* aChild, int32_t* outOffset)
+EditorBase::GetNodeLocation(nsIDOMNode* aChild,
+                            int32_t* outOffset)
 {
   MOZ_ASSERT(aChild && outOffset);
   NS_ENSURE_TRUE(aChild && outOffset, nullptr);
   *outOffset = -1;
 
   nsCOMPtr<nsIDOMNode> parent;
 
   MOZ_ALWAYS_SUCCEEDS(aChild->GetParentNode(getter_AddRefs(parent)));
   if (parent) {
     *outOffset = GetChildOffset(aChild, parent);
   }
 
   return parent.forget();
 }
 
 nsINode*
-nsEditor::GetNodeLocation(nsINode* aChild, int32_t* aOffset)
+EditorBase::GetNodeLocation(nsINode* aChild,
+                            int32_t* aOffset)
 {
   MOZ_ASSERT(aChild);
   MOZ_ASSERT(aOffset);
 
   nsINode* parent = aChild->GetParentNode();
   if (parent) {
     *aOffset = parent->IndexOf(aChild);
     MOZ_ASSERT(*aOffset != -1);
   } else {
     *aOffset = -1;
   }
   return parent;
 }
 
-// returns the number of things inside aNode.
-// If aNode is text, returns number of characters. If not, returns number of children nodes.
+/**
+ * Returns the number of things inside aNode.  If aNode is text, returns number
+ * of characters. If not, returns number of children nodes.
+ */
 nsresult
-nsEditor::GetLengthOfDOMNode(nsIDOMNode *aNode, uint32_t &aCount)
+EditorBase::GetLengthOfDOMNode(nsIDOMNode* aNode,
+                               uint32_t& aCount)
 {
   aCount = 0;
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   NS_ENSURE_TRUE(node, NS_ERROR_NULL_POINTER);
   aCount = node->Length();
   return NS_OK;
 }
 
-
 nsIContent*
-nsEditor::GetPriorNode(nsINode* aParentNode,
-                       int32_t aOffset,
-                       bool aEditableNode,
-                       bool aNoBlockCrossing)
+EditorBase::GetPriorNode(nsINode* aParentNode,
+                         int32_t aOffset,
+                         bool aEditableNode,
+                         bool aNoBlockCrossing)
 {
   MOZ_ASSERT(aParentNode);
 
   // If we are at the beginning of the node, or it is a text node, then just
   // look before it.
   if (!aOffset || aParentNode->NodeType() == nsIDOMNode::TEXT_NODE) {
     if (aNoBlockCrossing && IsBlockNode(aParentNode)) {
       // If we aren't allowed to cross blocks, don't look before this block.
@@ -3041,22 +3050,21 @@ nsEditor::GetPriorNode(nsINode* aParentN
   if (!resultNode || !aEditableNode || IsEditable(resultNode)) {
     return resultNode;
   }
 
   // restart the search from the non-editable node we just found
   return GetPriorNode(resultNode, aEditableNode, aNoBlockCrossing);
 }
 
-
 nsIContent*
-nsEditor::GetNextNode(nsINode* aParentNode,
-                      int32_t aOffset,
-                      bool aEditableNode,
-                      bool aNoBlockCrossing)
+EditorBase::GetNextNode(nsINode* aParentNode,
+                        int32_t aOffset,
+                        bool aEditableNode,
+                        bool aNoBlockCrossing)
 {
   MOZ_ASSERT(aParentNode);
 
   // if aParentNode is a text node, use its location instead
   if (aParentNode->NodeType() == nsIDOMNode::TEXT_NODE) {
     nsINode* parent = aParentNode->GetParentNode();
     NS_ENSURE_TRUE(parent, nullptr);
     aOffset = parent->IndexOf(aParentNode) + 1; // _after_ the text node
@@ -3092,34 +3100,34 @@ nsEditor::GetNextNode(nsINode* aParentNo
   if (aNoBlockCrossing && IsBlockNode(aParentNode)) {
     // don't cross out of parent block
     return nullptr;
   }
 
   return GetNextNode(aParentNode, aEditableNode, aNoBlockCrossing);
 }
 
-
 nsIContent*
-nsEditor::GetPriorNode(nsINode* aCurrentNode, bool aEditableNode,
-                       bool aNoBlockCrossing /* = false */)
+EditorBase::GetPriorNode(nsINode* aCurrentNode,
+                         bool aEditableNode,
+                         bool aNoBlockCrossing /* = false */)
 {
   MOZ_ASSERT(aCurrentNode);
 
   if (!IsDescendantOfEditorRoot(aCurrentNode)) {
     return nullptr;
   }
 
   return FindNode(aCurrentNode, false, aEditableNode, aNoBlockCrossing);
 }
 
 nsIContent*
-nsEditor::FindNextLeafNode(nsINode  *aCurrentNode,
-                           bool      aGoForward,
-                           bool      bNoBlockCrossing)
+EditorBase::FindNextLeafNode(nsINode* aCurrentNode,
+                             bool aGoForward,
+                             bool bNoBlockCrossing)
 {
   // called only by GetPriorNode so we don't need to check params.
   NS_PRECONDITION(IsDescendantOfEditorRoot(aCurrentNode) &&
                   !IsEditorRoot(aCurrentNode),
                   "Bogus arguments");
 
   nsINode* cur = aCurrentNode;
   for (;;) {
@@ -3159,34 +3167,34 @@ nsEditor::FindNextLeafNode(nsINode  *aCu
     cur = parent;
   }
 
   NS_NOTREACHED("What part of for(;;) do you not understand?");
   return nullptr;
 }
 
 nsIContent*
-nsEditor::GetNextNode(nsINode* aCurrentNode,
-                      bool aEditableNode,
-                      bool bNoBlockCrossing)
+EditorBase::GetNextNode(nsINode* aCurrentNode,
+                        bool aEditableNode,
+                        bool bNoBlockCrossing)
 {
   MOZ_ASSERT(aCurrentNode);
 
   if (!IsDescendantOfEditorRoot(aCurrentNode)) {
     return nullptr;
   }
 
   return FindNode(aCurrentNode, true, aEditableNode, bNoBlockCrossing);
 }
 
 nsIContent*
-nsEditor::FindNode(nsINode *aCurrentNode,
-                   bool     aGoForward,
-                   bool     aEditableNode,
-                   bool     bNoBlockCrossing)
+EditorBase::FindNode(nsINode* aCurrentNode,
+                     bool aGoForward,
+                     bool aEditableNode,
+                     bool bNoBlockCrossing)
 {
   if (IsEditorRoot(aCurrentNode)) {
     // Don't allow traversal above the root node! This helps
     // prevent us from accidentally editing browser content
     // when the editor is in a text widget.
 
     return nullptr;
   }
@@ -3201,18 +3209,18 @@ nsEditor::FindNode(nsINode *aCurrentNode
   if (!aEditableNode || IsEditable(candidate)) {
     return candidate;
   }
 
   return FindNode(candidate, aGoForward, aEditableNode, bNoBlockCrossing);
 }
 
 nsIContent*
-nsEditor::GetRightmostChild(nsINode *aCurrentNode,
-                            bool     bNoBlockCrossing)
+EditorBase::GetRightmostChild(nsINode* aCurrentNode,
+                              bool bNoBlockCrossing)
 {
   NS_ENSURE_TRUE(aCurrentNode, nullptr);
   nsIContent *cur = aCurrentNode->GetLastChild();
   if (!cur) {
     return nullptr;
   }
   for (;;) {
     if (bNoBlockCrossing && IsBlockNode(cur)) {
@@ -3225,18 +3233,18 @@ nsEditor::GetRightmostChild(nsINode *aCu
     cur = next;
   }
 
   NS_NOTREACHED("What part of for(;;) do you not understand?");
   return nullptr;
 }
 
 nsIContent*
-nsEditor::GetLeftmostChild(nsINode *aCurrentNode,
-                           bool     bNoBlockCrossing)
+EditorBase::GetLeftmostChild(nsINode* aCurrentNode,
+                             bool bNoBlockCrossing)
 {
   NS_ENSURE_TRUE(aCurrentNode, nullptr);
   nsIContent *cur = aCurrentNode->GetFirstChild();
   if (!cur) {
     return nullptr;
   }
   for (;;) {
     if (bNoBlockCrossing && IsBlockNode(cur)) {
@@ -3249,134 +3257,138 @@ nsEditor::GetLeftmostChild(nsINode *aCur
     cur = next;
   }
 
   NS_NOTREACHED("What part of for(;;) do you not understand?");
   return nullptr;
 }
 
 bool
-nsEditor::IsBlockNode(nsINode* aNode)
+EditorBase::IsBlockNode(nsINode* aNode)
 {
   // stub to be overridden in HTMLEditor.
   // screwing around with the class hierarchy here in order
   // to not duplicate the code in GetNextNode/GetPrevNode
-  // across both nsEditor/HTMLEditor.
+  // across both EditorBase/HTMLEditor.
   return false;
 }
 
 bool
-nsEditor::CanContain(nsINode& aParent, nsIContent& aChild)
+EditorBase::CanContain(nsINode& aParent,
+                       nsIContent& aChild)
 {
   switch (aParent.NodeType()) {
   case nsIDOMNode::ELEMENT_NODE:
   case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
     return TagCanContain(*aParent.NodeInfo()->NameAtom(), aChild);
   }
   return false;
 }
 
 bool
-nsEditor::CanContainTag(nsINode& aParent, nsIAtom& aChildTag)
+EditorBase::CanContainTag(nsINode& aParent,
+                          nsIAtom& aChildTag)
 {
   switch (aParent.NodeType()) {
   case nsIDOMNode::ELEMENT_NODE:
   case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
     return TagCanContainTag(*aParent.NodeInfo()->NameAtom(), aChildTag);
   }
   return false;
 }
 
 bool
-nsEditor::TagCanContain(nsIAtom& aParentTag, nsIContent& aChild)
+EditorBase::TagCanContain(nsIAtom& aParentTag,
+                          nsIContent& aChild)
 {
   switch (aChild.NodeType()) {
   case nsIDOMNode::TEXT_NODE:
   case nsIDOMNode::ELEMENT_NODE:
   case nsIDOMNode::DOCUMENT_FRAGMENT_NODE:
     return TagCanContainTag(aParentTag, *aChild.NodeInfo()->NameAtom());
   }
   return false;
 }
 
 bool
-nsEditor::TagCanContainTag(nsIAtom& aParentTag, nsIAtom& aChildTag)
+EditorBase::TagCanContainTag(nsIAtom& aParentTag,
+                             nsIAtom& aChildTag)
 {
   return true;
 }
 
 bool
-nsEditor::IsRoot(nsIDOMNode* inNode)
+EditorBase::IsRoot(nsIDOMNode* inNode)
 {
   NS_ENSURE_TRUE(inNode, false);
 
   nsCOMPtr<nsIDOMNode> rootNode = do_QueryInterface(GetRoot());
 
   return inNode == rootNode;
 }
 
 bool
-nsEditor::IsRoot(nsINode* inNode)
+EditorBase::IsRoot(nsINode* inNode)
 {
   NS_ENSURE_TRUE(inNode, false);
 
   nsCOMPtr<nsINode> rootNode = GetRoot();
 
   return inNode == rootNode;
 }
 
 bool
-nsEditor::IsEditorRoot(nsINode* aNode)
+EditorBase::IsEditorRoot(nsINode* aNode)
 {
   NS_ENSURE_TRUE(aNode, false);
   nsCOMPtr<nsINode> rootNode = GetEditorRoot();
   return aNode == rootNode;
 }
 
 bool
-nsEditor::IsDescendantOfRoot(nsIDOMNode* inNode)
+EditorBase::IsDescendantOfRoot(nsIDOMNode* inNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(inNode);
   return IsDescendantOfRoot(node);
 }
 
 bool
-nsEditor::IsDescendantOfRoot(nsINode* inNode)
+EditorBase::IsDescendantOfRoot(nsINode* inNode)
 {
   NS_ENSURE_TRUE(inNode, false);
   nsCOMPtr<nsIContent> root = GetRoot();
   NS_ENSURE_TRUE(root, false);
 
   return nsContentUtils::ContentIsDescendantOf(inNode, root);
 }
 
 bool
-nsEditor::IsDescendantOfEditorRoot(nsINode* aNode)
+EditorBase::IsDescendantOfEditorRoot(nsINode* aNode)
 {
   NS_ENSURE_TRUE(aNode, false);
   nsCOMPtr<nsIContent> root = GetEditorRoot();
   NS_ENSURE_TRUE(root, false);
 
   return nsContentUtils::ContentIsDescendantOf(aNode, root);
 }
 
 bool
-nsEditor::IsContainer(nsINode* aNode)
+EditorBase::IsContainer(nsINode* aNode)
 {
   return aNode ? true : false;
 }
 
 bool
-nsEditor::IsContainer(nsIDOMNode* aNode)
+EditorBase::IsContainer(nsIDOMNode* aNode)
 {
   return aNode ? true : false;
 }
 
 static inline bool
-IsElementVisible(dom::Element* aElement)
+IsElementVisible(Element* aElement)
 {
   if (aElement->GetPrimaryFrame()) {
     // It's visible, for our purposes
     return true;
   }
 
   nsIContent *cur = aElement;
   for (; ;) {
@@ -3424,24 +3436,24 @@ IsElementVisible(dom::Element* aElement)
                                                          nullptr, nullptr);
   if (styleContext) {
     return styleContext->StyleDisplay()->mDisplay != NS_STYLE_DISPLAY_NONE;
   }
   return false;
 }
 
 bool
-nsEditor::IsEditable(nsIDOMNode *aNode)
+EditorBase::IsEditable(nsIDOMNode* aNode)
 {
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
   return IsEditable(content);
 }
 
 bool
-nsEditor::IsEditable(nsINode* aNode)
+EditorBase::IsEditable(nsINode* aNode)
 {
   NS_ENSURE_TRUE(aNode, false);
 
   if (!aNode->IsNodeOfType(nsINode::eCONTENT) || IsMozEditorBogusNode(aNode) ||
       !IsModifiableNode(aNode)) {
     return false;
   }
 
@@ -3458,214 +3470,195 @@ nsEditor::IsEditable(nsINode* aNode)
     case nsIDOMNode::TEXT_NODE:
       return true; // element or text node; not invisible
     default:
       return false;
   }
 }
 
 bool
-nsEditor::IsMozEditorBogusNode(nsINode* element)
+EditorBase::IsMozEditorBogusNode(nsINode* element)
 {
   return element && element->IsElement() &&
          element->AsElement()->AttrValueIs(kNameSpaceID_None,
              kMOZEditorBogusNodeAttrAtom, kMOZEditorBogusNodeValue,
              eCaseMatters);
 }
 
 uint32_t
-nsEditor::CountEditableChildren(nsINode* aNode)
+EditorBase::CountEditableChildren(nsINode* aNode)
 {
   MOZ_ASSERT(aNode);
   uint32_t count = 0;
   for (nsIContent* child = aNode->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     if (IsEditable(child)) {
       ++count;
     }
   }
   return count;
 }
 
-//END nsEditor static utility methods
-
-
-NS_IMETHODIMP nsEditor::IncrementModificationCount(int32_t inNumMods)
+NS_IMETHODIMP
+EditorBase::IncrementModificationCount(int32_t inNumMods)
 {
   uint32_t oldModCount = mModCount;
 
   mModCount += inNumMods;
 
   if ((oldModCount == 0 && mModCount != 0)
    || (oldModCount != 0 && mModCount == 0))
     NotifyDocumentListeners(eDocumentStateChanged);
   return NS_OK;
 }
 
 
-NS_IMETHODIMP nsEditor::GetModificationCount(int32_t *outModCount)
+NS_IMETHODIMP
+EditorBase::GetModificationCount(int32_t* outModCount)
 {
   NS_ENSURE_ARG_POINTER(outModCount);
   *outModCount = mModCount;
   return NS_OK;
 }
 
 
-NS_IMETHODIMP nsEditor::ResetModificationCount()
+NS_IMETHODIMP
+EditorBase::ResetModificationCount()
 {
   bool doNotify = (mModCount != 0);
 
   mModCount = 0;
 
   if (doNotify)
     NotifyDocumentListeners(eDocumentStateChanged);
   return NS_OK;
 }
 
-//END nsEditor Private methods
-
-
-
-///////////////////////////////////////////////////////////////////////////
-// GetTag: digs out the atom for the tag of this node
-//
-nsIAtom *
-nsEditor::GetTag(nsIDOMNode *aNode)
+nsIAtom*
+EditorBase::GetTag(nsIDOMNode* aNode)
 {
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
 
   if (!content)
   {
-    NS_ASSERTION(aNode, "null node passed to nsEditor::GetTag()");
+    NS_ASSERTION(aNode, "null node passed to EditorBase::GetTag()");
 
     return nullptr;
   }
 
   return content->NodeInfo()->NameAtom();
 }
 
-
-///////////////////////////////////////////////////////////////////////////
-// GetTagString: digs out string for the tag of this node
-//
 nsresult
-nsEditor::GetTagString(nsIDOMNode *aNode, nsAString& outString)
+EditorBase::GetTagString(nsIDOMNode* aNode,
+                         nsAString& outString)
 {
   if (!aNode)
   {
-    NS_NOTREACHED("null node passed to nsEditor::GetTagString()");
+    NS_NOTREACHED("null node passed to EditorBase::GetTagString()");
     return NS_ERROR_NULL_POINTER;
   }
 
   nsIAtom *atom = GetTag(aNode);
   if (!atom)
   {
     return NS_ERROR_FAILURE;
   }
 
   atom->ToString(outString);
   return NS_OK;
 }
 
-
-///////////////////////////////////////////////////////////////////////////
-// NodesSameType: do these nodes have the same tag?
-//
 bool
-nsEditor::NodesSameType(nsIDOMNode *aNode1, nsIDOMNode *aNode2)
+EditorBase::NodesSameType(nsIDOMNode* aNode1,
+                          nsIDOMNode* aNode2)
 {
   if (!aNode1 || !aNode2) {
-    NS_NOTREACHED("null node passed to nsEditor::NodesSameType()");
+    NS_NOTREACHED("null node passed to EditorBase::NodesSameType()");
     return false;
   }
 
   nsCOMPtr<nsIContent> content1 = do_QueryInterface(aNode1);
   NS_ENSURE_TRUE(content1, false);
 
   nsCOMPtr<nsIContent> content2 = do_QueryInterface(aNode2);
   NS_ENSURE_TRUE(content2, false);
 
   return AreNodesSameType(content1, content2);
 }
 
-/* virtual */
 bool
-nsEditor::AreNodesSameType(nsIContent* aNode1, nsIContent* aNode2)
+EditorBase::AreNodesSameType(nsIContent* aNode1,
+                             nsIContent* aNode2)
 {
   MOZ_ASSERT(aNode1);
   MOZ_ASSERT(aNode2);
   return aNode1->NodeInfo()->NameAtom() == aNode2->NodeInfo()->NameAtom();
 }
 
-
-///////////////////////////////////////////////////////////////////////////
-// IsTextNode: true if node of dom type text
-//
 bool
-nsEditor::IsTextNode(nsIDOMNode *aNode)
+EditorBase::IsTextNode(nsIDOMNode* aNode)
 {
   if (!aNode)
   {
     NS_NOTREACHED("null node passed to IsTextNode()");
     return false;
   }
 
   uint16_t nodeType;
   aNode->GetNodeType(&nodeType);
   return (nodeType == nsIDOMNode::TEXT_NODE);
 }
 
 bool
-nsEditor::IsTextNode(nsINode *aNode)
+EditorBase::IsTextNode(nsINode* aNode)
 {
   return aNode->NodeType() == nsIDOMNode::TEXT_NODE;
 }
 
-///////////////////////////////////////////////////////////////////////////
-// GetChildAt: returns the node at this position index in the parent
-//
 nsCOMPtr<nsIDOMNode>
-nsEditor::GetChildAt(nsIDOMNode *aParent, int32_t aOffset)
+EditorBase::GetChildAt(nsIDOMNode* aParent, int32_t aOffset)
 {
   nsCOMPtr<nsIDOMNode> resultNode;
 
   nsCOMPtr<nsIContent> parent = do_QueryInterface(aParent);
 
   NS_ENSURE_TRUE(parent, resultNode);
 
   resultNode = do_QueryInterface(parent->GetChildAt(aOffset));
 
   return resultNode;
 }
 
-///////////////////////////////////////////////////////////////////////////
-// GetNodeAtRangeOffsetPoint: returns the node at this position in a range,
-// assuming that aParentOrNode is the node itself if it's a text node, or
-// the node's parent otherwise.
-//
+/**
+ * GetNodeAtRangeOffsetPoint() returns the node at this position in a range,
+ * assuming that aParentOrNode is the node itself if it's a text node, or
+ * the node's parent otherwise.
+ */
 nsIContent*
-nsEditor::GetNodeAtRangeOffsetPoint(nsIDOMNode* aParentOrNode, int32_t aOffset)
+EditorBase::GetNodeAtRangeOffsetPoint(nsIDOMNode* aParentOrNode,
+                                      int32_t aOffset)
 {
   nsCOMPtr<nsINode> parentOrNode = do_QueryInterface(aParentOrNode);
   NS_ENSURE_TRUE(parentOrNode || !aParentOrNode, nullptr);
   if (parentOrNode->GetAsText()) {
     return parentOrNode->AsContent();
   }
   return parentOrNode->GetChildAt(aOffset);
 }
 
-
-///////////////////////////////////////////////////////////////////////////
-// GetStartNodeAndOffset: returns whatever the start parent & offset is of
-//                        the first range in the selection.
+/**
+ * GetStartNodeAndOffset() returns whatever the start parent & offset is of
+ * the first range in the selection.
+ */
 nsresult
-nsEditor::GetStartNodeAndOffset(Selection* aSelection,
-                                       nsIDOMNode **outStartNode,
-                                       int32_t *outStartOffset)
+EditorBase::GetStartNodeAndOffset(Selection* aSelection,
+                                  nsIDOMNode** outStartNode,
+                                  int32_t* outStartOffset)
 {
   NS_ENSURE_TRUE(outStartNode && outStartOffset && aSelection, NS_ERROR_NULL_POINTER);
 
   nsCOMPtr<nsINode> startNode;
   nsresult rv = GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode),
                                       outStartOffset);
   if (NS_FAILED(rv)) {
     return rv;
@@ -3675,18 +3668,19 @@ nsEditor::GetStartNodeAndOffset(Selectio
     NS_ADDREF(*outStartNode = startNode->AsDOMNode());
   } else {
     *outStartNode = nullptr;
   }
   return NS_OK;
 }
 
 nsresult
-nsEditor::GetStartNodeAndOffset(Selection* aSelection, nsINode** aStartNode,
-                                int32_t* aStartOffset)
+EditorBase::GetStartNodeAndOffset(Selection* aSelection,
+                                  nsINode** aStartNode,
+                                  int32_t* aStartOffset)
 {
   MOZ_ASSERT(aSelection);
   MOZ_ASSERT(aStartNode);
   MOZ_ASSERT(aStartOffset);
 
   *aStartNode = nullptr;
   *aStartOffset = 0;
 
@@ -3699,24 +3693,24 @@ nsEditor::GetStartNodeAndOffset(Selectio
 
   NS_ENSURE_TRUE(range->IsPositioned(), NS_ERROR_FAILURE);
 
   NS_IF_ADDREF(*aStartNode = range->GetStartParent());
   *aStartOffset = range->StartOffset();
   return NS_OK;
 }
 
-
-///////////////////////////////////////////////////////////////////////////
-// GetEndNodeAndOffset: returns whatever the end parent & offset is of
-//                        the first range in the selection.
+/**
+ * GetEndNodeAndOffset() returns whatever the end parent & offset is of
+ * the first range in the selection.
+ */
 nsresult
-nsEditor::GetEndNodeAndOffset(Selection* aSelection,
-                                       nsIDOMNode **outEndNode,
-                                       int32_t *outEndOffset)
+EditorBase::GetEndNodeAndOffset(Selection* aSelection,
+                                nsIDOMNode** outEndNode,
+                                int32_t* outEndOffset)
 {
   NS_ENSURE_TRUE(outEndNode && outEndOffset && aSelection, NS_ERROR_NULL_POINTER);
 
   nsCOMPtr<nsINode> endNode;
   nsresult rv = GetEndNodeAndOffset(aSelection, getter_AddRefs(endNode),
                                     outEndOffset);
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -3724,18 +3718,19 @@ nsEditor::GetEndNodeAndOffset(Selection*
     NS_ADDREF(*outEndNode = endNode->AsDOMNode());
   } else {
     *outEndNode = nullptr;
   }
   return NS_OK;
 }
 
 nsresult
-nsEditor::GetEndNodeAndOffset(Selection* aSelection, nsINode** aEndNode,
-                              int32_t* aEndOffset)
+EditorBase::GetEndNodeAndOffset(Selection* aSelection,
+                                nsINode** aEndNode,
+                                int32_t* aEndOffset)
 {
   MOZ_ASSERT(aSelection);
   MOZ_ASSERT(aEndNode);
   MOZ_ASSERT(aEndOffset);
 
   *aEndNode = nullptr;
   *aEndOffset = 0;
 
@@ -3746,22 +3741,23 @@ nsEditor::GetEndNodeAndOffset(Selection*
 
   NS_ENSURE_TRUE(range->IsPositioned(), NS_ERROR_FAILURE);
 
   NS_IF_ADDREF(*aEndNode = range->GetEndParent());
   *aEndOffset = range->EndOffset();
   return NS_OK;
 }
 
-
-///////////////////////////////////////////////////////////////////////////
-// IsPreformatted: checks the style info for the node for the preformatted
-//                 text style.
+/**
+ * IsPreformatted() checks the style info for the node for the preformatted
+ * text style.
+ */
 nsresult
-nsEditor::IsPreformatted(nsIDOMNode *aNode, bool *aResult)
+EditorBase::IsPreformatted(nsIDOMNode* aNode,
+                           bool* aResult)
 {
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
 
   NS_ENSURE_TRUE(aResult && content, NS_ERROR_NULL_POINTER);
 
   nsCOMPtr<nsIPresShell> ps = GetPresShell();
   NS_ENSURE_TRUE(ps, NS_ERROR_NOT_INITIALIZED);
 
@@ -3801,34 +3797,34 @@ nsEditor::IsPreformatted(nsIDOMNode *aNo
  * that's why you were splitting the node.
  *
  * -1 is returned on failure, in unlikely cases like the selection being
  * unavailable or cloning the node failing.  Make sure not to use the returned
  * offset for anything without checking that it's valid!  If you're not using
  * the offset, it's okay to ignore the return value.
  */
 int32_t
-nsEditor::SplitNodeDeep(nsIContent& aNode,
-                        nsIContent& aSplitPointParent,
-                        int32_t aSplitPointOffset,
-                        EmptyContainers aEmptyContainers,
-                        nsIContent** aOutLeftNode,
-                        nsIContent** aOutRightNode)
+EditorBase::SplitNodeDeep(nsIContent& aNode,
+                          nsIContent& aSplitPointParent,
+                          int32_t aSplitPointOffset,
+                          EmptyContainers aEmptyContainers,
+                          nsIContent** aOutLeftNode,
+                          nsIContent** aOutRightNode)
 {
   MOZ_ASSERT(&aSplitPointParent == &aNode ||
              EditorUtils::IsDescendantOf(&aSplitPointParent, &aNode));
   int32_t offset = aSplitPointOffset;
 
   nsCOMPtr<nsIContent> leftNode, rightNode;
   OwningNonNull<nsIContent> nodeToSplit = aSplitPointParent;
   while (true) {
     // Need to insert rules code call here to do things like not split a list
     // if you are after the last <li> or before the first, etc.  For now we
     // just have some smarts about unneccessarily splitting text nodes, which
-    // should be universal enough to put straight in this nsEditor routine.
+    // should be universal enough to put straight in this EditorBase routine.
 
     bool didSplit = false;
 
     if ((aEmptyContainers == EmptyContainers::yes &&
          !nodeToSplit->GetAsText()) ||
         (offset && offset != (int32_t)nodeToSplit->Length())) {
       didSplit = true;
       ErrorResult rv;
@@ -3864,23 +3860,23 @@ nsEditor::SplitNodeDeep(nsIContent& aNod
   }
   if (aOutRightNode) {
     rightNode.forget(aOutRightNode);
   }
 
   return offset;
 }
 
-
 /**
  * This joins two like nodes "deeply", joining children as appropriate.
  * Returns the point of the join, or (nullptr, -1) in case of error.
  */
 EditorDOMPoint
-nsEditor::JoinNodeDeep(nsIContent& aLeftNode, nsIContent& aRightNode)
+EditorBase::JoinNodeDeep(nsIContent& aLeftNode,
+                         nsIContent& aRightNode)
 {
   // While the rightmost children and their descendants of the left node match
   // the leftmost children and their descendants of the right node, join them
   // up.
 
   nsCOMPtr<nsIContent> leftNodeToJoin = &aLeftNode;
   nsCOMPtr<nsIContent> rightNodeToJoin = &aRightNode;
   nsCOMPtr<nsINode> parentNode = aRightNode.GetParentNode();
@@ -3923,17 +3919,17 @@ nsEditor::JoinNodeDeep(nsIContent& aLeft
       return ret;
     }
   }
 
   return ret;
 }
 
 void
-nsEditor::BeginUpdateViewBatch()
+EditorBase::BeginUpdateViewBatch()
 {
   NS_PRECONDITION(mUpdateCount >= 0, "bad state");
 
   if (0 == mUpdateCount)
   {
     // Turn off selection updates and notifications.
 
     RefPtr<Selection> selection = GetSelection();
@@ -3941,18 +3937,18 @@ nsEditor::BeginUpdateViewBatch()
     if (selection) {
       selection->StartBatchChanges();
     }
   }
 
   mUpdateCount++;
 }
 
-
-nsresult nsEditor::EndUpdateViewBatch()
+nsresult
+EditorBase::EndUpdateViewBatch()
 {
   NS_PRECONDITION(mUpdateCount > 0, "bad state");
 
   if (mUpdateCount <= 0)
   {
     mUpdateCount = 0;
     return NS_ERROR_FAILURE;
   }
@@ -3968,25 +3964,24 @@ nsresult nsEditor::EndUpdateViewBatch()
       selection->EndBatchChanges();
     }
   }
 
   return NS_OK;
 }
 
 bool
-nsEditor::GetShouldTxnSetSelection()
+EditorBase::GetShouldTxnSetSelection()
 {
   return mShouldTxnSetSelection;
 }
 
-
 NS_IMETHODIMP
-nsEditor::DeleteSelectionImpl(EDirection aAction,
-                              EStripWrappers aStripWrappers)
+EditorBase::DeleteSelectionImpl(EDirection aAction,
+                                EStripWrappers aStripWrappers)
 {
   MOZ_ASSERT(aStripWrappers == eStrip || aStripWrappers == eNoStrip);
 
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_STATE(selection);
   RefPtr<EditAggregateTransaction> transaction;
   nsCOMPtr<nsINode> deleteNode;
   int32_t deleteCharOffset = 0, deleteCharLength = 0;
@@ -4032,17 +4027,17 @@ nsEditor::DeleteSelectionImpl(EDirection
       }
     }
   }
 
   return rv;
 }
 
 already_AddRefed<Element>
-nsEditor::DeleteSelectionAndCreateElement(nsIAtom& aTag)
+EditorBase::DeleteSelectionAndCreateElement(nsIAtom& aTag)
 {
   nsresult res = DeleteSelectionAndPrepareToCreateNode();
   NS_ENSURE_SUCCESS(res, nullptr);
 
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, nullptr);
 
   nsCOMPtr<nsINode> node = selection->GetAnchorNode();
@@ -4052,42 +4047,39 @@ nsEditor::DeleteSelectionAndCreateElemen
 
   // We want the selection to be just after the new node
   res = selection->Collapse(node, offset + 1);
   NS_ENSURE_SUCCESS(res, nullptr);
 
   return newElement.forget();
 }
 
-
-/* Non-interface, protected methods */
-
 TextComposition*
-nsEditor::GetComposition() const
+EditorBase::GetComposition() const
 {
   return mComposition;
 }
 
 bool
-nsEditor::IsIMEComposing() const
+EditorBase::IsIMEComposing() const
 {
   return mComposition && mComposition->IsComposing();
 }
 
 bool
-nsEditor::ShouldHandleIMEComposition() const
+EditorBase::ShouldHandleIMEComposition() const
 {
   // When the editor is being reframed, the old value may be restored with
   // InsertText().  In this time, the text should be inserted as not a part
   // of the composition.
   return mComposition && mDidPostCreate;
 }
 
 nsresult
-nsEditor::DeleteSelectionAndPrepareToCreateNode()
+EditorBase::DeleteSelectionAndPrepareToCreateNode()
 {
   nsresult res;
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   MOZ_ASSERT(selection->GetAnchorFocusRange());
 
   if (!selection->GetAnchorFocusRange()->Collapsed()) {
     res = DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip);
@@ -4129,20 +4121,18 @@ nsEditor::DeleteSelectionAndPrepareToCre
                                 node->GetParentNode()->IndexOf(node));
       MOZ_ASSERT(NS_SUCCEEDED(res));
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   return NS_OK;
 }
 
-
-
 void
-nsEditor::DoAfterDoTransaction(nsITransaction *aTxn)
+EditorBase::DoAfterDoTransaction(nsITransaction* aTxn)
 {
   bool isTransientTransaction;
   MOZ_ALWAYS_SUCCEEDS(aTxn->GetIsTransient(&isTransientTransaction));
 
   if (!isTransientTransaction)
   {
     // we need to deal here with the case where the user saved after some
     // edits, then undid one or more times. Then, the undo count is -ve,
@@ -4153,142 +4143,138 @@ nsEditor::DoAfterDoTransaction(nsITransa
     if (modCount < 0)
       modCount = -modCount;
 
     // don't count transient transactions
     MOZ_ALWAYS_SUCCEEDS(IncrementModificationCount(1));
   }
 }
 
-
 void
-nsEditor::DoAfterUndoTransaction()
+EditorBase::DoAfterUndoTransaction()
 {
   // all undoable transactions are non-transient
   MOZ_ALWAYS_SUCCEEDS(IncrementModificationCount(-1));
 }
 
 void
-nsEditor::DoAfterRedoTransaction()
+EditorBase::DoAfterRedoTransaction()
 {
   // all redoable transactions are non-transient
   MOZ_ALWAYS_SUCCEEDS(IncrementModificationCount(1));
 }
 
 already_AddRefed<ChangeAttributeTransaction>
-nsEditor::CreateTxnForSetAttribute(Element& aElement, nsIAtom& aAttribute,
-                                   const nsAString& aValue)
+EditorBase::CreateTxnForSetAttribute(Element& aElement,
+                                     nsIAtom& aAttribute,
+                                     const nsAString& aValue)
 {
   RefPtr<ChangeAttributeTransaction> transaction =
     new ChangeAttributeTransaction(aElement, aAttribute, &aValue);
 
   return transaction.forget();
 }
 
-
 already_AddRefed<ChangeAttributeTransaction>
-nsEditor::CreateTxnForRemoveAttribute(Element& aElement, nsIAtom& aAttribute)
+EditorBase::CreateTxnForRemoveAttribute(Element& aElement,
+                                        nsIAtom& aAttribute)
 {
   RefPtr<ChangeAttributeTransaction> transaction =
     new ChangeAttributeTransaction(aElement, aAttribute, nullptr);
 
   return transaction.forget();
 }
 
-
 already_AddRefed<CreateElementTransaction>
-nsEditor::CreateTxnForCreateElement(nsIAtom& aTag,
-                                    nsINode& aParent,
-                                    int32_t aPosition)
+EditorBase::CreateTxnForCreateElement(nsIAtom& aTag,
+                                      nsINode& aParent,
+                                      int32_t aPosition)
 {
   RefPtr<CreateElementTransaction> transaction =
     new CreateElementTransaction(*this, aTag, aParent, aPosition);
 
   return transaction.forget();
 }
 
 
 already_AddRefed<InsertNodeTransaction>
-nsEditor::CreateTxnForInsertNode(nsIContent& aNode,
-                                 nsINode& aParent,
-                                 int32_t aPosition)
+EditorBase::CreateTxnForInsertNode(nsIContent& aNode,
+                                   nsINode& aParent,
+                                   int32_t aPosition)
 {
   RefPtr<InsertNodeTransaction> transaction =
     new InsertNodeTransaction(aNode, aParent, aPosition, *this);
   return transaction.forget();
 }
 
 nsresult
-nsEditor::CreateTxnForDeleteNode(nsINode* aNode,
-                                 DeleteNodeTransaction** aTransaction)
+EditorBase::CreateTxnForDeleteNode(nsINode* aNode,
+                                   DeleteNodeTransaction** aTransaction)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
 
   RefPtr<DeleteNodeTransaction> transaction = new DeleteNodeTransaction();
 
   nsresult rv = transaction->Init(this, aNode, &mRangeUpdater);
   NS_ENSURE_SUCCESS(rv, rv);
 
   transaction.forget(aTransaction);
   return NS_OK;
 }
 
 already_AddRefed<CompositionTransaction>
-nsEditor::CreateTxnForComposition(const nsAString& aStringToInsert)
+EditorBase::CreateTxnForComposition(const nsAString& aStringToInsert)
 {
   MOZ_ASSERT(mIMETextNode);
   // During handling IME composition, mComposition must have been initialized.
   // TODO: We can simplify CompositionTransaction::Init() with TextComposition
   //       class.
   RefPtr<CompositionTransaction> transaction =
     new CompositionTransaction(*mIMETextNode, mIMETextOffset, mIMETextLength,
                                mComposition->GetRanges(), aStringToInsert,
                                *this);
   return transaction.forget();
 }
 
 NS_IMETHODIMP
-nsEditor::CreateTxnForAddStyleSheet(StyleSheetHandle aSheet,
-                                    AddStyleSheetTransaction** aTransaction)
+EditorBase::CreateTxnForAddStyleSheet(StyleSheetHandle aSheet,
+                                      AddStyleSheetTransaction** aTransaction)
 {
   RefPtr<AddStyleSheetTransaction> transaction = new AddStyleSheetTransaction();
 
   nsresult rv = transaction->Init(this, aSheet);
   if (NS_SUCCEEDED(rv)) {
     transaction.forget(aTransaction);
   }
 
   return rv;
 }
 
-
-
 NS_IMETHODIMP
-nsEditor::CreateTxnForRemoveStyleSheet(
-            StyleSheetHandle aSheet,
-            RemoveStyleSheetTransaction** aTransaction)
+EditorBase::CreateTxnForRemoveStyleSheet(
+              StyleSheetHandle aSheet,
+              RemoveStyleSheetTransaction** aTransaction)
 {
   RefPtr<RemoveStyleSheetTransaction> transaction =
     new RemoveStyleSheetTransaction();
 
   nsresult rv = transaction->Init(this, aSheet);
   if (NS_SUCCEEDED(rv)) {
     transaction.forget(aTransaction);
   }
 
   return rv;
 }
 
-
 nsresult
-nsEditor::CreateTxnForDeleteSelection(EDirection aAction,
-                                      EditAggregateTransaction** aTransaction,
-                                      nsINode** aNode,
-                                      int32_t* aOffset,
-                                      int32_t* aLength)
+EditorBase::CreateTxnForDeleteSelection(EDirection aAction,
+                                        EditAggregateTransaction** aTransaction,
+                                        nsINode** aNode,
+                                        int32_t* aOffset,
+                                        int32_t* aLength)
 {
   MOZ_ASSERT(aTransaction);
   *aTransaction = nullptr;
 
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_STATE(selection);
 
   // Check whether the selection is collapsed and we should do nothing:
@@ -4321,18 +4307,19 @@ nsEditor::CreateTxnForDeleteSelection(ED
   }
 
   aggregateTransaction.forget(aTransaction);
 
   return NS_OK;
 }
 
 already_AddRefed<DeleteTextTransaction>
-nsEditor::CreateTxnForDeleteCharacter(nsGenericDOMDataNode& aData,
-                                      uint32_t aOffset, EDirection aDirection)
+EditorBase::CreateTxnForDeleteCharacter(nsGenericDOMDataNode& aData,
+                                        uint32_t aOffset,
+                                        EDirection aDirection)
 {
   NS_ASSERTION(aDirection == eNext || aDirection == ePrevious,
                "Invalid direction");
   nsAutoString data;
   aData.GetData(data);
   NS_ASSERTION(data.Length(), "Trying to delete from a zero-length node");
   NS_ENSURE_TRUE(data.Length(), nullptr);
 
@@ -4356,23 +4343,23 @@ nsEditor::CreateTxnForDeleteCharacter(ns
     return nullptr;
   }
   return CreateTxnForDeleteText(aData, segOffset, segLength);
 }
 
 //XXX: currently, this doesn't handle edge conditions because GetNext/GetPrior
 //are not implemented
 nsresult
-nsEditor::CreateTxnForDeleteInsertionPoint(
-            nsRange* aRange,
-            EDirection aAction,
-            EditAggregateTransaction* aTransaction,
-            nsINode** aNode,
-            int32_t* aOffset,
-            int32_t* aLength)
+EditorBase::CreateTxnForDeleteInsertionPoint(
+              nsRange* aRange,
+              EDirection aAction,
+              EditAggregateTransaction* aTransaction,
+              nsINode** aNode,
+              int32_t* aOffset,
+              int32_t* aLength)
 {
   MOZ_ASSERT(aAction != eNone);
 
   nsresult res;
 
   // get the node and offset of the insertion point
   nsCOMPtr<nsINode> node = aRange->GetStartParent();
   NS_ENSURE_STATE(node);
@@ -4523,26 +4510,28 @@ nsEditor::CreateTxnForDeleteInsertionPoi
 
     NS_ADDREF(*aNode = selectedNode);
   }
 
   return NS_OK;
 }
 
 nsresult
-nsEditor::CreateRange(nsIDOMNode *aStartParent, int32_t aStartOffset,
-                      nsIDOMNode *aEndParent, int32_t aEndOffset,
-                      nsRange** aRange)
+EditorBase::CreateRange(nsIDOMNode* aStartParent,
+                        int32_t aStartOffset,
+                        nsIDOMNode* aEndParent,
+                        int32_t aEndOffset,
+                        nsRange** aRange)
 {
   return nsRange::CreateRange(aStartParent, aStartOffset, aEndParent,
                               aEndOffset, aRange);
 }
 
 nsresult
-nsEditor::AppendNodeToSelectionAsRange(nsIDOMNode *aNode)
+EditorBase::AppendNodeToSelectionAsRange(nsIDOMNode* aNode)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIDOMNode> parentNode;
   nsresult res = aNode->GetParentNode(getter_AddRefs(parentNode));
   NS_ENSURE_SUCCESS(res, res);
@@ -4553,64 +4542,65 @@ nsEditor::AppendNodeToSelectionAsRange(n
   RefPtr<nsRange> range;
   res = CreateRange(parentNode, offset, parentNode, offset+1, getter_AddRefs(range));
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(range, NS_ERROR_NULL_POINTER);
 
   return selection->AddRange(range);
 }
 
-nsresult nsEditor::ClearSelection()
+nsresult
+EditorBase::ClearSelection()
 {
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_FAILURE);
   return selection->RemoveAllRanges();
 }
 
 already_AddRefed<Element>
-nsEditor::CreateHTMLContent(nsIAtom* aTag)
+EditorBase::CreateHTMLContent(nsIAtom* aTag)
 {
   MOZ_ASSERT(aTag);
 
   nsCOMPtr<nsIDocument> doc = GetDocument();
   if (!doc) {
     return nullptr;
   }
 
   // XXX Wallpaper over editor bug (editor tries to create elements with an
   //     empty nodename).
   if (aTag == nsGkAtoms::_empty) {
-    NS_ERROR("Don't pass an empty tag to nsEditor::CreateHTMLContent, "
+    NS_ERROR("Don't pass an empty tag to EditorBase::CreateHTMLContent, "
              "check caller.");
     return nullptr;
   }
 
   return doc->CreateElem(nsDependentAtomString(aTag), nullptr,
                          kNameSpaceID_XHTML);
 }
 
 nsresult
-nsEditor::SetAttributeOrEquivalent(nsIDOMElement * aElement,
-                                   const nsAString & aAttribute,
-                                   const nsAString & aValue,
-                                   bool aSuppressTransaction)
+EditorBase::SetAttributeOrEquivalent(nsIDOMElement* aElement,
+                                     const nsAString& aAttribute,
+                                     const nsAString& aValue,
+                                     bool aSuppressTransaction)
 {
   return SetAttribute(aElement, aAttribute, aValue);
 }
 
 nsresult
-nsEditor::RemoveAttributeOrEquivalent(nsIDOMElement * aElement,
-                                      const nsAString & aAttribute,
-                                      bool aSuppressTransaction)
+EditorBase::RemoveAttributeOrEquivalent(nsIDOMElement* aElement,
+                                        const nsAString& aAttribute,
+                                        bool aSuppressTransaction)
 {
   return RemoveAttribute(aElement, aAttribute);
 }
 
 nsresult
-nsEditor::HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent)
+EditorBase::HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent)
 {
   // NOTE: When you change this method, you should also change:
   //   * editor/libeditor/tests/test_texteditor_keyevent_handling.html
   //   * editor/libeditor/tests/test_htmleditor_keyevent_handling.html
   //
   // And also when you add new key handling, you need to change the subclass's
   // HandleKeyPressEvent()'s switch statement.
 
@@ -4658,43 +4648,43 @@ nsEditor::HandleKeyPressEvent(nsIDOMKeyE
       DeleteSelection(nsIEditor::eNext, nsIEditor::eStrip);
       aKeyEvent->AsEvent()->PreventDefault(); // consumed
       return NS_OK;
   }
   return NS_OK;
 }
 
 nsresult
-nsEditor::HandleInlineSpellCheck(EditAction action,
+EditorBase::HandleInlineSpellCheck(EditAction action,
                                    Selection* aSelection,
-                                   nsIDOMNode *previousSelectedNode,
+                                   nsIDOMNode* previousSelectedNode,
                                    int32_t previousSelectedOffset,
-                                   nsIDOMNode *aStartNode,
+                                   nsIDOMNode* aStartNode,
                                    int32_t aStartOffset,
-                                   nsIDOMNode *aEndNode,
+                                   nsIDOMNode* aEndNode,
                                    int32_t aEndOffset)
 {
   // Have to cast action here because this method is from an IDL
   return mInlineSpellChecker ? mInlineSpellChecker->SpellCheckAfterEditorChange(
                                  (int32_t)action, aSelection,
                                  previousSelectedNode, previousSelectedOffset,
                                  aStartNode, aStartOffset, aEndNode,
                                  aEndOffset)
                              : NS_OK;
 }
 
 already_AddRefed<nsIContent>
-nsEditor::FindSelectionRoot(nsINode *aNode)
+EditorBase::FindSelectionRoot(nsINode* aNode)
 {
   nsCOMPtr<nsIContent> rootContent = GetRoot();
   return rootContent.forget();
 }
 
 nsresult
-nsEditor::InitializeSelection(nsIDOMEventTarget* aFocusEventTarget)
+EditorBase::InitializeSelection(nsIDOMEventTarget* aFocusEventTarget)
 {
   nsCOMPtr<nsINode> targetNode = do_QueryInterface(aFocusEventTarget);
   NS_ENSURE_TRUE(targetNode, NS_ERROR_INVALID_ARG);
   nsCOMPtr<nsIContent> selectionRootContent = FindSelectionRoot(targetNode);
   if (!selectionRootContent) {
     return NS_OK;
   }
 
@@ -4766,17 +4756,17 @@ nsEditor::InitializeSelection(nsIDOMEven
                                               mComposition->GetRanges());
     }
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::FinalizeSelection()
+EditorBase::FinalizeSelection()
 {
   nsCOMPtr<nsISelectionController> selCon;
   nsresult rv = GetSelectionController(getter_AddRefs(selCon));
   NS_ENSURE_SUCCESS(rv, rv);
 
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_STATE(selection);
 
@@ -4817,51 +4807,51 @@ nsEditor::FinalizeSelection()
     // independent selection should be marked as disabled.
     selCon->SetDisplaySelection(nsISelectionController::SELECTION_DISABLED);
   }
 
   selCon->RepaintSelection(nsISelectionController::SELECTION_NORMAL);
   return NS_OK;
 }
 
-dom::Element *
-nsEditor::GetRoot()
+Element*
+EditorBase::GetRoot()
 {
   if (!mRootElement)
   {
     nsCOMPtr<nsIDOMElement> root;
 
     // Let GetRootElement() do the work
     GetRootElement(getter_AddRefs(root));
   }
 
   return mRootElement;
 }
 
-dom::Element*
-nsEditor::GetEditorRoot()
+Element*
+EditorBase::GetEditorRoot()
 {
   return GetRoot();
 }
 
 Element*
-nsEditor::GetExposedRoot()
+EditorBase::GetExposedRoot()
 {
   Element* rootElement = GetRoot();
 
   // For plaintext editors, we need to ask the input/textarea element directly.
   if (rootElement && rootElement->IsRootOfNativeAnonymousSubtree()) {
     rootElement = rootElement->GetParent()->AsElement();
   }
 
   return rootElement;
 }
 
 nsresult
-nsEditor::DetermineCurrentDirection()
+EditorBase::DetermineCurrentDirection()
 {
   // Get the current root direction from its frame
   nsIContent* rootElement = GetExposedRoot();
   NS_ENSURE_TRUE(rootElement, NS_ERROR_FAILURE);
 
   // If we don't have an explicit direction, determine our direction
   // from the content's direction
   if (!(mFlags & (nsIPlaintextEditor::eEditorLeftToRight |
@@ -4878,17 +4868,17 @@ nsEditor::DetermineCurrentDirection()
       mFlags |= nsIPlaintextEditor::eEditorLeftToRight;
     }
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::SwitchTextDirection()
+EditorBase::SwitchTextDirection()
 {
   // Get the current root direction from its frame
   nsIContent* rootElement = GetExposedRoot();
 
   nsresult rv = DetermineCurrentDirection();
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Apply the opposite direction
@@ -4909,17 +4899,17 @@ nsEditor::SwitchTextDirection()
   if (NS_SUCCEEDED(rv)) {
     FireInputEvent();
   }
 
   return rv;
 }
 
 void
-nsEditor::SwitchTextDirectionTo(uint32_t aDirection)
+EditorBase::SwitchTextDirectionTo(uint32_t aDirection)
 {
   // Get the current root direction from its frame
   nsIContent* rootElement = GetExposedRoot();
 
   nsresult rv = DetermineCurrentDirection();
   NS_ENSURE_SUCCESS_VOID(rv);
 
   // Apply the requested direction
@@ -4941,17 +4931,18 @@ nsEditor::SwitchTextDirectionTo(uint32_t
 
   if (NS_SUCCEEDED(rv)) {
     FireInputEvent();
   }
 }
 
 #if DEBUG_JOE
 void
-nsEditor::DumpNode(nsIDOMNode *aNode, int32_t indent)
+EditorBase::DumpNode(nsIDOMNode* aNode,
+                     int32_t indent)
 {
   int32_t i;
   for (i=0; i<indent; i++)
     printf("  ");
 
   nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aNode);
   nsCOMPtr<nsIDOMDocumentFragment> docfrag = do_QueryInterface(aNode);
 
@@ -4990,50 +4981,50 @@ nsEditor::DumpNode(nsIDOMNode *aNode, in
     LossyCopyUTF16toASCII(str, cstr);
     cstr.ReplaceChar('\n', ' ');
     printf("<textnode> %s\n", cstr.get());
   }
 }
 #endif
 
 bool
-nsEditor::IsModifiableNode(nsIDOMNode *aNode)
+EditorBase::IsModifiableNode(nsIDOMNode* aNode)
 {
   return true;
 }
 
 bool
-nsEditor::IsModifiableNode(nsINode *aNode)
+EditorBase::IsModifiableNode(nsINode* aNode)
 {
   return true;
 }
 
 already_AddRefed<nsIContent>
-nsEditor::GetFocusedContent()
+EditorBase::GetFocusedContent()
 {
   nsCOMPtr<nsIDOMEventTarget> piTarget = GetDOMEventTarget();
   if (!piTarget) {
     return nullptr;
   }
 
   nsFocusManager* fm = nsFocusManager::GetFocusManager();
   NS_ENSURE_TRUE(fm, nullptr);
 
   nsCOMPtr<nsIContent> content = fm->GetFocusedContent();
   return SameCOMIdentity(content, piTarget) ? content.forget() : nullptr;
 }
 
 already_AddRefed<nsIContent>
-nsEditor::GetFocusedContentForIME()
+EditorBase::GetFocusedContentForIME()
 {
   return GetFocusedContent();
 }
 
 bool
-nsEditor::IsActiveInDOMWindow()
+EditorBase::IsActiveInDOMWindow()
 {
   nsCOMPtr<nsIDOMEventTarget> piTarget = GetDOMEventTarget();
   if (!piTarget) {
     return false;
   }
 
   nsFocusManager* fm = nsFocusManager::GetFocusManager();
   NS_ENSURE_TRUE(fm, false);
@@ -5043,17 +5034,17 @@ nsEditor::IsActiveInDOMWindow()
   nsCOMPtr<nsPIDOMWindowOuter> win;
   nsIContent* content =
     nsFocusManager::GetFocusedDescendant(ourWindow, false,
                                          getter_AddRefs(win));
   return SameCOMIdentity(content, piTarget);
 }
 
 bool
-nsEditor::IsAcceptableInputEvent(nsIDOMEvent* aEvent)
+EditorBase::IsAcceptableInputEvent(nsIDOMEvent* aEvent)
 {
   // If the event is trusted, the event should always cause input.
   NS_ENSURE_TRUE(aEvent, false);
 
   WidgetEvent* widgetEvent = aEvent->WidgetEventPtr();
   if (NS_WARN_IF(!widgetEvent)) {
     return false;
   }
@@ -5109,49 +5100,49 @@ nsEditor::IsAcceptableInputEvent(nsIDOME
   }
 
   // Otherwise, we shouldn't handle any input events when we're not an active
   // element of the DOM window.
   return IsActiveInDOMWindow();
 }
 
 void
-nsEditor::OnFocus(nsIDOMEventTarget* aFocusEventTarget)
+EditorBase::OnFocus(nsIDOMEventTarget* aFocusEventTarget)
 {
   InitializeSelection(aFocusEventTarget);
   if (mInlineSpellChecker) {
     mInlineSpellChecker->UpdateCurrentDictionary();
   }
 }
 
 NS_IMETHODIMP
-nsEditor::GetSuppressDispatchingInputEvent(bool *aSuppressed)
+EditorBase::GetSuppressDispatchingInputEvent(bool* aSuppressed)
 {
   NS_ENSURE_ARG_POINTER(aSuppressed);
   *aSuppressed = !mDispatchInputEvent;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::SetSuppressDispatchingInputEvent(bool aSuppress)
+EditorBase::SetSuppressDispatchingInputEvent(bool aSuppress)
 {
   mDispatchInputEvent = !aSuppress;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsEditor::GetIsInEditAction(bool* aIsInEditAction)
+EditorBase::GetIsInEditAction(bool* aIsInEditAction)
 {
   MOZ_ASSERT(aIsInEditAction, "aIsInEditAction must not be null");
   *aIsInEditAction = mIsInEditAction;
   return NS_OK;
 }
 
 int32_t
-nsEditor::GetIMESelectionStartOffsetIn(nsINode* aTextNode)
+EditorBase::GetIMESelectionStartOffsetIn(nsINode* aTextNode)
 {
   MOZ_ASSERT(aTextNode, "aTextNode must not be nullptr");
 
   nsCOMPtr<nsISelectionController> selectionController;
   nsresult rv = GetSelectionController(getter_AddRefs(selectionController));
   NS_ENSURE_SUCCESS(rv, -1);
   NS_ENSURE_TRUE(selectionController, -1);
 
@@ -5187,17 +5178,17 @@ nsEditor::GetIMESelectionStartOffsetIn(n
         minOffset = std::min(minOffset, range->EndOffset());
       }
     }
   }
   return minOffset < INT32_MAX ? minOffset : -1;
 }
 
 void
-nsEditor::HideCaret(bool aHide)
+EditorBase::HideCaret(bool aHide)
 {
   if (mHidingCaret == aHide) {
     return;
   }
 
   nsCOMPtr<nsIPresShell> presShell = GetPresShell();
   NS_ENSURE_TRUE_VOID(presShell);
   RefPtr<nsCaret> caret = presShell->GetCaret();
@@ -5205,8 +5196,10 @@ nsEditor::HideCaret(bool aHide)
 
   mHidingCaret = aHide;
   if (aHide) {
     caret->AddForceHide();
   } else {
     caret->RemoveForceHide();
   }
 }
+
+} // namespace mozilla
rename from editor/libeditor/nsEditor.h
rename to editor/libeditor/EditorBase.h
--- a/editor/libeditor/nsEditor.h
+++ b/editor/libeditor/EditorBase.h
@@ -1,31 +1,31 @@
 /* -*- 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__
+#ifndef mozilla_editor_EditorBase_h_
+#define mozilla_editor_EditorBase_h_
 
 #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
 #include "nsIEditorIMESupport.h"        // for NS_DECL_NSIEDITORIMESUPPORT, etc
 #include "nsIObserver.h"                // for NS_DECL_NSIOBSERVER, etc
 #include "nsIPhonetic.h"                // for NS_DECL_NSIPHONETIC, etc
 #include "nsIPlaintextEditor.h"         // for nsIPlaintextEditor, etc
 #include "nsISelectionController.h"     // for nsISelectionController constants
-#include "nsISupportsImpl.h"            // for nsEditor::Release, etc
+#include "nsISupportsImpl.h"            // for EditorBase::Release, etc
 #include "nsIWeakReferenceUtils.h"      // for nsWeakPtr
 #include "nsLiteralString.h"            // for NS_LITERAL_STRING
 #include "nsString.h"                   // for nsCString
 #include "nsWeakReference.h"            // for nsSupportsWeakReference
 #include "nscore.h"                     // for nsresult, nsAString, etc
 
 class nsIAtom;
 class nsIContent;
@@ -44,57 +44,22 @@ class nsINode;
 class nsIPresShell;
 class nsISupports;
 class nsITransaction;
 class nsIWidget;
 class nsRange;
 class nsString;
 class nsTransactionManager;
 
-namespace mozilla {
-class AddStyleSheetTransaction;
-class AutoRules;
-class AutoSelectionRestorer;
-class AutoTransactionsConserveSelection;
-class ChangeAttributeTransaction;
-class CompositionTransaction;
-class CreateElementTransaction;
-class DeleteNodeTransaction;
-class DeleteTextTransaction;
-class EditAggregateTransaction;
-class ErrorResult;
-class InsertNodeTransaction;
-class InsertTextTransaction;
-class JoinNodeTransaction;
-class RemoveStyleSheetTransaction;
-class SplitNodeTransaction;
-class TextComposition;
-struct EditorDOMPoint;
-
-namespace dom {
-class DataTransfer;
-class Element;
-class EventTarget;
-class Selection;
-class Text;
-} // namespace dom
-} // namespace mozilla
-
-namespace mozilla {
-namespace widget {
-struct IMEState;
-} // namespace widget
-} // namespace mozilla
-
-#define kMOZEditorBogusNodeAttrAtom nsGkAtoms::mozeditorbogusnode
-#define kMOZEditorBogusNodeValue NS_LITERAL_STRING("TRUE")
-
 // This is int32_t instead of int16_t because nsIInlineSpellChecker.idl's
 // spellCheckAfterEditorChange is defined to take it as a long.
-enum class EditAction : int32_t {
+// XXX EditAction causes unnecessary include of EditorBase from some places.
+//     Why don't you move this to nsIEditor.idl?
+enum class EditAction : int32_t
+{
   ignore = -1,
   none = 0,
   undo,
   redo,
   insertNode,
   createNode,
   deleteNode,
   splitNode,
@@ -129,96 +94,130 @@ enum class EditAction : int32_t {
   increaseZIndex      = 3018
 };
 
 inline bool operator!(const EditAction& aOp)
 {
   return aOp == EditAction::none;
 }
 
-/** implementation of an editor object.  it will be the controller/focal point
- *  for the main editor services. i.e. the GUIManager, publishing, transaction
- *  manager, event interfaces. the idea for the event interfaces is to have them
- *  delegate the actual commands to the editor independent of the XPFE implementation.
+namespace mozilla {
+class AddStyleSheetTransaction;
+class AutoRules;
+class AutoSelectionRestorer;
+class AutoTransactionsConserveSelection;
+class ChangeAttributeTransaction;
+class CompositionTransaction;
+class CreateElementTransaction;
+class DeleteNodeTransaction;
+class DeleteTextTransaction;
+class EditAggregateTransaction;
+class ErrorResult;
+class InsertNodeTransaction;
+class InsertTextTransaction;
+class JoinNodeTransaction;
+class RemoveStyleSheetTransaction;
+class SplitNodeTransaction;
+class TextComposition;
+struct EditorDOMPoint;
+
+namespace dom {
+class DataTransfer;
+class Element;
+class EventTarget;
+class Selection;
+class Text;
+} // namespace dom
+
+namespace widget {
+struct IMEState;
+} // namespace widget
+
+#define kMOZEditorBogusNodeAttrAtom nsGkAtoms::mozeditorbogusnode
+#define kMOZEditorBogusNodeValue NS_LITERAL_STRING("TRUE")
+
+/**
+ * Implementation of an editor object.  it will be the controller/focal point
+ * for the main editor services. i.e. the GUIManager, publishing, transaction
+ * manager, event interfaces. the idea for the event interfaces is to have them
+ * delegate the actual commands to the editor independent of the XPFE
+ * implementation.
  */
-class nsEditor : public nsIEditor,
-                 public nsIEditorIMESupport,
-                 public nsSupportsWeakReference,
-                 public nsIPhonetic
+class EditorBase : public nsIEditor
+                 , public nsIEditorIMESupport
+                 , public nsSupportsWeakReference
+                 , public nsIPhonetic
 {
 public:
-  typedef mozilla::ErrorResult        ErrorResult;
-  typedef mozilla::dom::Element       Element;
-  typedef mozilla::dom::Selection     Selection;
-  typedef mozilla::dom::Text          Text;
-  template<typename T> using OwningNonNull = mozilla::OwningNonNull<T>;
+  typedef dom::Element Element;
+  typedef dom::Selection Selection;
+  typedef dom::Text Text;
 
   enum IterDirection
   {
     kIterForward,
     kIterBackward
   };
 
-  /** The default constructor. This should suffice. the setting of the interfaces is done
-   *  after the construction of the editor class.
+  /**
+   * The default constructor. This should suffice. the setting of the
+   * interfaces is done after the construction of the editor class.
    */
-  nsEditor();
+  EditorBase();
 
 protected:
-  /** The default destructor. This should suffice. Should this be pure virtual
-   *  for someone to derive from the nsEditor later? I don't believe so.
+  /**
+   * The default destructor. This should suffice. Should this be pure virtual
+   * for someone to derive from the EditorBase later? I don't believe so.
    */
-  virtual ~nsEditor();
+  virtual ~EditorBase();
 
 public:
-//Interfaces for addref and release and queryinterface
-//NOTE: Use   NS_DECL_ISUPPORTS_INHERITED in any class inherited from nsEditor
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsEditor,
-                                           nsIEditor)
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(EditorBase, nsIEditor)
 
-  /* ------------ utility methods   -------------- */
   already_AddRefed<nsIDOMDocument> GetDOMDocument();
   already_AddRefed<nsIDocument> GetDocument();
   already_AddRefed<nsIPresShell> GetPresShell();
   already_AddRefed<nsIWidget> GetWidget();
   enum NotificationForEditorObservers
   {
     eNotifyEditorObserversOfEnd,
     eNotifyEditorObserversOfBefore,
     eNotifyEditorObserversOfCancel
   };
   void NotifyEditorObservers(NotificationForEditorObservers aNotification);
 
-  /* ------------ nsIEditor methods -------------- */
+  // nsIEditor methods
   NS_DECL_NSIEDITOR
 
-  /* ------------ nsIEditorIMESupport methods -------------- */
+  // nsIEditorIMESupport methods
   NS_DECL_NSIEDITORIMESUPPORT
 
   // nsIPhonetic
   NS_DECL_NSIPHONETIC
 
 public:
-
-  virtual bool IsModifiableNode(nsINode *aNode);
+  virtual bool IsModifiableNode(nsINode* aNode);
 
   virtual nsresult InsertTextImpl(const nsAString& aStringToInsert,
                                   nsCOMPtr<nsINode>* aInOutNode,
                                   int32_t* aInOutOffset,
                                   nsIDocument* aDoc);
   nsresult InsertTextIntoTextNodeImpl(const nsAString& aStringToInsert,
                                       Text& aTextNode, int32_t aOffset,
                                       bool aSuppressIME = false);
   NS_IMETHOD DeleteSelectionImpl(EDirection aAction,
                                  EStripWrappers aStripWrappers);
 
   already_AddRefed<Element> DeleteSelectionAndCreateElement(nsIAtom& aTag);
 
-  /* helper routines for node/parent manipulations */
+  /**
+   * Helper routines for node/parent manipulations.
+   */
   nsresult DeleteNode(nsINode* aNode);
   nsresult InsertNode(nsIContent& aNode, nsINode& aParent, int32_t aPosition);
   enum ECloneAttributes { eDontCloneAttributes, eCloneAttributes };
   already_AddRefed<Element> ReplaceContainer(Element* aOldContainer,
                                              nsIAtom* aNodeType,
                                              nsIAtom* aAttribute = nullptr,
                                              const nsAString* aValue = nullptr,
                                              ECloneAttributes aCloneAttributes
@@ -231,220 +230,250 @@ public:
                                                  nsIAtom* aAttribute = nullptr,
                                                  const nsAString* aValue =
                                                  nullptr);
   nsIContent* SplitNode(nsIContent& aNode, int32_t aOffset,
                         ErrorResult& aResult);
   nsresult JoinNodes(nsINode& aLeftNode, nsINode& aRightNode);
   nsresult MoveNode(nsIContent* aNode, nsINode* aParent, int32_t aOffset);
 
-  /* Method to replace certain CreateElementNS() calls.
-     Arguments:
-      nsIAtom* aTag          - tag you want
-  */
+  /**
+   * Method to replace certain CreateElementNS() calls.
+   *
+   * @param aTag        Tag you want.
+   */
   already_AddRefed<Element> CreateHTMLContent(nsIAtom* aTag);
 
-  // IME event handlers
-  virtual nsresult BeginIMEComposition(mozilla::WidgetCompositionEvent* aEvent);
+  /**
+   * IME event handlers.
+   */
+  virtual nsresult BeginIMEComposition(WidgetCompositionEvent* aEvent);
   virtual nsresult UpdateIMEComposition(nsIDOMEvent* aDOMTextEvent) = 0;
   void EndIMEComposition();
 
   void SwitchTextDirectionTo(uint32_t aDirection);
 
 protected:
   nsresult DetermineCurrentDirection();
   void FireInputEvent();
 
-  /** Create a transaction for setting aAttribute to aValue on aElement.  Never
-    * returns null.
-    */
-  already_AddRefed<mozilla::ChangeAttributeTransaction>
-  CreateTxnForSetAttribute(Element& aElement, nsIAtom& aAttribute,
-                           const nsAString& aValue);
+  /**
+   * Create a transaction for setting aAttribute to aValue on aElement.  Never
+   * returns null.
+   */
+  already_AddRefed<ChangeAttributeTransaction>
+    CreateTxnForSetAttribute(Element& aElement, nsIAtom& aAttribute,
+                             const nsAString& aValue);
 
-  /** Create a transaction for removing aAttribute on aElement.  Never returns
-    * null.
-    */
-  already_AddRefed<mozilla::ChangeAttributeTransaction>
-  CreateTxnForRemoveAttribute(Element& aElement, nsIAtom& aAttribute);
+  /**
+   * Create a transaction for removing aAttribute on aElement.  Never returns
+   * null.
+   */
+  already_AddRefed<ChangeAttributeTransaction>
+    CreateTxnForRemoveAttribute(Element& aElement, nsIAtom& aAttribute);
 
-  /** create a transaction for creating a new child node of aParent of type aTag.
-    */
-  already_AddRefed<mozilla::CreateElementTransaction>
-  CreateTxnForCreateElement(nsIAtom& aTag,
-                            nsINode& aParent,
-                            int32_t aPosition);
+  /**
+   * Create a transaction for creating a new child node of aParent of type aTag.
+   */
+  already_AddRefed<CreateElementTransaction>
+    CreateTxnForCreateElement(nsIAtom& aTag,
+                              nsINode& aParent,
+                              int32_t aPosition);
 
   already_AddRefed<Element> CreateNode(nsIAtom* aTag, nsINode* aParent,
                                        int32_t aPosition);
 
-  /** create a transaction for inserting aNode as a child of aParent.
-    */
-  already_AddRefed<mozilla::InsertNodeTransaction>
-  CreateTxnForInsertNode(nsIContent& aNode, nsINode& aParent, int32_t aOffset);
+  /**
+   * Create a transaction for inserting aNode as a child of aParent.
+   */
+  already_AddRefed<InsertNodeTransaction>
+    CreateTxnForInsertNode(nsIContent& aNode, nsINode& aParent,
+                           int32_t aOffset);
 
-  /** create a transaction for removing aNode from its parent.
-    */
-  nsresult CreateTxnForDeleteNode(
-             nsINode* aNode,
-             mozilla::DeleteNodeTransaction** aTransaction);
+  /**
+   * Create a transaction for removing aNode from its parent.
+   */
+  nsresult CreateTxnForDeleteNode(nsINode* aNode,
+                                  DeleteNodeTransaction** aTransaction);
 
   nsresult CreateTxnForDeleteSelection(
              EDirection aAction,
-             mozilla::EditAggregateTransaction** aTransaction,
+             EditAggregateTransaction** aTransaction,
              nsINode** aNode,
              int32_t* aOffset,
              int32_t* aLength);
 
   nsresult CreateTxnForDeleteInsertionPoint(
              nsRange* aRange,
              EDirection aAction,
-             mozilla::EditAggregateTransaction* aTransaction,
+             EditAggregateTransaction* aTransaction,
              nsINode** aNode,
              int32_t* aOffset,
              int32_t* aLength);
 
 
-  /** Create a transaction for inserting aStringToInsert into aTextNode.  Never
-    * returns null.
-    */
+  /**
+   * Create a transaction for inserting aStringToInsert into aTextNode.  Never
+   * returns null.
+   */
   already_AddRefed<mozilla::InsertTextTransaction>
-  CreateTxnForInsertText(const nsAString& aStringToInsert, Text& aTextNode,
-                         int32_t aOffset);
+    CreateTxnForInsertText(const nsAString& aStringToInsert, Text& aTextNode,
+                           int32_t aOffset);
 
-  // Never returns null.
+  /**
+   * Never returns null.
+   */
   already_AddRefed<mozilla::CompositionTransaction>
-  CreateTxnForComposition(const nsAString& aStringToInsert);
+    CreateTxnForComposition(const nsAString& aStringToInsert);
 
-  /** create a transaction for adding a style sheet
-    */
+  /**
+   * Create a transaction for adding a style sheet.
+   */
   NS_IMETHOD CreateTxnForAddStyleSheet(
-               mozilla::StyleSheetHandle aSheet,
-               mozilla::AddStyleSheetTransaction** aTransaction);
+               StyleSheetHandle aSheet,
+               AddStyleSheetTransaction** aTransaction);
 
-  /** create a transaction for removing a style sheet
-    */
+  /**
+   * Create a transaction for removing a style sheet.
+   */
   NS_IMETHOD CreateTxnForRemoveStyleSheet(
-               mozilla::StyleSheetHandle aSheet,
-               mozilla::RemoveStyleSheetTransaction** aTransaction);
+               StyleSheetHandle aSheet,
+               RemoveStyleSheetTransaction** aTransaction);
 
   nsresult DeleteText(nsGenericDOMDataNode& aElement,
                       uint32_t aOffset, uint32_t aLength);
 
-//  NS_IMETHOD DeleteRange(nsIDOMRange *aRange);
-
-  already_AddRefed<mozilla::DeleteTextTransaction>
-  CreateTxnForDeleteText(nsGenericDOMDataNode& aElement,
-                         uint32_t aOffset, uint32_t aLength);
+  already_AddRefed<DeleteTextTransaction>
+    CreateTxnForDeleteText(nsGenericDOMDataNode& aElement,
+                           uint32_t aOffset, uint32_t aLength);
 
-  already_AddRefed<mozilla::DeleteTextTransaction>
-  CreateTxnForDeleteCharacter(nsGenericDOMDataNode& aData, uint32_t aOffset,
-                              EDirection aDirection);
+  already_AddRefed<DeleteTextTransaction>
+    CreateTxnForDeleteCharacter(nsGenericDOMDataNode& aData, uint32_t aOffset,
+                                EDirection aDirection);
 
-  already_AddRefed<mozilla::SplitNodeTransaction>
-  CreateTxnForSplitNode(nsIContent& aNode, uint32_t aOffset);
+  already_AddRefed<SplitNodeTransaction>
+    CreateTxnForSplitNode(nsIContent& aNode, uint32_t aOffset);
 
-  already_AddRefed<mozilla::JoinNodeTransaction>
-  CreateTxnForJoinNode(nsINode& aLeftNode, nsINode& aRightNode);
+  already_AddRefed<JoinNodeTransaction>
+    CreateTxnForJoinNode(nsINode& aLeftNode, nsINode& aRightNode);
 
   /**
    * This method first deletes the selection, if it's not collapsed.  Then if
    * the selection lies in a CharacterData node, it splits it.  If the
    * selection is at this point collapsed in a CharacterData node, it's
    * adjusted to be collapsed right before or after the node instead (which is
    * always possible, since the node was split).
    */
   nsresult DeleteSelectionAndPrepareToCreateNode();
 
-
-  // called after a transaction is done successfully
+  /**
+   * Called after a transaction is done successfully.
+   */
   void DoAfterDoTransaction(nsITransaction *aTxn);
-  // called after a transaction is undone successfully
+
+  /**
+   * Called after a transaction is undone successfully.
+   */
+
   void DoAfterUndoTransaction();
-  // called after a transaction is redone successfully
+
+  /**
+   * Called after a transaction is redone successfully.
+   */
   void DoAfterRedoTransaction();
 
-  typedef enum {
+  enum TDocumentListenerNotification
+  {
     eDocumentCreated,
     eDocumentToBeDestroyed,
     eDocumentStateChanged
-  } TDocumentListenerNotification;
+  };
 
-  // tell the doc state listeners that the doc state has changed
-  NS_IMETHOD NotifyDocumentListeners(TDocumentListenerNotification aNotificationType);
+  /**
+   * Tell the doc state listeners that the doc state has changed.
+   */
+  NS_IMETHOD NotifyDocumentListeners(
+               TDocumentListenerNotification aNotificationType);
 
-  /** make the given selection span the entire document */
+  /**
+   * Make the given selection span the entire document.
+   */
   virtual nsresult SelectEntireDocument(Selection* aSelection);
 
-  /** helper method for scrolling the selection into view after
-   *  an edit operation. aScrollToAnchor should be true if you
-   *  want to scroll to the point where the selection was started.
-   *  If false, it attempts to scroll the end of the selection into view.
+  /**
+   * Helper method for scrolling the selection into view after
+   * an edit operation. aScrollToAnchor should be true if you
+   * want to scroll to the point where the selection was started.
+   * If false, it attempts to scroll the end of the selection into view.
    *
-   *  Editor methods *should* call this method instead of the versions
-   *  in the various selection interfaces, since this version makes sure
-   *  that the editor's sync/async settings for reflowing, painting, and
-   *  scrolling match.
+   * Editor methods *should* call this method instead of the versions
+   * in the various selection interfaces, since this version makes sure
+   * that the editor's sync/async settings for reflowing, painting, and
+   * scrolling match.
    */
   NS_IMETHOD ScrollSelectionIntoView(bool aScrollToAnchor);
 
-  // stub.  see comment in source.
   virtual bool IsBlockNode(nsINode* aNode);
 
-  // helper for GetPriorNode and GetNextNode
-  nsIContent* FindNextLeafNode(nsINode  *aCurrentNode,
-                               bool      aGoForward,
-                               bool      bNoBlockCrossing);
+  /**
+   * Helper for GetPriorNode() and GetNextNode().
+   */
+  nsIContent* FindNextLeafNode(nsINode* aCurrentNode,
+                               bool aGoForward,
+                               bool bNoBlockCrossing);
 
-  // install the event listeners for the editor
   virtual nsresult InstallEventListeners();
-
   virtual void CreateEventListeners();
-
-  // unregister and release our event listeners
   virtual void RemoveEventListeners();
 
   /**
    * Return true if spellchecking should be enabled for this editor.
    */
   bool GetDesiredSpellCheckState();
 
   bool CanEnableSpellCheck()
   {
     // Check for password/readonly/disabled, which are not spellchecked
-    // regardless of DOM. Also, check to see if spell check should be skipped or not.
-    return !IsPasswordEditor() && !IsReadonly() && !IsDisabled() && !ShouldSkipSpellCheck();
+    // regardless of DOM. Also, check to see if spell check should be skipped
+    // or not.
+    return !IsPasswordEditor() && !IsReadonly() && !IsDisabled() &&
+           !ShouldSkipSpellCheck();
   }
 
   /**
    * EnsureComposition() should be called by composition event handlers.  This
    * tries to get the composition for the event and set it to mComposition.
    */
-  void EnsureComposition(mozilla::WidgetCompositionEvent* aCompositionEvent);
+  void EnsureComposition(WidgetCompositionEvent* aCompositionEvent);
 
-  nsresult GetSelection(mozilla::SelectionType aSelectionType,
+  nsresult GetSelection(SelectionType aSelectionType,
                         nsISelection** aSelection);
 
 public:
-
-  /** All editor operations which alter the doc should be prefaced
-   *  with a call to StartOperation, naming the action and direction */
+  /**
+   * All editor operations which alter the doc should be prefaced
+   * with a call to StartOperation, naming the action and direction.
+   */
   NS_IMETHOD StartOperation(EditAction opID,
                             nsIEditor::EDirection aDirection);
 
-  /** All editor operations which alter the doc should be followed
-   *  with a call to EndOperation */
+  /**
+   * All editor operations which alter the doc should be followed
+   * with a call to EndOperation.
+   */
   NS_IMETHOD EndOperation();
 
-  /** routines for managing the preservation of selection across
-   *  various editor actions */
-  bool     ArePreservingSelection();
-  void     PreserveSelectionAcrossActions(Selection* aSel);
+  /**
+   * Routines for managing the preservation of selection across
+   * various editor actions.
+   */
+  bool ArePreservingSelection();
+  void PreserveSelectionAcrossActions(Selection* aSel);
   nsresult RestorePreservedSelection(Selection* aSel);
-  void     StopPreservingSelection();
+  void StopPreservingSelection();
 
   /**
    * SplitNode() creates a new node identical to an existing node, and split
    * the contents between the two nodes
    * @param aExistingRightNode  The node to split.  It will become the new
    *                            node's next sibling.
    * @param aOffset             The offset of aExistingRightNode's
    *                            content|children to do the split at
@@ -454,239 +483,291 @@ public:
   nsresult SplitNodeImpl(nsIContent& aExistingRightNode,
                          int32_t aOffset,
                          nsIContent& aNewLeftNode);
 
   /**
    * JoinNodes() takes 2 nodes and merge their content|children.
    * @param aNodeToKeep   The node that will remain after the join.
    * @param aNodeToJoin   The node that will be joined with aNodeToKeep.
-   *                      There is no requirement that the two nodes be of the same type.
+   *                      There is no requirement that the two nodes be of the
+   *                      same type.
    * @param aParent       The parent of aNodeToKeep
    */
   nsresult JoinNodesImpl(nsINode* aNodeToKeep,
                          nsINode* aNodeToJoin,
                          nsINode* aParent);
 
   /**
    * Return the offset of aChild in aParent.  Asserts fatally if parent or
    * child is null, or parent is not child's parent.
    */
-  static int32_t GetChildOffset(nsIDOMNode *aChild,
-                                nsIDOMNode *aParent);
+  static int32_t GetChildOffset(nsIDOMNode* aChild,
+                                nsIDOMNode* aParent);
 
   /**
-   *  Set outOffset to the offset of aChild in the parent.
-   *  Returns the parent of aChild.
+   * Set outOffset to the offset of aChild in the parent.
+   * Returns the parent of aChild.
    */
   static already_AddRefed<nsIDOMNode> GetNodeLocation(nsIDOMNode* aChild,
                                                       int32_t* outOffset);
   static nsINode* GetNodeLocation(nsINode* aChild, int32_t* aOffset);
 
-  /** returns the number of things inside aNode in the out-param aCount.
-    * @param  aNode is the node to get the length of.
-    *         If aNode is text, returns number of characters.
-    *         If not, returns number of children nodes.
-    * @param  aCount [OUT] the result of the above calculation.
-    */
+  /**
+   * Returns the number of things inside aNode in the out-param aCount.
+   * @param  aNode is the node to get the length of.
+   *         If aNode is text, returns number of characters.
+   *         If not, returns number of children nodes.
+   * @param  aCount [OUT] the result of the above calculation.
+   */
   static nsresult GetLengthOfDOMNode(nsIDOMNode *aNode, uint32_t &aCount);
 
-  /** get the node immediately prior to aCurrentNode
-    * @param aCurrentNode   the node from which we start the search
-    * @param aEditableNode  if true, only return an editable node
-    * @param aResultNode    [OUT] the node that occurs before aCurrentNode in the tree,
-    *                       skipping non-editable nodes if aEditableNode is true.
-    *                       If there is no prior node, aResultNode will be nullptr.
-    * @param bNoBlockCrossing If true, don't move across "block" nodes, whatever that means.
-    */
+  /**
+   * Get the node immediately prior to aCurrentNode.
+   * @param aCurrentNode   the node from which we start the search
+   * @param aEditableNode  if true, only return an editable node
+   * @param aResultNode    [OUT] the node that occurs before aCurrentNode in
+   *                             the tree, skipping non-editable nodes if
+   *                             aEditableNode is true.  If there is no prior
+   *                             node, aResultNode will be nullptr.
+   * @param bNoBlockCrossing If true, don't move across "block" nodes,
+   *                         whatever that means.
+   */
   nsIContent* GetPriorNode(nsINode* aCurrentNode, bool aEditableNode,
                            bool aNoBlockCrossing = false);
 
-  // and another version that takes a {parent,offset} pair rather than a node
+  /**
+   * And another version that takes a {parent,offset} pair rather than a node.
+   */
   nsIContent* GetPriorNode(nsINode* aParentNode,
                            int32_t aOffset,
                            bool aEditableNode,
                            bool aNoBlockCrossing = false);
 
 
-  /** get the node immediately after to aCurrentNode
-    * @param aCurrentNode   the node from which we start the search
-    * @param aEditableNode  if true, only return an editable node
-    * @param aResultNode    [OUT] the node that occurs after aCurrentNode in the tree,
-    *                       skipping non-editable nodes if aEditableNode is true.
-    *                       If there is no prior node, aResultNode will be nullptr.
-    */
+  /**
+   * Get the node immediately after to aCurrentNode.
+   * @param aCurrentNode   the node from which we start the search
+   * @param aEditableNode  if true, only return an editable node
+   * @param aResultNode    [OUT] the node that occurs after aCurrentNode in the
+   *                             tree, skipping non-editable nodes if
+   *                             aEditableNode is true.  If there is no prior
+   *                             node, aResultNode will be nullptr.
+   */
   nsIContent* GetNextNode(nsINode* aCurrentNode,
                           bool aEditableNode,
                           bool bNoBlockCrossing = false);
 
-  // and another version that takes a {parent,offset} pair rather than a node
+  /**
+   * And another version that takes a {parent,offset} pair rather than a node.
+   */
   nsIContent* GetNextNode(nsINode* aParentNode,
                           int32_t aOffset,
                           bool aEditableNode,
                           bool aNoBlockCrossing = false);
 
-  // Helper for GetNextNode and GetPriorNode
-  nsIContent* FindNode(nsINode *aCurrentNode,
-                       bool     aGoForward,
-                       bool     aEditableNode,
-                       bool     bNoBlockCrossing);
+  /**
+   * Helper for GetNextNode() and GetPriorNode().
+   */
+  nsIContent* FindNode(nsINode* aCurrentNode,
+                       bool aGoForward,
+                       bool aEditableNode,
+                       bool bNoBlockCrossing);
   /**
    * Get the rightmost child of aCurrentNode;
    * return nullptr if aCurrentNode has no children.
    */
-  nsIContent* GetRightmostChild(nsINode *aCurrentNode,
-                                bool     bNoBlockCrossing = false);
+  nsIContent* GetRightmostChild(nsINode* aCurrentNode,
+                                bool bNoBlockCrossing = false);
 
   /**
    * Get the leftmost child of aCurrentNode;
    * return nullptr if aCurrentNode has no children.
    */
   nsIContent* GetLeftmostChild(nsINode *aCurrentNode,
-                               bool     bNoBlockCrossing = false);
+                               bool bNoBlockCrossing = false);
 
-  /** returns true if aNode is of the type implied by aTag */
-  static inline bool NodeIsType(nsIDOMNode *aNode, nsIAtom *aTag)
+  /**
+   * Returns true if aNode is of the type implied by aTag.
+   */
+  static inline bool NodeIsType(nsIDOMNode* aNode, nsIAtom* aTag)
   {
     return GetTag(aNode) == aTag;
   }
 
-  /** returns true if aParent can contain a child of type aTag */
+  /**
+   * Returns true if aParent can contain a child of type aTag.
+   */
   bool CanContain(nsINode& aParent, nsIContent& aChild);
   bool CanContainTag(nsINode& aParent, nsIAtom& aTag);
   bool TagCanContain(nsIAtom& aParentTag, nsIContent& aChild);
   virtual bool TagCanContainTag(nsIAtom& aParentTag, nsIAtom& aChildTag);
 
-  /** returns true if aNode is our root node */
+  /**
+   * Returns true if aNode is our root node.
+   */
   bool IsRoot(nsIDOMNode* inNode);
   bool IsRoot(nsINode* inNode);
   bool IsEditorRoot(nsINode* aNode);
 
-  /** returns true if aNode is a descendant of our root node */
+  /**
+   * Returns true if aNode is a descendant of our root node.
+   */
   bool IsDescendantOfRoot(nsIDOMNode* inNode);
   bool IsDescendantOfRoot(nsINode* inNode);
   bool IsDescendantOfEditorRoot(nsINode* aNode);
 
-  /** returns true if aNode is a container */
+  /**
+   * Returns true if aNode is a container.
+   */
   virtual bool IsContainer(nsINode* aNode);
   virtual bool IsContainer(nsIDOMNode* aNode);
 
-  /** returns true if aNode is an editable node */
-  bool IsEditable(nsIDOMNode *aNode);
+  /**
+   * returns true if aNode is an editable node.
+   */
+  bool IsEditable(nsIDOMNode* aNode);
   virtual bool IsEditable(nsINode* aNode);
 
-  /** returns true if aNode is a MozEditorBogus node */
+  /**
+   * Returns true if aNode is a MozEditorBogus node.
+   */
   bool IsMozEditorBogusNode(nsINode* aNode);
 
-  /** counts number of editable child nodes */
+  /**
+   * Counts number of editable child nodes.
+   */
   uint32_t CountEditableChildren(nsINode* aNode);
 
-  /** Find the deep first and last children. */
+  /**
+   * Find the deep first and last children.
+   */
   nsINode* GetFirstEditableNode(nsINode* aRoot);
 
   /**
    * Returns current composition.
    */
-  mozilla::TextComposition* GetComposition() const;
+  TextComposition* GetComposition() const;
+
   /**
    * Returns true if there is composition string and not fixed.
    */
   bool IsIMEComposing() const;
+
   /**
    * Returns true when inserting text should be a part of current composition.
    */
   bool ShouldHandleIMEComposition() const;
 
-  /** from html rules code - migration in progress */
-  static nsresult GetTagString(nsIDOMNode *aNode, nsAString& outString);
-  static nsIAtom *GetTag(nsIDOMNode *aNode);
+  /**
+   * From html rules code - migration in progress.
+   */
+  static nsresult GetTagString(nsIDOMNode* aNode, nsAString& outString);
+  static nsIAtom* GetTag(nsIDOMNode* aNode);
 
-  bool NodesSameType(nsIDOMNode *aNode1, nsIDOMNode *aNode2);
+  bool NodesSameType(nsIDOMNode* aNode1, nsIDOMNode* aNode2);
   virtual bool AreNodesSameType(nsIContent* aNode1, nsIContent* aNode2);
 
-  static bool IsTextNode(nsIDOMNode *aNode);
-  static bool IsTextNode(nsINode *aNode);
+  static bool IsTextNode(nsIDOMNode* aNode);
+  static bool IsTextNode(nsINode* aNode);
 
-  static nsCOMPtr<nsIDOMNode> GetChildAt(nsIDOMNode *aParent, int32_t aOffset);
+  static nsCOMPtr<nsIDOMNode> GetChildAt(nsIDOMNode* aParent, int32_t aOffset);
   static nsIContent* GetNodeAtRangeOffsetPoint(nsIDOMNode* aParentOrNode,
                                                int32_t aOffset);
 
   static nsresult GetStartNodeAndOffset(Selection* aSelection,
                                         nsIDOMNode** outStartNode,
                                         int32_t* outStartOffset);
   static nsresult GetStartNodeAndOffset(Selection* aSelection,
                                         nsINode** aStartNode,
                                         int32_t* aStartOffset);
   static nsresult GetEndNodeAndOffset(Selection* aSelection,
                                       nsIDOMNode** outEndNode,
                                       int32_t* outEndOffset);
   static nsresult GetEndNodeAndOffset(Selection* aSelection,
                                       nsINode** aEndNode,
                                       int32_t* aEndOffset);
 #if DEBUG_JOE
-  static void DumpNode(nsIDOMNode *aNode, int32_t indent=0);
+  static void DumpNode(nsIDOMNode* aNode, int32_t indent = 0);
 #endif
-  Selection* GetSelection(mozilla::SelectionType aSelectionType =
-                            mozilla::SelectionType::eNormal);
+  Selection* GetSelection(SelectionType aSelectionType =
+                                          SelectionType::eNormal);
 
-  // Helpers to add a node to the selection.
-  // Used by table cell selection methods
-  nsresult CreateRange(nsIDOMNode *aStartParent, int32_t aStartOffset,
-                       nsIDOMNode *aEndParent, int32_t aEndOffset,
+  /**
+   * Helpers to add a node to the selection.
+   * Used by table cell selection methods.
+   */
+  nsresult CreateRange(nsIDOMNode* aStartParent, int32_t aStartOffset,
+                       nsIDOMNode* aEndParent, int32_t aEndOffset,
                        nsRange** aRange);
 
-  // Creates a range with just the supplied node and appends that to the selection
+  /**
+   * Creates a range with just the supplied node and appends that to the
+   * selection.
+   */
   nsresult AppendNodeToSelectionAsRange(nsIDOMNode *aNode);
-  // When you are using AppendNodeToSelectionAsRange, call this first to start a new selection
+
+  /**
+   * When you are using AppendNodeToSelectionAsRange(), call this first to
+   * start a new selection.
+   */
   nsresult ClearSelection();
 
-  nsresult IsPreformatted(nsIDOMNode *aNode, bool *aResult);
+  nsresult IsPreformatted(nsIDOMNode* aNode, bool* aResult);
 
   enum class EmptyContainers { no, yes };
   int32_t SplitNodeDeep(nsIContent& aNode, nsIContent& aSplitPointParent,
                         int32_t aSplitPointOffset,
                         EmptyContainers aEmptyContainers =
                           EmptyContainers::yes,
                         nsIContent** outLeftNode = nullptr,
                         nsIContent** outRightNode = nullptr);
-  mozilla::EditorDOMPoint JoinNodeDeep(nsIContent& aLeftNode,
-                                       nsIContent& aRightNode);
+  EditorDOMPoint JoinNodeDeep(nsIContent& aLeftNode,
+                              nsIContent& aRightNode);
 
   nsresult GetString(const nsAString& name, nsAString& value);
 
-  void BeginUpdateViewBatch(void);
-  virtual nsresult EndUpdateViewBatch(void);
+  void BeginUpdateViewBatch();
+  virtual nsresult EndUpdateViewBatch();
 
   bool GetShouldTxnSetSelection();
 
   virtual nsresult HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent);
 
   nsresult HandleInlineSpellCheck(EditAction action,
                                   Selection* aSelection,
-                                    nsIDOMNode *previousSelectedNode,
-                                    int32_t previousSelectedOffset,
-                                    nsIDOMNode *aStartNode,
-                                    int32_t aStartOffset,
-                                    nsIDOMNode *aEndNode,
-                                    int32_t aEndOffset);
+                                  nsIDOMNode* previousSelectedNode,
+                                  int32_t previousSelectedOffset,
+                                  nsIDOMNode* aStartNode,
+                                  int32_t aStartOffset,
+                                  nsIDOMNode* aEndNode,
+                                  int32_t aEndOffset);
 
-  virtual already_AddRefed<mozilla::dom::EventTarget> GetDOMEventTarget() = 0;
+  virtual already_AddRefed<dom::EventTarget> GetDOMEventTarget() = 0;
 
-  // Fast non-refcounting editor root element accessor
+  /**
+   * Fast non-refcounting editor root element accessor
+   */
   Element* GetRoot();
 
-  // Likewise, but gets the editor's root instead, which is different for HTML
-  // editors
+  /**
+   * Likewise, but gets the editor's root instead, which is different for HTML
+   * editors.
+   */
   virtual Element* GetEditorRoot();
 
-  // Likewise, but gets the text control element instead of the root for
-  // plaintext editors
+  /**
+   * Likewise, but gets the text control element instead of the root for
+   * plaintext editors.
+   */
   Element* GetExposedRoot();
 
-  // Accessor methods to flags
+  /**
+   * Accessor methods to flags.
+   */
   bool IsPlaintextEditor() const
   {
     return (mFlags & nsIPlaintextEditor::eEditorPlaintextMask) != 0;
   }
 
   bool IsSingleLineEditor() const
   {
     return (mFlags & nsIPlaintextEditor::eEditorSingleLineMask) != 0;
@@ -753,67 +834,88 @@ public:
            IsInteractionAllowed();
   }
 
   bool HasIndependentSelection() const
   {
     return !!mSelConWeak;
   }
 
-  // Get the input event target. This might return null.
+  /**
+   * Get the input event target. This might return null.
+   */
   virtual already_AddRefed<nsIContent> GetInputEventTargetContent() = 0;
 
-  // Get the focused content, if we're focused.  Returns null otherwise.
+  /**
+   * Get the focused content, if we're focused.  Returns null otherwise.
+   */
   virtual already_AddRefed<nsIContent> GetFocusedContent();
 
-  // Get the focused content for the argument of some IMEStateManager's
-  // methods.
+  /**
+   * Get the focused content for the argument of some IMEStateManager's
+   * methods.
+   */
   virtual already_AddRefed<nsIContent> GetFocusedContentForIME();
 
-  // Whether the editor is active on the DOM window.  Note that when this
-  // returns true but GetFocusedContent() returns null, it means that this editor was
-  // focused when the DOM window was active.
+  /**
+   * Whether the editor is active on the DOM window.  Note that when this
+   * returns true but GetFocusedContent() returns null, it means that this editor was
+   * focused when the DOM window was active.
+   */
   virtual bool IsActiveInDOMWindow();
 
-  // Whether the aEvent should be handled by this editor or not.  When this
-  // returns FALSE, The aEvent shouldn't be handled on this editor,
-  // i.e., The aEvent should be handled by another inner editor or ancestor
-  // elements.
+  /**
+   * Whether the aEvent should be handled by this editor or not.  When this
+   * returns FALSE, The aEvent shouldn't be handled on this editor,
+   * i.e., The aEvent should be handled by another inner editor or ancestor
+   * elements.
+   */
   virtual bool IsAcceptableInputEvent(nsIDOMEvent* aEvent);
 
-  // FindSelectionRoot() returns a selection root of this editor when aNode
-  // gets focus.  aNode must be a content node or a document node.  When the
-  // target isn't a part of this editor, returns nullptr.  If this is for
-  // designMode, you should set the document node to aNode except that an
-  // element in the document has focus.
+  /**
+   * FindSelectionRoot() returns a selection root of this editor when aNode
+   * gets focus.  aNode must be a content node or a document node.  When the
+   * target isn't a part of this editor, returns nullptr.  If this is for
+   * designMode, you should set the document node to aNode except that an
+   * element in the document has focus.
+   */
   virtual already_AddRefed<nsIContent> FindSelectionRoot(nsINode* aNode);
 
-  // Initializes selection and caret for the editor.  If aEventTarget isn't
-  // a host of the editor, i.e., the editor doesn't get focus, this does
-  // nothing.
+  /**
+   * Initializes selection and caret for the editor.  If aEventTarget isn't
+   * a host of the editor, i.e., the editor doesn't get focus, this does
+   * nothing.
+   */
   nsresult InitializeSelection(nsIDOMEventTarget* aFocusEventTarget);
 
-  // This method has to be called by EditorEventListener::Focus.
-  // All actions that have to be done when the editor is focused needs to be
-  // added here.
+  /**
+   * This method has to be called by EditorEventListener::Focus.
+   * All actions that have to be done when the editor is focused needs to be
+   * added here.
+   */
   void OnFocus(nsIDOMEventTarget* aFocusEventTarget);
 
-  // Used to insert content from a data transfer into the editable area.
-  // This is called for each item in the data transfer, with the index of
-  // each item passed as aIndex.
-  virtual nsresult InsertFromDataTransfer(mozilla::dom::DataTransfer *aDataTransfer,
+  /**
+   * Used to insert content from a data transfer into the editable area.
+   * This is called for each item in the data transfer, with the index of
+   * each item passed as aIndex.
+   */
+  virtual nsresult InsertFromDataTransfer(dom::DataTransfer* aDataTransfer,
                                           int32_t aIndex,
-                                          nsIDOMDocument *aSourceDoc,
-                                          nsIDOMNode *aDestinationNode,
+                                          nsIDOMDocument* aSourceDoc,
+                                          nsIDOMNode* aDestinationNode,
                                           int32_t aDestOffset,
                                           bool aDoDeleteSelection) = 0;
 
   virtual nsresult InsertFromDrop(nsIDOMEvent* aDropEvent) = 0;
 
-  virtual already_AddRefed<nsIDOMNode> FindUserSelectAllNode(nsIDOMNode* aNode) { return nullptr; }
+  virtual already_AddRefed<nsIDOMNode> FindUserSelectAllNode(nsIDOMNode* aNode)
+  {
+    return nullptr;
+  }
 
   /**
    * GetIMESelectionStartOffsetIn() returns the start offset of IME selection in
    * the aTextNode.  If there is no IME selection, returns -1.
    */
   int32_t GetIMESelectionStartOffsetIn(nsINode* aTextNode);
 
   /**
@@ -826,80 +928,102 @@ public:
   /**
    * HideCaret() hides caret with nsCaret::AddForceHide() or may show carent
    * with nsCaret::RemoveForceHide().  This does NOT set visibility of
    * nsCaret.  Therefore, this is stateless.
    */
   void HideCaret(bool aHide);
 
 protected:
-  enum Tristate {
+  enum Tristate
+  {
     eTriUnset,
     eTriFalse,
     eTriTrue
   };
-  // Spellchecking
-  nsCString mContentMIMEType;       // MIME type of the doc we are editing.
+
+  // MIME type of the doc we are editing.
+  nsCString mContentMIMEType;
 
   nsCOMPtr<nsIInlineSpellChecker> mInlineSpellChecker;
 
   RefPtr<nsTransactionManager> mTxnMgr;
-  nsCOMPtr<Element> mRootElement; // cached root node
-  RefPtr<Text>    mIMETextNode; // current IME text node
-  nsCOMPtr<mozilla::dom::EventTarget> mEventTarget; // The form field as an event receiver
+  // Cached root node.
+  nsCOMPtr<Element> mRootElement;
+  // Current IME text node.
+  RefPtr<Text> mIMETextNode;
+  // The form field as an event receiver.
+  nsCOMPtr<dom::EventTarget> mEventTarget;
   nsCOMPtr<nsIDOMEventListener> mEventListener;
-  nsWeakPtr        mSelConWeak;          // weak reference to the nsISelectionController
-  nsWeakPtr        mPlaceHolderTxn;      // weak reference to placeholder for begin/end batch purposes
-  nsWeakPtr        mDocWeak;             // weak reference to the nsIDOMDocument
-  nsIAtom          *mPlaceHolderName;    // name of placeholder transaction
+  // Weak reference to the nsISelectionController.
+  nsWeakPtr mSelConWeak;
+  // Weak reference to placeholder for begin/end batch purposes.
+  nsWeakPtr mPlaceHolderTxn;
+  // Weak reference to the nsIDOMDocument.
+  nsWeakPtr mDocWeak;
+  // Name of placeholder transaction.
+  nsIAtom* mPlaceHolderName;
   // Saved selection state for placeholder transaction batching.
-  mozilla::SelectionState* mSelState;
-  nsString         *mPhonetic;
+  SelectionState* mSelState;
+  nsString* mPhonetic;
   // IME composition this is not null between compositionstart and
   // compositionend.
-  RefPtr<mozilla::TextComposition> mComposition;
+  RefPtr<TextComposition> mComposition;
 
-  // various listeners
-  // Listens to all low level actions on the doc
+  // Listens to all low level actions on the doc.
   nsTArray<OwningNonNull<nsIEditActionListener>> mActionListeners;
-  // Just notify once per high level change
+  // Just notify once per high level change.
   nsTArray<OwningNonNull<nsIEditorObserver>> mEditorObservers;
-  // Listen to overall doc state (dirty or not, just created, etc)
+  // Listen to overall doc state (dirty or not, just created, etc).
   nsTArray<OwningNonNull<nsIDocumentStateListener>> mDocStateListeners;
 
   // Cached selection for AutoSelectionRestorer.
-  mozilla::SelectionState mSavedSel;
+  SelectionState mSavedSel;
   // Utility class object for maintaining preserved ranges.
-  mozilla::RangeUpdater mRangeUpdater;
+  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.
+  // Number of modifications (for undo/redo stack).
+  uint32_t mModCount;
+  // Behavior flags. See nsIPlaintextEditor.idl for the flags we use.
+  uint32_t mFlags;
 
-  int32_t           mUpdateCount;
+  int32_t mUpdateCount;
 
-  int32_t           mPlaceHolderBatch;   // nesting count for batching
-  EditAction        mAction;             // the current editor action
+  // Nesting count for batching.
+  int32_t mPlaceHolderBatch;
+  // The current editor action.
+  EditAction mAction;
 
-  uint32_t          mIMETextOffset;    // offset in text node where IME comp string begins
+  // Offset in text node where IME comp string begins.
+  uint32_t mIMETextOffset;
   // The Length of the composition string or commit string.  If this is length
   // of commit string, the length is truncated by maxlength attribute.
-  uint32_t          mIMETextLength;
+  uint32_t mIMETextLength;
 
-  EDirection        mDirection;          // the current direction of editor action
-  int8_t            mDocDirtyState;      // -1 = not initialized
-  uint8_t           mSpellcheckCheckboxState; // a Tristate value
+  // The current direction of editor action.
+  EDirection mDirection;
+  // -1 = not initialized
+  int8_t mDocDirtyState;
+  // A Tristate value.
+  uint8_t mSpellcheckCheckboxState;
 
-  bool mShouldTxnSetSelection;  // turn off for conservative selection adjustment by txns
-  bool mDidPreDestroy;    // whether PreDestroy has been called
-  bool mDidPostCreate;    // whether PostCreate has been called
+  // Turn off for conservative selection adjustment by transactions.
+  bool mShouldTxnSetSelection;
+  // Whether PreDestroy has been called.
+  bool mDidPreDestroy;
+  // Whether PostCreate has been called.
+  bool mDidPostCreate;
   bool mDispatchInputEvent;
-  bool mIsInEditAction;   // true while the instance is handling an edit action
-  bool mHidingCaret;      // whether caret is hidden forcibly.
+  // True while the instance is handling an edit action.
+  bool mIsInEditAction;
+  // Whether caret is hidden forcibly.
+  bool mHidingCaret;
 
   friend bool NSCanUnload(nsISupports* serviceMgr);
-  friend class mozilla::AutoRules;
-  friend class mozilla::AutoSelectionRestorer;
-  friend class mozilla::AutoTransactionsConserveSelection;
-  friend class mozilla::RangeUpdater;
+  friend class AutoRules;
+  friend class AutoSelectionRestorer;
+  friend class AutoTransactionsConserveSelection;
+  friend class RangeUpdater;
 };
 
+} // namespace mozilla
 
-#endif
+#endif // #ifndef mozilla_editor_EditorBase_h_
--- a/editor/libeditor/EditorEventListener.cpp
+++ b/editor/libeditor/EditorEventListener.cpp
@@ -1,29 +1,29 @@
 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=4 sw=2 et tw=78: */
 /* 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 "EditorEventListener.h"
 
+#include "EditorBase.h"                 // for EditorBase, etc
 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
 #include "mozilla/EventListenerManager.h" // for EventListenerManager
 #include "mozilla/IMEStateManager.h"    // for IMEStateManager
 #include "mozilla/Preferences.h"        // for Preferences
 #include "mozilla/TextEvents.h"         // for WidgetCompositionEvent
 #include "mozilla/dom/Element.h"        // for Element
 #include "mozilla/dom/Event.h"          // for Event
 #include "mozilla/dom/EventTarget.h"    // for EventTarget
 #include "mozilla/dom/Selection.h"
 #include "nsAString.h"
 #include "nsCaret.h"                    // for nsCaret
 #include "nsDebug.h"                    // for NS_ENSURE_TRUE, etc
-#include "nsEditor.h"                   // for nsEditor, etc
 #include "nsFocusManager.h"             // for nsFocusManager
 #include "nsGkAtoms.h"                  // for nsGkAtoms, nsGkAtoms::input
 #include "nsIClipboard.h"               // for nsIClipboard, etc
 #include "nsIContent.h"                 // for nsIContent
 #include "nsIController.h"              // for nsIController
 #include "nsID.h"
 #include "mozilla/dom/DOMStringList.h"
 #include "mozilla/dom/DataTransfer.h"
@@ -31,17 +31,17 @@
 #include "nsIDOMDragEvent.h"            // for nsIDOMDragEvent
 #include "nsIDOMElement.h"              // for nsIDOMElement
 #include "nsIDOMEvent.h"                // for nsIDOMEvent
 #include "nsIDOMEventTarget.h"          // for nsIDOMEventTarget
 #include "nsIDOMKeyEvent.h"             // for nsIDOMKeyEvent
 #include "nsIDOMMouseEvent.h"           // for nsIDOMMouseEvent
 #include "nsIDOMNode.h"                 // for nsIDOMNode
 #include "nsIDocument.h"                // for nsIDocument
-#include "nsIEditor.h"                  // for nsEditor::GetSelection, etc
+#include "nsIEditor.h"                  // for EditorBase::GetSelection, etc
 #include "nsIEditorIMESupport.h"
 #include "nsIEditorMailSupport.h"       // for nsIEditorMailSupport
 #include "nsIFocusManager.h"            // for nsIFocusManager
 #include "nsIFormControl.h"             // for nsIFormControl, etc
 #include "nsIHTMLEditor.h"              // for nsIHTMLEditor
 #include "nsINode.h"                    // for nsINode, ::NODE_IS_EDITABLE, etc
 #include "nsIPlaintextEditor.h"         // for nsIPlaintextEditor, etc
 #include "nsIPresShell.h"               // for nsIPresShell
@@ -93,65 +93,65 @@ DoCommandCallback(Command aCommand, void
   nsresult rv = controller->IsCommandEnabled(commandStr, &commandEnabled);
   NS_ENSURE_SUCCESS_VOID(rv);
   if (commandEnabled) {
     controller->DoCommand(commandStr);
   }
 }
 
 EditorEventListener::EditorEventListener()
-  : mEditor(nullptr)
+  : mEditorBase(nullptr)
   , mCommitText(false)
   , mInTransaction(false)
   , mMouseDownOrUpConsumedByIME(false)
 #ifdef HANDLE_NATIVE_TEXT_DIRECTION_SWITCH
   , mHaveBidiKeyboards(false)
   , mShouldSwitchTextDirection(false)
   , mSwitchToRTL(false)
 #endif
 {
 }
 
 EditorEventListener::~EditorEventListener()
 {
-  if (mEditor) {
+  if (mEditorBase) {
     NS_WARNING("We're not uninstalled");
     Disconnect();
   }
 }
 
 nsresult
-EditorEventListener::Connect(nsEditor* aEditor)
+EditorEventListener::Connect(EditorBase* aEditorBase)
 {
-  NS_ENSURE_ARG(aEditor);
+  NS_ENSURE_ARG(aEditorBase);
 
 #ifdef HANDLE_NATIVE_TEXT_DIRECTION_SWITCH
   nsIBidiKeyboard* bidiKeyboard = nsContentUtils::GetBidiKeyboard();
   if (bidiKeyboard) {
     bool haveBidiKeyboards = false;
     bidiKeyboard->GetHaveBidiKeyboards(&haveBidiKeyboards);
     mHaveBidiKeyboards = haveBidiKeyboards;
   }
 #endif
 
-  mEditor = aEditor;
+  mEditorBase = aEditorBase;
 
   nsresult rv = InstallToEditor();
   if (NS_FAILED(rv)) {
     Disconnect();
   }
   return rv;
 }
 
 nsresult
 EditorEventListener::InstallToEditor()
 {
-  NS_PRECONDITION(mEditor, "The caller must set mEditor");
+  NS_PRECONDITION(mEditorBase, "The caller must set mEditorBase");
 
-  nsCOMPtr<EventTarget> piTarget = mEditor->GetDOMEventTarget();
+  nsCOMPtr<EventTarget> piTarget = mEditorBase->GetDOMEventTarget();
   NS_ENSURE_TRUE(piTarget, NS_ERROR_FAILURE);
 
   // register the event listeners with the listener manager
   EventListenerManager* elmP = piTarget->GetOrCreateListenerManager();
   NS_ENSURE_STATE(elmP);
 
 #ifdef HANDLE_NATIVE_TEXT_DIRECTION_SWITCH
   elmP->AddEventListenerByType(this,
@@ -209,42 +209,42 @@ EditorEventListener::InstallToEditor()
                                TrustedEventsAtSystemGroupBubble());
 
   return NS_OK;
 }
 
 void
 EditorEventListener::Disconnect()
 {
-  if (!mEditor) {
+  if (!mEditorBase) {
     return;
   }
   UninstallFromEditor();
 
   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
   if (fm) {
     nsCOMPtr<nsIDOMElement> domFocus;
     fm->GetFocusedElement(getter_AddRefs(domFocus));
     nsCOMPtr<nsINode> focusedElement = do_QueryInterface(domFocus);
-    mozilla::dom::Element* root = mEditor->GetRoot();
+    mozilla::dom::Element* root = mEditorBase->GetRoot();
     if (focusedElement && root &&
         nsContentUtils::ContentIsDescendantOf(focusedElement, root)) {
       // Reset the Selection ancestor limiter and SelectionController state
-      // that nsEditor::InitializeSelection set up.
-      mEditor->FinalizeSelection();
+      // that EditorBase::InitializeSelection set up.
+      mEditorBase->FinalizeSelection();
     }
   }
 
-  mEditor = nullptr;
+  mEditorBase = nullptr;
 }
 
 void
 EditorEventListener::UninstallFromEditor()
 {
-  nsCOMPtr<EventTarget> piTarget = mEditor->GetDOMEventTarget();
+  nsCOMPtr<EventTarget> piTarget = mEditorBase->GetDOMEventTarget();
   if (!piTarget) {
     return;
   }
 
   EventListenerManager* elmP = piTarget->GetOrCreateListenerManager();
   if (!elmP) {
     return;
   }
@@ -296,34 +296,34 @@ EditorEventListener::UninstallFromEditor
   elmP->RemoveEventListenerByType(this,
                                   NS_LITERAL_STRING("compositionend"),
                                   TrustedEventsAtSystemGroupBubble());
 }
 
 already_AddRefed<nsIPresShell>
 EditorEventListener::GetPresShell()
 {
-  NS_PRECONDITION(mEditor,
+  NS_PRECONDITION(mEditorBase,
     "The caller must check whether this is connected to an editor");
-  return mEditor->GetPresShell();
+  return mEditorBase->GetPresShell();
 }
 
 nsPresContext*
 EditorEventListener::GetPresContext()
 {
   nsCOMPtr<nsIPresShell> presShell = GetPresShell();
   return presShell ? presShell->GetPresContext() : nullptr;
 }
 
 nsIContent*
 EditorEventListener::GetFocusedRootContent()
 {
-  NS_ENSURE_TRUE(mEditor, nullptr);
+  NS_ENSURE_TRUE(mEditorBase, nullptr);
 
-  nsCOMPtr<nsIContent> focusedContent = mEditor->GetFocusedContent();
+  nsCOMPtr<nsIContent> focusedContent = mEditorBase->GetFocusedContent();
   if (!focusedContent) {
     return nullptr;
   }
 
   nsIDocument* composedDoc = focusedContent->GetComposedDoc();
   NS_ENSURE_TRUE(composedDoc, nullptr);
 
   if (composedDoc->HasFlag(NODE_IS_EDITABLE)) {
@@ -331,34 +331,34 @@ EditorEventListener::GetFocusedRootConte
   }
 
   return focusedContent;
 }
 
 bool
 EditorEventListener::EditorHasFocus()
 {
-  NS_PRECONDITION(mEditor,
+  NS_PRECONDITION(mEditorBase,
     "The caller must check whether this is connected to an editor");
-  nsCOMPtr<nsIContent> focusedContent = mEditor->GetFocusedContent();
+  nsCOMPtr<nsIContent> focusedContent = mEditorBase->GetFocusedContent();
   if (!focusedContent) {
     return false;
   }
   nsIDocument* composedDoc = focusedContent->GetComposedDoc();
   return !!composedDoc;
 }
 
 NS_IMPL_ISUPPORTS(EditorEventListener, nsIDOMEventListener)
 
 NS_IMETHODIMP
 EditorEventListener::HandleEvent(nsIDOMEvent* aEvent)
 {
-  NS_ENSURE_TRUE(mEditor, NS_ERROR_FAILURE);
+  NS_ENSURE_TRUE(mEditorBase, NS_ERROR_FAILURE);
 
-  nsCOMPtr<nsIEditor> kungFuDeathGrip = mEditor;
+  nsCOMPtr<nsIEditor> kungFuDeathGrip = mEditorBase;
 
   WidgetEvent* internalEvent = aEvent->WidgetEventPtr();
 
   // Let's handle each event with the message of the internal event of the
   // coming event.  If the DOM event was created with improper interface,
   // e.g., keydown event is created with |new MouseEvent("keydown", {});|,
   // its message is always 0.  Therefore, we can ban such strange event easy.
   // However, we need to handle strange "focus" and "blur" event.  See the
@@ -545,18 +545,18 @@ EditorEventListener::KeyUp(nsIDOMKeyEven
   if (!mHaveBidiKeyboards) {
     return NS_OK;
   }
 
   uint32_t keyCode = 0;
   aKeyEvent->GetKeyCode(&keyCode);
   if ((keyCode == nsIDOMKeyEvent::DOM_VK_SHIFT ||
        keyCode == nsIDOMKeyEvent::DOM_VK_CONTROL) &&
-      mShouldSwitchTextDirection && mEditor->IsPlaintextEditor()) {
-    mEditor->SwitchTextDirectionTo(mSwitchToRTL ?
+      mShouldSwitchTextDirection && mEditorBase->IsPlaintextEditor()) {
+    mEditorBase->SwitchTextDirectionTo(mSwitchToRTL ?
       nsIPlaintextEditor::eEditorRightToLeft :
       nsIPlaintextEditor::eEditorLeftToRight);
     mShouldSwitchTextDirection = false;
   }
   return NS_OK;
 }
 
 nsresult
@@ -584,33 +584,33 @@ EditorEventListener::KeyDown(nsIDOMKeyEv
 }
 #endif
 
 nsresult
 EditorEventListener::KeyPress(nsIDOMKeyEvent* aKeyEvent)
 {
   NS_ENSURE_TRUE(aKeyEvent, NS_OK);
 
-  if (!mEditor->IsAcceptableInputEvent(aKeyEvent->AsEvent())) {
+  if (!mEditorBase->IsAcceptableInputEvent(aKeyEvent->AsEvent())) {
     return NS_OK;
   }
 
   // DOM event handling happens in two passes, the client pass and the system
   // pass.  We do all of our processing in the system pass, to allow client
   // handlers the opportunity to cancel events and prevent typing in the editor.
   // If the client pass cancelled the event, defaultPrevented will be true
   // below.
 
   bool defaultPrevented;
   aKeyEvent->AsEvent()->GetDefaultPrevented(&defaultPrevented);
   if (defaultPrevented) {
     return NS_OK;
   }
 
-  nsresult rv = mEditor->HandleKeyPressEvent(aKeyEvent);
+  nsresult rv = mEditorBase->HandleKeyPressEvent(aKeyEvent);
   NS_ENSURE_SUCCESS(rv, rv);
 
   aKeyEvent->AsEvent()->GetDefaultPrevented(&defaultPrevented);
   if (defaultPrevented) {
     return NS_OK;
   }
 
   if (!ShouldHandleNativeKeyBindings(aKeyEvent)) {
@@ -626,32 +626,32 @@ EditorEventListener::KeyPress(nsIDOMKeyE
   // If the event is created by chrome script, the widget is always nullptr.
   if (!widget) {
     nsCOMPtr<nsIPresShell> ps = GetPresShell();
     nsPresContext* pc = ps ? ps->GetPresContext() : nullptr;
     widget = pc ? pc->GetNearestWidget() : nullptr;
     NS_ENSURE_TRUE(widget, NS_OK);
   }
 
-  nsCOMPtr<nsIDocument> doc = mEditor->GetDocument();
+  nsCOMPtr<nsIDocument> doc = mEditorBase->GetDocument();
   bool handled = widget->ExecuteNativeKeyBinding(
                            nsIWidget::NativeKeyBindingsForRichTextEditor,
                            *keyEvent, DoCommandCallback, doc);
   if (handled) {
     aKeyEvent->AsEvent()->PreventDefault();
   }
   return NS_OK;
 }
 
 nsresult
 EditorEventListener::MouseClick(nsIDOMMouseEvent* aMouseEvent)
 {
   // nothing to do if editor isn't editable or clicked on out of the editor.
-  if (mEditor->IsReadonly() || mEditor->IsDisabled() ||
-      !mEditor->IsAcceptableInputEvent(aMouseEvent->AsEvent())) {
+  if (mEditorBase->IsReadonly() || mEditorBase->IsDisabled() ||
+      !mEditorBase->IsAcceptableInputEvent(aMouseEvent->AsEvent())) {
     return NS_OK;
   }
 
   // Notifies clicking on editor to IMEStateManager even when the event was
   // consumed.
   if (EditorHasFocus()) {
     nsPresContext* presContext = GetPresContext();
     if (presContext) {
@@ -664,17 +664,17 @@ EditorEventListener::MouseClick(nsIDOMMo
   nsresult rv = aMouseEvent->AsEvent()->GetDefaultPrevented(&preventDefault);
   if (NS_FAILED(rv) || preventDefault) {
     // We're done if 'preventdefault' is true (see for example bug 70698).
     return rv;
   }
 
   // If we got a mouse down inside the editing area, we should force the
   // IME to commit before we change the cursor position
-  mEditor->ForceCompositionEnd();
+  mEditorBase->ForceCompositionEnd();
 
   int16_t button = -1;
   aMouseEvent->GetButton(&button);
   if (button == 1) {
     return HandleMiddleClickPaste(aMouseEvent);
   }
   return NS_OK;
 }
@@ -692,29 +692,29 @@ EditorEventListener::HandleMiddleClickPa
   if (NS_FAILED(aMouseEvent->GetRangeParent(getter_AddRefs(parent)))) {
     return NS_ERROR_NULL_POINTER;
   }
   int32_t offset = 0;
   if (NS_FAILED(aMouseEvent->GetRangeOffset(&offset))) {
     return NS_ERROR_NULL_POINTER;
   }
 
-  RefPtr<Selection> selection = mEditor->GetSelection();
+  RefPtr<Selection> selection = mEditorBase->GetSelection();
   if (selection) {
     selection->Collapse(parent, offset);
   }
 
   // If the ctrl key is pressed, we'll do paste as quotation.
   // Would've used the alt key, but the kde wmgr treats alt-middle specially.
   bool ctrlKey = false;
   aMouseEvent->GetCtrlKey(&ctrlKey);
 
   nsCOMPtr<nsIEditorMailSupport> mailEditor;
   if (ctrlKey) {
-    mailEditor = do_QueryObject(mEditor);
+    mailEditor = do_QueryObject(mEditorBase);
   }
 
   nsresult rv;
   int32_t clipboard = nsIClipboard::kGlobalClipboard;
   nsCOMPtr<nsIClipboard> clipboardService =
     do_GetService("@mozilla.org/widget/clipboard;1", &rv);
   if (NS_SUCCEEDED(rv)) {
     bool selectionSupported;
@@ -722,17 +722,17 @@ EditorEventListener::HandleMiddleClickPa
     if (NS_SUCCEEDED(rv) && selectionSupported) {
       clipboard = nsIClipboard::kSelectionClipboard;
     }
   }
 
   if (mailEditor) {
     mailEditor->PasteAsQuotation(clipboard);
   } else {
-    mEditor->Paste(clipboard);
+    mEditorBase->Paste(clipboard);
   }
 
   // Prevent the event from propagating up to be possibly handled
   // again by the containing window:
   aMouseEvent->AsEvent()->StopPropagation();
   aMouseEvent->AsEvent()->PreventDefault();
 
   // We processed the event, whether drop/paste succeeded or not
@@ -760,33 +760,33 @@ EditorEventListener::NotifyIMEOfMouseBut
                                                      aMouseEvent);
 }
 
 nsresult
 EditorEventListener::MouseDown(nsIDOMMouseEvent* aMouseEvent)
 {
   // FYI: This may be called by HTMLEditorEventListener::MouseDown() even
   //      when the event is not acceptable for committing composition.
-  mEditor->ForceCompositionEnd();
+  mEditorBase->ForceCompositionEnd();
   return NS_OK;
 }
 
 nsresult
 EditorEventListener::HandleText(nsIDOMEvent* aTextEvent)
 {
-  if (!mEditor->IsAcceptableInputEvent(aTextEvent)) {
+  if (!mEditorBase->IsAcceptableInputEvent(aTextEvent)) {
     return NS_OK;
   }
 
   // if we are readonly or disabled, then do nothing.
-  if (mEditor->IsReadonly() || mEditor->IsDisabled()) {
+  if (mEditorBase->IsReadonly() || mEditorBase->IsDisabled()) {
     return NS_OK;
   }
 
-  return mEditor->UpdateIMEComposition(aTextEvent);
+  return mEditorBase->UpdateIMEComposition(aTextEvent);
 }
 
 /**
  * Drag event implementation
  */
 
 nsresult
 EditorEventListener::DragEnter(nsIDOMDragEvent* aDragEvent)
@@ -899,52 +899,52 @@ EditorEventListener::Drop(nsIDOMDragEven
 
   nsCOMPtr<nsIDOMNode> parent;
   aDragEvent->GetRangeParent(getter_AddRefs(parent));
   nsCOMPtr<nsIContent> dropParent = do_QueryInterface(parent);
   NS_ENSURE_TRUE(dropParent, NS_ERROR_FAILURE);
 
   if (!dropParent->IsEditable() || !CanDrop(aDragEvent)) {
     // was it because we're read-only?
-    if ((mEditor->IsReadonly() || mEditor->IsDisabled()) &&
+    if ((mEditorBase->IsReadonly() || mEditorBase->IsDisabled()) &&
         !IsFileControlTextBox()) {
       // it was decided to "eat" the event as this is the "least surprise"
       // since someone else handling it might be unintentional and the
       // user could probably re-drag to be not over the disabled/readonly
       // editfields if that is what is desired.
       return aDragEvent->AsEvent()->StopPropagation();
     }
     return NS_OK;
   }
 
   aDragEvent->AsEvent()->StopPropagation();
   aDragEvent->AsEvent()->PreventDefault();
-  return mEditor->InsertFromDrop(aDragEvent->AsEvent());
+  return mEditorBase->InsertFromDrop(aDragEvent->AsEvent());
 }
 
 bool
 EditorEventListener::CanDrop(nsIDOMDragEvent* aEvent)
 {
   // if the target doc is read-only, we can't drop
-  if (mEditor->IsReadonly() || mEditor->IsDisabled()) {
+  if (mEditorBase->IsReadonly() || mEditorBase->IsDisabled()) {
     return false;
   }
 
   nsCOMPtr<nsIDOMDataTransfer> domDataTransfer;
   aEvent->GetDataTransfer(getter_AddRefs(domDataTransfer));
   nsCOMPtr<DataTransfer> dataTransfer = do_QueryInterface(domDataTransfer);
   NS_ENSURE_TRUE(dataTransfer, false);
 
   RefPtr<DOMStringList> types = dataTransfer->Types();
 
   // Plaintext editors only support dropping text. Otherwise, HTML and files
   // can be dropped as well.
   if (!types->Contains(NS_LITERAL_STRING(kTextMime)) &&
       !types->Contains(NS_LITERAL_STRING(kMozTextInternal)) &&
-      (mEditor->IsPlaintextEditor() ||
+      (mEditorBase->IsPlaintextEditor() ||
        (!types->Contains(NS_LITERAL_STRING(kHTMLMime)) &&
         !types->Contains(NS_LITERAL_STRING(kFileMime))))) {
     return false;
   }
 
   // If there is no source node, this is probably an external drag and the
   // drop is allowed. The later checks rely on checking if the drag target
   // is the same as the drag source.
@@ -952,17 +952,17 @@ EditorEventListener::CanDrop(nsIDOMDragE
   dataTransfer->GetMozSourceNode(getter_AddRefs(sourceNode));
   if (!sourceNode) {
     return true;
   }
 
   // There is a source node, so compare the source documents and this document.
   // Disallow drops on the same document.
 
-  nsCOMPtr<nsIDOMDocument> domdoc = mEditor->GetDOMDocument();
+  nsCOMPtr<nsIDOMDocument> domdoc = mEditorBase->GetDOMDocument();
   NS_ENSURE_TRUE(domdoc, false);
 
   nsCOMPtr<nsIDOMDocument> sourceDoc;
   nsresult rv = sourceNode->GetOwnerDocument(getter_AddRefs(sourceDoc));
   NS_ENSURE_SUCCESS(rv, false);
 
   // If the source and the dest are not same document, allow to drop it always.
   if (domdoc != sourceDoc) {
@@ -972,17 +972,17 @@ EditorEventListener::CanDrop(nsIDOMDragE
   // If the source node is a remote browser, treat this as coming from a
   // different document and allow the drop.
   nsCOMPtr<nsIContent> sourceContent = do_QueryInterface(sourceNode);
   TabParent* tp = TabParent::GetFrom(sourceContent);
   if (tp) {
     return true;
   }
 
-  RefPtr<Selection> selection = mEditor->GetSelection();
+  RefPtr<Selection> selection = mEditorBase->GetSelection();
   if (!selection) {
     return false;
   }
 
   // If selection is collapsed, allow to drop it always.
   if (selection->Collapsed()) {
     return true;
   }
@@ -1016,47 +1016,47 @@ EditorEventListener::CanDrop(nsIDOMDragE
     }
   }
   return true;
 }
 
 nsresult
 EditorEventListener::HandleStartComposition(nsIDOMEvent* aCompositionEvent)
 {
-  if (!mEditor->IsAcceptableInputEvent(aCompositionEvent)) {
+  if (!mEditorBase->IsAcceptableInputEvent(aCompositionEvent)) {
     return NS_OK;
   }
   WidgetCompositionEvent* compositionStart =
     aCompositionEvent->WidgetEventPtr()->AsCompositionEvent();
-  return mEditor->BeginIMEComposition(compositionStart);
+  return mEditorBase->BeginIMEComposition(compositionStart);
 }
 
 void
 EditorEventListener::HandleEndComposition(nsIDOMEvent* aCompositionEvent)
 {
-  if (!mEditor->IsAcceptableInputEvent(aCompositionEvent)) {
+  if (!mEditorBase->IsAcceptableInputEvent(aCompositionEvent)) {
     return;
   }
 
-  mEditor->EndIMEComposition();
+  mEditorBase->EndIMEComposition();
 }
 
 nsresult
 EditorEventListener::Focus(nsIDOMEvent* aEvent)
 {
   NS_ENSURE_TRUE(aEvent, NS_OK);
 
   // Don't turn on selection and caret when the editor is disabled.
-  if (mEditor->IsDisabled()) {
+  if (mEditorBase->IsDisabled()) {
     return NS_OK;
   }
 
   // Spell check a textarea the first time that it is focused.
   SpellCheckIfNeeded();
-  if (!mEditor) {
+  if (!mEditorBase) {
     // In e10s, this can cause us to flush notifications, which can destroy
     // the node we're about to focus.
     return NS_OK;
   }
 
   nsCOMPtr<nsIDOMEventTarget> target;
   aEvent->GetTarget(getter_AddRefs(target));
   nsCOMPtr<nsINode> node = do_QueryInterface(target);
@@ -1071,39 +1071,39 @@ EditorEventListener::Focus(nsIDOMEvent* 
 
   if (node->IsNodeOfType(nsINode::eCONTENT)) {
     // XXX If the focus event target is a form control in contenteditable
     // element, perhaps, the parent HTML editor should do nothing by this
     // handler.  However, FindSelectionRoot() returns the root element of the
     // contenteditable editor.  So, the editableRoot value is invalid for
     // the plain text editor, and it will be set to the wrong limiter of
     // the selection.  However, fortunately, actual bugs are not found yet.
-    nsCOMPtr<nsIContent> editableRoot = mEditor->FindSelectionRoot(node);
+    nsCOMPtr<nsIContent> editableRoot = mEditorBase->FindSelectionRoot(node);
 
     // make sure that the element is really focused in case an earlier
     // listener in the chain changed the focus.
     if (editableRoot) {
       nsIFocusManager* fm = nsFocusManager::GetFocusManager();
       NS_ENSURE_TRUE(fm, NS_OK);
 
       nsCOMPtr<nsIDOMElement> element;
       fm->GetFocusedElement(getter_AddRefs(element));
       if (!SameCOMIdentity(element, target)) {
         return NS_OK;
       }
     }
   }
 
-  mEditor->OnFocus(target);
+  mEditorBase->OnFocus(target);
 
   nsCOMPtr<nsIPresShell> ps = GetPresShell();
   NS_ENSURE_TRUE(ps, NS_OK);
-  nsCOMPtr<nsIContent> focusedContent = mEditor->GetFocusedContentForIME();
+  nsCOMPtr<nsIContent> focusedContent = mEditorBase->GetFocusedContentForIME();
   IMEStateManager::OnFocusInEditor(ps->GetPresContext(), focusedContent,
-                                   mEditor);
+                                   mEditorBase);
 
   return NS_OK;
 }
 
 nsresult
 EditorEventListener::Blur(nsIDOMEvent* aEvent)
 {
   NS_ENSURE_TRUE(aEvent, NS_OK);
@@ -1111,38 +1111,38 @@ EditorEventListener::Blur(nsIDOMEvent* a
   // check if something else is focused. If another element is focused, then
   // we should not change the selection.
   nsIFocusManager* fm = nsFocusManager::GetFocusManager();
   NS_ENSURE_TRUE(fm, NS_OK);
 
   nsCOMPtr<nsIDOMElement> element;
   fm->GetFocusedElement(getter_AddRefs(element));
   if (!element) {
-    mEditor->FinalizeSelection();
+    mEditorBase->FinalizeSelection();
   }
   return NS_OK;
 }
 
 void
 EditorEventListener::SpellCheckIfNeeded()
 {
   // If the spell check skip flag is still enabled from creation time,
   // disable it because focused editors are allowed to spell check.
   uint32_t currentFlags = 0;
-  mEditor->GetFlags(&currentFlags);
+  mEditorBase->GetFlags(&currentFlags);
   if(currentFlags & nsIPlaintextEditor::eEditorSkipSpellCheck) {
     currentFlags ^= nsIPlaintextEditor::eEditorSkipSpellCheck;
-    mEditor->SetFlags(currentFlags);
+    mEditorBase->SetFlags(currentFlags);
   }
 }
 
 bool
 EditorEventListener::IsFileControlTextBox()
 {
-  dom::Element* root = mEditor->GetRoot();
+  Element* root = mEditorBase->GetRoot();
   if (!root || !root->ChromeOnlyAccess()) {
     return false;
   }
   nsIContent* parent = root->FindFirstNonChromeOnlyAccessContent();
   if (!parent || !parent->IsHTMLElement(nsGkAtoms::input)) {
     return false;
   }
   nsCOMPtr<nsIFormControl> formControl = do_QueryInterface(parent);
@@ -1163,22 +1163,22 @@ EditorEventListener::ShouldHandleNativeK
   nsCOMPtr<nsIDOMEventTarget> target;
   aKeyEvent->AsEvent()->GetTarget(getter_AddRefs(target));
   nsCOMPtr<nsIContent> targetContent = do_QueryInterface(target);
   if (!targetContent) {
     return false;
   }
 
   nsCOMPtr<nsIHTMLEditor> htmlEditor =
-    do_QueryInterface(static_cast<nsIEditor*>(mEditor));
+    do_QueryInterface(static_cast<nsIEditor*>(mEditorBase));
   if (!htmlEditor) {
     return false;
   }
 
-  nsCOMPtr<nsIDocument> doc = mEditor->GetDocument();
+  nsCOMPtr<nsIDocument> doc = mEditorBase->GetDocument();
   if (doc->HasFlag(NODE_IS_EDITABLE)) {
     // Don't need to perform any checks in designMode documents.
     return true;
   }
 
   nsIContent* editingHost = htmlEditor->GetActiveEditingHost();
   if (!editingHost) {
     return false;
--- a/editor/libeditor/EditorEventListener.h
+++ b/editor/libeditor/EditorEventListener.h
@@ -14,37 +14,38 @@
 
 class nsCaret;
 class nsIContent;
 class nsIDOMDragEvent;
 class nsIDOMEvent;
 class nsIDOMKeyEvent;
 class nsIDOMMouseEvent;
 class nsIPresShell;
-class nsEditor;
 class nsPresContext;
 
 // X.h defines KeyPress
 #ifdef KeyPress
 #undef KeyPress
 #endif
 
 #ifdef XP_WIN
 // On Windows, we support switching the text direction by pressing Ctrl+Shift
 #define HANDLE_NATIVE_TEXT_DIRECTION_SWITCH
 #endif
 
 namespace mozilla {
 
+class EditorBase;
+
 class EditorEventListener : public nsIDOMEventListener
 {
 public:
   EditorEventListener();
 
-  virtual nsresult Connect(nsEditor* aEditor);
+  virtual nsresult Connect(EditorBase* aEditorBase);
 
   void Disconnect();
 
   NS_DECL_ISUPPORTS
   NS_DECL_NSIDOMEVENTLISTENER
 
   void SpellCheckIfNeeded();
 
@@ -80,17 +81,17 @@ protected:
   nsIContent* GetFocusedRootContent();
   // Returns true if IME consumes the mouse event.
   bool NotifyIMEOfMouseButtonEvent(nsIDOMMouseEvent* aMouseEvent);
   bool EditorHasFocus();
   bool IsFileControlTextBox();
   bool ShouldHandleNativeKeyBindings(nsIDOMKeyEvent* aKeyEvent);
   nsresult HandleMiddleClickPaste(nsIDOMMouseEvent* aMouseEvent);
 
-  nsEditor* mEditor; // weak
+  EditorBase* mEditorBase; // weak
   RefPtr<nsCaret> mCaret;
   bool mCommitText;
   bool mInTransaction;
   bool mMouseDownOrUpConsumedByIME;
 #ifdef HANDLE_NATIVE_TEXT_DIRECTION_SWITCH
   bool mHaveBidiKeyboards;
   bool mShouldSwitchTextDirection;
   bool mSwitchToRTL;
--- a/editor/libeditor/EditorUtils.cpp
+++ b/editor/libeditor/EditorUtils.cpp
@@ -29,50 +29,50 @@ namespace mozilla {
 using namespace dom;
 
 /******************************************************************************
  * AutoSelectionRestorer
  *****************************************************************************/
 
 AutoSelectionRestorer::AutoSelectionRestorer(
                          Selection* aSelection,
-                         nsEditor* aEditor
+                         EditorBase* aEditorBase
                          MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)
-  : mEditor(nullptr)
+  : mEditorBase(nullptr)
 {
   MOZ_GUARD_OBJECT_NOTIFIER_INIT;
-  if (NS_WARN_IF(!aSelection) || NS_WARN_IF(!aEditor)) {
+  if (NS_WARN_IF(!aSelection) || NS_WARN_IF(!aEditorBase)) {
     return;
   }
-  if (aEditor->ArePreservingSelection()) {
+  if (aEditorBase->ArePreservingSelection()) {
     // We already have initialized mSavedSel, so this must be nested call.
     return;
   }
   mSelection = aSelection;
-  mEditor = aEditor;
-  mEditor->PreserveSelectionAcrossActions(mSelection);
+  mEditorBase = aEditorBase;
+  mEditorBase->PreserveSelectionAcrossActions(mSelection);
 }
 
 AutoSelectionRestorer::~AutoSelectionRestorer()
 {
-  NS_ASSERTION(!mSelection || mEditor,
-               "mEditor should be non-null when mSelection is");
+  NS_ASSERTION(!mSelection || mEditorBase,
+               "mEditorBase should be non-null when mSelection is");
   // mSelection will be null if this was nested call.
-  if (mSelection && mEditor->ArePreservingSelection()) {
-    mEditor->RestorePreservedSelection(mSelection);
+  if (mSelection && mEditorBase->ArePreservingSelection()) {
+    mEditorBase->RestorePreservedSelection(mSelection);
   }
 }
 
 void
 AutoSelectionRestorer::Abort()
 {
-  NS_ASSERTION(!mSelection || mEditor,
-               "mEditor should be non-null when mSelection is");
+  NS_ASSERTION(!mSelection || mEditorBase,
+               "mEditorBase should be non-null when mSelection is");
   if (mSelection) {
-    mEditor->StopPreservingSelection();
+    mEditorBase->StopPreservingSelection();
   }
 }
 
 /******************************************************************************
  * some helper classes for iterating the dom tree
  *****************************************************************************/
 
 DOMIterator::DOMIterator(nsINode& aNode MOZ_GUARD_OBJECT_NOTIFIER_PARAM_IN_IMPL)
--- a/editor/libeditor/EditorUtils.h
+++ b/editor/libeditor/EditorUtils.h
@@ -2,23 +2,23 @@
 /* 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 EditorUtils_h_
 #define EditorUtils_h_
 
+#include "EditorBase.h"
+#include "mozilla/GuardObjects.h"
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsIDOMNode.h"
 #include "nsIEditor.h"
 #include "nscore.h"
-#include "mozilla/GuardObjects.h"
 
 class nsIAtom;
 class nsIContentIterator;
 class nsIDOMDocument;
 class nsIDOMEvent;
 class nsISimpleEnumerator;
 class nsITransferable;
 class nsRange;
@@ -83,26 +83,26 @@ public:
  * stack based helper class for saving/restoring selection.  Note that this
  * assumes that the nodes involved are still around afterwards!
  */
 class MOZ_RAII AutoSelectionRestorer final
 {
 private:
   // Ref-counted reference to the selection that we are supposed to restore.
   RefPtr<dom::Selection> mSelection;
-  nsEditor* mEditor;  // Non-owning ref to nsEditor.
+  EditorBase* mEditorBase;  // Non-owning ref to EditorBase.
   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 
 public:
   /**
    * Constructor responsible for remembering all state needed to restore
    * aSelection.
    */
   AutoSelectionRestorer(dom::Selection* aSelection,
-                        nsEditor* aEditor
+                        EditorBase* aEditorBase
                         MOZ_GUARD_OBJECT_NOTIFIER_PARAM);
 
   /**
    * Destructor restores mSelection to its former state
    */
   ~AutoSelectionRestorer();
 
   /**
@@ -112,103 +112,103 @@ public:
 };
 
 /***************************************************************************
  * stack based helper class for StartOperation()/EndOperation() sandwich
  */
 class MOZ_RAII AutoRules final
 {
 public:
-  AutoRules(nsEditor* aEditor, EditAction aAction,
+  AutoRules(EditorBase* aEditorBase, EditAction aAction,
             nsIEditor::EDirection aDirection
             MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
-    : mEditor(aEditor)
+    : mEditorBase(aEditorBase)
     , mDoNothing(false)
   {
     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
     // mAction will already be set if this is nested call
-    if (mEditor && !mEditor->mAction) {
-      mEditor->StartOperation(aAction, aDirection);
+    if (mEditorBase && !mEditorBase->mAction) {
+      mEditorBase->StartOperation(aAction, aDirection);
     } else {
       mDoNothing = true; // nested calls will end up here
     }
   }
 
   ~AutoRules()
   {
-    if (mEditor && !mDoNothing) {
-      mEditor->EndOperation();
+    if (mEditorBase && !mDoNothing) {
+      mEditorBase->EndOperation();
     }
   }
 
 protected:
-  nsEditor* mEditor;
+  EditorBase* mEditorBase;
   bool mDoNothing;
   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 
 /***************************************************************************
  * stack based helper class for turning off active selection adjustment
  * by low level transactions
  */
 class MOZ_RAII AutoTransactionsConserveSelection final
 {
 public:
-  explicit AutoTransactionsConserveSelection(nsEditor* aEditor
+  explicit AutoTransactionsConserveSelection(EditorBase* aEditorBase
                                              MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
-    : mEditor(aEditor)
+    : mEditorBase(aEditorBase)
     , mOldState(true)
   {
     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
-    if (mEditor) {
-      mOldState = mEditor->GetShouldTxnSetSelection();
-      mEditor->SetShouldTxnSetSelection(false);
+    if (mEditorBase) {
+      mOldState = mEditorBase->GetShouldTxnSetSelection();
+      mEditorBase->SetShouldTxnSetSelection(false);
     }
   }
 
   ~AutoTransactionsConserveSelection()
   {
-    if (mEditor) {
-      mEditor->SetShouldTxnSetSelection(mOldState);
+    if (mEditorBase) {
+      mEditorBase->SetShouldTxnSetSelection(mOldState);
     }
   }
 
 protected:
-  nsEditor* mEditor;
+  EditorBase* mEditorBase;
   bool mOldState;
   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 
 /***************************************************************************
  * stack based helper class for batching reflow and paint requests.
  */
 class MOZ_RAII AutoUpdateViewBatch final
 {
 public:
-  explicit AutoUpdateViewBatch(nsEditor* aEditor
+  explicit AutoUpdateViewBatch(EditorBase* aEditorBase
                                MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
-    : mEditor(aEditor)
+    : mEditorBase(aEditorBase)
   {
     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
-    NS_ASSERTION(mEditor, "null mEd pointer!");
+    NS_ASSERTION(mEditorBase, "null mEditorBase pointer!");
 
-    if (mEditor) {
-      mEditor->BeginUpdateViewBatch();
+    if (mEditorBase) {
+      mEditorBase->BeginUpdateViewBatch();
     }
   }
 
   ~AutoUpdateViewBatch()
   {
-    if (mEditor) {
-      mEditor->EndUpdateViewBatch();
+    if (mEditorBase) {
+      mEditorBase->EndUpdateViewBatch();
     }
   }
 
 protected:
-  nsEditor* mEditor;
+  EditorBase* mEditorBase;
   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 
 /******************************************************************************
  * some helper classes for iterating the dom tree
  *****************************************************************************/
 
 class BoolDomIterFunctor
--- a/editor/libeditor/HTMLAbsPositionEditor.cpp
+++ b/editor/libeditor/HTMLAbsPositionEditor.cpp
@@ -15,17 +15,16 @@
 #include "mozilla/dom/Selection.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/mozalloc.h"
 #include "nsAString.h"
 #include "nsAlgorithm.h"
 #include "nsCOMPtr.h"
 #include "nsComputedDOMStyle.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsGkAtoms.h"
 #include "nsIContent.h"
 #include "nsROCSSPrimitiveValue.h"
 #include "nsIDOMCSSStyleDeclaration.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMEventListener.h"
 #include "nsIDOMEventTarget.h"
--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -25,17 +25,16 @@
 #include "nsAutoPtr.h"
 #include "nsAString.h"
 #include "nsAlgorithm.h"
 #include "nsCRT.h"
 #include "nsCRTGlue.h"
 #include "nsComponentManagerUtils.h"
 #include "nsContentUtils.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsGkAtoms.h"
 #include "nsIAtom.h"
 #include "nsIContent.h"
 #include "nsIContentIterator.h"
 #include "nsID.h"
 #include "nsIDOMCharacterData.h"
 #include "nsIDOMDocument.h"
@@ -1151,17 +1150,17 @@ HTMLEditRules::AppendInnerFormatNodes(ns
 
 nsresult
 HTMLEditRules::GetFormatString(nsIDOMNode* aNode,
                                nsAString& outFormat)
 {
   NS_ENSURE_TRUE(aNode, NS_ERROR_NULL_POINTER);
 
   if (HTMLEditUtils::IsFormatNode(aNode)) {
-    nsCOMPtr<nsIAtom> atom = nsEditor::GetTag(aNode);
+    nsCOMPtr<nsIAtom> atom = EditorBase::GetTag(aNode);
     atom->ToString(outFormat);
   }
   else
     outFormat.Truncate();
 
   return NS_OK;
 }
 
@@ -2923,17 +2922,17 @@ HTMLEditRules::DidDeleteSelection(Select
   if (citeNode) {
     bool isEmpty = true, seenBR = false;
     NS_ENSURE_STATE(mHTMLEditor);
     mHTMLEditor->IsEmptyNodeImpl(citeNode, &isEmpty, true, true, false,
                                  &seenBR);
     if (isEmpty)
     {
       int32_t offset;
-      nsCOMPtr<nsINode> parent = nsEditor::GetNodeLocation(citeNode, &offset);
+      nsCOMPtr<nsINode> parent = EditorBase::GetNodeLocation(citeNode, &offset);
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->DeleteNode(citeNode);
       NS_ENSURE_SUCCESS(res, res);
       if (parent && seenBR)
       {
         NS_ENSURE_STATE(mHTMLEditor);
         nsCOMPtr<Element> brNode = mHTMLEditor->CreateBR(parent, offset);
         NS_ENSURE_STATE(brNode);
@@ -3065,17 +3064,17 @@ HTMLEditRules::WillMakeList(Selection* a
   nsCOMPtr<Element> curList, prevListItem;
 
   for (uint32_t i = 0; i < listCount; i++) {
     // here's where we actually figure out what to do
     nsCOMPtr<Element> newBlock;
     NS_ENSURE_STATE(arrayOfNodes[i]->IsContent());
     OwningNonNull<nsIContent> curNode = *arrayOfNodes[i]->AsContent();
     int32_t offset;
-    curParent = nsEditor::GetNodeLocation(curNode, &offset);
+    curParent = EditorBase::GetNodeLocation(curNode, &offset);
 
     // make sure we don't assemble content that is in different table cells
     // into the same list.  respect table cell boundaries when listifying.
     if (curList && InDifferentTableElements(curList, curNode)) {
       curList = nullptr;
     }
 
     // if curNode is a Break, delete it, and quit remembering prev list item
@@ -3129,18 +3128,18 @@ HTMLEditRules::WillMakeList(Selection* a
           NS_ENSURE_STATE(mHTMLEditor);
           NS_ENSURE_STATE(curParent->IsContent());
           ErrorResult rv;
           nsCOMPtr<nsIContent> splitNode =
             mHTMLEditor->SplitNode(*curParent->AsContent(), offset, rv);
           NS_ENSURE_TRUE(!rv.Failed(), rv.StealNSResult());
           newBlock = splitNode ? splitNode->AsElement() : nullptr;
           int32_t offset;
-          nsCOMPtr<nsINode> parent = nsEditor::GetNodeLocation(curParent,
-                                                               &offset);
+          nsCOMPtr<nsINode> parent = EditorBase::GetNodeLocation(curParent,
+                                                                 &offset);
           NS_ENSURE_STATE(mHTMLEditor);
           curList = mHTMLEditor->CreateNode(listType, parent, offset);
           NS_ENSURE_STATE(curList);
         }
         // move list item to new list
         NS_ENSURE_STATE(mHTMLEditor);
         res = mHTMLEditor->MoveNode(curNode, curList, -1);
         NS_ENSURE_SUCCESS(res, res);
@@ -5134,35 +5133,36 @@ HTMLEditRules::NormalizeSelection(Select
     // of going "down" into a block and "up" out of a block.
     if (wsEndObj.mStartReason == WSType::otherBlock) {
       // endpoint is just after the close of a block.
       nsCOMPtr<nsIDOMNode> child =
         GetAsDOMNode(mHTMLEditor->GetRightmostChild(wsEndObj.mStartReasonNode,
                                                     true));
       if (child)
       {
-        newEndNode = nsEditor::GetNodeLocation(child, &newEndOffset);
+        newEndNode = EditorBase::GetNodeLocation(child, &newEndOffset);
         ++newEndOffset; // offset *after* child
       }
       // else block is empty - we can leave selection alone here, i think.
     } else if (wsEndObj.mStartReason == WSType::thisBlock) {
       // endpoint is just after start of this block
       nsCOMPtr<nsIDOMNode> child;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetPriorHTMLNode(endNode, endOffset, address_of(child));
       if (child)
       {
-        newEndNode = nsEditor::GetNodeLocation(child, &newEndOffset);
+        newEndNode = EditorBase::GetNodeLocation(child, &newEndOffset);
         ++newEndOffset; // offset *after* child
       }
       // else block is empty - we can leave selection alone here, i think.
     } else if (wsEndObj.mStartReason == WSType::br) {
       // endpoint is just after break.  lets adjust it to before it.
-      newEndNode = nsEditor::GetNodeLocation(GetAsDOMNode(wsEndObj.mStartReasonNode),
-                                             &newEndOffset);
+      newEndNode =
+        EditorBase::GetNodeLocation(GetAsDOMNode(wsEndObj.mStartReasonNode),
+                                    &newEndOffset);
     }
   }
 
 
   // similar dealio for start of range
   WSRunObject wsStartObj(mHTMLEditor, startNode, startOffset);
   // is there any intervening visible whitespace?  if so we can't push selection past that,
   // it would visibly change maening of users selection
@@ -5174,33 +5174,34 @@ HTMLEditRules::NormalizeSelection(Select
     // of going "down" into a block and "up" out of a block.
     if (wsStartObj.mEndReason == WSType::otherBlock) {
       // startpoint is just before the start of a block.
       nsCOMPtr<nsIDOMNode> child =
         GetAsDOMNode(mHTMLEditor->GetLeftmostChild(wsStartObj.mEndReasonNode,
                                                    true));
       if (child)
       {
-        newStartNode = nsEditor::GetNodeLocation(child, &newStartOffset);
+        newStartNode = EditorBase::GetNodeLocation(child, &newStartOffset);
       }
       // else block is empty - we can leave selection alone here, i think.
     } else if (wsStartObj.mEndReason == WSType::thisBlock) {
       // startpoint is just before end of this block
       nsCOMPtr<nsIDOMNode> child;
       NS_ENSURE_STATE(mHTMLEditor);
       res = mHTMLEditor->GetNextHTMLNode(startNode, startOffset, address_of(child));
       if (child)
       {
-        newStartNode = nsEditor::GetNodeLocation(child, &newStartOffset);
+        newStartNode = EditorBase::GetNodeLocation(child, &newStartOffset);
       }
       // else block is empty - we can leave selection alone here, i think.
     } else if (wsStartObj.mEndReason == WSType::br) {
       // startpoint is just before a break.  lets adjust it to after it.
-      newStartNode = nsEditor::GetNodeLocation(GetAsDOMNode(wsStartObj.mEndReasonNode),
-                                               &newStartOffset);
+      newStartNode =
+        EditorBase::GetNodeLocation(GetAsDOMNode(wsStartObj.mEndReasonNode),
+                                    &newStartOffset);
       ++newStartOffset; // offset *after* break
     }
   }
 
   // there is a demented possiblity we have to check for.  We might have a very strange selection
   // that is not collapsed and yet does not contain any editable content, and satisfies some of the
   // above conditions that cause tweaking.  In this case we don't want to tweak the selection into
   // a block it was never in, etc.  There are a variety of strategies one might use to try to
@@ -5512,19 +5513,19 @@ HTMLEditRules::PromoteRange(nsRange& aRa
 
   GetPromotedPoint(kStart, GetAsDOMNode(startNode), startOffset,
                    aOperationType, address_of(opStartNode), &opStartOffset);
   GetPromotedPoint(kEnd, GetAsDOMNode(endNode), endOffset, aOperationType,
                    address_of(opEndNode), &opEndOffset);
 
   // Make sure that the new range ends up to be in the editable section.
   if (!mHTMLEditor->IsDescendantOfEditorRoot(
-        nsEditor::GetNodeAtRangeOffsetPoint(opStartNode, opStartOffset)) ||
+        EditorBase::GetNodeAtRangeOffsetPoint(opStartNode, opStartOffset)) ||
       !mHTMLEditor->IsDescendantOfEditorRoot(
-        nsEditor::GetNodeAtRangeOffsetPoint(opEndNode, opEndOffset - 1))) {
+        EditorBase::GetNodeAtRangeOffsetPoint(opEndNode, opEndOffset - 1))) {
     return;
   }
 
   DebugOnly<nsresult> res = aRange.SetStart(opStartNode, opStartOffset);
   MOZ_ASSERT(NS_SUCCEEDED(res));
   res = aRange.SetEnd(opEndNode, opEndOffset);
   MOZ_ASSERT(NS_SUCCEEDED(res));
 }
@@ -5908,33 +5909,33 @@ HTMLEditRules::BustUpInlinesAtRangeEndpo
   if (endInline && !isCollapsed)
   {
     nsCOMPtr<nsINode> resultEndNode = endInline->GetParentNode();
     NS_ENSURE_STATE(mHTMLEditor);
     // item.endNode must be content if endInline isn't null
     int32_t resultEndOffset =
       mHTMLEditor->SplitNodeDeep(*endInline, *item.endNode->AsContent(),
                                  item.endOffset,
-                                 nsEditor::EmptyContainers::no);
+                                 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);
 
   if (startInline)
   {
     nsCOMPtr<nsINode> resultStartNode = startInline->GetParentNode();
     NS_ENSURE_STATE(mHTMLEditor);
     int32_t resultStartOffset =
       mHTMLEditor->SplitNodeDeep(*startInline, *item.startNode->AsContent(),
                                  item.startOffset,
-                                 nsEditor::EmptyContainers::no);
+                                 EditorBase::EmptyContainers::no);
     NS_ENSURE_TRUE(resultStartOffset != -1, NS_ERROR_FAILURE);
     // reset range
     item.startNode = resultStartNode;
     item.startOffset = resultStartOffset;
   }
 
   return NS_OK;
 }
@@ -6214,17 +6215,17 @@ HTMLEditRules::ReturnInParagraph(Selecti
   if (!aSelection || !aPara || !node || !aCancel || !aHandled) {
     return NS_ERROR_NULL_POINTER;
   }
   *aCancel = false;
   *aHandled = false;
   nsresult res;
 
   int32_t offset;
-  nsCOMPtr<nsINode> parent = nsEditor::GetNodeLocation(node, &offset);
+  nsCOMPtr<nsINode> parent = EditorBase::GetNodeLocation(node, &offset);
 
   NS_ENSURE_STATE(mHTMLEditor);
   bool doesCRCreateNewP = mHTMLEditor->GetReturnInParagraphCreatesNewParagraph();
 
   bool newBRneeded = false;
   bool newSelNode = false;
   nsCOMPtr<nsIContent> sibling;
   nsCOMPtr<nsIDOMNode> selNode = aNode;
@@ -6375,17 +6376,17 @@ HTMLEditRules::SplitParagraph(nsIDOMNode
   if (mHTMLEditor->IsTextNode(child) ||
       mHTMLEditor->IsContainer(child))
   {
     aSelection->Collapse(child,0);
   }
   else
   {
     int32_t offset;
-    nsCOMPtr<nsIDOMNode> parent = nsEditor::GetNodeLocation(child, &offset);
+    nsCOMPtr<nsIDOMNode> parent = EditorBase::GetNodeLocation(child, &offset);
     aSelection->Collapse(parent,offset);
   }
   return res;
 }
 
 /**
  * ReturnInListItem: do the right thing for returns pressed in list items
  */
@@ -6736,17 +6737,17 @@ HTMLEditRules::ApplyBlockStyle(nsTArray<
     // new block of correct type.
     // XXX: pre can't hold everything the others can
     if (HTMLEditUtils::IsMozDiv(curNode) ||
         HTMLEditUtils::IsFormatNode(curNode)) {
       // Forget any previous block used for previous inline nodes
       curBlock = nullptr;
       newBlock = mHTMLEditor->ReplaceContainer(curNode->AsElement(),
                                                &aBlockTag, nullptr, nullptr,
-                                               nsEditor::eCloneAttributes);
+                                               EditorBase::eCloneAttributes);
       NS_ENSURE_STATE(newBlock);
     } else if (HTMLEditUtils::IsTable(curNode) ||
                HTMLEditUtils::IsList(curNode) ||
                curNode->IsAnyOfHTMLElements(nsGkAtoms::tbody,
                                             nsGkAtoms::tr,
                                             nsGkAtoms::td,
                                             nsGkAtoms::li,
                                             nsGkAtoms::blockquote,
@@ -7159,37 +7160,37 @@ HTMLEditRules::PinSelectionToNewBlock(Se
     // selection is after block.  put at end of block.
     nsCOMPtr<nsIDOMNode> tmp = GetAsDOMNode(mNewBlock);
     NS_ENSURE_STATE(mHTMLEditor);
     tmp = GetAsDOMNode(mHTMLEditor->GetLastEditableChild(*block));
     uint32_t endPoint;
     if (mHTMLEditor->IsTextNode(tmp) ||
         mHTMLEditor->IsContainer(tmp))
     {
-      res = nsEditor::GetLengthOfDOMNode(tmp, endPoint);
+      res = EditorBase::GetLengthOfDOMNode(tmp, endPoint);
       NS_ENSURE_SUCCESS(res, res);
     }
     else
     {
-      tmp = nsEditor::GetNodeLocation(tmp, (int32_t*)&endPoint);
+      tmp = EditorBase::GetNodeLocation(tmp, (int32_t*)&endPoint);
       endPoint++;  // want to be after this node
     }
     return aSelection->Collapse(tmp, (int32_t)endPoint);
   }
   else
   {
     // selection is before block.  put at start of block.
     nsCOMPtr<nsIDOMNode> tmp = GetAsDOMNode(mNewBlock);
     NS_ENSURE_STATE(mHTMLEditor);
     tmp = GetAsDOMNode(mHTMLEditor->GetFirstEditableChild(*block));
     int32_t offset;
     if (mHTMLEditor->IsTextNode(tmp) ||
         mHTMLEditor->IsContainer(tmp))
     {
-      tmp = nsEditor::GetNodeLocation(tmp, &offset);
+      tmp = EditorBase::GetNodeLocation(tmp, &offset);
     }
     return aSelection->Collapse(tmp, 0);
   }
 }
 
 void
 HTMLEditRules::CheckInterlinePosition(Selection& aSelection)
 {
@@ -7252,17 +7253,17 @@ HTMLEditRules::AdjustSelection(Selection
   NS_ENSURE_SUCCESS(res, res);
   temp = selNode;
 
   // are we in an editable node?
   NS_ENSURE_STATE(mHTMLEditor);
   while (!mHTMLEditor->IsEditable(selNode))
   {
     // scan up the tree until we find an editable place to be
-    selNode = nsEditor::GetNodeLocation(temp, &selOffset);
+    selNode = EditorBase::GetNodeLocation(temp, &selOffset);
     NS_ENSURE_TRUE(selNode, NS_ERROR_FAILURE);
     temp = selNode;
     NS_ENSURE_STATE(mHTMLEditor);
   }
 
   // make sure we aren't in an empty block - user will see no cursor.  If this
   // is happening, put a <br> in the block if allowed.
   NS_ENSURE_STATE(mHTMLEditor);
@@ -7319,17 +7320,17 @@ HTMLEditRules::AdjustSelection(Selection
           // need to insert special moz BR. Why?  Because if we don't
           // the user will see no new line for the break.  Also, things
           // like table cells won't grow in height.
           nsCOMPtr<nsIDOMNode> brNode;
           res = CreateMozBR(GetAsDOMNode(selNode), selOffset,
                             getter_AddRefs(brNode));
           NS_ENSURE_SUCCESS(res, res);
           nsCOMPtr<nsIDOMNode> brParent =
-            nsEditor::GetNodeLocation(brNode, &selOffset);
+            EditorBase::GetNodeLocation(brNode, &selOffset);
           // selection stays *before* moz-br, sticking to it
           aSelection->SetInterlinePosition(true);
           res = aSelection->Collapse(brParent, selOffset);
           NS_ENSURE_SUCCESS(res, res);
         }
         else
         {
           NS_ENSURE_STATE(mHTMLEditor);
@@ -7344,26 +7345,26 @@ HTMLEditRules::AdjustSelection(Selection
       }
     }
   }
 
   // we aren't in a textnode: are we adjacent to text or a break or an image?
   NS_ENSURE_STATE(mHTMLEditor);
   nearNode = mHTMLEditor->GetPriorHTMLNode(selNode, selOffset, true);
   if (nearNode && (TextEditUtils::IsBreak(nearNode) ||
-                   nsEditor::IsTextNode(nearNode) ||
+                   EditorBase::IsTextNode(nearNode) ||
                    HTMLEditUtils::IsImage(nearNode) ||
                    nearNode->IsHTMLElement(nsGkAtoms::hr))) {
     // this is a good place for the caret to be
     return NS_OK;
   }
   NS_ENSURE_STATE(mHTMLEditor);
   nearNode = mHTMLEditor->GetNextHTMLNode(selNode, selOffset, true);
   if (nearNode && (TextEditUtils::IsBreak(nearNode) ||
-                   nsEditor::IsTextNode(nearNode) ||
+                   EditorBase::IsTextNode(nearNode) ||
                    nearNode->IsAnyOfHTMLElements(nsGkAtoms::img,
                                                  nsGkAtoms::hr))) {
     return NS_OK; // this is a good place for the caret to be
   }
 
   // look for a nearby text node.
   // prefer the correct direction.
   nsCOMPtr<nsIDOMNode> nearNodeDOM = GetAsDOMNode(nearNode);
@@ -7381,17 +7382,17 @@ HTMLEditRules::AdjustSelection(Selection
       int32_t offset = 0;
       // put selection in right place:
       if (aAction == nsIEditor::ePrevious)
         textNode->GetLength((uint32_t*)&offset);
       res = aSelection->Collapse(nearNode,offset);
     }
     else  // must be break or image
     {
-      selNode = nsEditor::GetNodeLocation(nearNode, &selOffset);
+      selNode = EditorBase::GetNodeLocation(nearNode, &selOffset);
       if (aAction == nsIEditor::ePrevious) selOffset++;  // want to be beyond it if we backed up to it
       res = aSelection->Collapse(selNode, selOffset);
     }
   }
   return res;
 }
 
 
@@ -8061,17 +8062,17 @@ NS_IMETHODIMP
 HTMLEditRules::WillJoinNodes(nsIDOMNode* aLeftNode,
                              nsIDOMNode* aRightNode,
                              nsIDOMNode* aParent)
 {
   if (!mListenerEnabled) {
     return NS_OK;
   }
   // remember split point
-  nsresult res = nsEditor::GetLengthOfDOMNode(aLeftNode, mJoinOffset);
+  nsresult res = EditorBase::GetLengthOfDOMNode(aLeftNode, mJoinOffset);
   return res;
 }
 
 NS_IMETHODIMP
 HTMLEditRules::DidJoinNodes(nsIDOMNode* aLeftNode,
                             nsIDOMNode* aRightNode,
                             nsIDOMNode* aParent,
                             nsresult aResult)
@@ -8213,17 +8214,17 @@ HTMLEditRules::RemoveAlignment(nsIDOMNod
     {
       tmp = nullptr;
     }
     bool isBlock;
     NS_ENSURE_STATE(mHTMLEditor);
     res = mHTMLEditor->NodeIsBlockStatic(child, &isBlock);
     NS_ENSURE_SUCCESS(res, res);
 
-    if (nsEditor::NodeIsType(child, nsGkAtoms::center)) {
+    if (EditorBase::NodeIsType(child, nsGkAtoms::center)) {
       // the current node is a CENTER element
       // first remove children's alignment
       res = RemoveAlignment(child, aAlignType, true);
       NS_ENSURE_SUCCESS(res, res);
 
       // we may have to insert BRs in first and last position of element's children
       // if the nodes before/after are not blocks and not BRs
       res = MakeSureElemStartsOrEndsOnCR(child);
--- a/editor/libeditor/HTMLEditRules.h
+++ b/editor/libeditor/HTMLEditRules.h
@@ -5,17 +5,16 @@
 
 #ifndef HTMLEditRules_h_
 #define HTMLEditRules_h_
 
 #include "SelectionState.h"
 #include "TextEditRules.h"
 #include "TypeInState.h"
 #include "nsCOMPtr.h"
-#include "nsEditor.h"
 #include "nsIEditActionListener.h"
 #include "nsIEditor.h"
 #include "nsIHTMLEditor.h"
 #include "nsISupportsImpl.h"
 #include "nsTArray.h"
 #include "nscore.h"
 
 class nsIAtom;
--- a/editor/libeditor/HTMLEditUtils.cpp
+++ b/editor/libeditor/HTMLEditUtils.cpp
@@ -1,24 +1,24 @@
 /* -*- 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 "HTMLEditUtils.h"
 
+#include "EditorBase.h"                 // for EditorBase
 #include "TextEditUtils.h"              // for TextEditUtils
 #include "mozilla/ArrayUtils.h"         // for ArrayLength
 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
 #include "mozilla/dom/Element.h"        // for Element, nsINode
 #include "nsAString.h"                  // for nsAString_internal::IsEmpty
 #include "nsCOMPtr.h"                   // for nsCOMPtr, operator==, etc
 #include "nsCaseTreatment.h"
 #include "nsDebug.h"                    // for NS_PRECONDITION, etc
-#include "nsEditor.h"                   // for nsEditor
 #include "nsError.h"                    // for NS_SUCCEEDED
 #include "nsGkAtoms.h"                  // for nsGkAtoms, nsGkAtoms::a, etc
 #include "nsHTMLTags.h"
 #include "nsIAtom.h"                    // for nsIAtom
 #include "nsIDOMHTMLAnchorElement.h"    // for nsIDOMHTMLAnchorElement
 #include "nsIDOMNode.h"                 // for nsIDOMNode
 #include "nsNameSpaceManager.h"        // for kNameSpaceID_None
 #include "nsLiteralString.h"            // for NS_LITERAL_STRING
@@ -83,17 +83,17 @@ HTMLEditUtils::IsFormatNode(nsINode* aNo
 /**
  * IsNodeThatCanOutdent() returns true if aNode is a list, list item or
  * blockquote.
  */
 bool
 HTMLEditUtils::IsNodeThatCanOutdent(nsIDOMNode* aNode)
 {
   MOZ_ASSERT(aNode);
-  nsCOMPtr<nsIAtom> nodeAtom = nsEditor::GetTag(aNode);
+  nsCOMPtr<nsIAtom> nodeAtom = EditorBase::GetTag(aNode);
   return (nodeAtom == nsGkAtoms::ul)
       || (nodeAtom == nsGkAtoms::ol)
       || (nodeAtom == nsGkAtoms::dl)
       || (nodeAtom == nsGkAtoms::li)
       || (nodeAtom == nsGkAtoms::dd)
       || (nodeAtom == nsGkAtoms::dt)
       || (nodeAtom == nsGkAtoms::blockquote);
 }
@@ -121,26 +121,26 @@ HTMLEditUtils::IsHeader(nsIDOMNode* aNod
 }
 
 /**
  * IsParagraph() returns true if aNode is an html paragraph.
  */
 bool
 HTMLEditUtils::IsParagraph(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::p);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::p);
 }
 
 /**
  * IsHR() returns true if aNode is an horizontal rule.
  */
 bool
 HTMLEditUtils::IsHR(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::hr);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::hr);
 }
 
 /**
  * IsListItem() returns true if aNode is an html list item.
  */
 bool
 HTMLEditUtils::IsListItem(nsIDOMNode* aNode)
 {
@@ -209,32 +209,32 @@ HTMLEditUtils::IsTableElementButNotTable
 }
 
 /**
  * IsTable() returns true if aNode is an html table.
  */
 bool
 HTMLEditUtils::IsTable(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::table);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::table);
 }
 
 bool
 HTMLEditUtils::IsTable(nsINode* aNode)
 {
   return aNode && aNode->IsHTMLElement(nsGkAtoms::table);
 }
 
 /**
  * IsTableRow() returns true if aNode is an html tr.
  */
 bool
 HTMLEditUtils::IsTableRow(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::tr);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::tr);
 }
 
 /**
  * IsTableCell() returns true if aNode is an html td or th.
  */
 bool
 HTMLEditUtils::IsTableCell(nsIDOMNode* aNode)
 {
@@ -281,60 +281,60 @@ HTMLEditUtils::IsList(nsINode* aNode)
 }
 
 /**
  * IsOrderedList() returns true if aNode is an html ordered list.
  */
 bool
 HTMLEditUtils::IsOrderedList(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::ol);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::ol);
 }
 
 
 /**
  * IsUnorderedList() returns true if aNode is an html unordered list.
  */
 bool
 HTMLEditUtils::IsUnorderedList(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::ul);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::ul);
 }
 
 /**
  * IsBlockquote() returns true if aNode is an html blockquote node.
  */
 bool
 HTMLEditUtils::IsBlockquote(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::blockquote);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::blockquote);
 }
 
 /**
  * IsPre() returns true if aNode is an html pre node.
  */
 bool
 HTMLEditUtils::IsPre(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::pre);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::pre);
 }
 
 /**
  * IsImage() returns true if aNode is an html image node.
  */
 bool
 HTMLEditUtils::IsImage(nsINode* aNode)
 {
   return aNode && aNode->IsHTMLElement(nsGkAtoms::img);
 }
 
 bool
 HTMLEditUtils::IsImage(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::img);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::img);
 }
 
 bool
 HTMLEditUtils::IsLink(nsIDOMNode *aNode)
 {
   nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
   return node && IsLink(node);
 }
@@ -376,17 +376,17 @@ HTMLEditUtils::IsNamedAnchor(nsINode* aN
 }
 
 /**
  * IsDiv() returns true if aNode is an html div node.
  */
 bool
 HTMLEditUtils::IsDiv(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::div);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::div);
 }
 
 /**
  * IsMozDiv() returns true if aNode is an html div node with |type = _moz|.
  */
 bool
 HTMLEditUtils::IsMozDiv(nsIDOMNode* aNode)
 {
@@ -460,17 +460,17 @@ HTMLEditUtils::IsFormWidget(nsINode* aNo
                                     nsGkAtoms::meter,
                                     nsGkAtoms::input);
 }
 
 bool
 HTMLEditUtils::SupportsAlignAttr(nsIDOMNode* aNode)
 {
   MOZ_ASSERT(aNode);
-  nsCOMPtr<nsIAtom> nodeAtom = nsEditor::GetTag(aNode);
+  nsCOMPtr<nsIAtom> nodeAtom = EditorBase::GetTag(aNode);
   return (nodeAtom == nsGkAtoms::hr)
       || (nodeAtom == nsGkAtoms::table)
       || (nodeAtom == nsGkAtoms::tbody)
       || (nodeAtom == nsGkAtoms::tfoot)
       || (nodeAtom == nsGkAtoms::thead)
       || (nodeAtom == nsGkAtoms::tr)
       || (nodeAtom == nsGkAtoms::td)
       || (nodeAtom == nsGkAtoms::th)
--- a/editor/libeditor/HTMLEditor.cpp
+++ b/editor/libeditor/HTMLEditor.cpp
@@ -230,18 +230,18 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddColumnBeforeButton)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRemoveColumnButton)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddColumnAfterButton)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddRowBeforeButton)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRemoveRowButton)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAddRowAfterButton)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_IMPL_ADDREF_INHERITED(HTMLEditor, nsEditor)
-NS_IMPL_RELEASE_INHERITED(HTMLEditor, nsEditor)
+NS_IMPL_ADDREF_INHERITED(HTMLEditor, EditorBase)
+NS_IMPL_RELEASE_INHERITED(HTMLEditor, EditorBase)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(HTMLEditor)
   NS_INTERFACE_MAP_ENTRY(nsIHTMLEditor)
   NS_INTERFACE_MAP_ENTRY(nsIHTMLObjectResizer)
   NS_INTERFACE_MAP_ENTRY(nsIHTMLAbsPosEditor)
   NS_INTERFACE_MAP_ENTRY(nsIHTMLInlineTableEditor)
   NS_INTERFACE_MAP_ENTRY(nsITableEditor)
   NS_INTERFACE_MAP_ENTRY(nsIEditorStyleSheets)
@@ -351,17 +351,17 @@ HTMLEditor::PreDestroy(bool aDestroyingF
 }
 
 NS_IMETHODIMP
 HTMLEditor::GetRootElement(nsIDOMElement** aRootElement)
 {
   NS_ENSURE_ARG_POINTER(aRootElement);
 
   if (mRootElement) {
-    return nsEditor::GetRootElement(aRootElement);
+    return EditorBase::GetRootElement(aRootElement);
   }
 
   *aRootElement = nullptr;
 
   // Use the HTML documents body element as the editor root if we didn't
   // get a root element during initialization.
 
   nsCOMPtr<nsIDOMElement> rootElement;
@@ -604,38 +604,38 @@ HTMLEditor::BeginningOfDocument()
 
 nsresult
 HTMLEditor::HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent)
 {
   // NOTE: When you change this method, you should also change:
   //   * editor/libeditor/tests/test_htmleditor_keyevent_handling.html
 
   if (IsReadonly() || IsDisabled()) {
-    // When we're not editable, the events are handled on nsEditor, so, we can
+    // When we're not editable, the events are handled on EditorBase, so, we can
     // bypass TextEditor.
-    return nsEditor::HandleKeyPressEvent(aKeyEvent);
+    return EditorBase::HandleKeyPressEvent(aKeyEvent);
   }
 
   WidgetKeyboardEvent* nativeKeyEvent =
     aKeyEvent->AsEvent()->WidgetEventPtr()->AsKeyboardEvent();
   NS_ENSURE_TRUE(nativeKeyEvent, NS_ERROR_UNEXPECTED);
   NS_ASSERTION(nativeKeyEvent->mMessage == eKeyPress,
                "HandleKeyPressEvent gets non-keypress event");
 
   switch (nativeKeyEvent->mKeyCode) {
     case NS_VK_META:
     case NS_VK_WIN:
     case NS_VK_SHIFT:
     case NS_VK_CONTROL:
     case NS_VK_ALT:
     case NS_VK_BACK:
     case NS_VK_DELETE:
-      // These keys are handled on nsEditor, so, we can bypass
+      // These keys are handled on EditorBase, so, we can bypass
       // TextEditor.
-      return nsEditor::HandleKeyPressEvent(aKeyEvent);
+      return EditorBase::HandleKeyPressEvent(aKeyEvent);
     case NS_VK_TAB: {
       if (IsPlaintextEditor()) {
         // If this works as plain text editor, e.g., mail editor for plain
         // text, should be handled on TextEditor.
         return TextEditor::HandleKeyPressEvent(aKeyEvent);
       }
 
       if (IsTabbable()) {
@@ -826,17 +826,17 @@ HTMLEditor::SetDocumentTitle(const nsASt
     new SetDocumentTitleTransaction();
   NS_ENSURE_TRUE(transaction, NS_ERROR_OUT_OF_MEMORY);
 
   nsresult rv = transaction->Init(this, &aTitle);
   NS_ENSURE_SUCCESS(rv, rv);
 
   //Don't let Rules System change the selection
   AutoTransactionsConserveSelection dontChangeSelection(this);
-  return nsEditor::DoTransaction(transaction);
+  return EditorBase::DoTransaction(transaction);
 }
 
 /**
  * GetBlockNodeParent returns enclosing block level ancestor, if any.
  */
 Element*
 HTMLEditor::GetBlockNodeParent(nsINode* aNode)
 {
@@ -3105,17 +3105,17 @@ HTMLEditor::GetEmbeddedObjects(nsISuppor
 }
 
 NS_IMETHODIMP
 HTMLEditor::DeleteSelectionImpl(EDirection aAction,
                                 EStripWrappers aStripWrappers)
 {
   MOZ_ASSERT(aStripWrappers == eStrip || aStripWrappers == eNoStrip);
 
-  nsresult res = nsEditor::DeleteSelectionImpl(aAction, aStripWrappers);
+  nsresult res = EditorBase::DeleteSelectionImpl(aAction, aStripWrappers);
   NS_ENSURE_SUCCESS(res, res);
 
   // If we weren't asked to strip any wrappers, we're done.
   if (aStripWrappers == eNoStrip) {
     return NS_OK;
   }
 
   RefPtr<Selection> selection = GetSelection();
@@ -3170,45 +3170,45 @@ NS_IMETHODIMP
 HTMLEditor::DeleteNode(nsIDOMNode* aNode)
 {
   // do nothing if the node is read-only
   nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
   if (!IsModifiableNode(aNode) && !IsMozEditorBogusNode(content)) {
     return NS_ERROR_FAILURE;
   }
 
-  return nsEditor::DeleteNode(aNode);
+  return EditorBase::DeleteNode(aNode);
 }
 
 nsresult
 HTMLEditor::DeleteText(nsGenericDOMDataNode& aCharData,
                        uint32_t aOffset,
                        uint32_t aLength)
 {
   // Do nothing if the node is read-only
   if (!IsModifiableNode(&aCharData)) {
     return NS_ERROR_FAILURE;
   }
 
-  return nsEditor::DeleteText(aCharData, aOffset, aLength);
+  return EditorBase::DeleteText(aCharData, aOffset, aLength);
 }
 
 nsresult
 HTMLEditor::InsertTextImpl(const nsAString& aStringToInsert,
                            nsCOMPtr<nsINode>* aInOutNode,
                            int32_t* aInOutOffset,
                            nsIDocument* aDoc)
 {
   // Do nothing if the node is read-only
   if (!IsModifiableNode(*aInOutNode)) {
     return NS_ERROR_FAILURE;
   }
 
-  return nsEditor::InsertTextImpl(aStringToInsert, aInOutNode, aInOutOffset,
-                                  aDoc);
+  return EditorBase::InsertTextImpl(aStringToInsert, aInOutNode, aInOutOffset,
+                                    aDoc);
 }
 
 void
 HTMLEditor::ContentAppended(nsIDocument* aDocument,
                             nsIContent* aContainer,
                             nsIContent* aFirstNewContent,
                             int32_t aIndexInContainer)
 {
@@ -3468,17 +3468,17 @@ HTMLEditor::StyleSheetLoaded(StyleSheetH
  */
 NS_IMETHODIMP
 HTMLEditor::StartOperation(EditAction opID,
                            nsIEditor::EDirection aDirection)
 {
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
-  nsEditor::StartOperation(opID, aDirection);  // will set mAction, mDirection
+  EditorBase::StartOperation(opID, aDirection);  // will set mAction, mDirection
   if (mRules) return mRules->BeforeEdit(mAction, mDirection);
   return NS_OK;
 }
 
 /**
  * All editor operations which alter the doc should be followed
  * with a call to EndOperation.
  */
@@ -3486,17 +3486,17 @@ NS_IMETHODIMP
 HTMLEditor::EndOperation()
 {
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
   // post processing
   nsresult res = NS_OK;
   if (mRules) res = mRules->AfterEdit(mAction, mDirection);
-  nsEditor::EndOperation();  // will clear mAction, mDirection
+  EditorBase::EndOperation();  // will clear mAction, mDirection
   return res;
 }
 
 bool
 HTMLEditor::TagCanContainTag(nsIAtom& aParentTag,
                              nsIAtom& aChildTag)
 {
   nsIParserService* parserService = nsContentUtils::GetParserService();
@@ -3558,17 +3558,17 @@ HTMLEditor::SelectEntireDocument(Selecti
   NS_ENSURE_SUCCESS(res, res);
 
   if (bDocIsEmpty)
   {
     // if its empty dont select entire doc - that would select the bogus node
     return aSelection->Collapse(rootElement, 0);
   }
 
-  return nsEditor::SelectEntireDocument(aSelection);
+  return EditorBase::SelectEntireDocument(aSelection);
 }
 
 NS_IMETHODIMP
 HTMLEditor::SelectAll()
 {
   ForceCompositionEnd();
 
   RefPtr<Selection> selection = GetSelection();
@@ -3737,17 +3737,17 @@ HTMLEditor::GetEnclosingTable(nsIDOMNode
   return ret;
 }
 
 
 /**
  * This method scans the selection for adjacent text nodes
  * and collapses them into a single text node.
  * "adjacent" means literally adjacent siblings of the same parent.
- * Uses nsEditor::JoinNodes so action is undoable.
+ * Uses EditorBase::JoinNodes so action is undoable.
  * Should be called within the context of a batch transaction.
  */
 nsresult
 HTMLEditor::CollapseAdjacentTextNodes(nsRange* aInRange)
 {
   NS_ENSURE_TRUE(aInRange, NS_ERROR_NULL_POINTER);
   AutoTransactionsConserveSelection dontSpazMySelection(this);
   nsTArray<nsCOMPtr<nsIDOMNode> > textNodes;
@@ -4367,17 +4367,17 @@ HTMLEditor::IsEmptyNodeImpl(nsINode* aNo
                           HTMLEditUtils::IsTableCell(aNode);
 
   // loop over children of node. if no children, or all children are either
   // empty text nodes or non-editable, then node qualifies as empty
   for (nsCOMPtr<nsIContent> child = aNode->GetFirstChild();
        child;
        child = child->GetNextSibling()) {
     // Is the child editable and non-empty?  if so, return false
-    if (nsEditor::IsEditable(child)) {
+    if (EditorBase::IsEditable(child)) {
       if (child->NodeType() == nsIDOMNode::TEXT_NODE) {
         nsresult rv = IsVisTextNode(child, outIsEmptyNode, aSafeToAskFrames);
         NS_ENSURE_SUCCESS(rv, rv);
         // break out if we find we aren't emtpy
         if (!*outIsEmptyNode) {
           return NS_OK;
         }
       } else {
@@ -4821,17 +4821,17 @@ HTMLEditor::GetElementOrigin(nsIDOMEleme
   aY = nsPresContext::AppUnitsToIntCSSPixels(off.y);
 
   return NS_OK;
 }
 
 nsresult
 HTMLEditor::EndUpdateViewBatch()
 {
-  nsresult res = nsEditor::EndUpdateViewBatch();
+  nsresult res = EditorBase::EndUpdateViewBatch();
   NS_ENSURE_SUCCESS(res, res);
 
   // We may need to show resizing handles or update existing ones after
   // all transactions are done. This way of doing is preferred to DOM
   // mutation events listeners because all the changes the user can apply
   // to a document may result in multiple events, some of them quite hard
   // to listen too (in particular when an ancestor of the selection is
   // changed but the selection itself is not changed).
@@ -5173,17 +5173,17 @@ HTMLEditor::OurWindowHasFocus()
   nsCOMPtr<nsIDocument> doc = do_QueryReferent(mDocWeak);
   nsPIDOMWindowOuter* ourWindow = doc->GetWindow();
   return ourWindow == focusedWindow;
 }
 
 bool
 HTMLEditor::IsAcceptableInputEvent(nsIDOMEvent* aEvent)
 {
-  if (!nsEditor::IsAcceptableInputEvent(aEvent)) {
+  if (!EditorBase::IsAcceptableInputEvent(aEvent)) {
     return false;
   }
 
   // While there is composition, all composition events in its top level window
   // are always fired on the composing editor.  Therefore, if this editor has
   // composition, the composition events should be handled in this editor.
   if (mComposition && aEvent->WidgetEventPtr()->AsCompositionEvent()) {
     return true;
--- a/editor/libeditor/HTMLEditor.h
+++ b/editor/libeditor/HTMLEditor.h
@@ -113,17 +113,17 @@ public:
   virtual bool IsActiveInDOMWindow() override;
   virtual already_AddRefed<dom::EventTarget> GetDOMEventTarget() override;
   virtual Element* GetEditorRoot() override;
   virtual already_AddRefed<nsIContent> FindSelectionRoot(
                                          nsINode *aNode) override;
   virtual bool IsAcceptableInputEvent(nsIDOMEvent* aEvent) override;
   virtual already_AddRefed<nsIContent> GetInputEventTargetContent() override;
   virtual bool IsEditable(nsINode* aNode) override;
-  using nsEditor::IsEditable;
+  using EditorBase::IsEditable;
 
   // nsStubMutationObserver overrides
   NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED
   NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED
   NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED
 
   // nsIEditorIMESupport overrides
   NS_IMETHOD GetPreferredIMEState(widget::IMEState* aState) override;
@@ -243,17 +243,17 @@ public:
 
   /**
    * This sets background on the appropriate container element (table, cell,)
    * or calls into nsTextEditor to set the page background.
    */
   nsresult SetCSSBackgroundColor(const nsAString& aColor);
   nsresult SetHTMLBackgroundColor(const nsAString& aColor);
 
-  // Block methods moved from nsEditor
+  // Block methods moved from EditorBase
   static Element* GetBlockNodeParent(nsINode* aNode);
   static nsIDOMNode* GetBlockNodeParent(nsIDOMNode* aNode);
   static Element* GetBlock(nsINode& aNode);
 
   void IsNextCharInNodeWhitespace(nsIContent* aContent,
                                   int32_t aOffset,
                                   bool* outIsSpace,
                                   bool* outIsNBSP,
@@ -261,34 +261,34 @@ public:
                                   int32_t* outOffset = 0);
   void IsPrevCharInNodeWhitespace(nsIContent* aContent,
                                   int32_t aOffset,
                                   bool* outIsSpace,
                                   bool* outIsNBSP,
                                   nsIContent** outNode = nullptr,
                                   int32_t* outOffset = 0);
 
-  // Overrides of nsEditor interface methods
+  // Overrides of EditorBase interface methods
   nsresult EndUpdateViewBatch() override;
 
   NS_IMETHOD Init(nsIDOMDocument* aDoc, nsIContent* aRoot,
                   nsISelectionController* aSelCon, uint32_t aFlags,
                   const nsAString& aValue) override;
   NS_IMETHOD PreDestroy(bool aDestroyingFrames) override;
 
   /**
    * @param aElement        Must not be null.
    */
   static bool NodeIsBlockStatic(const nsINode* aElement);
   static nsresult NodeIsBlockStatic(nsIDOMNode *aNode, bool *aIsBlock);
 
 protected:
   virtual ~HTMLEditor();
 
-  using nsEditor::IsBlockNode;
+  using EditorBase::IsBlockNode;
   virtual bool IsBlockNode(nsINode *aNode) override;
 
 public:
   // XXX Why don't we move following methods above for grouping by the origins?
   NS_IMETHOD SetFlags(uint32_t aFlags) override;
 
   NS_IMETHOD Paste(int32_t aSelectionType) override;
   NS_IMETHOD CanPaste(int32_t aSelectionType, bool* aCanPaste) override;
--- a/editor/libeditor/HTMLEditorDataTransfer.cpp
+++ b/editor/libeditor/HTMLEditorDataTransfer.cpp
@@ -27,17 +27,16 @@
 #include "nsCOMPtr.h"
 #include "nsCRT.h"
 #include "nsCRTGlue.h"
 #include "nsComponentManagerUtils.h"
 #include "nsIScriptError.h"
 #include "nsContentUtils.h"
 #include "nsDebug.h"
 #include "nsDependentSubstring.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsGkAtoms.h"
 #include "nsIClipboard.h"
 #include "nsIContent.h"
 #include "nsIContentFilter.h"
 #include "nsIDOMComment.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMDocumentFragment.h"
--- a/editor/libeditor/HTMLEditorEventListener.cpp
+++ b/editor/libeditor/HTMLEditorEventListener.cpp
@@ -6,17 +6,16 @@
 #include "HTMLEditorEventListener.h"
 
 #include "HTMLEditor.h"
 #include "HTMLEditUtils.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/Selection.h"
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMEvent.h"
 #include "nsIDOMEventTarget.h"
 #include "nsIDOMMouseEvent.h"
 #include "nsIDOMNode.h"
 #include "nsIEditor.h"
 #include "nsIHTMLEditor.h"
@@ -28,32 +27,32 @@
 #include "nsRange.h"
 
 namespace mozilla {
 
 using namespace dom;
 
 #ifdef DEBUG
 nsresult
-HTMLEditorEventListener::Connect(nsEditor* aEditor)
+HTMLEditorEventListener::Connect(EditorBase* aEditorBase)
 {
-  nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryObject(aEditor);
+  nsCOMPtr<nsIHTMLEditor> htmlEditor = do_QueryObject(aEditorBase);
   nsCOMPtr<nsIHTMLInlineTableEditor> htmlInlineTableEditor =
-    do_QueryObject(aEditor);
+    do_QueryObject(aEditorBase);
   NS_PRECONDITION(htmlEditor && htmlInlineTableEditor,
                   "Set HTMLEditor or its sub class");
-  return EditorEventListener::Connect(aEditor);
+  return EditorEventListener::Connect(aEditorBase);
 }
 #endif
 
 HTMLEditor*
 HTMLEditorEventListener::GetHTMLEditor()
 {
   // mEditor must be HTMLEditor or its subclass.
-  return static_cast<HTMLEditor*>(mEditor);
+  return static_cast<HTMLEditor*>(mEditorBase);
 }
 
 nsresult
 HTMLEditorEventListener::MouseUp(nsIDOMMouseEvent* aMouseEvent)
 {
   HTMLEditor* htmlEditor = GetHTMLEditor();
 
   nsCOMPtr<nsIDOMEventTarget> target;
@@ -100,17 +99,17 @@ HTMLEditorEventListener::MouseDown(nsIDO
 
   nsCOMPtr<nsIDOMEventTarget> target;
   rv = aMouseEvent->AsEvent()->GetExplicitOriginalTarget(getter_AddRefs(target));
   NS_ENSURE_SUCCESS(rv, rv);
   NS_ENSURE_TRUE(target, NS_ERROR_NULL_POINTER);
   nsCOMPtr<nsIDOMElement> element = do_QueryInterface(target);
 
   if (isContextClick || (buttonNumber == 0 && clickCount == 2)) {
-    RefPtr<Selection> selection = mEditor->GetSelection();
+    RefPtr<Selection> selection = mEditorBase->GetSelection();
     NS_ENSURE_TRUE(selection, NS_OK);
 
     // Get location of mouse within target node
     nsCOMPtr<nsIDOMNode> parent;
     rv = aMouseEvent->GetRangeParent(getter_AddRefs(parent));
     NS_ENSURE_SUCCESS(rv, rv);
     NS_ENSURE_TRUE(parent, NS_ERROR_FAILURE);
 
--- a/editor/libeditor/HTMLEditorEventListener.h
+++ b/editor/libeditor/HTMLEditorEventListener.h
@@ -4,37 +4,36 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef HTMLEditorEventListener_h_
 #define HTMLEditorEventListener_h_
 
 #include "EditorEventListener.h"
 #include "nscore.h"
 
-class nsEditor;
-
 namespace mozilla {
 
+class EditorBase;
 class HTMLEditor;
 
 class HTMLEditorEventListener final : public EditorEventListener
 {
 public:
   HTMLEditorEventListener()
     : EditorEventListener()
   {
   }
 
   virtual ~HTMLEditorEventListener()
   {
   }
 
 #ifdef DEBUG
   // WARNING: You must be use HTMLEditor or its sub class for this class.
-  virtual nsresult Connect(nsEditor* aEditor) override;
+  virtual nsresult Connect(EditorBase* aEditorBase) override;
 #endif
 
 protected:
   virtual nsresult MouseDown(nsIDOMMouseEvent* aMouseEvent) override;
   virtual nsresult MouseUp(nsIDOMMouseEvent* aMouseEvent) override;
   virtual nsresult MouseClick(nsIDOMMouseEvent* aMouseEvent) override;
 
   inline HTMLEditor* GetHTMLEditor();
--- a/editor/libeditor/HTMLStyleEditor.cpp
+++ b/editor/libeditor/HTMLStyleEditor.cpp
@@ -15,17 +15,16 @@
 #include "mozilla/dom/Element.h"
 #include "mozilla/mozalloc.h"
 #include "nsAString.h"
 #include "nsAttrName.h"
 #include "nsCOMPtr.h"
 #include "nsCaseTreatment.h"
 #include "nsComponentManagerUtils.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsGkAtoms.h"
 #include "nsIAtom.h"
 #include "nsIContent.h"
 #include "nsIContentIterator.h"
 #include "nsIDOMElement.h"
 #include "nsIEditor.h"
 #include "nsIEditorIMESupport.h"
@@ -47,17 +46,17 @@ class nsISupports;
 namespace mozilla {
 
 using namespace dom;
 
 static bool
 IsEmptyTextNode(HTMLEditor* aThis, nsINode* aNode)
 {
   bool isEmptyTextNode = false;
-  return nsEditor::IsTextNode(aNode) &&
+  return EditorBase::IsTextNode(aNode) &&
          NS_SUCCEEDED(aThis->IsEmptyNode(aNode, &isEmptyTextNode)) &&
          isEmptyTextNode;
 }
 
 NS_IMETHODIMP
 HTMLEditor::AddDefaultProperty(nsIAtom* aProperty,
                                const nsAString& aAttribute,
                                const nsAString& aValue)
--- a/editor/libeditor/HTMLTableEditor.cpp
+++ b/editor/libeditor/HTMLTableEditor.cpp
@@ -11,17 +11,16 @@
 #include "HTMLEditUtils.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/dom/Selection.h"
 #include "mozilla/dom/Element.h"
 #include "nsAString.h"
 #include "nsAlgorithm.h"
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsGkAtoms.h"
 #include "nsIAtom.h"
 #include "nsIContent.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMNode.h"
 #include "nsIEditor.h"
 #include "nsIFrame.h"
@@ -1974,23 +1973,23 @@ HTMLEditor::SwitchTableCellHeaderType(ns
   // 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);
   AutoSelectionRestorer selectionRestorer(selection, this);
 
   // Set to the opposite of current type
-  nsCOMPtr<nsIAtom> atom = nsEditor::GetTag(aSourceCell);
+  nsCOMPtr<nsIAtom> atom = EditorBase::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,
-      nullptr, nullptr, nsEditor::eCloneAttributes);
+      nullptr, nullptr, EditorBase::eCloneAttributes);
   NS_ENSURE_TRUE(newNode, NS_ERROR_FAILURE);
 
   // Return the new cell
   if (aNewCell)
   {
     nsCOMPtr<nsIDOMElement> newElement = do_QueryInterface(newNode);
     *aNewCell = newElement.get();
     NS_ADDREF(*aNewCell);
@@ -3247,17 +3246,17 @@ HTMLEditor::GetSelectedOrParentTableElem
       if (!selectedNode)
       {
         selectedNode = anchorNode;
         // If anchor doesn't have a child, we can't be selecting a table element,
         //  so don't do the following:
       }
       else
       {
-        nsCOMPtr<nsIAtom> atom = nsEditor::GetTag(selectedNode);
+        nsCOMPtr<nsIAtom> atom = EditorBase::GetTag(selectedNode);
 
         if (atom == nsGkAtoms::td) {
           tableOrCellElement = do_QueryInterface(selectedNode);
           aTagName = tdName;
           // Each cell is in its own selection range,
           //  so count signals multiple-cell selection
           res = selection->GetRangeCount(aSelectedCount);
           NS_ENSURE_SUCCESS(res, res);
--- a/editor/libeditor/InsertNodeTransaction.cpp
+++ b/editor/libeditor/InsertNodeTransaction.cpp
@@ -1,39 +1,40 @@
 /* -*- 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 "InsertNodeTransaction.h"
 
+#include "EditorBase.h"                 // for EditorBase
+
 #include "mozilla/dom/Selection.h"      // for Selection
 
 #include "nsAString.h"
 #include "nsDebug.h"                    // for NS_ENSURE_TRUE, etc
-#include "nsEditor.h"                   // for nsEditor
 #include "nsError.h"                    // for NS_ERROR_NULL_POINTER, etc
 #include "nsIContent.h"                 // for nsIContent
 #include "nsMemory.h"                   // for nsMemory
 #include "nsReadableUtils.h"            // for ToNewCString
 #include "nsString.h"                   // for nsString
 
 namespace mozilla {
 
 using namespace dom;
 
 InsertNodeTransaction::InsertNodeTransaction(nsIContent& aNode,
                                              nsINode& aParent,
                                              int32_t aOffset,
-                                             nsEditor& aEditor)
+                                             EditorBase& aEditorBase)
   : EditTransactionBase()
   , mNode(&aNode)
   , mParent(&aParent)
   , mOffset(aOffset)
-  , mEditor(aEditor)
+  , mEditorBase(aEditorBase)
 {
 }
 
 InsertNodeTransaction::~InsertNodeTransaction()
 {
 }
 
 NS_IMPL_CYCLE_COLLECTION_INHERITED(InsertNodeTransaction, EditTransactionBase,
@@ -54,25 +55,25 @@ InsertNodeTransaction::DoTransaction()
   if (mOffset > static_cast<int32_t>(count) || mOffset == -1) {
     // -1 is sentinel value meaning "append at end"
     mOffset = count;
   }
 
   // Note, it's ok for ref to be null. That means append.
   nsCOMPtr<nsIContent> ref = mParent->GetChildAt(mOffset);
 
-  mEditor.MarkNodeDirty(GetAsDOMNode(mNode));
+  mEditorBase.MarkNodeDirty(GetAsDOMNode(mNode));
 
   ErrorResult rv;
   mParent->InsertBefore(*mNode, ref, rv);
   NS_ENSURE_TRUE(!rv.Failed(), rv.StealNSResult());
 
   // Only set selection to insertion point if editor gives permission
-  if (mEditor.GetShouldTxnSetSelection()) {
-    RefPtr<Selection> selection = mEditor.GetSelection();
+  if (mEditorBase.GetShouldTxnSetSelection()) {
+    RefPtr<Selection> selection = mEditorBase.GetSelection();
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     // Place the selection just after the inserted element
     selection->Collapse(mParent, mOffset + 1);
   } else {
     // Do nothing - DOM Range gravity will adjust selection
   }
   return NS_OK;
 }
--- a/editor/libeditor/InsertNodeTransaction.h
+++ b/editor/libeditor/InsertNodeTransaction.h
@@ -7,34 +7,34 @@
 #define InsertNodeTransaction_h_
 
 #include "EditTransactionBase.h"        // for EditTransactionBase, etc
 #include "nsCOMPtr.h"                   // for nsCOMPtr
 #include "nsCycleCollectionParticipant.h"
 #include "nsIContent.h"                 // for nsIContent
 #include "nsISupportsImpl.h"            // for NS_DECL_ISUPPORTS_INHERITED
 
-class nsEditor;
+namespace mozilla {
 
-namespace mozilla {
+class EditorBase;
 
 /**
  * A transaction that inserts a single element
  */
 class InsertNodeTransaction final : public EditTransactionBase
 {
 public:
   /**
    * Initialize the transaction.
    * @param aNode       The node to insert.
    * @param aParent     The node to insert into.
    * @param aOffset     The offset in aParent to insert aNode.
    */
   InsertNodeTransaction(nsIContent& aNode, nsINode& aParent, int32_t aOffset,
-                        nsEditor& aEditor);
+                        EditorBase& aEditorBase);
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(InsertNodeTransaction,
                                            EditTransactionBase)
 
   NS_DECL_EDITTRANSACTIONBASE
 
 protected:
@@ -45,14 +45,14 @@ protected:
 
   // The node into which the new node will be inserted.
   nsCOMPtr<nsINode> mParent;
 
   // The index in mParent for the new node.
   int32_t mOffset;
 
   // The editor for this transaction.
-  nsEditor& mEditor;
+  EditorBase& mEditorBase;
 };
 
 } // namespace mozilla
 
 #endif // #ifndef InsertNodeTransaction_h_
--- a/editor/libeditor/InsertTextTransaction.cpp
+++ b/editor/libeditor/InsertTextTransaction.cpp
@@ -1,36 +1,36 @@
 /* -*- 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 "InsertTextTransaction.h"
 
+#include "EditorBase.h"                 // mEditorBase
 #include "mozilla/dom/Selection.h"      // Selection local var
 #include "mozilla/dom/Text.h"           // mTextNode
 #include "nsAString.h"                  // nsAString parameter
 #include "nsDebug.h"                    // for NS_ASSERTION, etc
-#include "nsEditor.h"                   // mEditor
 #include "nsError.h"                    // for NS_OK, etc
 #include "nsQueryObject.h"              // for do_QueryObject
 
 namespace mozilla {
 
 using namespace dom;
 
 InsertTextTransaction::InsertTextTransaction(Text& aTextNode,
                                              uint32_t aOffset,
                                              const nsAString& aStringToInsert,
-                                             nsEditor& aEditor)
+                                             EditorBase& aEditorBase)
   : EditTransactionBase()
   , mTextNode(&aTextNode)
   , mOffset(aOffset)
   , mStringToInsert(aStringToInsert)
-  , mEditor(aEditor)
+  , mEditorBase(aEditorBase)
 {
 }
 
 InsertTextTransaction::~InsertTextTransaction()
 {
 }
 
 NS_IMPL_CYCLE_COLLECTION_INHERITED(InsertTextTransaction, EditTransactionBase,
@@ -47,18 +47,18 @@ NS_INTERFACE_MAP_END_INHERITING(EditTran
 
 NS_IMETHODIMP
 InsertTextTransaction::DoTransaction()
 {
   nsresult res = mTextNode->InsertData(mOffset, mStringToInsert);
   NS_ENSURE_SUCCESS(res, res);
 
   // Only set selection to insertion point if editor gives permission
-  if (mEditor.GetShouldTxnSetSelection()) {
-    RefPtr<Selection> selection = mEditor.GetSelection();
+  if (mEditorBase.GetShouldTxnSetSelection()) {
+    RefPtr<Selection> selection = mEditorBase.GetSelection();
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     res = selection->Collapse(mTextNode,
                               mOffset + mStringToInsert.Length());
     NS_ASSERTION(NS_SUCCEEDED(res),
                  "Selection could not be collapsed after insert");
   } else {
     // Do nothing - DOM Range gravity will adjust selection
   }
--- a/editor/libeditor/InsertTextTransaction.h
+++ b/editor/libeditor/InsertTextTransaction.h
@@ -8,25 +8,25 @@
 
 #include "EditTransactionBase.h"        // base class
 #include "nsCycleCollectionParticipant.h" // various macros
 #include "nsID.h"                       // NS_DECLARE_STATIC_IID_ACCESSOR
 #include "nsISupportsImpl.h"            // NS_DECL_ISUPPORTS_INHERITED
 #include "nsString.h"                   // nsString members
 #include "nscore.h"                     // NS_IMETHOD, nsAString
 
-class nsEditor;
 class nsITransaction;
 
 #define NS_INSERTTEXTTXN_IID \
 { 0x8c9ad77f, 0x22a7, 0x4d01, \
   { 0xb1, 0x59, 0x8a, 0x0f, 0xdb, 0x1d, 0x08, 0xe9 } }
 
 namespace mozilla {
 
+class EditorBase;
 namespace dom {
 class Text;
 } // namespace dom
 
 /**
  * A transaction that inserts text into a content node.
  */
 class InsertTextTransaction final : public EditTransactionBase
@@ -36,17 +36,17 @@ public:
 
   /**
    * @param aElement        The text content node.
    * @param aOffset         The location in aElement to do the insertion.
    * @param aString         The new text to insert.
    * @param aPresShell      Used to get and set the selection.
    */
   InsertTextTransaction(dom::Text& aTextNode, uint32_t aOffset,
-                        const nsAString& aString, nsEditor& aEditor);
+                        const nsAString& aString, EditorBase& aEditorBase);
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(InsertTextTransaction,
                                            EditTransactionBase)
 
   NS_DECL_EDITTRANSACTIONBASE
 
   NS_IMETHOD Merge(nsITransaction* aTransaction, bool* aDidMerge) override;
@@ -67,16 +67,16 @@ private:
 
   // The offset into mTextNode where the insertion is to take place.
   uint32_t mOffset;
 
   // The text to insert into mTextNode at mOffset.
   nsString mStringToInsert;
 
   // The editor, which we'll need to get the selection.
-  nsEditor& mEditor;
+  EditorBase& mEditorBase;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(InsertTextTransaction, NS_INSERTTEXTTXN_IID)
 
 } // namespace mozilla
 
 #endif // #ifndef InsertTextTransaction_h_
--- a/editor/libeditor/JoinNodeTransaction.cpp
+++ b/editor/libeditor/JoinNodeTransaction.cpp
@@ -1,32 +1,33 @@
 /* -*- 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 "JoinNodeTransaction.h"
+
+#include "EditorBase.h"                 // for EditorBase
 #include "nsAString.h"
 #include "nsDebug.h"                    // for NS_ASSERTION, etc
-#include "nsEditor.h"                   // for nsEditor
 #include "nsError.h"                    // for NS_ERROR_NULL_POINTER, etc
 #include "nsIContent.h"                 // for nsIContent
 #include "nsIDOMCharacterData.h"        // for nsIDOMCharacterData
-#include "nsIEditor.h"                  // for nsEditor::IsModifiableNode
+#include "nsIEditor.h"                  // for EditorBase::IsModifiableNode
 #include "nsISupportsImpl.h"            // for QueryInterface, etc
 
 namespace mozilla {
 
 using namespace dom;
 
-JoinNodeTransaction::JoinNodeTransaction(nsEditor& aEditor,
+JoinNodeTransaction::JoinNodeTransaction(EditorBase& aEditorBase,
                                          nsINode& aLeftNode,
                                          nsINode& aRightNode)
   : EditTransactionBase()
-  , mEditor(aEditor)
+  , mEditorBase(aEditorBase)
   , mLeftNode(&aLeftNode)
   , mRightNode(&aRightNode)
   , mOffset(0)
   , mParent(nullptr)
 {
 }
 
 NS_IMPL_CYCLE_COLLECTION_INHERITED(JoinNodeTransaction, EditTransactionBase,
@@ -35,17 +36,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(JoinN
                                    mParent)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JoinNodeTransaction)
 NS_INTERFACE_MAP_END_INHERITING(EditTransactionBase)
 
 nsresult
 JoinNodeTransaction::CheckValidity()
 {
-  if (!mEditor.IsModifiableNode(mLeftNode->GetParentNode())) {
+  if (!mEditorBase.IsModifiableNode(mLeftNode->GetParentNode())) {
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 
 // After DoTransaction() and RedoTransaction(), the left node is removed from
 // the content tree and right node remains.
 NS_IMETHODIMP
@@ -61,17 +62,17 @@ JoinNodeTransaction::DoTransaction()
     return NS_ERROR_INVALID_ARG;
   }
 
   // Set this instance's mParent.  Other methods will see a non-null mParent
   // and know all is well
   mParent = leftParent;
   mOffset = mLeftNode->Length();
 
-  return mEditor.JoinNodesImpl(mRightNode, mLeftNode, mParent);
+  return mEditorBase.JoinNodesImpl(mRightNode, mLeftNode, mParent);
 }
 
 //XXX: What if instead of split, we just deleted the unneeded children of
 //     mRight and re-inserted mLeft?
 NS_IMETHODIMP
 JoinNodeTransaction::UndoTransaction()
 {
   MOZ_ASSERT(mParent);
--- a/editor/libeditor/JoinNodeTransaction.h
+++ b/editor/libeditor/JoinNodeTransaction.h
@@ -7,51 +7,52 @@
 #define JoinNodeTransaction_h_
 
 #include "EditTransactionBase.h"        // for EditTransactionBase, etc
 #include "nsCOMPtr.h"                   // for nsCOMPtr
 #include "nsCycleCollectionParticipant.h"
 #include "nsID.h"                       // for REFNSIID
 #include "nscore.h"                     // for NS_IMETHOD
 
-class nsEditor;
 class nsINode;
 
 namespace mozilla {
 
+class EditorBase;
+
 /**
  * A transaction that joins two nodes E1 (left node) and E2 (right node) into a
  * single node E.  The children of E are the children of E1 followed by the
  * children of E2.  After DoTransaction() and RedoTransaction(), E1 is removed
  * from the content tree and E2 remains.
  */
 class JoinNodeTransaction final : public EditTransactionBase
 {
 public:
   /**
-   * @param aEditor         The provider of core editing operations.
+   * @param aEditorBase     The provider of core editing operations.
    * @param aLeftNode       The first of two nodes to join.
    * @param aRightNode      The second of two nodes to join.
    */
-  JoinNodeTransaction(nsEditor& aEditor,
+  JoinNodeTransaction(EditorBase& aEditorBase,
                       nsINode& aLeftNode, nsINode& aRightNode);
 
   /**
    * Call this after constructing to ensure the inputs are correct.
    */
   nsresult CheckValidity();
 
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(JoinNodeTransaction,
                                            EditTransactionBase)
   NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
 
   NS_DECL_EDITTRANSACTIONBASE
 
 protected:
-  nsEditor&  mEditor;
+  EditorBase& mEditorBase;
 
   // The nodes to operate upon.  After the merge, mRightNode remains and
   // mLeftNode is removed from the content tree.
   nsCOMPtr<nsINode> mLeftNode;
   nsCOMPtr<nsINode> mRightNode;
 
   // The offset into mNode where the children of mElement are split (for
   // undo). mOffset is the index of the first child in the right node.  -1
--- a/editor/libeditor/PlaceholderTransaction.cpp
+++ b/editor/libeditor/PlaceholderTransaction.cpp
@@ -1,33 +1,33 @@
 /* -*- 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 "PlaceholderTransaction.h"
 
 #include "CompositionTransaction.h"
+#include "EditorBase.h"
 #include "mozilla/dom/Selection.h"
-#include "nsEditor.h"
 #include "nsGkAtoms.h"
 #include "nsQueryObject.h"
 
 namespace mozilla {
 
 using namespace dom;
 
 PlaceholderTransaction::PlaceholderTransaction()
   : EditAggregateTransaction()
   , mAbsorb(true)
   , mForwarding(nullptr)
   , mCompositionTransaction(nullptr)
   , mCommitted(false)
   , mStartSel(nullptr)
-  , mEditor(nullptr)
+  , mEditorBase(nullptr)
 {
 }
 
 PlaceholderTransaction::~PlaceholderTransaction()
 {
 }
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(PlaceholderTransaction)
@@ -50,23 +50,23 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
 NS_INTERFACE_MAP_END_INHERITING(EditAggregateTransaction)
 
 NS_IMPL_ADDREF_INHERITED(PlaceholderTransaction, EditAggregateTransaction)
 NS_IMPL_RELEASE_INHERITED(PlaceholderTransaction, EditAggregateTransaction)
 
 NS_IMETHODIMP
 PlaceholderTransaction::Init(nsIAtom* aName,
                              SelectionState* aSelState,
-                             nsEditor* aEditor)
+                             EditorBase* aEditorBase)
 {
-  NS_ENSURE_TRUE(aEditor && aSelState, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(aEditorBase && aSelState, NS_ERROR_NULL_POINTER);
 
   mName = aName;
   mStartSel = aSelState;
-  mEditor = aEditor;
+  mEditorBase = aEditorBase;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 PlaceholderTransaction::DoTransaction()
 {
   return NS_OK;
 }
@@ -76,30 +76,30 @@ PlaceholderTransaction::UndoTransaction(
 {
   // Undo transactions.
   nsresult rv = EditAggregateTransaction::UndoTransaction();
   NS_ENSURE_SUCCESS(rv, rv);
 
   NS_ENSURE_TRUE(mStartSel, NS_ERROR_NULL_POINTER);
 
   // now restore selection
-  RefPtr<Selection> selection = mEditor->GetSelection();
+  RefPtr<Selection> selection = mEditorBase->GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   return mStartSel->RestoreSelection(selection);
 }
 
 NS_IMETHODIMP
 PlaceholderTransaction::RedoTransaction()
 {
   // Redo transactions.
   nsresult rv = EditAggregateTransaction::RedoTransaction();
   NS_ENSURE_SUCCESS(rv, rv);
 
   // now restore selection
-  RefPtr<Selection> selection = mEditor->GetSelection();
+  RefPtr<Selection> selection = mEditorBase->GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   return mEndSel.RestoreSelection(selection);
 }
 
 
 NS_IMETHODIMP
 PlaceholderTransaction::Merge(nsITransaction* aTransaction,
                               bool* aDidMerge)
@@ -258,15 +258,15 @@ PlaceholderTransaction::Commit()
 {
   mCommitted = true;
   return NS_OK;
 }
 
 nsresult
 PlaceholderTransaction::RememberEndingSelection()
 {
-  RefPtr<Selection> selection = mEditor->GetSelection();
+  RefPtr<Selection> selection = mEditorBase->GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   mEndSel.SaveSelection(selection);
   return NS_OK;
 }
 
 } // namespace mozilla
--- a/editor/libeditor/PlaceholderTransaction.h
+++ b/editor/libeditor/PlaceholderTransaction.h
@@ -42,17 +42,17 @@ public:
   NS_DECL_EDITTRANSACTIONBASE
 
   NS_IMETHOD RedoTransaction() override;
   NS_IMETHOD Merge(nsITransaction* aTransaction, bool* aDidMerge) override;
 
 // ------------ nsIAbsorbingTransaction -----------------------
 
   NS_IMETHOD Init(nsIAtom* aName, SelectionState* aSelState,
-                  nsEditor* aEditor) override;
+                  EditorBase* aEditorBase) override;
 
   NS_IMETHOD GetTxnName(nsIAtom** aName) override;
 
   NS_IMETHOD StartSelectionEquals(SelectionState* aSelState,
                                   bool* aResult) override;
 
   NS_IMETHOD EndPlaceHolderBatch() override;
 
@@ -79,14 +79,14 @@ protected:
   // at the end.  This is so that UndoTransaction() and RedoTransaction() can
   // restore the selection properly.
 
   // Use a pointer because this is constructed before we exist.
   nsAutoPtr<SelectionState> mStartSel; 
   SelectionState mEndSel;
 
   // The editor for this transaction.
-  nsEditor* mEditor;
+  EditorBase* mEditorBase;
 };
 
 } // namespace mozilla
 
 #endif // #ifndef PlaceholderTransaction_h_
--- a/editor/libeditor/SelectionState.cpp
+++ b/editor/libeditor/SelectionState.cpp
@@ -6,17 +6,16 @@
 #include "SelectionState.h"
 
 #include "EditorUtils.h"                // for EditorUtils
 #include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
 #include "mozilla/dom/Selection.h"      // for Selection
 #include "nsAString.h"                  // for nsAString_internal::Length
 #include "nsCycleCollectionParticipant.h"
 #include "nsDebug.h"                    // for NS_ENSURE_TRUE, etc
-#include "nsEditor.h"                   // for nsEditor
 #include "nsError.h"                    // for NS_OK, etc
 #include "nsIContent.h"                 // for nsIContent
 #include "nsIDOMCharacterData.h"        // for nsIDOMCharacterData
 #include "nsIDOMNode.h"                 // for nsIDOMNode
 #include "nsISupportsImpl.h"            // for nsRange::Release
 #include "nsRange.h"                    // for nsRange
 
 namespace mozilla {
--- a/editor/libeditor/SplitNodeTransaction.cpp
+++ b/editor/libeditor/SplitNodeTransaction.cpp
@@ -1,31 +1,31 @@
 /* -*- 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 "SplitNodeTransaction.h"
 
+#include "EditorBase.h"                 // for EditorBase
 #include "mozilla/dom/Selection.h"
 #include "nsAString.h"
 #include "nsDebug.h"                    // for NS_ASSERTION, etc
-#include "nsEditor.h"                   // for nsEditor
 #include "nsError.h"                    // for NS_ERROR_NOT_INITIALIZED, etc
 #include "nsIContent.h"                 // for nsIContent
 
 namespace mozilla {
 
 using namespace dom;
 
-SplitNodeTransaction::SplitNodeTransaction(nsEditor& aEditor,
+SplitNodeTransaction::SplitNodeTransaction(EditorBase& aEditorBase,
                                            nsIContent& aNode,
                                            int32_t aOffset)
   : EditTransactionBase()
-  , mEditor(aEditor)
+  , mEditorBase(aEditorBase)
   , mExistingRightNode(&aNode)
   , mOffset(aOffset)
   , mNewLeftNode(nullptr)
   , mParent(nullptr)
 {
 }
 
 SplitNodeTransaction::~SplitNodeTransaction()
@@ -46,39 +46,39 @@ SplitNodeTransaction::DoTransaction()
 {
   // Create a new node
   ErrorResult rv;
   // Don't use .downcast directly because AsContent has an assertion we want
   nsCOMPtr<nsINode> clone = mExistingRightNode->CloneNode(false, rv);
   NS_ASSERTION(!rv.Failed() && clone, "Could not create clone");
   NS_ENSURE_TRUE(!rv.Failed() && clone, rv.StealNSResult());
   mNewLeftNode = dont_AddRef(clone.forget().take()->AsContent());
-  mEditor.MarkNodeDirty(mExistingRightNode->AsDOMNode());
+  mEditorBase.MarkNodeDirty(mExistingRightNode->AsDOMNode());
 
   // Get the parent node
   mParent = mExistingRightNode->GetParentNode();
   NS_ENSURE_TRUE(mParent, NS_ERROR_NULL_POINTER);
 
   // Insert the new node
-  rv = mEditor.SplitNodeImpl(*mExistingRightNode, mOffset, *mNewLeftNode);
-  if (mEditor.GetShouldTxnSetSelection()) {
-    RefPtr<Selection> selection = mEditor.GetSelection();
+  rv = mEditorBase.SplitNodeImpl(*mExistingRightNode, mOffset, *mNewLeftNode);
+  if (mEditorBase.GetShouldTxnSetSelection()) {
+    RefPtr<Selection> selection = mEditorBase.GetSelection();
     NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
     rv = selection->Collapse(mNewLeftNode, mOffset);
   }
   return rv.StealNSResult();
 }
 
 NS_IMETHODIMP
 SplitNodeTransaction::UndoTransaction()
 {
   MOZ_ASSERT(mNewLeftNode && mParent);
 
   // This assumes Do inserted the new node in front of the prior existing node
-  return mEditor.JoinNodesImpl(mExistingRightNode, mNewLeftNode, mParent);
+  return mEditorBase.JoinNodesImpl(mExistingRightNode, mNewLeftNode, mParent);
 }
 
 /* Redo cannot simply resplit the right node, because subsequent transactions
  * on the redo stack may depend on the left node existing in its previous
  * state.
  */
 NS_IMETHODIMP
 SplitNodeTransaction::RedoTransaction()
--- a/editor/libeditor/SplitNodeTransaction.h
+++ b/editor/libeditor/SplitNodeTransaction.h
@@ -7,52 +7,54 @@
 #define SplitNodeTransaction_h_
 
 #include "EditTransactionBase.h"        // for EditTxn, etc
 #include "nsCOMPtr.h"                   // for nsCOMPtr
 #include "nsCycleCollectionParticipant.h"
 #include "nsISupportsImpl.h"            // for NS_DECL_ISUPPORTS_INHERITED
 #include "nscore.h"                     // for NS_IMETHOD
 
-class nsEditor;
 class nsIContent;
 class nsINode;
 
 namespace mozilla {
 
+class EditorBase;
+
 /**
  * A transaction that splits a node into two identical nodes, with the children
  * divided between the new nodes.
  */
 class SplitNodeTransaction final : public EditTransactionBase
 {
 public:
   /**
-   * @param aEditor  The provider of core editing operations
-   * @param aNode    The node to split
-   * @param aOffset  The location within aNode to do the split.  aOffset may
-   *                 refer to children of aNode, or content of aNode.  The left
-   *                 node will have child|content 0..aOffset-1.
+   * @param aEditorBase The provider of core editing operations
+   * @param aNode       The node to split
+   * @param aOffset     The location within aNode to do the split.  aOffset may
+   *                    refer to children of aNode, or content of aNode.  The
+   *                    left node will have child|content 0..aOffset-1.
    */
-  SplitNodeTransaction(nsEditor& aEditor, nsIContent& aNode, int32_t aOffset);
+  SplitNodeTransaction(EditorBase& aEditorBase, nsIContent& aNode,
+                       int32_t aOffset);
 
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(SplitNodeTransaction,
                                            EditTransactionBase)
 
   NS_DECL_EDITTRANSACTIONBASE
 
   NS_IMETHOD RedoTransaction() override;
 
   nsIContent* GetNewNode();
 
 protected:
   virtual ~SplitNodeTransaction();
 
-  nsEditor& mEditor;
+  EditorBase& mEditorBase;
 
   // The node to operate upon.
   nsCOMPtr<nsIContent> mExistingRightNode;
 
   // The offset into mExistingRightNode where its children are split.  mOffset
   // is the index of the first child in the right node.  -1 means the new node
   // gets no children.
   int32_t mOffset;
--- a/editor/libeditor/TextEditRules.cpp
+++ b/editor/libeditor/TextEditRules.cpp
@@ -17,17 +17,16 @@
 #include "mozilla/dom/Selection.h"
 #include "nsAString.h"
 #include "nsCOMPtr.h"
 #include "nsCRT.h"
 #include "nsCRTGlue.h"
 #include "nsComponentManagerUtils.h"
 #include "nsContentUtils.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsGkAtoms.h"
 #include "nsIContent.h"
 #include "nsIDOMCharacterData.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMNode.h"
 #include "nsIDOMNodeFilter.h"
@@ -455,34 +454,37 @@ TextEditRules::CollapseSelectionToTraili
   res = nodeAsText->GetLength(&length);
   NS_ENSURE_SUCCESS(res, res);
 
   // nothing to do if we're not at the end of the text node
   if (selOffset != int32_t(length))
     return NS_OK;
 
   int32_t parentOffset;
-  nsCOMPtr<nsIDOMNode> parentNode = nsEditor::GetNodeLocation(selNode, &parentOffset);
+  nsCOMPtr<nsIDOMNode> parentNode =
+    EditorBase::GetNodeLocation(selNode, &parentOffset);
 
   NS_ENSURE_STATE(mTextEditor);
   nsCOMPtr<nsIDOMNode> root = do_QueryInterface(mTextEditor->GetRoot());
   NS_ENSURE_TRUE(root, NS_ERROR_NULL_POINTER);
   if (parentNode != root) return NS_OK;
 
   nsCOMPtr<nsIDOMNode> nextNode = mTextEditor->GetChildAt(parentNode,
                                                           parentOffset + 1);
   if (nextNode && TextEditUtils::IsMozBR(nextNode)) {
     res = aSelection->Collapse(parentNode, parentOffset + 1);
     NS_ENSURE_SUCCESS(res, res);
   }
   return res;
 }
 
 static inline already_AddRefed<nsIDOMNode>
-GetTextNode(Selection* selection, nsEditor* editor) {
+GetTextNode(Selection* selection,
+            EditorBase* editor)
+{
   int32_t selOffset;
   nsCOMPtr<nsIDOMNode> selNode;
   nsresult res = editor->GetStartNodeAndOffset(selection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(res, nullptr);
   if (!editor->IsTextNode(selNode)) {
     // Get an nsINode from the nsIDOMNode
     nsCOMPtr<nsINode> node = do_QueryInterface(selNode);
     // if node is null, return it to indicate there's no text
--- a/editor/libeditor/TextEditRules.h
+++ b/editor/libeditor/TextEditRules.h
@@ -3,17 +3,17 @@
  * 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 mozilla_editor_TextEditRules_h_
 #define mozilla_editor_TextEditRules_h_
 
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
-#include "nsEditor.h"
+#include "EditorBase.h"
 #include "nsIEditRules.h"
 #include "nsIEditor.h"
 #include "nsISupportsImpl.h"
 #include "nsITimer.h"
 #include "nsString.h"
 #include "nscore.h"
 
 class nsIDOMElement;
--- a/editor/libeditor/TextEditUtils.cpp
+++ b/editor/libeditor/TextEditUtils.cpp
@@ -7,17 +7,16 @@
 
 #include "TextEditor.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/dom/Element.h"
 #include "nsAString.h"
 #include "nsCOMPtr.h"
 #include "nsCaseTreatment.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsGkAtoms.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMNode.h"
 #include "nsNameSpaceManager.h"
 #include "nsLiteralString.h"
 #include "nsString.h"
 
@@ -28,26 +27,26 @@ namespace mozilla {
  ******************************************************************************/
 
 /**
  * IsBody() returns true if aNode is an html body node.
  */
 bool
 TextEditUtils::IsBody(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::body);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::body);
 }
 
 /**
  * IsBreak() returns true if aNode is an html break node.
  */
 bool
 TextEditUtils::IsBreak(nsIDOMNode* aNode)
 {
-  return nsEditor::NodeIsType(aNode, nsGkAtoms::br);
+  return EditorBase::NodeIsType(aNode, nsGkAtoms::br);
 }
 
 bool
 TextEditUtils::IsBreak(nsINode* aNode)
 {
   MOZ_ASSERT(aNode);
   return aNode->IsHTMLElement(nsGkAtoms::br);
 }
--- a/editor/libeditor/TextEditor.cpp
+++ b/editor/libeditor/TextEditor.cpp
@@ -62,17 +62,17 @@ class nsIOutputStream;
 class nsISupports;
 class nsISupportsArray;
 
 namespace mozilla {
 
 using namespace dom;
 
 TextEditor::TextEditor()
-  : nsEditor()
+  : EditorBase()
   , mRules(nullptr)
   , mWrapColumn(0)
   , mMaxTextLength(-1)
   , mInitTriggerCounter(0)
   , mNewlineHandling(nsIPlaintextEditor::eNewlinesPasteToFirst)
 #ifdef XP_WIN
   , mCaretStyle(1)
 #else
@@ -91,33 +91,33 @@ TextEditor::~TextEditor()
   RemoveEventListeners();
 
   if (mRules)
     mRules->DetachEditor();
 }
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(TextEditor)
 
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(TextEditor, nsEditor)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(TextEditor, EditorBase)
   if (tmp->mRules)
     tmp->mRules->DetachEditor();
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mRules)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(TextEditor, nsEditor)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(TextEditor, EditorBase)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRules)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_IMPL_ADDREF_INHERITED(TextEditor, nsEditor)
-NS_IMPL_RELEASE_INHERITED(TextEditor, nsEditor)
+NS_IMPL_ADDREF_INHERITED(TextEditor, EditorBase)
+NS_IMPL_RELEASE_INHERITED(TextEditor, EditorBase)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(TextEditor)
   NS_INTERFACE_MAP_ENTRY(nsIPlaintextEditor)
   NS_INTERFACE_MAP_ENTRY(nsIEditorMailSupport)
-NS_INTERFACE_MAP_END_INHERITING(nsEditor)
+NS_INTERFACE_MAP_END_INHERITING(EditorBase)
 
 
 NS_IMETHODIMP
 TextEditor::Init(nsIDOMDocument* aDoc,
                  nsIContent* aRoot,
                  nsISelectionController* aSelCon,
                  uint32_t aFlags,
                  const nsAString& aInitialValue)
@@ -130,17 +130,17 @@ TextEditor::Init(nsIDOMDocument* aDoc,
     mRules->DetachEditor();
   }
 
   {
     // block to scope AutoEditInitRulesTrigger
     AutoEditInitRulesTrigger rulesTrigger(this, rulesRes);
 
     // Init the base editor
-    res = nsEditor::Init(aDoc, aRoot, aSelCon, aFlags, aInitialValue);
+    res = EditorBase::Init(aDoc, aRoot, aSelCon, aFlags, aInitialValue);
   }
 
   NS_ENSURE_SUCCESS(rulesRes, rulesRes);
 
   // mRules may not have been initialized yet, when this is called via
   // HTMLEditor::Init.
   if (mRules) {
     mRules->SetInitialValue(aInitialValue);
@@ -212,17 +212,17 @@ TextEditor::EndEditorInit()
     }
   }
   return res;
 }
 
 NS_IMETHODIMP
 TextEditor::SetDocumentCharacterSet(const nsACString& characterSet)
 {
-  nsresult rv = nsEditor::SetDocumentCharacterSet(characterSet);
+  nsresult rv = EditorBase::SetDocumentCharacterSet(characterSet);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Update META charset element.
   nsCOMPtr<nsIDOMDocument> domdoc = GetDOMDocument();
   NS_ENSURE_TRUE(domdoc, NS_ERROR_NOT_INITIALIZED);
 
   if (UpdateMetaCharset(domdoc, characterSet)) {
     return NS_OK;
@@ -306,20 +306,20 @@ TextEditor::UpdateMetaCharset(nsIDOMDocu
     if (!FindInReadable(charsetEquals, start, end,
                         nsCaseInsensitiveStringComparator())) {
       continue;
     }
 
     // set attribute to <original prefix> charset=text/html
     nsCOMPtr<nsIDOMElement> metaElement = do_QueryInterface(metaNode);
     MOZ_ASSERT(metaElement);
-    rv = nsEditor::SetAttribute(metaElement, NS_LITERAL_STRING("content"),
-                                Substring(originalStart, start) +
-                                  charsetEquals +
-                                  NS_ConvertASCIItoUTF16(aCharacterSet));
+    rv = EditorBase::SetAttribute(metaElement, NS_LITERAL_STRING("content"),
+                                  Substring(originalStart, start) +
+                                    charsetEquals +
+                                    NS_ConvertASCIItoUTF16(aCharacterSet));
     return NS_SUCCEEDED(rv);
   }
   return false;
 }
 
 NS_IMETHODIMP
 TextEditor::InitRules()
 {
@@ -354,36 +354,36 @@ TextEditor::HandleKeyPressEvent(nsIDOMKe
   // NOTE: When you change this method, you should also change:
   //   * editor/libeditor/tests/test_texteditor_keyevent_handling.html
   //   * editor/libeditor/tests/test_htmleditor_keyevent_handling.html
   //
   // And also when you add new key handling, you need to change the subclass's
   // HandleKeyPressEvent()'s switch statement.
 
   if (IsReadonly() || IsDisabled()) {
-    // When we're not editable, the events handled on nsEditor.
-    return nsEditor::HandleKeyPressEvent(aKeyEvent);
+    // When we're not editable, the events handled on EditorBase.
+    return EditorBase::HandleKeyPressEvent(aKeyEvent);
   }
 
   WidgetKeyboardEvent* nativeKeyEvent =
     aKeyEvent->AsEvent()->WidgetEventPtr()->AsKeyboardEvent();
   NS_ENSURE_TRUE(nativeKeyEvent, NS_ERROR_UNEXPECTED);
   NS_ASSERTION(nativeKeyEvent->mMessage == eKeyPress,
                "HandleKeyPressEvent gets non-keypress event");
 
   switch (nativeKeyEvent->mKeyCode) {
     case NS_VK_META:
     case NS_VK_WIN:
     case NS_VK_SHIFT:
     case NS_VK_CONTROL:
     case NS_VK_ALT:
     case NS_VK_BACK:
     case NS_VK_DELETE:
-      // These keys are handled on nsEditor
-      return nsEditor::HandleKeyPressEvent(aKeyEvent);
+      // These keys are handled on EditorBase
+      return EditorBase::HandleKeyPressEvent(aKeyEvent);
     case NS_VK_TAB: {
       if (IsTabbable()) {
         return NS_OK; // let it be used for focus switching
       }
 
       if (nativeKeyEvent->IsShift() || nativeKeyEvent->IsControl() ||
           nativeKeyEvent->IsAlt() || nativeKeyEvent->IsMeta() ||
           nativeKeyEvent->IsOS()) {
@@ -841,17 +841,17 @@ TextEditor::BeginIMEComposition(WidgetCo
     NS_ENSURE_TRUE(mRules, NS_ERROR_NULL_POINTER);
     // Protect the edit rules object from dying
     nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
     TextEditRules* textEditRules = static_cast<TextEditRules*>(mRules.get());
     textEditRules->ResetIMETextPWBuf();
   }
 
-  return nsEditor::BeginIMEComposition(aEvent);
+  return EditorBase::BeginIMEComposition(aEvent);
 }
 
 nsresult
 TextEditor::UpdateIMEComposition(nsIDOMEvent* aDOMTextEvent)
 {
   MOZ_ASSERT(aDOMTextEvent, "aDOMTextEvent must not be nullptr");
 
   WidgetCompositionEvent* compositionChangeEvent =
@@ -1101,17 +1101,17 @@ TextEditor::Undo(uint32_t aCount)
 
   TextRulesInfo ruleInfo(EditAction::undo);
   RefPtr<Selection> selection = GetSelection();
   bool cancel, handled;
   nsresult result = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
 
   if (!cancel && NS_SUCCEEDED(result))
   {
-    result = nsEditor::Undo(aCount);
+    result = EditorBase::Undo(aCount);
     result = mRules->DidDoAction(selection, &ruleInfo, result);
   }
 
   NotifyEditorObservers(eNotifyEditorObserversOfEnd);
   return result;
 }
 
 NS_IMETHODIMP
@@ -1130,17 +1130,17 @@ TextEditor::Redo(uint32_t aCount)
 
   TextRulesInfo ruleInfo(EditAction::redo);
   RefPtr<Selection> selection = GetSelection();
   bool cancel, handled;
   nsresult result = mRules->WillDoAction(selection, &ruleInfo, &cancel, &handled);
 
   if (!cancel && NS_SUCCEEDED(result))
   {
-    result = nsEditor::Redo(aCount);
+    result = EditorBase::Redo(aCount);
     result = mRules->DidDoAction(selection, &ruleInfo, result);
   }
 
   NotifyEditorObservers(eNotifyEditorObserversOfEnd);
   return result;
 }
 
 bool
@@ -1549,17 +1549,17 @@ TextEditor::GetEmbeddedObjects(nsISuppor
  */
 NS_IMETHODIMP
 TextEditor::StartOperation(EditAction opID,
                            nsIEditor::EDirection aDirection)
 {
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
-  nsEditor::StartOperation(opID, aDirection);  // will set mAction, mDirection
+  EditorBase::StartOperation(opID, aDirection);  // will set mAction, mDirection
   if (mRules) return mRules->BeforeEdit(mAction, mDirection);
   return NS_OK;
 }
 
 /**
  * All editor operations which alter the doc should be followed
  * with a call to EndOperation.
  */
@@ -1567,17 +1567,17 @@ NS_IMETHODIMP
 TextEditor::EndOperation()
 {
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
   // post processing
   nsresult res = NS_OK;
   if (mRules) res = mRules->AfterEdit(mAction, mDirection);
-  nsEditor::EndOperation();  // will clear mAction, mDirection
+  EditorBase::EndOperation();  // will clear mAction, mDirection
   return res;
 }
 
 nsresult
 TextEditor::SelectEntireDocument(Selection* aSelection)
 {
   if (!aSelection || !mRules) { return NS_ERROR_NULL_POINTER; }
 
@@ -1592,17 +1592,17 @@ TextEditor::SelectEntireDocument(Selecti
     nsCOMPtr<nsIDOMElement> rootElement = do_QueryInterface(GetRoot());
     NS_ENSURE_TRUE(rootElement, NS_ERROR_FAILURE);
 
     // if it's empty don't select entire doc - that would select the bogus node
     return aSelection->Collapse(rootElement, 0);
   }
 
   SelectionBatcher selectionBatcher(aSelection);
-  nsresult rv = nsEditor::SelectEntireDocument(aSelection);
+  nsresult rv = EditorBase::SelectEntireDocument(aSelection);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Don't select the trailing BR node if we have one
   int32_t selOffset;
   nsCOMPtr<nsIDOMNode> selNode;
   rv = GetEndNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -1627,20 +1627,20 @@ TextEditor::GetDOMEventTarget()
 
 
 nsresult
 TextEditor::SetAttributeOrEquivalent(nsIDOMElement* aElement,
                                      const nsAString& aAttribute,
                                      const nsAString& aValue,
                                      bool aSuppressTransaction)
 {
-  return nsEditor::SetAttribute(aElement, aAttribute, aValue);
+  return EditorBase::SetAttribute(aElement, aAttribute, aValue);
 }
 
 nsresult
 TextEditor::RemoveAttributeOrEquivalent(nsIDOMElement* aElement,
                                         const nsAString& aAttribute,
                                         bool aSuppressTransaction)
 {
-  return nsEditor::RemoveAttribute(aElement, aAttribute);
+  return EditorBase::RemoveAttribute(aElement, aAttribute);
 }
 
 } // namespace mozilla
--- a/editor/libeditor/TextEditor.h
+++ b/editor/libeditor/TextEditor.h
@@ -1,19 +1,19 @@
 /* -*- 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 mozilla_editor_TextEditor_h_
 #define mozilla_editor_TextEditor_h_
 
+#include "EditorBase.h"
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
-#include "nsEditor.h"
 #include "nsIEditor.h"
 #include "nsIEditorMailSupport.h"
 #include "nsIPlaintextEditor.h"
 #include "nsISupportsImpl.h"
 #include "nscore.h"
 
 class nsIContent;
 class nsIDOMDocument;
@@ -35,40 +35,40 @@ class TextEditRules;
 namespace dom {
 class Selection;
 } // namespace dom
 
 /**
  * The text editor implementation.
  * Use to edit text document represented as a DOM tree.
  */
-class TextEditor : public nsEditor
+class TextEditor : public EditorBase
                  , public nsIPlaintextEditor
                  , public nsIEditorMailSupport
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
-  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(TextEditor, nsEditor)
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(TextEditor, EditorBase)
 
   enum ETypingAction
   {
     eTypedText,  /* user typed text */
     eTypedBR,    /* user typed shift-enter to get a br */
     eTypedBreak  /* user typed enter */
   };
 
   TextEditor();
 
   // nsIPlaintextEditor methods
   NS_DECL_NSIPLAINTEXTEDITOR
 
   // nsIEditorMailSupport overrides
   NS_DECL_NSIEDITORMAILSUPPORT
 
-  // Overrides of nsEditor interface methods
+  // Overrides of EditorBase interface methods
   NS_IMETHOD SetAttributeOrEquivalent(nsIDOMElement* aElement,
                                       const nsAString& aAttribute,
                                       const nsAString& aValue,
                                       bool aSuppressTransaction) override;
   NS_IMETHOD RemoveAttributeOrEquivalent(nsIDOMElement* aElement,
                                          const nsAString& aAttribute,
                                          bool aSuppressTransaction) override;
 
--- a/editor/libeditor/TextEditorDataTransfer.cpp
+++ b/editor/libeditor/TextEditorDataTransfer.cpp
@@ -11,17 +11,16 @@
 #include "mozilla/MouseEvents.h"
 #include "mozilla/dom/Selection.h"
 #include "nsAString.h"
 #include "nsCOMPtr.h"
 #include "nsCRT.h"
 #include "nsComponentManagerUtils.h"
 #include "nsContentUtils.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
 #include "nsError.h"
 #include "nsIClipboard.h"
 #include "nsIContent.h"
 #include "nsIDOMDataTransfer.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMDragEvent.h"
 #include "nsIDOMEvent.h"
 #include "nsIDOMNode.h"
--- a/editor/libeditor/TypeInState.cpp
+++ b/editor/libeditor/TypeInState.cpp
@@ -2,22 +2,22 @@
 /* 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 "TypeInState.h"
 
 #include <stddef.h>
 
+#include "nsError.h"
 #include "mozilla/dom/Selection.h"
 #include "mozilla/mozalloc.h"
 #include "nsAString.h"
 #include "nsDebug.h"
-#include "nsEditor.h"
-#include "nsError.h"
+#include "EditorBase.h"
 #include "nsGkAtoms.h"
 #include "nsIDOMNode.h"
 #include "nsISupportsBase.h"
 #include "nsISupportsImpl.h"
 #include "nsReadableUtils.h"
 #include "nsStringFwd.h"
 
 class nsIAtom;
@@ -58,17 +58,19 @@ nsresult
 TypeInState::UpdateSelState(Selection* aSelection)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
 
   if (!aSelection->Collapsed()) {
     return NS_OK;
   }
 
-  return nsEditor::GetStartNodeAndOffset(aSelection, getter_AddRefs(mLastSelectionContainer), &mLastSelectionOffset);
+  return EditorBase::GetStartNodeAndOffset(
+                       aSelection, getter_AddRefs(mLastSelectionContainer),
+                       &mLastSelectionOffset);
 }
 
 
 NS_IMETHODIMP
 TypeInState::NotifySelectionChanged(nsIDOMDocument* aDOMDocument,
                                     nsISelection* aSelection,
                                     int16_t aReason)
 {
@@ -87,18 +89,18 @@ TypeInState::NotifySelectionChanged(nsID
   if (aSelection) {
     int32_t rangeCount = selection->RangeCount();
 
     if (selection->Collapsed() && rangeCount) {
       nsCOMPtr<nsIDOMNode> selNode;
       int32_t selOffset = 0;
 
       nsresult result =
-        nsEditor::GetStartNodeAndOffset(selection, getter_AddRefs(selNode),
-                                        &selOffset);
+        EditorBase::GetStartNodeAndOffset(selection, getter_AddRefs(selNode),
+                                          &selOffset);
 
       NS_ENSURE_SUCCESS(result, result);
 
       if (selNode && selNode == mLastSelectionContainer && selOffset == mLastSelectionOffset)
       {
         // We got a bogus selection changed notification!
         return NS_OK;
       }
--- a/editor/libeditor/moz.build
+++ b/editor/libeditor/moz.build
@@ -9,21 +9,21 @@ MOCHITEST_MANIFESTS += [
     'tests/mochitest.ini',
 ]
 
 MOCHITEST_CHROME_MANIFESTS += ['tests/chrome.ini']
 
 BROWSER_CHROME_MANIFESTS += ['tests/browser.ini']
 
 EXPORTS += [
-    'nsEditor.h',
     'nsIEditRules.h',
 ]
 
 EXPORTS.mozilla.editor += [
+    'EditorBase.h',
     'EditorController.h',
     'HTMLEditor.h',
     'SelectionState.h',
     'TextEditor.h',
     'TextEditRules.h',
 ]
 
 UNIFIED_SOURCES += [
@@ -31,16 +31,17 @@ UNIFIED_SOURCES += [
     'ChangeStyleTransaction.cpp',
     'CompositionTransaction.cpp',
     'CreateElementTransaction.cpp',
     'CSSEditUtils.cpp',
     'DeleteNodeTransaction.cpp',
     'DeleteRangeTransaction.cpp',
     'DeleteTextTransaction.cpp',
     'EditAggregateTransaction.cpp',
+    'EditorBase.cpp',
     'EditorCommands.cpp',
     'EditorController.cpp',
     'EditorEventListener.cpp',
     'EditorUtils.cpp',
     'EditTransactionBase.cpp',
     'HTMLAbsPositionEditor.cpp',
     'HTMLAnonymousNodeEditor.cpp',
     'HTMLEditor.cpp',
@@ -52,17 +53,16 @@ UNIFIED_SOURCES += [
     'HTMLInlineTableEditor.cpp',
     'HTMLStyleEditor.cpp',
     'HTMLTableEditor.cpp',
     'HTMLURIRefObject.cpp',
     'InsertNodeTransaction.cpp',
     'InsertTextTransaction.cpp',
     'InternetCiter.cpp',
     'JoinNodeTransaction.cpp',
-    'nsEditor.cpp',
     'PlaceholderTransaction.cpp',
     'SelectionState.cpp',
     'SetDocumentTitleTransaction.cpp',
     'SplitNodeTransaction.cpp',
     'StyleSheetTransactions.cpp',
     'TextEditor.cpp',
     'TextEditorDataTransfer.cpp',
     'TextEditorTest.cpp',
--- a/editor/libeditor/nsIAbsorbingTransaction.h
+++ b/editor/libeditor/nsIAbsorbingTransaction.h
@@ -17,30 +17,31 @@ Transaction interface to outside world
     0xa6cf9116, \
     0x15b3, \
     0x11d2, \
     {0x93, 0x2e, 0x00, 0x80, 0x5f, 0x8a, 0xdd, 0x32} }
 
 class nsIAtom;
 
 namespace mozilla {
+class EditorBase;
 class SelectionState;
 } // namespace mozilla
 
 /**
  * A transaction interface mixin - for transactions that can support.
  * the placeholder absorbtion idiom.
  */
 class nsIAbsorbingTransaction  : public nsISupports{
 public:
 
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IABSORBINGTRANSACTION_IID)
 
   NS_IMETHOD Init(nsIAtom* aName, mozilla::SelectionState* aSelState,
-                  nsEditor* aEditor) = 0;
+                  mozilla::EditorBase* aEditorBase) = 0;
 
   NS_IMETHOD EndPlaceHolderBatch()=0;
 
   NS_IMETHOD GetTxnName(nsIAtom **aName)=0;
 
   NS_IMETHOD StartSelectionEquals(mozilla::SelectionState* aSelState,
                                   bool* aResult) = 0;
 
--- a/editor/libeditor/nsIEditRules.h
+++ b/editor/libeditor/nsIEditRules.h
@@ -5,17 +5,17 @@
 
 #ifndef nsIEditRules_h_
 #define nsIEditRules_h_
 
 #define NS_IEDITRULES_IID \
 { 0x3836386d, 0x806a, 0x488d, \
   { 0x8b, 0xab, 0xaf, 0x42, 0xbb, 0x4c, 0x90, 0x66 } }
 
-#include "nsEditor.h" // for EditAction enum
+#include "mozilla/editor/EditorBase.h" // for EditAction enum
 
 namespace mozilla {
 
 class TextEditor;
 namespace dom {
 class Selection;
 } // namespace dom
 
--- a/extensions/spellcheck/src/mozInlineSpellChecker.cpp
+++ b/extensions/spellcheck/src/mozInlineSpellChecker.cpp
@@ -27,16 +27,17 @@
  * true when we get any change, and false once there is no possibility
  * something changed that we need to check on navigation. Navigation events
  * tend to be a little tricky because we want to check the current word on
  * exit if something has changed. If we navigate inside the word, we don't want
  * to do anything. As a result, this flag is cleared in FinishNavigationEvent
  * when we know that we are checking as a result of navigation.
  */
 
+#include "EditorBase.h"
 #include "EditorUtils.h"
 #include "mozilla/Services.h"
 #include "mozilla/dom/Selection.h"
 #include "mozInlineSpellChecker.h"
 #include "mozInlineSpellWordUtil.h"
 #include "mozISpellI18NManager.h"
 #include "nsCOMPtr.h"
 #include "nsCRT.h"
@@ -61,17 +62,16 @@
 #include "nsIServiceManager.h"
 #include "nsITextServicesFilter.h"
 #include "nsString.h"
 #include "nsThreadUtils.h"
 #include "nsUnicharUtils.h"
 #include "nsIContent.h"
 #include "nsRange.h"
 #include "nsContentUtils.h"
-#include "nsEditor.h"
 #include "nsIObserverService.h"
 #include "nsITextControlElement.h"
 #include "prtime.h"
 
 using namespace mozilla;
 using namespace mozilla::dom;
 
 // Set to spew messages to the console about what is happening.
--- a/extensions/spellcheck/src/mozInlineSpellChecker.h
+++ b/extensions/spellcheck/src/mozInlineSpellChecker.h
@@ -1,23 +1,23 @@
 /* -*- 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 __mozinlinespellchecker_h__
 #define __mozinlinespellchecker_h__
 
+#include "EditorBase.h"
 #include "nsRange.h"
 #include "nsIEditorSpellCheck.h"
 #include "nsIEditActionListener.h"
 #include "nsIInlineSpellChecker.h"
 #include "nsIDOMTreeWalker.h"
 #include "nsWeakReference.h"
-#include "nsEditor.h"
 #include "nsIDOMEventListener.h"
 #include "nsWeakReference.h"
 #include "mozISpellI18NUtil.h"
 #include "nsCycleCollectionParticipant.h"
 
 // X.h defines KeyPress
 #ifdef KeyPress
 #undef KeyPress
--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -7602,17 +7602,17 @@ nsLayoutUtils::GetEditableRootContentByC
   // If the document is in designMode we should return nullptr.
   if (!aDocument || aDocument->HasFlag(NODE_IS_EDITABLE)) {
     return nullptr;
   }
 
   // contenteditable only works with HTML document.
   // Note: Use nsIDOMHTMLDocument rather than nsIHTMLDocument for getting the
   //       body node because nsIDOMHTMLDocument::GetBody() does something
-  //       additional work for some cases and nsEditor uses them.
+  //       additional work for some cases and EditorBase uses them.
   nsCOMPtr<nsIDOMHTMLDocument> domHTMLDoc = do_QueryInterface(aDocument);
   if (!domHTMLDoc) {
     return nullptr;
   }
 
   Element* rootElement = aDocument->GetRootElement();
   if (rootElement && rootElement->IsEditable()) {
     return rootElement;
--- a/layout/build/nsLayoutModule.cpp
+++ b/layout/build/nsLayoutModule.cpp
@@ -131,17 +131,16 @@ using mozilla::dom::PushNotifier;
 { 0x2fc2d3e3, 0x020f, 0x404e, { 0xb0, 0x6a, 0x6e, 0xcf, 0x3e, 0xa2, 0x33, 0x4a } }
 #endif
 
 #include "AudioChannelAgent.h"
 using mozilla::dom::AudioChannelAgent;
 
 // Editor stuff
 #include "nsEditorCID.h"
-#include "nsEditor.h"
 #include "mozilla/editor/EditorController.h" //CID
 #include "mozilla/editor/HTMLEditor.h"
 
 #include "nsTextServicesDocument.h"
 #include "nsTextServicesCID.h"
 
 #include "nsScriptSecurityManager.h"
 #include "nsPrincipal.h"
--- a/widget/windows/KeyboardLayout.cpp
+++ b/widget/windows/KeyboardLayout.cpp
@@ -252,18 +252,18 @@ ModifierKeyState::Update()
   EnsureAltGr();
 }
 
 void
 ModifierKeyState::Unset(Modifiers aRemovingModifiers)
 {
   mModifiers &= ~aRemovingModifiers;
   // Note that we don't need to unset AltGr flag here automatically.
-  // For nsEditor, we need to remove Alt and Control flags but AltGr isn't
-  // checked in nsEditor, so, it can be kept.
+  // For EditorBase, we need to remove Alt and Control flags but AltGr isn't
+  // checked in EditorBase, so, it can be kept.
 }
 
 void
 ModifierKeyState::Set(Modifiers aAddingModifiers)
 {
   mModifiers |= aAddingModifiers;
   EnsureAltGr();
 }
@@ -578,17 +578,17 @@ VirtualKey::GetUniChars(ShiftState aShif
     result.FillModifiers(ShiftStateToModifiers(aShiftState));
     return result;
   }
 
   if ((aShiftState & STATE_ALT_CONTROL) == STATE_ALT_CONTROL) {
     // Even if the shifted chars and the unshifted chars are same, we
     // should consume the Alt key state and the Ctrl key state when
     // AltGr key is pressed. Because if we don't consume them, the input
-    // events are ignored on nsEditor. (I.e., Users cannot input the
+    // events are ignored on EditorBase. (I.e., Users cannot input the
     // characters with this key combination.)
     Modifiers finalModifiers = ShiftStateToModifiers(aShiftState);
     finalModifiers &= ~(MODIFIER_ALT | MODIFIER_CONTROL);
     result.FillModifiers(finalModifiers);
     return result;
   }
 
   UniCharsAndModifiers unmodifiedReslt =
@@ -1694,17 +1694,17 @@ NativeKey::HandleCharMessage(const MSG& 
       keypressEvent.mKeyCode = mDOMKeyCode;
     }
     nsresult rv = mDispatcher->BeginNativeInputTransaction();
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return true;
     }
 
     // When AltGr (Alt+Ctrl) is pressed, that causes normal text input.
-    // At this time, if either alt or ctrl flag is set, nsEditor ignores the
+    // At this time, if either alt or ctrl flag is set, EditorBase ignores the
     // keypress event.  For avoiding this issue, we should remove ctrl and alt
     // flags.
     ModifierKeyState modKeyState(mModKeyState);
     modKeyState.Unset(MODIFIER_ALT | MODIFIER_CONTROL);
     nsEventStatus status = InitKeyEvent(keypressEvent, modKeyState, &aCharMsg);
     bool dispatched =
       mDispatcher->MaybeDispatchKeypressEvents(keypressEvent, status,
                                                const_cast<NativeKey*>(this));