Bug 1260651 part.58 Rename nsPlaintextEditor to mozilla::TextEditor (and their file names too) r?ehsan draft
authorMasayuki Nakano <masayuki@d-toybox.com>
Sat, 25 Jun 2016 11:29:31 +0900
changeset 381309 637060de3a6a90711ad741f48f40a41a7546ee8e
parent 381308 be3ee8e8dd267ec67c78d40c909a46b8f13bde3c
child 381310 03f5f1561c98458fd3d8f400d54c64e07ea106c8
push id21453
push usermasayuki@d-toybox.com
push dateSat, 25 Jun 2016 10:50:45 +0000
reviewersehsan
bugs1260651
milestone50.0a1
Bug 1260651 part.58 Rename nsPlaintextEditor to mozilla::TextEditor (and their file names too) r?ehsan This patch renames nsPlaintextEditor to mozilla::TextEditor. Additionally, renames TextEditRules::mEditor to TextEditRules::mTextEditor for making its type clearer. Finally, renaming following files: nsPlaintextEditor.h -> TextEditor.h (exposed as mozilla/editor/TextEditor.h) nsPlaintextEditor.cpp -> TextEditor.cpp nsPlaintextDataTransfer.cpp -> TextEditorDataTransfer.cpp MozReview-Commit-ID: Lw8oJi4WglA
editor/libeditor/HTMLEditRules.cpp
editor/libeditor/HTMLEditRules.h
editor/libeditor/HTMLEditor.cpp
editor/libeditor/HTMLEditor.h
editor/libeditor/HTMLEditorDataTransfer.cpp
editor/libeditor/TextEditRules.cpp
editor/libeditor/TextEditRules.h
editor/libeditor/TextEditRulesBidi.cpp
editor/libeditor/TextEditUtils.cpp
editor/libeditor/TextEditUtils.h
editor/libeditor/TextEditor.cpp
editor/libeditor/TextEditor.h
editor/libeditor/TextEditorDataTransfer.cpp
editor/libeditor/moz.build
editor/libeditor/nsIEditRules.h
editor/libeditor/nsPlaintextDataTransfer.cpp
editor/libeditor/nsPlaintextEditor.cpp
editor/libeditor/nsPlaintextEditor.h
layout/build/nsLayoutModule.cpp
--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -7,16 +7,17 @@
 #include "HTMLEditRules.h"
 
 #include <stdlib.h>
 
 #include "CSSEditUtils.h"
 #include "EditorUtils.h"
 #include "HTMLEditor.h"
 #include "HTMLEditUtils.h"
+#include "TextEditor.h"
 #include "TextEditUtils.h"
 #include "WSRunObject.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/MathAlgorithms.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/dom/Selection.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/OwningNonNull.h"
@@ -40,17 +41,16 @@
 #include "nsIDOMDocument.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMNode.h"
 #include "nsIDOMText.h"
 #include "nsIHTMLAbsPosEditor.h"
 #include "nsIHTMLDocument.h"
 #include "nsINode.h"
 #include "nsLiteralString.h"
-#include "nsPlaintextEditor.h"
 #include "nsRange.h"
 #include "nsReadableUtils.h"
 #include "nsString.h"
 #include "nsStringFwd.h"
 #include "nsTArray.h"
 #include "nsTextNode.h"
 #include "nsThreadUtils.h"
 #include "nsUnicharUtils.h"
@@ -224,17 +224,17 @@ NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION
   NS_INTERFACE_TABLE_INHERITED(HTMLEditRules, nsIEditActionListener)
 NS_INTERFACE_TABLE_TAIL_INHERITING(TextEditRules)
 
 NS_IMPL_CYCLE_COLLECTION_INHERITED(HTMLEditRules, TextEditRules,
                                    mDocChangeRange, mUtilRange, mNewBlock,
                                    mRangeItem)
 
 NS_IMETHODIMP
-HTMLEditRules::Init(nsPlaintextEditor* aTextEditor)
+HTMLEditRules::Init(TextEditor* aTextEditor)
 {
   InitFields();
 
   mHTMLEditor = static_cast<HTMLEditor*>(aTextEditor);
   nsresult res;
 
   // call through to base class Init
   res = TextEditRules::Init(aTextEditor);
@@ -1461,17 +1461,17 @@ HTMLEditRules::WillLoadHTML(Selection* a
 
   *aCancel = false;
 
   // Delete mBogusNode if it exists. If we really need one,
   // it will be added during post-processing in AfterEditInner().
 
   if (mBogusNode)
   {
-    mEditor->DeleteNode(mBogusNode);
+    mTextEditor->DeleteNode(mBogusNode);
     mBogusNode = nullptr;
   }
 
   return NS_OK;
 }
 
 nsresult
 HTMLEditRules::WillInsertBreak(Selection& aSelection,
@@ -2465,17 +2465,19 @@ HTMLEditRules::DeleteNodeIfCollapsedText
 nsresult
 HTMLEditRules::InsertBRIfNeeded(Selection* aSelection)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
 
   // get selection
   nsCOMPtr<nsINode> node;
   int32_t offset;
-  nsresult res = mEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(node), &offset);
+  nsresult res = mTextEditor->GetStartNodeAndOffset(aSelection,
+                                                    getter_AddRefs(node),
+                                                    &offset);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 
   // inline elements don't need any br
   if (!IsBlockNode(*node)) {
     return NS_OK;
   }
 
@@ -2905,17 +2907,19 @@ HTMLEditRules::DidDeleteSelection(Select
                                   nsIEditor::EDirection aDir,
                                   nsresult aResult)
 {
   if (!aSelection) { return NS_ERROR_NULL_POINTER; }
 
   // find where we are
   nsCOMPtr<nsINode> startNode;
   int32_t startOffset;
-  nsresult res = mEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode), &startOffset);
+  nsresult res = mTextEditor->GetStartNodeAndOffset(aSelection,
+                                                    getter_AddRefs(startNode),
+                                                    &startOffset);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);
 
   // find any enclosing mailcite
   nsCOMPtr<Element> citeNode = GetTopEnclosingMailCite(*startNode);
   if (citeNode) {
     bool isEmpty = true, seenBR = false;
     NS_ENSURE_STATE(mHTMLEditor);
@@ -3658,17 +3662,17 @@ HTMLEditRules::WillCSSIndent(Selection* 
       if (curNode && IsBlockNode(*curNode)) {
         ChangeIndentation(*curNode->AsElement(), Change::plus);
         curQuote = nullptr;
       }
       else {
         if (!curQuote)
         {
           // First, check that our element can contain a div.
-          if (!mEditor->CanContainTag(*curParent, *nsGkAtoms::div)) {
+          if (!mTextEditor->CanContainTag(*curParent, *nsGkAtoms::div)) {
             return NS_OK; // cancelled
           }
 
           res = SplitAsNeeded(*nsGkAtoms::div, curParent, offset);
           NS_ENSURE_SUCCESS(res, res);
           NS_ENSURE_STATE(mHTMLEditor);
           curQuote = mHTMLEditor->CreateNode(nsGkAtoms::div, curParent,
                                              offset);
@@ -3889,17 +3893,17 @@ HTMLEditRules::WillHTMLIndent(Selection*
         // in a different table cell.
         if (curQuote && InDifferentTableElements(curQuote, curNode)) {
           curQuote = nullptr;
         }
 
         if (!curQuote)
         {
           // First, check that our element can contain a blockquote.
-          if (!mEditor->CanContainTag(*curParent, *nsGkAtoms::blockquote)) {
+          if (!mTextEditor->CanContainTag(*curParent, *nsGkAtoms::blockquote)) {
             return NS_OK; // cancelled
           }
 
           res = SplitAsNeeded(*nsGkAtoms::blockquote, curParent, offset);
           NS_ENSURE_SUCCESS(res, res);
           NS_ENSURE_STATE(mHTMLEditor);
           curQuote = mHTMLEditor->CreateNode(nsGkAtoms::blockquote, curParent,
                                              offset);
@@ -4639,17 +4643,17 @@ HTMLEditRules::WillAlign(Selection& aSel
       }
       // Clear out curDiv so that we don't put nodes after this one into it
     }
 
     // Need to make a div to put things in if we haven't already, or if this
     // node doesn't go in div we used earlier.
     if (!curDiv || transitionList[i]) {
       // First, check that our element can contain a div.
-      if (!mEditor->CanContainTag(*curParent, *nsGkAtoms::div)) {
+      if (!mTextEditor->CanContainTag(*curParent, *nsGkAtoms::div)) {
         // Cancelled
         return NS_OK;
       }
 
       rv = SplitAsNeeded(*nsGkAtoms::div, curParent, offset);
       NS_ENSURE_SUCCESS(rv, rv);
       curDiv = mHTMLEditor->CreateNode(nsGkAtoms::div, curParent, offset);
       NS_ENSURE_STATE(curDiv);
@@ -6255,17 +6259,17 @@ HTMLEditRules::ReturnInParagraph(Selecti
           TextEditUtils::HasMozAttr(GetAsDOMNode(sibling))) {
         NS_ENSURE_STATE(mHTMLEditor);
         newBRneeded = true;
         offset++;
       }
     } else {
       if (doesCRCreateNewP) {
         nsCOMPtr<nsIDOMNode> tmp;
-        res = mEditor->SplitNode(aNode, aOffset, getter_AddRefs(tmp));
+        res = mTextEditor->SplitNode(aNode, aOffset, getter_AddRefs(tmp));
         NS_ENSURE_SUCCESS(res, res);
         selNode = tmp;
       }
 
       newBRneeded = true;
       offset++;
     }
   } else {
@@ -6483,17 +6487,17 @@ HTMLEditRules::ReturnInListItem(Selectio
           nsCOMPtr<nsINode> list = aListItem.GetParentNode();
           int32_t itemOffset = list ? list->IndexOf(&aListItem) : -1;
 
           nsIAtom* listAtom = nodeAtom == nsGkAtoms::dt ? nsGkAtoms::dd
                                                         : nsGkAtoms::dt;
           nsCOMPtr<Element> newListItem =
             mHTMLEditor->CreateNode(listAtom, list, itemOffset + 1);
           NS_ENSURE_STATE(newListItem);
-          res = mEditor->DeleteNode(&aListItem);
+          res = mTextEditor->DeleteNode(&aListItem);
           NS_ENSURE_SUCCESS(res, res);
           res = aSelection.Collapse(newListItem, 0);
           NS_ENSURE_SUCCESS(res, res);
 
           return NS_OK;
         }
 
         nsCOMPtr<Element> brNode;
@@ -8733,17 +8737,17 @@ HTMLEditRules::DocumentModifiedWorker()
   RefPtr<Selection> selection = mHTMLEditor->GetSelection();
   if (!selection) {
     return;
   }
 
   // Delete our bogus node, if we have one, since the document might not be
   // empty any more.
   if (mBogusNode) {
-    mEditor->DeleteNode(mBogusNode);
+    mTextEditor->DeleteNode(mBogusNode);
     mBogusNode = nullptr;
   }
 
   // Try to recreate the bogus node if needed.
   CreateBogusNodeIfNeeded(selection);
 }
 
 } // namespace mozilla
--- a/editor/libeditor/HTMLEditRules.h
+++ b/editor/libeditor/HTMLEditRules.h
@@ -20,23 +20,23 @@
 
 class nsIAtom;
 class nsIDOMCharacterData;
 class nsIDOMDocument;
 class nsIDOMElement;
 class nsIDOMNode;
 class nsIEditor;
 class nsINode;
-class nsPlaintextEditor;
 class nsRange;
 
 namespace mozilla {
 
 class HTMLEditor;
 class RulesInfo;
+class TextEditor;
 struct EditorDOMPoint;
 namespace dom {
 class Element;
 class Selection;
 } // namespace dom
 
 struct StyleCache final : public PropItem
 {
@@ -71,17 +71,17 @@ class HTMLEditRules : public TextEditRul
 {
 public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(HTMLEditRules, TextEditRules)
 
   HTMLEditRules();
 
   // nsIEditRules methods
-  NS_IMETHOD Init(nsPlaintextEditor* aTextEditor) override;
+  NS_IMETHOD Init(TextEditor* aTextEditor) override;
   NS_IMETHOD DetachEditor() override;
   NS_IMETHOD BeforeEdit(EditAction action,
                         nsIEditor::EDirection aDirection) override;
   NS_IMETHOD AfterEdit(EditAction action,
                        nsIEditor::EDirection aDirection) override;
   NS_IMETHOD WillDoAction(Selection* aSelection, RulesInfo* aInfo,
                           bool* aCancel, bool* aHandled) override;
   NS_IMETHOD DidDoAction(Selection* aSelection, RulesInfo* aInfo,
--- a/editor/libeditor/HTMLEditor.cpp
+++ b/editor/libeditor/HTMLEditor.cpp
@@ -89,17 +89,17 @@ IsLinkTag(const nsString& s)
 
 static bool
 IsNamedAnchorTag(const nsString& s)
 {
   return s.EqualsIgnoreCase("anchor") || s.EqualsIgnoreCase("namedanchor");
 }
 
 HTMLEditor::HTMLEditor()
-  : nsPlaintextEditor()
+  : TextEditor()
   , mCRInParagraphCreatesParagraph(false)
   , mCSSAware(false)
   , mSelectedCellIndex(0)
   , mIsObjectResizingEnabled(true)
   , mIsResizing(false)
   , mPreserveRatio(false)
   , mResizedObjectIsAnImage(false)
   , mIsAbsolutelyPositioningEnabled(true)
@@ -189,24 +189,24 @@ HTMLEditor::HideAnonymousEditingUIs()
   if (mInlineEditedCell)
     HideInlineTableEditingUI();
   if (mResizedObject)
     HideResizers();
 }
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(HTMLEditor)
 
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(HTMLEditor, nsPlaintextEditor)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(HTMLEditor, TextEditor)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mTypeInState)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mStyleSheets)
 
   tmp->HideAnonymousEditingUIs();
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(HTMLEditor, nsPlaintextEditor)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(HTMLEditor, TextEditor)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTypeInState)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mStyleSheets)
 
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopLeftHandle)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopHandle)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mTopRightHandle)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mLeftHandle)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRightHandle)
@@ -242,17 +242,17 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_
   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)
   NS_INTERFACE_MAP_ENTRY(nsICSSLoaderObserver)
   NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
-NS_INTERFACE_MAP_END_INHERITING(nsPlaintextEditor)
+NS_INTERFACE_MAP_END_INHERITING(TextEditor)
 
 NS_IMETHODIMP
 HTMLEditor::Init(nsIDOMDocument* aDoc,
                  nsIContent* aRoot,
                  nsISelectionController* aSelCon,
                  uint32_t aFlags,
                  const nsAString& aInitialValue)
 {
@@ -263,17 +263,17 @@ HTMLEditor::Init(nsIDOMDocument* aDoc,
   nsresult result = NS_OK, rulesRes = NS_OK;
 
   if (1)
   {
     // block to scope AutoEditInitRulesTrigger
     AutoEditInitRulesTrigger rulesTrigger(this, rulesRes);
 
     // Init the plaintext editor
-    result = nsPlaintextEditor::Init(aDoc, aRoot, nullptr, aFlags, aInitialValue);
+    result = TextEditor::Init(aDoc, aRoot, nullptr, aFlags, aInitialValue);
     if (NS_FAILED(result)) { return result; }
 
     // Init mutation observer
     nsCOMPtr<nsINode> document = do_QueryInterface(aDoc);
     document->AddMutationObserverUnlessExists(this);
 
     // disable Composer-only features
     if (IsMailEditor())
@@ -342,17 +342,17 @@ HTMLEditor::PreDestroy(bool aDestroyingF
   {
     RemoveOverrideStyleSheet(mStyleSheetURLs[0]);
   }
 
   // Clean up after our anonymous content -- we don't want these nodes to
   // stay around (which they would, since the frames have an owning reference).
   HideAnonymousEditingUIs();
 
-  return nsPlaintextEditor::PreDestroy(aDestroyingFrames);
+  return TextEditor::PreDestroy(aDestroyingFrames);
 }
 
 NS_IMETHODIMP
 HTMLEditor::GetRootElement(nsIDOMElement** aRootElement)
 {
   NS_ENSURE_ARG_POINTER(aRootElement);
 
   if (mRootElement) {
@@ -492,23 +492,23 @@ HTMLEditor::RemoveEventListeners()
       target->RemoveEventListener(NS_LITERAL_STRING("resize"),
                                   mResizeEventListenerP, false);
     }
   }
 
   mMouseMotionListenerP = nullptr;
   mResizeEventListenerP = nullptr;
 
-  nsPlaintextEditor::RemoveEventListeners();
+  TextEditor::RemoveEventListeners();
 }
 
 NS_IMETHODIMP
 HTMLEditor::SetFlags(uint32_t aFlags)
 {
-  nsresult rv = nsPlaintextEditor::SetFlags(aFlags);
+  nsresult rv = TextEditor::SetFlags(aFlags);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Sets mCSSAware to correspond to aFlags. This toggles whether CSS is
   // used to style elements in the editor. Note that the editor is only CSS
   // aware by default in Composer and in the mail editor.
   mCSSAware = !NoCSS() && !IsMailEditor();
 
   return NS_OK;
@@ -516,17 +516,17 @@ HTMLEditor::SetFlags(uint32_t aFlags)
 
 NS_IMETHODIMP
 HTMLEditor::InitRules()
 {
   if (!mRules) {
     // instantiate the rules for the html editor
     mRules = new HTMLEditRules();
   }
-  return mRules->Init(static_cast<nsPlaintextEditor*>(this));
+  return mRules->Init(static_cast<TextEditor*>(this));
 }
 
 NS_IMETHODIMP
 HTMLEditor::BeginningOfDocument()
 {
   if (!mDocWeak) {
     return NS_ERROR_NOT_INITIALIZED;
   }
@@ -605,17 +605,17 @@ 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
-    // bypass nsPlaintextEditor.
+    // bypass TextEditor.
     return nsEditor::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");
@@ -624,23 +624,23 @@ HTMLEditor::HandleKeyPressEvent(nsIDOMKe
     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
-      // nsPlaintextEditor.
+      // TextEditor.
       return nsEditor::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 nsPlaintextEditor.
-        return nsPlaintextEditor::HandleKeyPressEvent(aKeyEvent);
+        // text, should be handled on TextEditor.
+        return TextEditor::HandleKeyPressEvent(aKeyEvent);
       }
 
       if (IsTabbable()) {
         return NS_OK; // let it be used for focus switching
       }
 
       if (nativeKeyEvent->IsControl() || nativeKeyEvent->IsAlt() ||
           nativeKeyEvent->IsMeta() || nativeKeyEvent->IsOS()) {
@@ -1041,17 +1041,17 @@ HTMLEditor::TypedText(const nsAString& a
   AutoPlaceHolderBatch batch(this, nsGkAtoms::TypingTxnName);
 
   if (aAction == eTypedBR) {
     // only inserts a br node
     nsCOMPtr<nsIDOMNode> brNode;
     return InsertBR(address_of(brNode));
   }
 
-  return nsPlaintextEditor::TypedText(aString, aAction);
+  return TextEditor::TypedText(aString, aAction);
 }
 
 NS_IMETHODIMP
 HTMLEditor::TabInTable(bool inIsShift,
                        bool* outHandled)
 {
   NS_ENSURE_TRUE(outHandled, NS_ERROR_NULL_POINTER);
   *outHandled = false;
@@ -5278,17 +5278,17 @@ HTMLEditor::GetInputEventTargetContent()
 {
   nsCOMPtr<nsIContent> target = GetActiveEditingHost();
   return target.forget();
 }
 
 bool
 HTMLEditor::IsEditable(nsINode* aNode)
 {
-  if (!nsPlaintextEditor::IsEditable(aNode)) {
+  if (!TextEditor::IsEditable(aNode)) {
     return false;
   }
   if (aNode->IsElement()) {
     // If we're dealing with an element, then ask it whether it's editable.
     return aNode->IsEditable();
   }
   // We might be dealing with a text node for example, which we always consider
   // to be editable.
--- a/editor/libeditor/HTMLEditor.h
+++ b/editor/libeditor/HTMLEditor.h
@@ -2,16 +2,17 @@
 /* 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 HTMLEditor_h_
 #define HTMLEditor_h_
 
 #include "CSSEditUtils.h"
+#include "TextEditor.h"
 
 #include "mozilla/Attributes.h"
 #include "mozilla/StyleSheetHandle.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/File.h"
 
 #include "nsAttrName.h"
 #include "nsAutoPtr.h"
@@ -28,17 +29,16 @@
 #include "nsIEditRules.h"
 #include "nsIHTMLAbsPosEditor.h"
 #include "nsIHTMLEditor.h"
 #include "nsIHTMLInlineTableEditor.h"
 #include "nsIHTMLObjectResizeListener.h"
 #include "nsIHTMLObjectResizer.h"
 #include "nsISelectionListener.h"
 #include "nsITableEditor.h"
-#include "nsPlaintextEditor.h"
 #include "nsPoint.h"
 #include "nsStubMutationObserver.h"
 #include "nsTArray.h"
 
 class nsDocumentFragment;
 class nsIDOMKeyEvent;
 class nsITransferable;
 class nsIClipboard;
@@ -62,17 +62,17 @@ class DocumentFragment;
 namespace widget {
 struct IMEState;
 } // namespace widget
 
 /**
  * The HTML editor implementation.<br>
  * Use to edit HTML document represented as a DOM tree.
  */
-class HTMLEditor final : public nsPlaintextEditor
+class HTMLEditor final : public TextEditor
                        , public nsIHTMLEditor
                        , public nsIHTMLObjectResizer
                        , public nsIHTMLAbsPosEditor
                        , public nsITableEditor
                        , public nsIHTMLInlineTableEditor
                        , public nsIEditorStyleSheets
                        , public nsICSSLoaderObserver
                        , public nsStubMutationObserver
@@ -92,24 +92,24 @@ public:
   {
     kX      = 0,
     kY      = 1,
     kWidth  = 2,
     kHeight = 3
   };
 
   NS_DECL_ISUPPORTS_INHERITED
-  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(HTMLEditor, nsPlaintextEditor)
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(HTMLEditor, TextEditor)
 
   HTMLEditor();
 
   bool GetReturnInParagraphCreatesNewParagraph();
   Element* GetSelectionContainer();
 
-  // nsPlaintextEditor overrides
+  // TextEditor overrides
   NS_IMETHOD GetIsDocumentEditable(bool* aIsDocumentEditable) override;
   NS_IMETHOD BeginningOfDocument() override;
   virtual nsresult HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent) override;
   virtual already_AddRefed<nsIContent> GetFocusedContent() override;
   virtual already_AddRefed<nsIContent> GetFocusedContentForIME() override;
   virtual bool IsActiveInDOMWindow() override;
   virtual already_AddRefed<dom::EventTarget> GetDOMEventTarget() override;
   virtual Element* GetEditorRoot() override;
--- a/editor/libeditor/HTMLEditorDataTransfer.cpp
+++ b/editor/libeditor/HTMLEditorDataTransfer.cpp
@@ -6,16 +6,17 @@
 
 #include "HTMLEditor.h"
 
 #include <string.h>
 
 #include "EditorUtils.h"
 #include "HTMLEditUtils.h"
 #include "SelectionState.h"
+#include "TextEditor.h"
 #include "TextEditUtils.h"
 #include "WSRunObject.h"
 #include "mozilla/dom/DataTransfer.h"
 #include "mozilla/dom/DocumentFragment.h"
 #include "mozilla/dom/DOMStringList.h"
 #include "mozilla/OwningNonNull.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/Base64.h"
@@ -67,17 +68,16 @@
 #include "nsISupportsPrimitives.h"
 #include "nsISupportsUtils.h"
 #include "nsITransferable.h"
 #include "nsIURI.h"
 #include "nsIVariant.h"
 #include "nsLinebreakConverter.h"
 #include "nsLiteralString.h"
 #include "nsNetUtil.h"
-#include "nsPlaintextEditor.h"
 #include "nsRange.h"
 #include "nsReadableUtils.h"
 #include "nsServiceManagerUtils.h"
 #include "nsStreamUtils.h"
 #include "nsString.h"
 #include "nsStringFwd.h"
 #include "nsStringIterator.h"
 #include "nsSubstringTuple.h"
@@ -1551,19 +1551,19 @@ HTMLEditor::PasteNoFormatting(int32_t aS
   ForceCompositionEnd();
 
   // Get Clipboard Service
   nsresult rv;
   nsCOMPtr<nsIClipboard> clipboard(do_GetService("@mozilla.org/widget/clipboard;1", &rv));
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Get the nsITransferable interface for getting the data from the clipboard.
-  // use nsPlaintextEditor::PrepareTransferable() to force unicode plaintext data.
+  // use TextEditor::PrepareTransferable() to force unicode plaintext data.
   nsCOMPtr<nsITransferable> trans;
-  rv = nsPlaintextEditor::PrepareTransferable(getter_AddRefs(trans));
+  rv = TextEditor::PrepareTransferable(getter_AddRefs(trans));
   if (NS_SUCCEEDED(rv) && trans)
   {
     // Get the Data from the clipboard
     if (NS_SUCCEEDED(clipboard->GetData(trans, aSelectionType)) && IsModifiable())
     {
       const nsAFlatString& empty = EmptyString();
       rv = InsertFromTransferable(trans, nullptr, empty, empty, false, nullptr, 0,
                                   true);
@@ -1857,17 +1857,17 @@ HTMLEditor::InsertAsQuotation(const nsAS
     return InsertAsPlaintextQuotation(aQuotedText, true, aNodeInserted);
 
   nsAutoString citation;
   return InsertAsCitedQuotation(aQuotedText, citation, false,
                                 aNodeInserted);
 }
 
 // Insert plaintext as a quotation, with cite marks (e.g. "> ").
-// This differs from its corresponding method in nsPlaintextEditor
+// This differs from its corresponding method in TextEditor
 // in that here, quoted material is enclosed in a <pre> tag
 // in order to preserve the original line wrapping.
 NS_IMETHODIMP
 HTMLEditor::InsertAsPlaintextQuotation(const nsAString& aQuotedText,
                                        bool aAddCites,
                                        nsIDOMNode** aNodeInserted)
 {
   // get selection
@@ -1905,19 +1905,19 @@ HTMLEditor::InsertAsPlaintextQuotation(c
     newNode->SetAttr(kNameSpaceID_None, nsGkAtoms::style,
                      NS_LITERAL_STRING("white-space: pre-wrap;"), true);
 
     // and set the selection inside it:
     selection->Collapse(newNode, 0);
   }
 
   if (aAddCites)
-    rv = nsPlaintextEditor::InsertAsQuotation(aQuotedText, aNodeInserted);
+    rv = TextEditor::InsertAsQuotation(aQuotedText, aNodeInserted);
   else
-    rv = nsPlaintextEditor::InsertText(aQuotedText);
+    rv = TextEditor::InsertText(aQuotedText);
   // Note that if !aAddCites, aNodeInserted isn't set.
   // That's okay because the routines that use aAddCites
   // don't need to know the inserted node.
 
   if (aNodeInserted && NS_SUCCEEDED(rv))
   {
     *aNodeInserted = GetAsDOMNode(newNode);
     NS_IF_ADDREF(*aNodeInserted);
@@ -1933,23 +1933,23 @@ HTMLEditor::InsertAsPlaintextQuotation(c
     }
   }
   return rv;
 }
 
 NS_IMETHODIMP
 HTMLEditor::StripCites()
 {
-  return nsPlaintextEditor::StripCites();
+  return TextEditor::StripCites();
 }
 
 NS_IMETHODIMP
 HTMLEditor::Rewrap(bool aRespectNewlines)
 {
-  return nsPlaintextEditor::Rewrap(aRespectNewlines);
+  return TextEditor::Rewrap(aRespectNewlines);
 }
 
 NS_IMETHODIMP
 HTMLEditor::InsertAsCitedQuotation(const nsAString& aQuotedText,
                                    const nsAString& aCitation,
                                    bool aInsertHTML,
                                    nsIDOMNode** aNodeInserted)
 {
--- a/editor/libeditor/TextEditRules.cpp
+++ b/editor/libeditor/TextEditRules.cpp
@@ -1,16 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "TextEditRules.h"
 
 #include "EditorUtils.h"
+#include "TextEditor.h"
 #include "TextEditUtils.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/LookAndFeel.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/TextComposition.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/NodeIterator.h"
 #include "mozilla/dom/Selection.h"
@@ -33,17 +34,16 @@
 #include "nsIDOMNodeIterator.h"
 #include "nsIDOMNodeList.h"
 #include "nsIDOMText.h"
 #include "nsNameSpaceManager.h"
 #include "nsINode.h"
 #include "nsIPlaintextEditor.h"
 #include "nsISupportsBase.h"
 #include "nsLiteralString.h"
-#include "nsPlaintextEditor.h"
 #include "nsUnicharUtils.h"
 
 namespace mozilla {
 
 using namespace dom;
 
 #define CANCEL_OPERATION_IF_READONLY_OR_DISABLED \
   if (IsReadonly() || IsDisabled()) \
@@ -52,33 +52,33 @@ using namespace dom;
     return NS_OK;       \
   };
 
 /********************************************************
  * mozilla::TextEditRules
  ********************************************************/
 
 TextEditRules::TextEditRules()
-  : mEditor(nullptr)
+  : mTextEditor(nullptr)
   , mPasswordIMEIndex(0)
   , mCachedSelectionOffset(0)
   , mActionNesting(0)
   , mLockRulesSniffing(false)
   , mDidExplicitlySetInterline(false)
   , mDeleteBidiImmediately(false)
   , mLastStart(0)
   , mLastLength(0)
 {
   InitFields();
 }
 
 void
 TextEditRules::InitFields()
 {
-  mEditor = nullptr;
+  mTextEditor = nullptr;
   mPasswordText.Truncate();
   mPasswordIMEText.Truncate();
   mPasswordIMEIndex = 0;
   mBogusNode = nullptr;
   mCachedSelectionNode = nullptr;
   mCachedSelectionOffset = 0;
   mActionNesting = 0;
   mLockRulesSniffing = false;
@@ -87,17 +87,18 @@ TextEditRules::InitFields()
   mTheAction = EditAction::none;
   mTimer = nullptr;
   mLastStart = 0;
   mLastLength = 0;
 }
 
 TextEditRules::~TextEditRules()
 {
-   // do NOT delete mEditor here.  We do not hold a ref count to mEditor.  mEditor owns our lifespan.
+   // do NOT delete mTextEditor here.  We do not hold a ref count to
+   // mTextEditor.  mTextEditor owns our lifespan.
 
   if (mTimer)
     mTimer->Cancel();
 }
 
 NS_IMPL_CYCLE_COLLECTION(TextEditRules, mBogusNode, mCachedSelectionNode)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(TextEditRules)
@@ -105,41 +106,41 @@ NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(
   NS_INTERFACE_MAP_ENTRY(nsITimerCallback)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIEditRules)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(TextEditRules)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(TextEditRules)
 
 NS_IMETHODIMP
-TextEditRules::Init(nsPlaintextEditor* aTextEditor)
+TextEditRules::Init(TextEditor* aTextEditor)
 {
   if (!aTextEditor) {
     return NS_ERROR_NULL_POINTER;
   }
 
   InitFields();
 
   // We hold a non-refcounted reference back to our editor.
-  mEditor = aTextEditor;
-  RefPtr<Selection> selection = mEditor->GetSelection();
+  mTextEditor = aTextEditor;
+  RefPtr<Selection> selection = mTextEditor->GetSelection();
   NS_WARN_IF_FALSE(selection, "editor cannot get selection");
 
   // Put in a magic br if needed. This method handles null selection,
   // which should never happen anyway
   nsresult res = CreateBogusNodeIfNeeded(selection);
   NS_ENSURE_SUCCESS(res, res);
 
   // If the selection hasn't been set up yet, set it up collapsed to the end of
   // our editable content.
   int32_t rangeCount;
   res = selection->GetRangeCount(&rangeCount);
   NS_ENSURE_SUCCESS(res, res);
   if (!rangeCount) {
-    res = mEditor->EndOfDocument();
+    res = mTextEditor->EndOfDocument();
     NS_ENSURE_SUCCESS(res, res);
   }
 
   if (IsPlaintextEditor())
   {
     // ensure trailing br node
     res = CreateTrailingBRIfNeeded();
     NS_ENSURE_SUCCESS(res, res);
@@ -161,17 +162,17 @@ TextEditRules::SetInitialValue(const nsA
 }
 
 NS_IMETHODIMP
 TextEditRules::DetachEditor()
 {
   if (mTimer)
     mTimer->Cancel();
 
-  mEditor = nullptr;
+  mTextEditor = nullptr;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 TextEditRules::BeforeEdit(EditAction action,
                           nsIEditor::EDirection aDirection)
 {
   if (mLockRulesSniffing) return NS_OK;
@@ -181,18 +182,18 @@ TextEditRules::BeforeEdit(EditAction act
   if (!mActionNesting)
   {
     // let rules remember the top level action
     mTheAction = action;
   }
   mActionNesting++;
 
   // get the selection and cache the position before editing
-  NS_ENSURE_STATE(mEditor);
-  RefPtr<Selection> selection = mEditor->GetSelection();
+  NS_ENSURE_STATE(mTextEditor);
+  RefPtr<Selection> selection = mTextEditor->GetSelection();
   NS_ENSURE_STATE(selection);
 
   selection->GetAnchorNode(getter_AddRefs(mCachedSelectionNode));
   selection->GetAnchorOffset(&mCachedSelectionOffset);
 
   return NS_OK;
 }
 
@@ -203,24 +204,25 @@ TextEditRules::AfterEdit(EditAction acti
   if (mLockRulesSniffing) return NS_OK;
 
   AutoLockRulesSniffing lockIt(this);
 
   NS_PRECONDITION(mActionNesting>0, "bad action nesting!");
   nsresult res = NS_OK;
   if (!--mActionNesting)
   {
-    NS_ENSURE_STATE(mEditor);
-    RefPtr<Selection> selection = mEditor->GetSelection();
+    NS_ENSURE_STATE(mTextEditor);
+    RefPtr<Selection> selection = mTextEditor->GetSelection();
     NS_ENSURE_STATE(selection);
 
-    NS_ENSURE_STATE(mEditor);
-    res = mEditor->HandleInlineSpellCheck(action, selection,
-                                          mCachedSelectionNode, mCachedSelectionOffset,
-                                          nullptr, 0, nullptr, 0);
+    NS_ENSURE_STATE(mTextEditor);
+    res = mTextEditor->HandleInlineSpellCheck(action, selection,
+                                              mCachedSelectionNode,
+                                              mCachedSelectionOffset,
+                                              nullptr, 0, nullptr, 0);
     NS_ENSURE_SUCCESS(res, res);
 
     // if only trailing <br> remaining remove it
     res = RemoveRedundantTrailingBR();
     if (NS_FAILED(res))
       return res;
 
     // detect empty doc
@@ -285,20 +287,20 @@ TextEditRules::WillDoAction(Selection* a
   }
 }
 
 NS_IMETHODIMP
 TextEditRules::DidDoAction(Selection* aSelection,
                            RulesInfo* aInfo,
                            nsresult aResult)
 {
-  NS_ENSURE_STATE(mEditor);
+  NS_ENSURE_STATE(mTextEditor);
   // don't let any txns in here move the selection around behind our back.
   // Note that this won't prevent explicit selection setting from working.
-  AutoTransactionsConserveSelection dontSpazMySelection(mEditor);
+  AutoTransactionsConserveSelection dontSpazMySelection(mTextEditor);
 
   NS_ENSURE_TRUE(aSelection && aInfo, NS_ERROR_NULL_POINTER);
 
   // my kingdom for dynamic cast
   TextRulesInfo* info = static_cast<TextRulesInfo*>(aInfo);
 
   switch (info->action)
   {
@@ -344,18 +346,18 @@ TextEditRules::WillInsert(Selection& aSe
     return;
   }
 
   // initialize out param
   *aCancel = false;
 
   // check for the magic content node and delete it if it exists
   if (mBogusNode) {
-    NS_ENSURE_TRUE_VOID(mEditor);
-    mEditor->DeleteNode(mBogusNode);
+    NS_ENSURE_TRUE_VOID(mTextEditor);
+    mTextEditor->DeleteNode(mBogusNode);
     mBogusNode = nullptr;
   }
 }
 
 nsresult
 TextEditRules::DidInsert(Selection* aSelection,
                          nsresult aResult)
 {
@@ -392,18 +394,18 @@ TextEditRules::WillInsertBreak(Selection
     *aCancel = false;
 
     // if the selection isn't collapsed, delete it.
     bool bCollapsed;
     res = aSelection->GetIsCollapsed(&bCollapsed);
     NS_ENSURE_SUCCESS(res, res);
     if (!bCollapsed)
     {
-      NS_ENSURE_STATE(mEditor);
-      res = mEditor->DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip);
+      NS_ENSURE_STATE(mTextEditor);
+      res = mTextEditor->DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip);
       NS_ENSURE_SUCCESS(res, res);
     }
 
     WillInsert(*aSelection, aCancel);
     // initialize out param
     // we want to ignore result of WillInsert()
     *aCancel = false;
 
@@ -423,54 +425,55 @@ TextEditRules::CollapseSelectionToTraili
 {
   // we only need to execute the stuff below if we are a plaintext editor.
   // html editors have a different mechanism for putting in mozBR's
   // (because there are a bunch more places you have to worry about it in html)
   if (!IsPlaintextEditor()) {
     return NS_OK;
   }
 
-  NS_ENSURE_STATE(mEditor);
+  NS_ENSURE_STATE(mTextEditor);
 
   // If there is no selection ranges, we should set to the end of the editor.
   // This is usually performed in TextEditRules::Init(), however, if the
   // editor is reframed, this may be called by AfterEdit().
   if (!aSelection->RangeCount()) {
-    mEditor->EndOfDocument();
+    mTextEditor->EndOfDocument();
   }
 
   // if we are at the end of the textarea, we need to set the
   // selection to stick to the mozBR at the end of the textarea.
   int32_t selOffset;
   nsCOMPtr<nsIDOMNode> selNode;
   nsresult res;
-  res = mEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode), &selOffset);
+  res = mTextEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(selNode),
+                                           &selOffset);
   NS_ENSURE_SUCCESS(res, res);
 
   nsCOMPtr<nsIDOMText> nodeAsText = do_QueryInterface(selNode);
   if (!nodeAsText) return NS_OK; // nothing to do if we're not at a text node
 
   uint32_t length;
   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);
 
-  NS_ENSURE_STATE(mEditor);
-  nsCOMPtr<nsIDOMNode> root = do_QueryInterface(mEditor->GetRoot());
+  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 = mEditor->GetChildAt(parentNode,
-                                                      parentOffset + 1);
+  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>
@@ -492,34 +495,34 @@ GetTextNode(Selection* selection, nsEdit
         return nullptr;
       }
     }
   }
   return selNode.forget();
 }
 #ifdef DEBUG
 #define ASSERT_PASSWORD_LENGTHS_EQUAL()                                \
-  if (IsPasswordEditor() && mEditor->GetRoot()) {                      \
+  if (IsPasswordEditor() && mTextEditor->GetRoot()) {                  \
     int32_t txtLen;                                                    \
-    mEditor->GetTextLength(&txtLen);                                   \
+    mTextEditor->GetTextLength(&txtLen);                               \
     NS_ASSERTION(mPasswordText.Length() == uint32_t(txtLen),           \
                  "password length not equal to number of asterisks");  \
   }
 #else
 #define ASSERT_PASSWORD_LENGTHS_EQUAL()
 #endif
 
 // static
 void
 TextEditRules::HandleNewLines(nsString& aString,
                               int32_t aNewlineHandling)
 {
   if (aNewlineHandling < 0) {
     int32_t caretStyle;
-    nsPlaintextEditor::GetDefaultEditorPrefs(aNewlineHandling, caretStyle);
+    TextEditor::GetDefaultEditorPrefs(aNewlineHandling, caretStyle);
   }
 
   switch(aNewlineHandling)
   {
   case nsIPlaintextEditor::eNewlinesReplaceWithSpaces:
     // Strip trailing newlines first so we don't wind up with trailing spaces
     aString.Trim(CRLF, false, true);
     aString.ReplaceChar(CRLF, ' ');
@@ -619,29 +622,30 @@ TextEditRules::WillInsertText(EditAction
     return NS_OK;
   }
 
   int32_t start = 0;
   int32_t end = 0;
 
   // handle password field docs
   if (IsPasswordEditor()) {
-    NS_ENSURE_STATE(mEditor);
-    nsContentUtils::GetSelectionInTextControl(aSelection, mEditor->GetRoot(),
+    NS_ENSURE_STATE(mTextEditor);
+    nsContentUtils::GetSelectionInTextControl(aSelection,
+                                              mTextEditor->GetRoot(),
                                               start, end);
   }
 
   // if the selection isn't collapsed, delete it.
   bool bCollapsed;
   res = aSelection->GetIsCollapsed(&bCollapsed);
   NS_ENSURE_SUCCESS(res, res);
   if (!bCollapsed)
   {
-    NS_ENSURE_STATE(mEditor);
-    res = mEditor->DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip);
+    NS_ENSURE_STATE(mTextEditor);
+    res = mTextEditor->DeleteSelection(nsIEditor::eNone, nsIEditor::eStrip);
     NS_ENSURE_SUCCESS(res, res);
   }
 
   WillInsert(*aSelection, aCancel);
   // initialize out param
   // we want to ignore result of WillInsert()
   *aCancel = false;
 
@@ -664,18 +668,18 @@ TextEditRules::WillInsertText(EditAction
   // 3. strip newlines
   // 4. replace with commas
   // 5. strip newlines and surrounding whitespace
   // So find out what we're expected to do:
   if (IsSingleLineEditor())
   {
     nsAutoString tString(*outString);
 
-    NS_ENSURE_STATE(mEditor);
-    HandleNewLines(tString, mEditor->mNewlineHandling);
+    NS_ENSURE_STATE(mTextEditor);
+    HandleNewLines(tString, mTextEditor->mNewlineHandling);
 
     outString->Assign(tString);
   }
 
   if (IsPasswordEditor())
   {
     // manage the password buffer
     mPasswordText.Insert(*outString, start);
@@ -704,50 +708,52 @@ TextEditRules::WillInsertText(EditAction
 
   // get the (collapsed) selection location
   NS_ENSURE_STATE(aSelection->GetRangeAt(0));
   nsCOMPtr<nsINode> selNode = aSelection->GetRangeAt(0)->GetStartParent();
   int32_t selOffset = aSelection->GetRangeAt(0)->StartOffset();
   NS_ENSURE_STATE(selNode);
 
   // don't put text in places that can't have it
-  NS_ENSURE_STATE(mEditor);
-  if (!mEditor->IsTextNode(selNode) &&
-      !mEditor->CanContainTag(*selNode, *nsGkAtoms::textTagName)) {
+  NS_ENSURE_STATE(mTextEditor);
+  if (!mTextEditor->IsTextNode(selNode) &&
+      !mTextEditor->CanContainTag(*selNode, *nsGkAtoms::textTagName)) {
     return NS_ERROR_FAILURE;
   }
 
   // we need to get the doc
-  NS_ENSURE_STATE(mEditor);
-  nsCOMPtr<nsIDocument> doc = mEditor->GetDocument();
+  NS_ENSURE_STATE(mTextEditor);
+  nsCOMPtr<nsIDocument> doc = mTextEditor->GetDocument();
   NS_ENSURE_TRUE(doc, NS_ERROR_NOT_INITIALIZED);
 
   if (aAction == EditAction::insertIMEText) {
-    NS_ENSURE_STATE(mEditor);
+    NS_ENSURE_STATE(mTextEditor);
     // Find better insertion point to insert text.
-    mEditor->FindBetterInsertionPoint(selNode, selOffset);
+    mTextEditor->FindBetterInsertionPoint(selNode, selOffset);
     // If there is one or more IME selections, its minimum offset should be
     // the insertion point.
-    int32_t IMESelectionOffset = mEditor->GetIMESelectionStartOffsetIn(selNode);
+    int32_t IMESelectionOffset =
+      mTextEditor->GetIMESelectionStartOffsetIn(selNode);
     if (IMESelectionOffset >= 0) {
       selOffset = IMESelectionOffset;
     }
-    res = mEditor->InsertTextImpl(*outString, address_of(selNode), &selOffset, doc);
+    res = mTextEditor->InsertTextImpl(*outString, address_of(selNode),
+                                      &selOffset, doc);
     NS_ENSURE_SUCCESS(res, res);
   } else {
     // aAction == EditAction::insertText; find where we are
     nsCOMPtr<nsINode> curNode = selNode;
     int32_t curOffset = selOffset;
 
     // don't spaz my selection in subtransactions
-    NS_ENSURE_STATE(mEditor);
-    AutoTransactionsConserveSelection dontSpazMySelection(mEditor);
+    NS_ENSURE_STATE(mTextEditor);
+    AutoTransactionsConserveSelection dontSpazMySelection(mTextEditor);
 
-    res = mEditor->InsertTextImpl(*outString, address_of(curNode),
-                                  &curOffset, doc);
+    res = mTextEditor->InsertTextImpl(*outString, address_of(curNode),
+                                      &curOffset, doc);
     NS_ENSURE_SUCCESS(res, res);
 
     if (curNode)
     {
       // Make the caret attach to the inserted text, unless this text ends with a LF,
       // in which case make the caret attach to the next line.
       bool endsWithLF =
         !outString->IsEmpty() && outString->Last() == nsCRT::LF;
@@ -840,23 +846,24 @@ TextEditRules::WillDeleteSelection(Selec
   // batch the selectionchange events, such that a single event fires after
   // the AutoHideSelectionChanges destructor has been run.
   SelectionBatcher selectionBatcher(aSelection);
   AutoHideSelectionChanges hideSelection(aSelection);
   nsAutoScriptBlocker scriptBlocker;
 
   if (IsPasswordEditor())
   {
-    NS_ENSURE_STATE(mEditor);
-    res = mEditor->ExtendSelectionForDelete(aSelection, &aCollapsedAction);
+    NS_ENSURE_STATE(mTextEditor);
+    res = mTextEditor->ExtendSelectionForDelete(aSelection, &aCollapsedAction);
     NS_ENSURE_SUCCESS(res, res);
 
     // manage the password buffer
     int32_t start, end;
-    nsContentUtils::GetSelectionInTextControl(aSelection, mEditor->GetRoot(),
+    nsContentUtils::GetSelectionInTextControl(aSelection,
+                                              mTextEditor->GetRoot(),
                                               start, end);
 
     if (LookAndFeel::GetEchoPassword()) {
       HideLastPWInput();
       mLastStart = start;
       mLastLength = 0;
       if (mTimer)
       {
@@ -877,71 +884,74 @@ TextEditRules::WillDeleteSelection(Selec
     else {  // extended selection
       mPasswordText.Cut(start, end-start);
     }
   }
   else
   {
     nsCOMPtr<nsIDOMNode> startNode;
     int32_t startOffset;
-    NS_ENSURE_STATE(mEditor);
-    res = mEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode), &startOffset);
+    NS_ENSURE_STATE(mTextEditor);
+    res = mTextEditor->GetStartNodeAndOffset(aSelection,
+                                             getter_AddRefs(startNode),
+                                             &startOffset);
     NS_ENSURE_SUCCESS(res, res);
     NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);
 
     bool bCollapsed;
     res = aSelection->GetIsCollapsed(&bCollapsed);
     NS_ENSURE_SUCCESS(res, res);
 
     if (!bCollapsed)
       return NS_OK;
 
     // Test for distance between caret and text that will be deleted
     res = CheckBidiLevelForDeletion(aSelection, startNode, startOffset, aCollapsedAction, aCancel);
     NS_ENSURE_SUCCESS(res, res);
     if (*aCancel) return NS_OK;
 
-    NS_ENSURE_STATE(mEditor);
-    res = mEditor->ExtendSelectionForDelete(aSelection, &aCollapsedAction);
+    NS_ENSURE_STATE(mTextEditor);
+    res = mTextEditor->ExtendSelectionForDelete(aSelection, &aCollapsedAction);
     NS_ENSURE_SUCCESS(res, res);
   }
 
-  NS_ENSURE_STATE(mEditor);
-  res = mEditor->DeleteSelectionImpl(aCollapsedAction, nsIEditor::eStrip);
+  NS_ENSURE_STATE(mTextEditor);
+  res = mTextEditor->DeleteSelectionImpl(aCollapsedAction, nsIEditor::eStrip);
   NS_ENSURE_SUCCESS(res, res);
 
   *aHandled = true;
   ASSERT_PASSWORD_LENGTHS_EQUAL()
   return NS_OK;
 }
 
 nsresult
 TextEditRules::DidDeleteSelection(Selection* aSelection,
                                   nsIEditor::EDirection aCollapsedAction,
                                   nsresult aResult)
 {
   nsCOMPtr<nsIDOMNode> startNode;
   int32_t startOffset;
-  NS_ENSURE_STATE(mEditor);
-  nsresult res = mEditor->GetStartNodeAndOffset(aSelection, getter_AddRefs(startNode), &startOffset);
+  NS_ENSURE_STATE(mTextEditor);
+  nsresult res = mTextEditor->GetStartNodeAndOffset(aSelection,
+                                                    getter_AddRefs(startNode),
+                                                    &startOffset);
   NS_ENSURE_SUCCESS(res, res);
   NS_ENSURE_TRUE(startNode, NS_ERROR_FAILURE);
 
   // delete empty text nodes at selection
-  if (mEditor->IsTextNode(startNode))
-  {
+  if (mTextEditor->IsTextNode(startNode)) {
     nsCOMPtr<nsIDOMText> textNode = do_QueryInterface(startNode);
     uint32_t strLength;
     res = textNode->GetLength(&strLength);
     NS_ENSURE_SUCCESS(res, res);
 
     // are we in an empty text node?
     if (!strLength)
     {
-      res = mEditor->DeleteNode(startNode);
+      res = mTextEditor->DeleteNode(startNode);
       NS_ENSURE_SUCCESS(res, res);
     }
   }
   if (!mDidExplicitlySetInterline)
   {
     // We prevent the caret from sticking on the left of prior BR
     // (i.e. the end of previous line) after this deletion.  Bug 92124
     res = aSelection->SetInterlinePosition(true);
@@ -972,21 +982,21 @@ TextEditRules::WillUndo(Selection* aSele
 nsresult
 TextEditRules::DidUndo(Selection* aSelection,
                        nsresult aResult)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
   // If aResult is an error, we return it.
   NS_ENSURE_SUCCESS(aResult, aResult);
 
-  NS_ENSURE_STATE(mEditor);
-  dom::Element* theRoot = mEditor->GetRoot();
+  NS_ENSURE_STATE(mTextEditor);
+  dom::Element* theRoot = mTextEditor->GetRoot();
   NS_ENSURE_TRUE(theRoot, NS_ERROR_FAILURE);
-  nsIContent* node = mEditor->GetLeftmostChild(theRoot);
-  if (node && mEditor->IsMozEditorBogusNode(node)) {
+  nsIContent* node = mTextEditor->GetLeftmostChild(theRoot);
+  if (node && mTextEditor->IsMozEditorBogusNode(node)) {
     mBogusNode = do_QueryInterface(node);
   } else {
     mBogusNode = nullptr;
   }
   return aResult;
 }
 
 nsresult
@@ -1005,18 +1015,18 @@ TextEditRules::WillRedo(Selection* aSele
 nsresult
 TextEditRules::DidRedo(Selection* aSelection,
                        nsresult aResult)
 {
   nsresult res = aResult;  // if aResult is an error, we return it.
   if (!aSelection) { return NS_ERROR_NULL_POINTER; }
   if (NS_SUCCEEDED(res))
   {
-    NS_ENSURE_STATE(mEditor);
-    nsCOMPtr<nsIDOMElement> theRoot = do_QueryInterface(mEditor->GetRoot());
+    NS_ENSURE_STATE(mTextEditor);
+    nsCOMPtr<nsIDOMElement> theRoot = do_QueryInterface(mTextEditor->GetRoot());
     NS_ENSURE_TRUE(theRoot, NS_ERROR_FAILURE);
 
     nsCOMPtr<nsIDOMHTMLCollection> nodeList;
     res = theRoot->GetElementsByTagName(NS_LITERAL_STRING("br"),
                                         getter_AddRefs(nodeList));
     NS_ENSURE_SUCCESS(res, res);
     if (nodeList)
     {
@@ -1028,17 +1038,17 @@ TextEditRules::DidRedo(Selection* aSelec
         mBogusNode = nullptr;
         return NS_OK;
       }
 
       nsCOMPtr<nsIDOMNode> node;
       nodeList->Item(0, getter_AddRefs(node));
       nsCOMPtr<nsIContent> content = do_QueryInterface(node);
       MOZ_ASSERT(content);
-      if (mEditor->IsMozEditorBogusNode(content)) {
+      if (mTextEditor->IsMozEditorBogusNode(content)) {
         mBogusNode = node;
       } else {
         mBogusNode = nullptr;
       }
     }
   }
   return res;
 }
@@ -1089,18 +1099,18 @@ TextEditRules::RemoveRedundantTrailingBR
   // If the bogus node exists, we have no work to do
   if (mBogusNode)
     return NS_OK;
 
   // Likewise, nothing to be done if we could never have inserted a trailing br
   if (IsSingleLineEditor())
     return NS_OK;
 
-  NS_ENSURE_STATE(mEditor);
-  RefPtr<dom::Element> body = mEditor->GetRoot();
+  NS_ENSURE_STATE(mTextEditor);
+  RefPtr<dom::Element> body = mTextEditor->GetRoot();
   if (!body)
     return NS_ERROR_NULL_POINTER;
 
   uint32_t childCount = body->GetChildCount();
   if (childCount > 1) {
     // The trailing br is redundant if it is the only remaining child node
     return NS_OK;
   }
@@ -1131,97 +1141,99 @@ TextEditRules::RemoveRedundantTrailingBR
 nsresult
 TextEditRules::CreateTrailingBRIfNeeded()
 {
   // but only if we aren't a single line edit field
   if (IsSingleLineEditor()) {
     return NS_OK;
   }
 
-  NS_ENSURE_STATE(mEditor);
-  dom::Element* body = mEditor->GetRoot();
+  NS_ENSURE_STATE(mTextEditor);
+  dom::Element* body = mTextEditor->GetRoot();
   NS_ENSURE_TRUE(body, NS_ERROR_NULL_POINTER);
 
   nsIContent* lastChild = body->GetLastChild();
   // assuming CreateBogusNodeIfNeeded() has been called first
   NS_ENSURE_TRUE(lastChild, NS_ERROR_NULL_POINTER);
 
   if (!lastChild->IsHTMLElement(nsGkAtoms::br)) {
-    AutoTransactionsConserveSelection dontSpazMySelection(mEditor);
+    AutoTransactionsConserveSelection dontSpazMySelection(mTextEditor);
     nsCOMPtr<nsIDOMNode> domBody = do_QueryInterface(body);
     return CreateMozBR(domBody, body->Length());
   }
 
   // Check to see if the trailing BR is a former bogus node - this will have
   // stuck around if we previously morphed a trailing node into a bogus node.
-  if (!mEditor->IsMozEditorBogusNode(lastChild)) {
+  if (!mTextEditor->IsMozEditorBogusNode(lastChild)) {
     return NS_OK;
   }
 
   // Morph it back to a mozBR
   lastChild->UnsetAttr(kNameSpaceID_None, kMOZEditorBogusNodeAttrAtom, false);
   lastChild->SetAttr(kNameSpaceID_None, nsGkAtoms::type,
                      NS_LITERAL_STRING("_moz"), true);
   return NS_OK;
 }
 
 nsresult
 TextEditRules::CreateBogusNodeIfNeeded(Selection* aSelection)
 {
   NS_ENSURE_TRUE(aSelection, NS_ERROR_NULL_POINTER);
-  NS_ENSURE_TRUE(mEditor, NS_ERROR_NULL_POINTER);
+  NS_ENSURE_TRUE(mTextEditor, NS_ERROR_NULL_POINTER);
 
   if (mBogusNode) {
     // Let's not create more than one, ok?
     return NS_OK;
   }
 
   // tell rules system to not do any post-processing
-  AutoRules beginRulesSniffing(mEditor, EditAction::ignore, nsIEditor::eNone);
+  AutoRules beginRulesSniffing(mTextEditor, EditAction::ignore,
+                               nsIEditor::eNone);
 
-  nsCOMPtr<dom::Element> body = mEditor->GetRoot();
+  nsCOMPtr<dom::Element> body = mTextEditor->GetRoot();
   if (!body) {
     // We don't even have a body yet, don't insert any bogus nodes at
     // this point.
     return NS_OK;
   }
 
   // Now we've got the body element. Iterate over the body element's children,
   // looking for editable content. If no editable content is found, insert the
   // bogus node.
   for (nsCOMPtr<nsIContent> bodyChild = body->GetFirstChild();
        bodyChild;
        bodyChild = bodyChild->GetNextSibling()) {
-    if (mEditor->IsMozEditorBogusNode(bodyChild) ||
-        !mEditor->IsEditable(body) || // XXX hoist out of the loop?
-        mEditor->IsEditable(bodyChild) || mEditor->IsBlockNode(bodyChild)) {
+    if (mTextEditor->IsMozEditorBogusNode(bodyChild) ||
+        !mTextEditor->IsEditable(body) || // XXX hoist out of the loop?
+        mTextEditor->IsEditable(bodyChild) ||
+        mTextEditor->IsBlockNode(bodyChild)) {
       return NS_OK;
     }
   }
 
   // Skip adding the bogus node if body is read-only.
-  if (!mEditor->IsModifiableNode(body)) {
+  if (!mTextEditor->IsModifiableNode(body)) {
     return NS_OK;
   }
 
   // Create a br.
-  nsCOMPtr<Element> newContent = mEditor->CreateHTMLContent(nsGkAtoms::br);
+  nsCOMPtr<Element> newContent = mTextEditor->CreateHTMLContent(nsGkAtoms::br);
   NS_ENSURE_STATE(newContent);
 
   // set mBogusNode to be the newly created <br>
   mBogusNode = do_QueryInterface(newContent);
   NS_ENSURE_TRUE(mBogusNode, NS_ERROR_NULL_POINTER);
 
   // Give it a special attribute.
   newContent->SetAttr(kNameSpaceID_None, kMOZEditorBogusNodeAttrAtom,
                       kMOZEditorBogusNodeValue, false);
 
   // Put the node in the document.
   nsCOMPtr<nsIDOMNode> bodyNode = do_QueryInterface(body);
-  nsresult rv = mEditor->InsertNode(mBogusNode, bodyNode, 0);
+  nsresult rv = mTextEditor->InsertNode(mBogusNode, bodyNode, 0);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Set selection.
   aSelection->CollapseNative(body, 0);
   return NS_OK;
 }
 
 
@@ -1237,40 +1249,41 @@ TextEditRules::TruncateInsertionIfNeeded
   nsresult res = NS_OK;
   if (!aOutString->Assign(*aInString, mozilla::fallible)) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   if (aTruncated) {
     *aTruncated = false;
   }
 
-  NS_ENSURE_STATE(mEditor);
-  if ((-1 != aMaxLength) && IsPlaintextEditor() && !mEditor->IsIMEComposing() )
-  {
+  NS_ENSURE_STATE(mTextEditor);
+  if (-1 != aMaxLength && IsPlaintextEditor() &&
+      !mTextEditor->IsIMEComposing()) {
     // Get the current text length.
     // Get the length of inString.
     // Get the length of the selection.
     //   If selection is collapsed, it is length 0.
     //   Subtract the length of the selection from the len(doc)
     //   since we'll delete the selection on insert.
     //   This is resultingDocLength.
     // Get old length of IME composing string
     //   which will be replaced by new one.
     // If (resultingDocLength) is at or over max, cancel the insert
     // If (resultingDocLength) + (length of input) > max,
     //    set aOutString to subset of inString so length = max
     int32_t docLength;
-    res = mEditor->GetTextLength(&docLength);
+    res = mTextEditor->GetTextLength(&docLength);
     if (NS_FAILED(res)) { return res; }
 
     int32_t start, end;
-    nsContentUtils::GetSelectionInTextControl(aSelection, mEditor->GetRoot(),
+    nsContentUtils::GetSelectionInTextControl(aSelection,
+                                              mTextEditor->GetRoot(),
                                               start, end);
 
-    TextComposition* composition = mEditor->GetComposition();
+    TextComposition* composition = mTextEditor->GetComposition();
     int32_t oldCompStrLength = composition ? composition->String().Length() : 0;
 
     const int32_t selectionLength = end - start;
     const int32_t resultingDocLength = docLength - selectionLength - oldCompStrLength;
     if (resultingDocLength >= aMaxLength)
     {
       // This call is guaranteed to reduce the capacity of the string, so it
       // cannot cause an OOM.
@@ -1350,24 +1363,24 @@ TextEditRules::HideLastPWInput()
   if (!mLastLength) {
     // Special case, we're trying to replace a range that no longer exists
     return NS_OK;
   }
 
   nsAutoString hiddenText;
   FillBufWithPWChars(&hiddenText, mLastLength);
 
-  NS_ENSURE_STATE(mEditor);
-  RefPtr<Selection> selection = mEditor->GetSelection();
+  NS_ENSURE_STATE(mTextEditor);
+  RefPtr<Selection> selection = mTextEditor->GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
   int32_t start, end;
-  nsContentUtils::GetSelectionInTextControl(selection, mEditor->GetRoot(),
+  nsContentUtils::GetSelectionInTextControl(selection, mTextEditor->GetRoot(),
                                             start, end);
 
-  nsCOMPtr<nsIDOMNode> selNode = GetTextNode(selection, mEditor);
+  nsCOMPtr<nsIDOMNode> selNode = GetTextNode(selection, mTextEditor);
   NS_ENSURE_TRUE(selNode, NS_OK);
 
   nsCOMPtr<nsIDOMCharacterData> nodeAsText(do_QueryInterface(selNode));
   NS_ENSURE_TRUE(nodeAsText, NS_OK);
 
   nodeAsText->ReplaceData(mLastStart, mLastLength, hiddenText);
   selection->Collapse(selNode, start);
   if (start != end)
@@ -1397,24 +1410,25 @@ TextEditRules::FillBufWithPWChars(nsAStr
 nsresult
 TextEditRules::CreateMozBR(nsIDOMNode* inParent,
                            int32_t inOffset,
                            nsIDOMNode** outBRNode)
 {
   NS_ENSURE_TRUE(inParent, NS_ERROR_NULL_POINTER);
 
   nsCOMPtr<nsIDOMNode> brNode;
-  NS_ENSURE_STATE(mEditor);
-  nsresult res = mEditor->CreateBR(inParent, inOffset, address_of(brNode));
+  NS_ENSURE_STATE(mTextEditor);
+  nsresult res = mTextEditor->CreateBR(inParent, inOffset, address_of(brNode));
   NS_ENSURE_SUCCESS(res, res);
 
   // give it special moz attr
   nsCOMPtr<nsIDOMElement> brElem = do_QueryInterface(brNode);
   if (brElem) {
-    res = mEditor->SetAttribute(brElem, NS_LITERAL_STRING("type"), NS_LITERAL_STRING("_moz"));
+    res = mTextEditor->SetAttribute(brElem, NS_LITERAL_STRING("type"),
+                                    NS_LITERAL_STRING("_moz"));
     NS_ENSURE_SUCCESS(res, res);
   }
 
   if (outBRNode) {
     brNode.forget(outBRNode);
   }
   return NS_OK;
 }
@@ -1423,47 +1437,47 @@ NS_IMETHODIMP
 TextEditRules::DocumentModified()
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 bool
 TextEditRules::IsPasswordEditor() const
 {
-  return mEditor ? mEditor->IsPasswordEditor() : false;
+  return mTextEditor ? mTextEditor->IsPasswordEditor() : false;
 }
 
 bool
 TextEditRules::IsSingleLineEditor() const
 {
-  return mEditor ? mEditor->IsSingleLineEditor() : false;
+  return mTextEditor ? mTextEditor->IsSingleLineEditor() : false;
 }
 
 bool
 TextEditRules::IsPlaintextEditor() const
 {
-  return mEditor ? mEditor->IsPlaintextEditor() : false;
+  return mTextEditor ? mTextEditor->IsPlaintextEditor() : false;
 }
 
 bool
 TextEditRules::IsReadonly() const
 {
-  return mEditor ? mEditor->IsReadonly() : false;
+  return mTextEditor ? mTextEditor->IsReadonly() : false;
 }
 
 bool
 TextEditRules::IsDisabled() const
 {
-  return mEditor ? mEditor->IsDisabled() : false;
+  return mTextEditor ? mTextEditor->IsDisabled() : false;
 }
 bool
 TextEditRules::IsMailEditor() const
 {
-  return mEditor ? mEditor->IsMailEditor() : false;
+  return mTextEditor ? mTextEditor->IsMailEditor() : false;
 }
 
 bool
 TextEditRules::DontEchoPassword() const
 {
-  return mEditor ? mEditor->DontEchoPassword() : false;
+  return mTextEditor ? mTextEditor->DontEchoPassword() : false;
 }
 
 } // namespace mozilla
--- a/editor/libeditor/TextEditRules.h
+++ b/editor/libeditor/TextEditRules.h
@@ -13,21 +13,21 @@
 #include "nsIEditor.h"
 #include "nsISupportsImpl.h"
 #include "nsITimer.h"
 #include "nsString.h"
 #include "nscore.h"
 
 class nsIDOMElement;
 class nsIDOMNode;
-class nsPlaintextEditor;
 
 namespace mozilla {
 
 class AutoLockRulesSniffing;
+class TextEditor;
 namespace dom {
 class Selection;
 } // namespace dom
 
 /**
  * Object that encapsulates HTML text-specific editing rules.
  *
  * To be a good citizen, edit rules must live by these restrictions:
@@ -50,17 +50,17 @@ public:
 
   NS_DECL_NSITIMERCALLBACK
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(TextEditRules, nsIEditRules)
 
   TextEditRules();
 
   // nsIEditRules methods
-  NS_IMETHOD Init(nsPlaintextEditor* aTextEditor) override;
+  NS_IMETHOD Init(TextEditor* aTextEditor) override;
   NS_IMETHOD SetInitialValue(const nsAString& aValue) override;
   NS_IMETHOD DetachEditor() override;
   NS_IMETHOD BeforeEdit(EditAction action,
                         nsIEditor::EDirection aDirection) override;
   NS_IMETHOD AfterEdit(EditAction action,
                        nsIEditor::EDirection aDirection) override;
   NS_IMETHOD WillDoAction(Selection* aSelection, RulesInfo* aInfo,
                           bool* aCancel, bool* aHandled) override;
@@ -220,17 +220,17 @@ protected:
   bool IsSingleLineEditor() const;
   bool IsPlaintextEditor() const;
   bool IsReadonly() const;
   bool IsDisabled() const;
   bool IsMailEditor() const;
   bool DontEchoPassword() const;
 
   // Note that we do not refcount the editor.
-  nsPlaintextEditor* mEditor;
+  TextEditor* mTextEditor;
   // A buffer we use to store the real value of password editors.
   nsString mPasswordText;
   // A buffer we use to track the IME composition string.
   nsString mPasswordIMEText;
   uint32_t mPasswordIMEIndex;
   // Magic node acts as placeholder in empty doc.
   nsCOMPtr<nsIDOMNode> mBogusNode;
   // Cached selected node.
--- a/editor/libeditor/TextEditRulesBidi.cpp
+++ b/editor/libeditor/TextEditRulesBidi.cpp
@@ -1,26 +1,26 @@
 /* -*- 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 "TextEditRules.h"
 
+#include "TextEditor.h"
+#include "mozilla/dom/Selection.h"
 #include "nsCOMPtr.h"
 #include "nsDebug.h"
 #include "nsError.h"
 #include "nsFrameSelection.h"
 #include "nsIContent.h"
 #include "nsIDOMNode.h"
 #include "nsIEditor.h"
 #include "nsIPresShell.h"
-#include "mozilla/dom/Selection.h"
 #include "nsISupportsImpl.h"
-#include "nsPlaintextEditor.h"
 #include "nsPresContext.h"
 #include "nscore.h"
 
 namespace mozilla {
 
 using namespace dom;
 
 // Test for distance between caret and text that will be deleted
@@ -29,17 +29,17 @@ TextEditRules::CheckBidiLevelForDeletion
                                          nsIDOMNode* aSelNode,
                                          int32_t aSelOffset,
                                          nsIEditor::EDirection aAction,
                                          bool* aCancel)
 {
   NS_ENSURE_ARG_POINTER(aCancel);
   *aCancel = false;
 
-  nsCOMPtr<nsIPresShell> shell = mEditor->GetPresShell();
+  nsCOMPtr<nsIPresShell> shell = mTextEditor->GetPresShell();
   NS_ENSURE_TRUE(shell, NS_ERROR_NOT_INITIALIZED);
 
   nsPresContext *context = shell->GetPresContext();
   NS_ENSURE_TRUE(context, NS_ERROR_NULL_POINTER);
 
   if (!context->BidiEnabled())
     return NS_OK;
 
--- a/editor/libeditor/TextEditUtils.cpp
+++ b/editor/libeditor/TextEditUtils.cpp
@@ -1,29 +1,29 @@
 /* -*- 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 "TextEditUtils.h"
 
+#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 "nsPlaintextEditor.h"
 #include "nsString.h"
 
 namespace mozilla {
 
 /******************************************************************************
  * TextEditUtils
  ******************************************************************************/
 
@@ -89,19 +89,18 @@ TextEditUtils::HasMozAttr(nsIDOMNode* aN
   nsresult rv = element->GetAttribute(NS_LITERAL_STRING("type"), typeAttrVal);
   return NS_SUCCEEDED(rv) && typeAttrVal.LowerCaseEqualsLiteral("_moz");
 }
 
 /******************************************************************************
  * AutoEditInitRulesTrigger
  ******************************************************************************/
 
-AutoEditInitRulesTrigger::AutoEditInitRulesTrigger(
-                            nsPlaintextEditor* aTextEditor,
-                            nsresult& aResult)
+AutoEditInitRulesTrigger::AutoEditInitRulesTrigger(TextEditor* aTextEditor,
+                                                   nsresult& aResult)
   : mTextEditor(aTextEditor)
   , mResult(aResult)
 {
   if (mTextEditor) {
     mTextEditor->BeginEditorInit();
   }
 }
 
--- a/editor/libeditor/TextEditUtils.h
+++ b/editor/libeditor/TextEditUtils.h
@@ -5,20 +5,21 @@
 
 #ifndef TextEditUtils_h_
 #define TextEditUtils_h_
 
 #include "nscore.h"
 
 class nsIDOMNode;
 class nsINode;
-class nsPlaintextEditor;
 
 namespace mozilla {
 
+class TextEditor;
+
 class TextEditUtils final
 {
 public:
   // from TextEditRules:
   static bool IsBody(nsIDOMNode* aNode);
   static bool IsBreak(nsIDOMNode* aNode);
   static bool IsBreak(nsINode* aNode);
   static bool IsMozBR(nsIDOMNode* aNode);
@@ -28,19 +29,19 @@ public:
 
 /***************************************************************************
  * stack based helper class for detecting end of editor initialization, in
  * order to trigger "end of init" initialization of the edit rules.
  */
 class AutoEditInitRulesTrigger final
 {
 private:
-  nsPlaintextEditor* mTextEditor;
+  TextEditor* mTextEditor;
   nsresult& mResult;
 
 public:
-  AutoEditInitRulesTrigger(nsPlaintextEditor* aTextEditor, nsresult& aResult);
+  AutoEditInitRulesTrigger(TextEditor* aTextEditor, nsresult& aResult);
   ~AutoEditInitRulesTrigger();
 };
 
 } // naemspace mozilla
 
 #endif // #ifndef TextEditUtils_h_
rename from editor/libeditor/nsPlaintextEditor.cpp
rename to editor/libeditor/TextEditor.cpp
--- a/editor/libeditor/nsPlaintextEditor.cpp
+++ b/editor/libeditor/TextEditor.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 "nsPlaintextEditor.h"
+#include "TextEditor.h"
 
 #include "EditorUtils.h"  // AutoEditBatch, AutoRules
 #include "InternetCiter.h"
 #include "TextEditRules.h"
 #include "TextEditUtils.h"
 #include "gfxFontUtils.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/Preferences.h"
@@ -57,73 +57,75 @@
 #include "nsSubstringTuple.h"
 #include "nsUnicharUtils.h"
 #include "nsXPCOM.h"
 
 class nsIOutputStream;
 class nsISupports;
 class nsISupportsArray;
 
-using namespace mozilla;
-using namespace mozilla::dom;
+namespace mozilla {
+
+using namespace dom;
 
-nsPlaintextEditor::nsPlaintextEditor()
-: nsEditor()
-, mRules(nullptr)
-, mWrapColumn(0)
-, mMaxTextLength(-1)
-, mInitTriggerCounter(0)
-, mNewlineHandling(nsIPlaintextEditor::eNewlinesPasteToFirst)
+TextEditor::TextEditor()
+  : nsEditor()
+  , mRules(nullptr)
+  , mWrapColumn(0)
+  , mMaxTextLength(-1)
+  , mInitTriggerCounter(0)
+  , mNewlineHandling(nsIPlaintextEditor::eNewlinesPasteToFirst)
 #ifdef XP_WIN
-, mCaretStyle(1)
+  , mCaretStyle(1)
 #else
-, mCaretStyle(0)
+  , mCaretStyle(0)
 #endif
 {
   // check the "single line editor newline handling"
   // and "caret behaviour in selection" prefs
   GetDefaultEditorPrefs(mNewlineHandling, mCaretStyle);
 }
 
-nsPlaintextEditor::~nsPlaintextEditor()
+TextEditor::~TextEditor()
 {
   // Remove event listeners. Note that if we had an HTML editor,
   //  it installed its own instead of these
   RemoveEventListeners();
 
   if (mRules)
     mRules->DetachEditor();
 }
 
-NS_IMPL_CYCLE_COLLECTION_CLASS(nsPlaintextEditor)
+NS_IMPL_CYCLE_COLLECTION_CLASS(TextEditor)
 
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsPlaintextEditor, nsEditor)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(TextEditor, nsEditor)
   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(nsPlaintextEditor, nsEditor)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(TextEditor, nsEditor)
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mRules)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
-NS_IMPL_ADDREF_INHERITED(nsPlaintextEditor, nsEditor)
-NS_IMPL_RELEASE_INHERITED(nsPlaintextEditor, nsEditor)
+NS_IMPL_ADDREF_INHERITED(TextEditor, nsEditor)
+NS_IMPL_RELEASE_INHERITED(TextEditor, nsEditor)
 
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(nsPlaintextEditor)
+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_IMETHODIMP nsPlaintextEditor::Init(nsIDOMDocument *aDoc,
-                                      nsIContent *aRoot,
-                                      nsISelectionController *aSelCon,
-                                      uint32_t aFlags,
-                                      const nsAString& aInitialValue)
+NS_IMETHODIMP
+TextEditor::Init(nsIDOMDocument* aDoc,
+                 nsIContent* aRoot,
+                 nsISelectionController* aSelCon,
+                 uint32_t aFlags,
+                 const nsAString& aInitialValue)
 {
   NS_PRECONDITION(aDoc, "bad arg");
   NS_ENSURE_TRUE(aDoc, NS_ERROR_NULL_POINTER);
 
   nsresult res = NS_OK, rulesRes = NS_OK;
   if (mRules) {
     mRules->DetachEditor();
   }
@@ -146,17 +148,17 @@ NS_IMETHODIMP nsPlaintextEditor::Init(ns
 
   return res;
 }
 
 static int32_t sNewlineHandlingPref = -1,
                sCaretStylePref = -1;
 
 static void
-EditorPrefsChangedCallback(const char *aPrefName, void *)
+EditorPrefsChangedCallback(const char* aPrefName, void *)
 {
   if (nsCRT::strcmp(aPrefName, "editor.singleLine.pasteNewlines") == 0) {
     sNewlineHandlingPref =
       Preferences::GetInt("editor.singleLine.pasteNewlines",
                           nsIPlaintextEditor::eNewlinesPasteToFirst);
   } else if (nsCRT::strcmp(aPrefName, "layout.selection.caret_style") == 0) {
     sCaretStylePref = Preferences::GetInt("layout.selection.caret_style",
 #ifdef XP_WIN
@@ -166,40 +168,40 @@ EditorPrefsChangedCallback(const char *a
 #else
                                                  0);
 #endif
   }
 }
 
 // static
 void
-nsPlaintextEditor::GetDefaultEditorPrefs(int32_t &aNewlineHandling,
-                                         int32_t &aCaretStyle)
+TextEditor::GetDefaultEditorPrefs(int32_t& aNewlineHandling,
+                                  int32_t& aCaretStyle)
 {
   if (sNewlineHandlingPref == -1) {
     Preferences::RegisterCallback(EditorPrefsChangedCallback,
                                   "editor.singleLine.pasteNewlines");
     EditorPrefsChangedCallback("editor.singleLine.pasteNewlines", nullptr);
     Preferences::RegisterCallback(EditorPrefsChangedCallback,
                                   "layout.selection.caret_style");
     EditorPrefsChangedCallback("layout.selection.caret_style", nullptr);
   }
 
   aNewlineHandling = sNewlineHandlingPref;
   aCaretStyle = sCaretStylePref;
 }
 
 void
-nsPlaintextEditor::BeginEditorInit()
+TextEditor::BeginEditorInit()
 {
   mInitTriggerCounter++;
 }
 
 nsresult
-nsPlaintextEditor::EndEditorInit()
+TextEditor::EndEditorInit()
 {
   nsresult res = NS_OK;
   NS_PRECONDITION(mInitTriggerCounter > 0, "ended editor init before we began?");
   mInitTriggerCounter--;
   if (mInitTriggerCounter == 0)
   {
     res = InitRules();
     if (NS_SUCCEEDED(res)) {
@@ -208,17 +210,17 @@ nsPlaintextEditor::EndEditorInit()
       EnableUndo(false);
       EnableUndo(true);
     }
   }
   return res;
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::SetDocumentCharacterSet(const nsACString& characterSet)
+TextEditor::SetDocumentCharacterSet(const nsACString& characterSet)
 {
   nsresult rv = nsEditor::SetDocumentCharacterSet(characterSet);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Update META charset element.
   nsCOMPtr<nsIDOMDocument> domdoc = GetDOMDocument();
   NS_ENSURE_TRUE(domdoc, NS_ERROR_NOT_INITIALIZED);
 
@@ -257,18 +259,18 @@ nsPlaintextEditor::SetDocumentCharacterS
   metaElement->SetAttr(kNameSpaceID_None, nsGkAtoms::content,
                        NS_LITERAL_STRING("text/html;charset=") +
                          NS_ConvertASCIItoUTF16(characterSet),
                        true);
   return NS_OK;
 }
 
 bool
-nsPlaintextEditor::UpdateMetaCharset(nsIDOMDocument* aDocument,
-                                     const nsACString& aCharacterSet)
+TextEditor::UpdateMetaCharset(nsIDOMDocument* aDocument,
+                              const nsACString& aCharacterSet)
 {
   MOZ_ASSERT(aDocument);
   // get a list of META tags
   nsCOMPtr<nsIDOMNodeList> list;
   nsresult rv = aDocument->GetElementsByTagName(NS_LITERAL_STRING("meta"),
                                                 getter_AddRefs(list));
   NS_ENSURE_SUCCESS(rv, false);
   NS_ENSURE_TRUE(list, false);
@@ -313,44 +315,46 @@ nsPlaintextEditor::UpdateMetaCharset(nsI
                                 Substring(originalStart, start) +
                                   charsetEquals +
                                   NS_ConvertASCIItoUTF16(aCharacterSet));
     return NS_SUCCEEDED(rv);
   }
   return false;
 }
 
-NS_IMETHODIMP nsPlaintextEditor::InitRules()
+NS_IMETHODIMP
+TextEditor::InitRules()
 {
   if (!mRules) {
     // instantiate the rules for this text editor
     mRules = new TextEditRules();
   }
   return mRules->Init(this);
 }
 
 
 NS_IMETHODIMP
-nsPlaintextEditor::GetIsDocumentEditable(bool *aIsDocumentEditable)
+TextEditor::GetIsDocumentEditable(bool* aIsDocumentEditable)
 {
   NS_ENSURE_ARG_POINTER(aIsDocumentEditable);
 
   nsCOMPtr<nsIDOMDocument> doc = GetDOMDocument();
   *aIsDocumentEditable = doc && IsModifiable();
 
   return NS_OK;
 }
 
-bool nsPlaintextEditor::IsModifiable()
+bool
+TextEditor::IsModifiable()
 {
   return !IsReadonly();
 }
 
 nsresult
-nsPlaintextEditor::HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent)
+TextEditor::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.
 
@@ -415,50 +419,50 @@ nsPlaintextEditor::HandleKeyPressEvent(n
 
 /* This routine is needed to provide a bottleneck for typing for logging
    purposes.  Can't use HandleKeyPress() (above) for that since it takes
    a nsIDOMKeyEvent* parameter.  So instead we pass enough info through
    to TypedText() to determine what action to take, but without passing
    an event.
    */
 NS_IMETHODIMP
-nsPlaintextEditor::TypedText(const nsAString& aString, ETypingAction aAction)
+TextEditor::TypedText(const nsAString& aString, ETypingAction aAction)
 {
   AutoPlaceHolderBatch batch(this, nsGkAtoms::TypingTxnName);
 
   switch (aAction) {
     case eTypedText:
       return InsertText(aString);
     case eTypedBreak:
       return InsertLineBreak();
     default:
       // eTypedBR is only for HTML
       return NS_ERROR_FAILURE;
   }
 }
 
 Element*
-nsPlaintextEditor::CreateBRImpl(nsCOMPtr<nsINode>* aInOutParent,
-                                int32_t* aInOutOffset,
-                                EDirection aSelect)
+TextEditor::CreateBRImpl(nsCOMPtr<nsINode>* aInOutParent,
+                         int32_t* aInOutOffset,
+                         EDirection aSelect)
 {
   nsCOMPtr<nsIDOMNode> parent(GetAsDOMNode(*aInOutParent));
   nsCOMPtr<nsIDOMNode> br;
   // We ignore the retval, and assume it's fine if the br is non-null
   CreateBRImpl(address_of(parent), aInOutOffset, address_of(br), aSelect);
   *aInOutParent = do_QueryInterface(parent);
   nsCOMPtr<Element> ret(do_QueryInterface(br));
   return ret;
 }
 
 nsresult
-nsPlaintextEditor::CreateBRImpl(nsCOMPtr<nsIDOMNode>* aInOutParent,
-                                int32_t* aInOutOffset,
-                                nsCOMPtr<nsIDOMNode>* outBRNode,
-                                EDirection aSelect)
+TextEditor::CreateBRImpl(nsCOMPtr<nsIDOMNode>* aInOutParent,
+                         int32_t* aInOutOffset,
+                         nsCOMPtr<nsIDOMNode>* outBRNode,
+                         EDirection aSelect)
 {
   NS_ENSURE_TRUE(aInOutParent && *aInOutParent && aInOutOffset && outBRNode, NS_ERROR_NULL_POINTER);
   *outBRNode = nullptr;
   nsresult res;
 
   // we need to insert a br.  unfortunately, we may have to split a text node to do it.
   nsCOMPtr<nsIDOMNode> node = *aInOutParent;
   int32_t theOffset = *aInOutOffset;
@@ -521,25 +525,29 @@ nsPlaintextEditor::CreateBRImpl(nsCOMPtr
       selection->SetInterlinePosition(true);
       res = selection->Collapse(parent, offset);
     }
   }
   return NS_OK;
 }
 
 
-NS_IMETHODIMP nsPlaintextEditor::CreateBR(nsIDOMNode *aNode, int32_t aOffset, nsCOMPtr<nsIDOMNode> *outBRNode, EDirection aSelect)
+NS_IMETHODIMP
+TextEditor::CreateBR(nsIDOMNode* aNode,
+                     int32_t aOffset,
+                     nsCOMPtr<nsIDOMNode>* outBRNode,
+                     EDirection aSelect)
 {
   nsCOMPtr<nsIDOMNode> parent = aNode;
   int32_t offset = aOffset;
   return CreateBRImpl(address_of(parent), &offset, outBRNode, aSelect);
 }
 
 nsresult
-nsPlaintextEditor::InsertBR(nsCOMPtr<nsIDOMNode>* outBRNode)
+TextEditor::InsertBR(nsCOMPtr<nsIDOMNode>* outBRNode)
 {
   NS_ENSURE_TRUE(outBRNode, NS_ERROR_NULL_POINTER);
   *outBRNode = nullptr;
 
   // calling it text insertion to trigger moz br treatment by rules
   AutoRules beginRulesSniffing(this, EditAction::insertText, nsIEditor::eNext);
 
   RefPtr<Selection> selection = GetSelection();
@@ -561,18 +569,18 @@ nsPlaintextEditor::InsertBR(nsCOMPtr<nsI
 
   // position selection after br
   selNode = GetNodeLocation(*outBRNode, &selOffset);
   selection->SetInterlinePosition(true);
   return selection->Collapse(selNode, selOffset+1);
 }
 
 nsresult
-nsPlaintextEditor::ExtendSelectionForDelete(Selection* aSelection,
-                                            nsIEditor::EDirection *aAction)
+TextEditor::ExtendSelectionForDelete(Selection* aSelection,
+                                     nsIEditor::EDirection* aAction)
 {
   nsresult result = NS_OK;
 
   bool bCollapsed = aSelection->Collapsed();
 
   if (*aAction == eNextWord || *aAction == ePreviousWord
       || (*aAction == eNext && bCollapsed)
       || (*aAction == ePrevious && bCollapsed)
@@ -641,18 +649,18 @@ nsPlaintextEditor::ExtendSelectionForDel
         result = NS_OK;
         break;
     }
   }
   return result;
 }
 
 nsresult
-nsPlaintextEditor::DeleteSelection(EDirection aAction,
-                                   EStripWrappers aStripWrappers)
+TextEditor::DeleteSelection(EDirection aAction,
+                            EStripWrappers aStripWrappers)
 {
   MOZ_ASSERT(aStripWrappers == eStrip || aStripWrappers == eNoStrip);
 
   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
 
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
@@ -700,17 +708,18 @@ nsPlaintextEditor::DeleteSelection(EDire
   {
     // post-process
     result = mRules->DidDoAction(selection, &ruleInfo, result);
   }
 
   return result;
 }
 
-NS_IMETHODIMP nsPlaintextEditor::InsertText(const nsAString &aStringToInsert)
+NS_IMETHODIMP
+TextEditor::InsertText(const nsAString& aStringToInsert)
 {
   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
 
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
   EditAction opID = EditAction::insertText;
   if (ShouldHandleIMEComposition()) {
@@ -741,17 +750,18 @@ NS_IMETHODIMP nsPlaintextEditor::InsertT
   if (!cancel)
   {
     // post-process
     res = mRules->DidDoAction(selection, &ruleInfo, res);
   }
   return res;
 }
 
-NS_IMETHODIMP nsPlaintextEditor::InsertLineBreak()
+NS_IMETHODIMP
+TextEditor::InsertLineBreak()
 {
   if (!mRules) { return NS_ERROR_NOT_INITIALIZED; }
 
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
   AutoEditBatch beginBatching(this);
   AutoRules beginRulesSniffing(this, EditAction::insertBreak, nsIEditor::eNext);
@@ -818,34 +828,34 @@ NS_IMETHODIMP nsPlaintextEditor::InsertL
     // post-process, always called if WillInsertBreak didn't return cancel==true
     res = mRules->DidDoAction(selection, &ruleInfo, res);
   }
 
   return res;
 }
 
 nsresult
-nsPlaintextEditor::BeginIMEComposition(WidgetCompositionEvent* aEvent)
+TextEditor::BeginIMEComposition(WidgetCompositionEvent* aEvent)
 {
   NS_ENSURE_TRUE(!mComposition, NS_OK);
 
   if (IsPasswordEditor()) {
     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);
 }
 
 nsresult
-nsPlaintextEditor::UpdateIMEComposition(nsIDOMEvent* aDOMTextEvent)
+TextEditor::UpdateIMEComposition(nsIDOMEvent* aDOMTextEvent)
 {
   MOZ_ASSERT(aDOMTextEvent, "aDOMTextEvent must not be nullptr");
 
   WidgetCompositionEvent* compositionChangeEvent =
     aDOMTextEvent->WidgetEventPtr()->AsCompositionEvent();
   NS_ENSURE_TRUE(compositionChangeEvent, NS_ERROR_INVALID_ARG);
   MOZ_ASSERT(compositionChangeEvent->mMessage == eCompositionChange,
              "The internal event should be eCompositionChange");
@@ -894,37 +904,37 @@ nsPlaintextEditor::UpdateIMEComposition(
   if (!compositionChangeEvent->IsFollowedByCompositionEnd()) {
     NotifyEditorObservers(eNotifyEditorObserversOfEnd);
   }
 
   return rv;
 }
 
 already_AddRefed<nsIContent>
-nsPlaintextEditor::GetInputEventTargetContent()
+TextEditor::GetInputEventTargetContent()
 {
   nsCOMPtr<nsIContent> target = do_QueryInterface(mEventTarget);
   return target.forget();
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::GetDocumentIsEmpty(bool *aDocumentIsEmpty)
+TextEditor::GetDocumentIsEmpty(bool* aDocumentIsEmpty)
 {
   NS_ENSURE_TRUE(aDocumentIsEmpty, NS_ERROR_NULL_POINTER);
 
   NS_ENSURE_TRUE(mRules, NS_ERROR_NOT_INITIALIZED);
 
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
   return mRules->DocumentIsEmpty(aDocumentIsEmpty);
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::GetTextLength(int32_t *aCount)
+TextEditor::GetTextLength(int32_t* aCount)
 {
   NS_ASSERTION(aCount, "null pointer");
 
   // initialize out params
   *aCount = 0;
 
   // special-case for empty document, to account for the bogus node
   bool docEmpty;
@@ -952,35 +962,32 @@ nsPlaintextEditor::GetTextLength(int32_t
     }
   }
 
   *aCount = totalLength;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::SetMaxTextLength(int32_t aMaxTextLength)
+TextEditor::SetMaxTextLength(int32_t aMaxTextLength)
 {
   mMaxTextLength = aMaxTextLength;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::GetMaxTextLength(int32_t* aMaxTextLength)
+TextEditor::GetMaxTextLength(int32_t* aMaxTextLength)
 {
   NS_ENSURE_TRUE(aMaxTextLength, NS_ERROR_INVALID_POINTER);
   *aMaxTextLength = mMaxTextLength;
   return NS_OK;
 }
 
-//
-// Get the wrap width
-//
 NS_IMETHODIMP
-nsPlaintextEditor::GetWrapWidth(int32_t *aWrapColumn)
+TextEditor::GetWrapWidth(int32_t* aWrapColumn)
 {
   NS_ENSURE_TRUE( aWrapColumn, NS_ERROR_NULL_POINTER);
 
   *aWrapColumn = mWrapColumn;
   return NS_OK;
 }
 
 //
@@ -996,21 +1003,18 @@ static void CutStyle(const char* stylena
     int32_t styleEnd = styleValue.Find(";", false, styleStart);
     if (styleEnd > styleStart)
       styleValue.Cut(styleStart, styleEnd - styleStart + 1);
     else
       styleValue.Cut(styleStart, styleValue.Length() - styleStart);
   }
 }
 
-//
-// Change the wrap width on the root of this document.
-//
 NS_IMETHODIMP
-nsPlaintextEditor::SetWrapWidth(int32_t aWrapColumn)
+TextEditor::SetWrapWidth(int32_t aWrapColumn)
 {
   SetWrapColumn(aWrapColumn);
 
   // Make sure we're a plaintext editor, otherwise we shouldn't
   // do the rest of this.
   if (!IsPlaintextEditor())
     return NS_OK;
 
@@ -1053,47 +1057,41 @@ nsPlaintextEditor::SetWrapWidth(int32_t 
   } else {
     styleValue.AppendLiteral("white-space: pre;");
   }
 
   return rootElement->SetAttr(kNameSpaceID_None, nsGkAtoms::style, styleValue, true);
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::SetWrapColumn(int32_t aWrapColumn)
+TextEditor::SetWrapColumn(int32_t aWrapColumn)
 {
   mWrapColumn = aWrapColumn;
   return NS_OK;
 }
 
-//
-// Get the newline handling for this editor
-//
 NS_IMETHODIMP
-nsPlaintextEditor::GetNewlineHandling(int32_t *aNewlineHandling)
+TextEditor::GetNewlineHandling(int32_t* aNewlineHandling)
 {
   NS_ENSURE_ARG_POINTER(aNewlineHandling);
 
   *aNewlineHandling = mNewlineHandling;
   return NS_OK;
 }
 
-//
-// Change the newline handling for this editor
-//
 NS_IMETHODIMP
-nsPlaintextEditor::SetNewlineHandling(int32_t aNewlineHandling)
+TextEditor::SetNewlineHandling(int32_t aNewlineHandling)
 {
   mNewlineHandling = aNewlineHandling;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::Undo(uint32_t aCount)
+TextEditor::Undo(uint32_t aCount)
 {
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
   AutoUpdateViewBatch beginViewBatching(this);
 
   ForceCompositionEnd();
 
@@ -1112,17 +1110,17 @@ nsPlaintextEditor::Undo(uint32_t aCount)
     result = mRules->DidDoAction(selection, &ruleInfo, result);
   }
 
   NotifyEditorObservers(eNotifyEditorObserversOfEnd);
   return result;
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::Redo(uint32_t aCount)
+TextEditor::Redo(uint32_t aCount)
 {
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
   AutoUpdateViewBatch beginViewBatching(this);
 
   ForceCompositionEnd();
 
@@ -1141,34 +1139,34 @@ nsPlaintextEditor::Redo(uint32_t aCount)
     result = mRules->DidDoAction(selection, &ruleInfo, result);
   }
 
   NotifyEditorObservers(eNotifyEditorObserversOfEnd);
   return result;
 }
 
 bool
-nsPlaintextEditor::CanCutOrCopy(PasswordFieldAllowed aPasswordFieldAllowed)
+TextEditor::CanCutOrCopy(PasswordFieldAllowed aPasswordFieldAllowed)
 {
   RefPtr<Selection> selection = GetSelection();
   if (!selection) {
     return false;
   }
 
   if (aPasswordFieldAllowed == ePasswordFieldNotAllowed &&
       IsPasswordEditor())
     return false;
 
   return !selection->Collapsed();
 }
 
 bool
-nsPlaintextEditor::FireClipboardEvent(EventMessage aEventMessage,
-                                      int32_t aSelectionType,
-                                      bool* aActionTaken)
+TextEditor::FireClipboardEvent(EventMessage aEventMessage,
+                               int32_t aSelectionType,
+                               bool* aActionTaken)
 {
   if (aEventMessage == ePaste) {
     ForceCompositionEnd();
   }
 
   nsCOMPtr<nsIPresShell> presShell = GetPresShell();
   NS_ENSURE_TRUE(presShell, false);
 
@@ -1182,66 +1180,71 @@ nsPlaintextEditor::FireClipboardEvent(Ev
     return false;
   }
 
   // If the event handler caused the editor to be destroyed, return false.
   // Otherwise return true to indicate that the event was not cancelled.
   return !mDidPreDestroy;
 }
 
-NS_IMETHODIMP nsPlaintextEditor::Cut()
+NS_IMETHODIMP
+TextEditor::Cut()
 {
   bool actionTaken = false;
   if (FireClipboardEvent(eCut, nsIClipboard::kGlobalClipboard, &actionTaken)) {
     DeleteSelection(eNone, eStrip);
   }
   return actionTaken ? NS_OK : NS_ERROR_FAILURE;
 }
 
-NS_IMETHODIMP nsPlaintextEditor::CanCut(bool *aCanCut)
+NS_IMETHODIMP
+TextEditor::CanCut(bool* aCanCut)
 {
   NS_ENSURE_ARG_POINTER(aCanCut);
   // Cut is always enabled in HTML documents
   nsCOMPtr<nsIDocument> doc = GetDocument();
   *aCanCut = (doc && doc->IsHTMLOrXHTML()) ||
     (IsModifiable() && CanCutOrCopy(ePasswordFieldNotAllowed));
   return NS_OK;
 }
 
-NS_IMETHODIMP nsPlaintextEditor::Copy()
+NS_IMETHODIMP
+TextEditor::Copy()
 {
   bool actionTaken = false;
   FireClipboardEvent(eCopy, nsIClipboard::kGlobalClipboard, &actionTaken);
 
   return actionTaken ? NS_OK : NS_ERROR_FAILURE;
 }
 
-NS_IMETHODIMP nsPlaintextEditor::CanCopy(bool *aCanCopy)
+NS_IMETHODIMP
+TextEditor::CanCopy(bool* aCanCopy)
 {
   NS_ENSURE_ARG_POINTER(aCanCopy);
   // Copy is always enabled in HTML documents
   nsCOMPtr<nsIDocument> doc = GetDocument();
   *aCanCopy = (doc && doc->IsHTMLOrXHTML()) ||
     CanCutOrCopy(ePasswordFieldNotAllowed);
   return NS_OK;
 }
 
-NS_IMETHODIMP nsPlaintextEditor::CanDelete(bool *aCanDelete)
+NS_IMETHODIMP
+TextEditor::CanDelete(bool* aCanDelete)
 {
   NS_ENSURE_ARG_POINTER(aCanDelete);
   *aCanDelete = IsModifiable() && CanCutOrCopy(ePasswordFieldAllowed);
   return NS_OK;
 }
 
 // Shared between OutputToString and OutputToStream
 NS_IMETHODIMP
-nsPlaintextEditor::GetAndInitDocEncoder(const nsAString& aFormatType,
-                                        uint32_t aFlags,
-                                        const nsACString& aCharset,
-                                        nsIDocumentEncoder** encoder)
+TextEditor::GetAndInitDocEncoder(const nsAString& aFormatType,
+                                 uint32_t aFlags,
+                                 const nsACString& aCharset,
+                                 nsIDocumentEncoder** encoder)
 {
   nsresult rv = NS_OK;
 
   nsAutoCString formatType(NS_DOC_ENCODER_CONTRACTID_BASE);
   LossyAppendUTF16toASCII(aFormatType, formatType);
   nsCOMPtr<nsIDocumentEncoder> docEncoder (do_CreateInstance(formatType.get(), &rv));
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -1283,19 +1286,19 @@ nsPlaintextEditor::GetAndInitDocEncoder(
   }
 
   docEncoder.forget(encoder);
   return NS_OK;
 }
 
 
 NS_IMETHODIMP
-nsPlaintextEditor::OutputToString(const nsAString& aFormatType,
-                                  uint32_t aFlags,
-                                  nsAString& aOutputString)
+TextEditor::OutputToString(const nsAString& aFormatType,
+                           uint32_t aFlags,
+                           nsAString& aOutputString)
 {
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
   nsString resultString;
   TextRulesInfo ruleInfo(EditAction::outputText);
   ruleInfo.outString = &resultString;
   // XXX Struct should store a nsAReadable*
@@ -1317,20 +1320,20 @@ nsPlaintextEditor::OutputToString(const 
 
   nsCOMPtr<nsIDocumentEncoder> encoder;
   rv = GetAndInitDocEncoder(aFormatType, aFlags, charsetStr, getter_AddRefs(encoder));
   NS_ENSURE_SUCCESS(rv, rv);
   return encoder->EncodeToString(aOutputString);
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::OutputToStream(nsIOutputStream* aOutputStream,
-                             const nsAString& aFormatType,
-                             const nsACString& aCharset,
-                             uint32_t aFlags)
+TextEditor::OutputToStream(nsIOutputStream* aOutputStream,
+                           const nsAString& aFormatType,
+                           const nsACString& aCharset,
+                           uint32_t aFlags)
 {
   nsresult rv;
 
   // special-case for empty document when requesting plain text,
   // to account for the bogus text node.
   // XXX Should there be a similar test in OutputToString?
   if (aFormatType.EqualsLiteral("text/plain"))
   {
@@ -1347,23 +1350,23 @@ nsPlaintextEditor::OutputToStream(nsIOut
                             getter_AddRefs(encoder));
 
   NS_ENSURE_SUCCESS(rv, rv);
 
   return encoder->EncodeToStream(aOutputStream);
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::InsertTextWithQuotations(const nsAString &aStringToInsert)
+TextEditor::InsertTextWithQuotations(const nsAString& aStringToInsert)
 {
   return InsertText(aStringToInsert);
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::PasteAsQuotation(int32_t aSelectionType)
+TextEditor::PasteAsQuotation(int32_t aSelectionType)
 {
   // Get Clipboard Service
   nsresult rv;
   nsCOMPtr<nsIClipboard> clipboard(do_GetService("@mozilla.org/widget/clipboard;1", &rv));
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Get the nsITransferable interface for getting the data from the clipboard
   nsCOMPtr<nsITransferable> trans;
@@ -1400,18 +1403,18 @@ nsPlaintextEditor::PasteAsQuotation(int3
     }
     free(flav);
   }
 
   return rv;
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::InsertAsQuotation(const nsAString& aQuotedText,
-                                     nsIDOMNode **aNodeInserted)
+TextEditor::InsertAsQuotation(const nsAString& aQuotedText,
+                              nsIDOMNode** aNodeInserted)
 {
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
   // Let the citer quote it for us:
   nsString quotedStuff;
   nsresult rv = InternetCiter::GetCiteString(aQuotedText, quotedStuff);
   NS_ENSURE_SUCCESS(rv, rv);
@@ -1444,50 +1447,50 @@ nsPlaintextEditor::InsertAsQuotation(con
       *aNodeInserted = 0;
       //NS_IF_ADDREF(*aNodeInserted);
     }
   }
   return rv;
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::PasteAsCitedQuotation(const nsAString& aCitation,
-                                         int32_t aSelectionType)
+TextEditor::PasteAsCitedQuotation(const nsAString& aCitation,
+                                  int32_t aSelectionType)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::InsertAsCitedQuotation(const nsAString& aQuotedText,
-                                          const nsAString& aCitation,
-                                          bool aInsertHTML,
-                                          nsIDOMNode **aNodeInserted)
+TextEditor::InsertAsCitedQuotation(const nsAString& aQuotedText,
+                                   const nsAString& aCitation,
+                                   bool aInsertHTML,
+                                   nsIDOMNode** aNodeInserted)
 {
   return InsertAsQuotation(aQuotedText, aNodeInserted);
 }
 
 nsresult
-nsPlaintextEditor::SharedOutputString(uint32_t aFlags,
-                                      bool* aIsCollapsed,
-                                      nsAString& aResult)
+TextEditor::SharedOutputString(uint32_t aFlags,
+                               bool* aIsCollapsed,
+                               nsAString& aResult)
 {
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NOT_INITIALIZED);
 
   *aIsCollapsed = selection->Collapsed();
 
   if (!*aIsCollapsed)
     aFlags |= nsIDocumentEncoder::OutputSelectionOnly;
   // If the selection isn't collapsed, we'll use the whole document.
 
   return OutputToString(NS_LITERAL_STRING("text/plain"), aFlags, aResult);
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::Rewrap(bool aRespectNewlines)
+TextEditor::Rewrap(bool aRespectNewlines)
 {
   int32_t wrapCol;
   nsresult rv = GetWrapWidth(&wrapCol);
   NS_ENSURE_SUCCESS(rv, NS_OK);
 
   // Rewrap makes no sense if there's no wrap column; default to 72.
   if (wrapCol <= 0)
     wrapCol = 72;
@@ -1507,17 +1510,17 @@ nsPlaintextEditor::Rewrap(bool aRespectN
 
   if (isCollapsed)    // rewrap the whole document
     SelectAll();
 
   return InsertTextWithQuotations(wrapped);
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::StripCites()
+TextEditor::StripCites()
 {
   nsAutoString current;
   bool isCollapsed;
   nsresult rv = SharedOutputString(nsIDocumentEncoder::OutputFormatted,
                                    &isCollapsed, current);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsString stripped;
@@ -1529,56 +1532,57 @@ nsPlaintextEditor::StripCites()
     rv = SelectAll();
     NS_ENSURE_SUCCESS(rv, rv);
   }
 
   return InsertText(stripped);
 }
 
 NS_IMETHODIMP
-nsPlaintextEditor::GetEmbeddedObjects(nsISupportsArray** aNodeList)
+TextEditor::GetEmbeddedObjects(nsISupportsArray** aNodeList)
 {
   *aNodeList = 0;
   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
-nsPlaintextEditor::StartOperation(EditAction opID,
-                                  nsIEditor::EDirection aDirection)
+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
   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 */
+/**
+ * All editor operations which alter the doc should be followed
+ * with a call to EndOperation.
+ */
 NS_IMETHODIMP
-nsPlaintextEditor::EndOperation()
+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
   return res;
 }
 
-
 nsresult
-nsPlaintextEditor::SelectEntireDocument(Selection* aSelection)
+TextEditor::SelectEntireDocument(Selection* aSelection)
 {
   if (!aSelection || !mRules) { return NS_ERROR_NULL_POINTER; }
 
   // Protect the edit rules object from dying
   nsCOMPtr<nsIEditRules> kungFuDeathGrip(mRules);
 
   // is doc empty?
   bool bDocIsEmpty;
@@ -1609,32 +1613,34 @@ nsPlaintextEditor::SelectEntireDocument(
     nsCOMPtr<nsIDOMNode> parentNode = GetNodeLocation(childNode, &parentOffset);
 
     return aSelection->Extend(parentNode, parentOffset);
   }
 
   return NS_OK;
 }
 
-already_AddRefed<mozilla::dom::EventTarget>
-nsPlaintextEditor::GetDOMEventTarget()
+already_AddRefed<EventTarget>
+TextEditor::GetDOMEventTarget()
 {
-  nsCOMPtr<mozilla::dom::EventTarget> copy = mEventTarget;
+  nsCOMPtr<EventTarget> copy = mEventTarget;
   return copy.forget();
 }
 
 
 nsresult
-nsPlaintextEditor::SetAttributeOrEquivalent(nsIDOMElement * aElement,
-                                            const nsAString & aAttribute,
-                                            const nsAString & aValue,
-                                            bool aSuppressTransaction)
+TextEditor::SetAttributeOrEquivalent(nsIDOMElement* aElement,
+                                     const nsAString& aAttribute,
+                                     const nsAString& aValue,
+                                     bool aSuppressTransaction)
 {
   return nsEditor::SetAttribute(aElement, aAttribute, aValue);
 }
 
 nsresult
-nsPlaintextEditor::RemoveAttributeOrEquivalent(nsIDOMElement * aElement,
-                                               const nsAString & aAttribute,
-                                               bool aSuppressTransaction)
+TextEditor::RemoveAttributeOrEquivalent(nsIDOMElement* aElement,
+                                        const nsAString& aAttribute,
+                                        bool aSuppressTransaction)
 {
   return nsEditor::RemoveAttribute(aElement, aAttribute);
 }
+
+} // namespace mozilla
rename from editor/libeditor/nsPlaintextEditor.h
rename to editor/libeditor/TextEditor.h
--- a/editor/libeditor/nsPlaintextEditor.h
+++ b/editor/libeditor/TextEditor.h
@@ -1,15 +1,15 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef nsPlaintextEditor_h__
-#define nsPlaintextEditor_h__
+#ifndef mozilla_editor_TextEditor_h_
+#define mozilla_editor_TextEditor_h_
 
 #include "nsCOMPtr.h"
 #include "nsCycleCollectionParticipant.h"
 #include "nsEditor.h"
 #include "nsIEditor.h"
 #include "nsIEditorMailSupport.h"
 #include "nsIPlaintextEditor.h"
 #include "nsISupportsImpl.h"
@@ -23,214 +23,223 @@ class nsIDOMKeyEvent;
 class nsIDOMNode;
 class nsIDocumentEncoder;
 class nsIEditRules;
 class nsIOutputStream;
 class nsISelectionController;
 class nsITransferable;
 
 namespace mozilla {
+
 class AutoEditInitRulesTrigger;
 class HTMLEditRules;
 class TextEditRules;
 namespace dom {
 class Selection;
 } // namespace dom
-} // namespace mozilla
 
 /**
  * The text editor implementation.
  * Use to edit text document represented as a DOM tree.
  */
-class nsPlaintextEditor : public nsEditor,
-                          public nsIPlaintextEditor,
-                          public nsIEditorMailSupport
+class TextEditor : public nsEditor
+                 , public nsIPlaintextEditor
+                 , public nsIEditorMailSupport
 {
-
 public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(TextEditor, nsEditor)
 
-// Interfaces for addref and release and queryinterface
-// NOTE macro used is for classes that inherit from
-// another class. Only the base class should use NS_DECL_ISUPPORTS
-  NS_DECL_ISUPPORTS_INHERITED
-  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsPlaintextEditor, nsEditor)
-
-  /* below used by TypedText() */
-  enum ETypingAction {
+  enum ETypingAction
+  {
     eTypedText,  /* user typed text */
     eTypedBR,    /* user typed shift-enter to get a br */
     eTypedBreak  /* user typed enter */
   };
 
-  nsPlaintextEditor();
+  TextEditor();
 
-  /* ------------ nsIPlaintextEditor methods -------------- */
+  // nsIPlaintextEditor methods
   NS_DECL_NSIPLAINTEXTEDITOR
 
-  /* ------------ nsIEditorMailSupport overrides -------------- */
+  // nsIEditorMailSupport overrides
   NS_DECL_NSIEDITORMAILSUPPORT
 
-  /* ------------ Overrides of nsEditor interface methods -------------- */
-  NS_IMETHOD SetAttributeOrEquivalent(nsIDOMElement * aElement,
-                                      const nsAString & aAttribute,
-                                      const nsAString & aValue,
+  // Overrides of nsEditor interface methods
+  NS_IMETHOD SetAttributeOrEquivalent(nsIDOMElement* aElement,
+                                      const nsAString& aAttribute,
+                                      const nsAString& aValue,
                                       bool aSuppressTransaction) override;
-  NS_IMETHOD RemoveAttributeOrEquivalent(nsIDOMElement * aElement,
-                                         const nsAString & aAttribute,
+  NS_IMETHOD RemoveAttributeOrEquivalent(nsIDOMElement* aElement,
+                                         const nsAString& aAttribute,
                                          bool aSuppressTransaction) override;
 
-  /** prepare the editor for use */
-  NS_IMETHOD Init(nsIDOMDocument *aDoc, nsIContent *aRoot,
-                  nsISelectionController *aSelCon, uint32_t aFlags,
+  NS_IMETHOD Init(nsIDOMDocument* aDoc, nsIContent* aRoot,
+                  nsISelectionController* aSelCon, uint32_t aFlags,
                   const nsAString& aValue) override;
 
-  NS_IMETHOD GetDocumentIsEmpty(bool *aDocumentIsEmpty) override;
-  NS_IMETHOD GetIsDocumentEditable(bool *aIsDocumentEditable) override;
+  NS_IMETHOD GetDocumentIsEmpty(bool* aDocumentIsEmpty) override;
+  NS_IMETHOD GetIsDocumentEditable(bool* aIsDocumentEditable) override;
 
   NS_IMETHOD DeleteSelection(EDirection aAction,
                              EStripWrappers aStripWrappers) override;
 
-  NS_IMETHOD SetDocumentCharacterSet(const nsACString & characterSet) override;
+  NS_IMETHOD SetDocumentCharacterSet(const nsACString& characterSet) override;
 
   NS_IMETHOD Undo(uint32_t aCount) override;
   NS_IMETHOD Redo(uint32_t aCount) override;
 
   NS_IMETHOD Cut() override;
-  NS_IMETHOD CanCut(bool *aCanCut) override;
+  NS_IMETHOD CanCut(bool* aCanCut) override;
   NS_IMETHOD Copy() override;
-  NS_IMETHOD CanCopy(bool *aCanCopy) override;
-  NS_IMETHOD CanDelete(bool *aCanDelete) override;
+  NS_IMETHOD CanCopy(bool* aCanCopy) override;
+  NS_IMETHOD CanDelete(bool* aCanDelete) override;
   NS_IMETHOD Paste(int32_t aSelectionType) override;
-  NS_IMETHOD CanPaste(int32_t aSelectionType, bool *aCanPaste) override;
-  NS_IMETHOD PasteTransferable(nsITransferable *aTransferable) override;
-  NS_IMETHOD CanPasteTransferable(nsITransferable *aTransferable, bool *aCanPaste) override;
+  NS_IMETHOD CanPaste(int32_t aSelectionType, bool* aCanPaste) override;
+  NS_IMETHOD PasteTransferable(nsITransferable* aTransferable) override;
+  NS_IMETHOD CanPasteTransferable(nsITransferable* aTransferable,
+                                  bool* aCanPaste) override;
 
   NS_IMETHOD OutputToString(const nsAString& aFormatType,
                             uint32_t aFlags,
                             nsAString& aOutputString) override;
 
   NS_IMETHOD OutputToStream(nsIOutputStream* aOutputStream,
                             const nsAString& aFormatType,
                             const nsACString& aCharsetOverride,
                             uint32_t aFlags) override;
 
-
-  /** 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) override;
 
-  /** 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() override;
 
-  /** make the given selection span the entire document */
+  /**
+   * Make the given selection span the entire document.
+   */
   virtual nsresult SelectEntireDocument(Selection* aSelection) override;
 
   virtual nsresult HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent) override;
 
-  virtual already_AddRefed<mozilla::dom::EventTarget> GetDOMEventTarget() override;
+  virtual already_AddRefed<dom::EventTarget> GetDOMEventTarget() override;
 
-  virtual nsresult BeginIMEComposition(mozilla::WidgetCompositionEvent* aEvent) override;
+  virtual nsresult BeginIMEComposition(WidgetCompositionEvent* aEvent) override;
   virtual nsresult UpdateIMEComposition(nsIDOMEvent* aTextEvent) override;
 
   virtual already_AddRefed<nsIContent> GetInputEventTargetContent() override;
 
-  /* ------------ Utility Routines, not part of public API -------------- */
+  // Utility Routines, not part of public API
   NS_IMETHOD TypedText(const nsAString& aString, ETypingAction aAction);
 
-  nsresult InsertTextAt(const nsAString &aStringToInsert,
-                        nsIDOMNode *aDestinationNode,
+  nsresult InsertTextAt(const nsAString& aStringToInsert,
+                        nsIDOMNode* aDestinationNode,
                         int32_t aDestOffset,
                         bool aDoDeleteSelection);
 
-  virtual nsresult InsertFromDataTransfer(mozilla::dom::DataTransfer *aDataTransfer,
+  virtual nsresult InsertFromDataTransfer(dom::DataTransfer* aDataTransfer,
                                           int32_t aIndex,
-                                          nsIDOMDocument *aSourceDoc,
-                                          nsIDOMNode *aDestinationNode,
+                                          nsIDOMDocument* aSourceDoc,
+                                          nsIDOMNode* aDestinationNode,
                                           int32_t aDestOffset,
                                           bool aDoDeleteSelection) override;
 
   virtual nsresult InsertFromDrop(nsIDOMEvent* aDropEvent) override;
 
   /**
    * Extends the selection for given deletion operation
    * If done, also update aAction to what's actually left to do after the
    * extension.
    */
   nsresult ExtendSelectionForDelete(Selection* aSelection,
-                                    nsIEditor::EDirection *aAction);
+                                    nsIEditor::EDirection* aAction);
 
-  // Return true if the data is safe to insert as the source and destination
-  // principals match, or we are in a editor context where this doesn't matter.
-  // Otherwise, the data must be sanitized first.
+  /**
+   * Return true if the data is safe to insert as the source and destination
+   * principals match, or we are in a editor context where this doesn't matter.
+   * Otherwise, the data must be sanitized first.
+   */
   bool IsSafeToInsertData(nsIDOMDocument* aSourceDoc);
 
-  static void GetDefaultEditorPrefs(int32_t &aNewLineHandling,
-                                    int32_t &aCaretStyle);
+  static void GetDefaultEditorPrefs(int32_t& aNewLineHandling,
+                                    int32_t& aCaretStyle);
 
 protected:
-  virtual  ~nsPlaintextEditor();
+  virtual ~TextEditor();
 
-  NS_IMETHOD  InitRules();
-  void        BeginEditorInit();
-  nsresult    EndEditorInit();
+  NS_IMETHOD InitRules();
+  void BeginEditorInit();
+  nsresult EndEditorInit();
 
-  // Helpers for output routines
   NS_IMETHOD GetAndInitDocEncoder(const nsAString& aFormatType,
                                   uint32_t aFlags,
                                   const nsACString& aCharset,
                                   nsIDocumentEncoder** encoder);
 
-  // key event helpers
-  NS_IMETHOD CreateBR(nsIDOMNode *aNode, int32_t aOffset,
-                      nsCOMPtr<nsIDOMNode> *outBRNode, EDirection aSelect = eNone);
+  NS_IMETHOD CreateBR(nsIDOMNode* aNode, int32_t aOffset,
+                      nsCOMPtr<nsIDOMNode> *outBRNode,
+                      EDirection aSelect = eNone);
   Element* CreateBRImpl(nsCOMPtr<nsINode>* aInOutParent, int32_t* aInOutOffset,
                         EDirection aSelect);
   nsresult CreateBRImpl(nsCOMPtr<nsIDOMNode>* aInOutParent,
                         int32_t* aInOutOffset,
                         nsCOMPtr<nsIDOMNode>* outBRNode,
                         EDirection aSelect);
   nsresult InsertBR(nsCOMPtr<nsIDOMNode>* outBRNode);
 
-  // factored methods for handling insertion of data from transferables (drag&drop or clipboard)
-  NS_IMETHOD PrepareTransferable(nsITransferable **transferable);
-  NS_IMETHOD InsertTextFromTransferable(nsITransferable *transferable,
-                                        nsIDOMNode *aDestinationNode,
+  /**
+   * Factored methods for handling insertion of data from transferables
+   * (drag&drop or clipboard).
+   */
+  NS_IMETHOD PrepareTransferable(nsITransferable** transferable);
+  NS_IMETHOD InsertTextFromTransferable(nsITransferable* transferable,
+                                        nsIDOMNode* aDestinationNode,
                                         int32_t aDestOffset,
                                         bool aDoDeleteSelection);
 
-  /** shared outputstring; returns whether selection is collapsed and resulting string */
-  nsresult SharedOutputString(uint32_t aFlags, bool* aIsCollapsed, nsAString& aResult);
+  /**
+   * Shared outputstring; returns whether selection is collapsed and resulting
+   * string.
+   */
+  nsresult SharedOutputString(uint32_t aFlags, bool* aIsCollapsed,
+                              nsAString& aResult);
 
-  /* small utility routine to test the eEditorReadonly bit */
+  /**
+   * Small utility routine to test the eEditorReadonly bit.
+   */
   bool IsModifiable();
 
-  enum PasswordFieldAllowed {
+  enum PasswordFieldAllowed
+  {
     ePasswordFieldAllowed,
     ePasswordFieldNotAllowed
   };
   bool CanCutOrCopy(PasswordFieldAllowed aPasswordFieldAllowed);
-  bool FireClipboardEvent(mozilla::EventMessage aEventMessage,
+  bool FireClipboardEvent(EventMessage aEventMessage,
                           int32_t aSelectionType,
                           bool* aActionTaken = nullptr);
 
   bool UpdateMetaCharset(nsIDOMDocument* aDocument,
                          const nsACString& aCharacterSet);
 
-// Data members
 protected:
-
-  nsCOMPtr<nsIEditRules>        mRules;
+  nsCOMPtr<nsIEditRules> mRules;
   int32_t mWrapColumn;
   int32_t mMaxTextLength;
   int32_t mInitTriggerCounter;
   int32_t mNewlineHandling;
   int32_t mCaretStyle;
 
-  // friends
-  friend class mozilla::AutoEditInitRulesTrigger;
-  friend class mozilla::HTMLEditRules;
-  friend class mozilla::TextEditRules;
+  friend class AutoEditInitRulesTrigger;
+  friend class HTMLEditRules;
+  friend class TextEditRules;
 };
 
-#endif //nsPlaintextEditor_h__
+} // namespace mozilla
 
+#endif // #ifndef mozilla_editor_TextEditor_h_
rename from editor/libeditor/nsPlaintextDataTransfer.cpp
rename to editor/libeditor/TextEditorDataTransfer.cpp
--- a/editor/libeditor/nsPlaintextDataTransfer.cpp
+++ b/editor/libeditor/TextEditorDataTransfer.cpp
@@ -1,13 +1,15 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#include "TextEditor.h"
+
 #include "EditorUtils.h"
 #include "SelectionState.h"
 #include "mozilla/ArrayUtils.h"
 #include "mozilla/MouseEvents.h"
 #include "mozilla/dom/Selection.h"
 #include "nsAString.h"
 #include "nsCOMPtr.h"
 #include "nsCRT.h"
@@ -33,30 +35,31 @@
 #include "nsIDocShellTreeItem.h"
 #include "nsIPrincipal.h"
 #include "nsIFormControl.h"
 #include "nsIPlaintextEditor.h"
 #include "nsISupportsPrimitives.h"
 #include "nsITransferable.h"
 #include "nsIVariant.h"
 #include "nsLiteralString.h"
-#include "nsPlaintextEditor.h"
 #include "nsRange.h"
 #include "nsServiceManagerUtils.h"
 #include "nsString.h"
 #include "nsXPCOM.h"
 #include "nscore.h"
 
 class nsILoadContext;
 class nsISupports;
 
-using namespace mozilla;
-using namespace mozilla::dom;
+namespace mozilla {
 
-NS_IMETHODIMP nsPlaintextEditor::PrepareTransferable(nsITransferable **transferable)
+using namespace dom;
+
+NS_IMETHODIMP
+TextEditor::PrepareTransferable(nsITransferable** transferable)
 {
   // Create generic Transferable for getting the data
   nsresult rv = CallCreateInstance("@mozilla.org/widget/transferable;1", transferable);
   NS_ENSURE_SUCCESS(rv, rv);
 
   // Get the nsITransferable interface for getting the data from the clipboard
   if (transferable) {
     nsCOMPtr<nsIDocument> destdoc = GetDocument();
@@ -64,20 +67,21 @@ NS_IMETHODIMP nsPlaintextEditor::Prepare
     (*transferable)->Init(loadContext);
 
     (*transferable)->AddDataFlavor(kUnicodeMime);
     (*transferable)->AddDataFlavor(kMozTextInternal);
   };
   return NS_OK;
 }
 
-nsresult nsPlaintextEditor::InsertTextAt(const nsAString &aStringToInsert,
-                                         nsIDOMNode *aDestinationNode,
-                                         int32_t aDestOffset,
-                                         bool aDoDeleteSelection)
+nsresult
+TextEditor::InsertTextAt(const nsAString& aStringToInsert,
+                         nsIDOMNode* aDestinationNode,
+                         int32_t aDestOffset,
+                         bool aDoDeleteSelection)
 {
   if (aDestinationNode)
   {
     nsresult res;
     RefPtr<Selection> selection = GetSelection();
     NS_ENSURE_STATE(selection);
 
     nsCOMPtr<nsIDOMNode> targetNode = aDestinationNode;
@@ -94,20 +98,21 @@ nsresult nsPlaintextEditor::InsertTextAt
 
     res = selection->Collapse(targetNode, targetOffset);
     NS_ENSURE_SUCCESS(res, res);
   }
 
   return InsertText(aStringToInsert);
 }
 
-NS_IMETHODIMP nsPlaintextEditor::InsertTextFromTransferable(nsITransferable *aTransferable,
-                                                            nsIDOMNode *aDestinationNode,
-                                                            int32_t aDestOffset,
-                                                            bool aDoDeleteSelection)
+NS_IMETHODIMP
+TextEditor::InsertTextFromTransferable(nsITransferable* aTransferable,
+                                       nsIDOMNode* aDestinationNode,
+                                       int32_t aDestOffset,
+                                       bool aDoDeleteSelection)
 {
   nsresult rv = NS_OK;
   char* bestFlavor = nullptr;
   nsCOMPtr<nsISupports> genericDataObj;
   uint32_t len = 0;
   if (NS_SUCCEEDED(aTransferable->GetAnyTransferData(&bestFlavor, getter_AddRefs(genericDataObj), &len))
       && bestFlavor && (0 == nsCRT::strcmp(bestFlavor, kUnicodeMime) ||
                         0 == nsCRT::strcmp(bestFlavor, kMozTextInternal)))
@@ -132,39 +137,41 @@ NS_IMETHODIMP nsPlaintextEditor::InsertT
   // Try to scroll the selection into view if the paste/drop succeeded
 
   if (NS_SUCCEEDED(rv))
     ScrollSelectionIntoView(false);
 
   return rv;
 }
 
-nsresult nsPlaintextEditor::InsertFromDataTransfer(DataTransfer *aDataTransfer,
-                                                   int32_t aIndex,
-                                                   nsIDOMDocument *aSourceDoc,
-                                                   nsIDOMNode *aDestinationNode,
-                                                   int32_t aDestOffset,
-                                                   bool aDoDeleteSelection)
+nsresult
+TextEditor::InsertFromDataTransfer(DataTransfer* aDataTransfer,
+                                   int32_t aIndex,
+                                   nsIDOMDocument* aSourceDoc,
+                                   nsIDOMNode* aDestinationNode,
+                                   int32_t aDestOffset,
+                                   bool aDoDeleteSelection)
 {
   nsCOMPtr<nsIVariant> data;
   DataTransfer::Cast(aDataTransfer)->GetDataAtNoSecurityCheck(NS_LITERAL_STRING("text/plain"), aIndex,
                                                               getter_AddRefs(data));
   if (data) {
     nsAutoString insertText;
     data->GetAsAString(insertText);
     nsContentUtils::PlatformToDOMLineBreaks(insertText);
 
     AutoEditBatch beginBatching(this);
     return InsertTextAt(insertText, aDestinationNode, aDestOffset, aDoDeleteSelection);
   }
 
   return NS_OK;
 }
 
-nsresult nsPlaintextEditor::InsertFromDrop(nsIDOMEvent* aDropEvent)
+nsresult
+TextEditor::InsertFromDrop(nsIDOMEvent* aDropEvent)
 {
   ForceCompositionEnd();
 
   nsCOMPtr<nsIDOMDragEvent> dragEvent(do_QueryInterface(aDropEvent));
   NS_ENSURE_TRUE(dragEvent, NS_ERROR_FAILURE);
 
   nsCOMPtr<nsIDOMDataTransfer> domDataTransfer;
   dragEvent->GetDataTransfer(getter_AddRefs(domDataTransfer));
@@ -315,17 +322,18 @@ nsresult nsPlaintextEditor::InsertFromDr
   }
 
   if (NS_SUCCEEDED(rv))
     ScrollSelectionIntoView(false);
 
   return rv;
 }
 
-NS_IMETHODIMP nsPlaintextEditor::Paste(int32_t aSelectionType)
+NS_IMETHODIMP
+TextEditor::Paste(int32_t aSelectionType)
 {
   if (!FireClipboardEvent(ePaste, aSelectionType)) {
     return NS_OK;
   }
 
   // Get Clipboard Service
   nsresult rv;
   nsCOMPtr<nsIClipboard> clipboard(do_GetService("@mozilla.org/widget/clipboard;1", &rv));
@@ -348,17 +356,18 @@ NS_IMETHODIMP nsPlaintextEditor::Paste(i
 
       rv = InsertTextFromTransferable(trans, nullptr, 0, true);
     }
   }
 
   return rv;
 }
 
-NS_IMETHODIMP nsPlaintextEditor::PasteTransferable(nsITransferable *aTransferable)
+NS_IMETHODIMP
+TextEditor::PasteTransferable(nsITransferable* aTransferable)
 {
   // Use an invalid value for the clipboard type as data comes from aTransferable
   // and we don't currently implement a way to put that in the data transfer yet.
   if (!FireClipboardEvent(ePaste, -1)) {
     return NS_OK;
   }
 
   if (!IsModifiable())
@@ -368,17 +377,19 @@ NS_IMETHODIMP nsPlaintextEditor::PasteTr
   nsCOMPtr<nsIDOMDocument> domdoc = GetDOMDocument();
   if (!EditorHookUtils::DoInsertionHook(domdoc, nullptr, aTransferable)) {
     return NS_OK;
   }
 
   return InsertTextFromTransferable(aTransferable, nullptr, 0, true);
 }
 
-NS_IMETHODIMP nsPlaintextEditor::CanPaste(int32_t aSelectionType, bool *aCanPaste)
+NS_IMETHODIMP
+TextEditor::CanPaste(int32_t aSelectionType,
+                     bool* aCanPaste)
 {
   NS_ENSURE_ARG_POINTER(aCanPaste);
   *aCanPaste = false;
 
   // can't paste if readonly
   if (!IsModifiable())
     return NS_OK;
 
@@ -395,17 +406,19 @@ NS_IMETHODIMP nsPlaintextEditor::CanPast
                                          aSelectionType, &haveFlavors);
   NS_ENSURE_SUCCESS(rv, rv);
 
   *aCanPaste = haveFlavors;
   return NS_OK;
 }
 
 
-NS_IMETHODIMP nsPlaintextEditor::CanPasteTransferable(nsITransferable *aTransferable, bool *aCanPaste)
+NS_IMETHODIMP
+TextEditor::CanPasteTransferable(nsITransferable* aTransferable,
+                                 bool* aCanPaste)
 {
   NS_ENSURE_ARG_POINTER(aCanPaste);
 
   // can't paste if readonly
   if (!IsModifiable()) {
     *aCanPaste = false;
     return NS_OK;
   }
@@ -424,17 +437,18 @@ NS_IMETHODIMP nsPlaintextEditor::CanPast
   if (NS_SUCCEEDED(rv) && data)
     *aCanPaste = true;
   else
     *aCanPaste = false;
 
   return NS_OK;
 }
 
-bool nsPlaintextEditor::IsSafeToInsertData(nsIDOMDocument* aSourceDoc)
+bool
+TextEditor::IsSafeToInsertData(nsIDOMDocument* aSourceDoc)
 {
   // Try to determine whether we should use a sanitizing fragment sink
   bool isSafe = false;
 
   nsCOMPtr<nsIDocument> destdoc = GetDocument();
   NS_ASSERTION(destdoc, "Where is our destination doc?");
   nsCOMPtr<nsIDocShellTreeItem> dsti = destdoc->GetDocShell();
   nsCOMPtr<nsIDocShellTreeItem> root;
@@ -452,8 +466,9 @@ bool nsPlaintextEditor::IsSafeToInsertDa
     nsIPrincipal* destPrincipal = destdoc->NodePrincipal();
     NS_ASSERTION(srcPrincipal && destPrincipal, "How come we don't have a principal?");
     srcPrincipal->Subsumes(destPrincipal, &isSafe);
   }
 
   return isSafe;
 }
 
+} // namespace mozilla
--- a/editor/libeditor/moz.build
+++ b/editor/libeditor/moz.build
@@ -17,16 +17,17 @@ EXPORTS += [
     'nsEditor.h',
     'nsIEditRules.h',
 ]
 
 EXPORTS.mozilla.editor += [
     'EditorController.h',
     'HTMLEditor.h',
     'SelectionState.h',
+    'TextEditor.h',
     'TextEditRules.h',
 ]
 
 UNIFIED_SOURCES += [
     'ChangeAttributeTransaction.cpp',
     'ChangeStyleTransaction.cpp',
     'CompositionTransaction.cpp',
     'CreateElementTransaction.cpp',
@@ -52,23 +53,23 @@ UNIFIED_SOURCES += [
     'HTMLStyleEditor.cpp',
     'HTMLTableEditor.cpp',
     'HTMLURIRefObject.cpp',
     'InsertNodeTransaction.cpp',
     'InsertTextTransaction.cpp',
     'InternetCiter.cpp',
     'JoinNodeTransaction.cpp',
     'nsEditor.cpp',
-    'nsPlaintextDataTransfer.cpp',
-    'nsPlaintextEditor.cpp',
     'PlaceholderTransaction.cpp',
     'SelectionState.cpp',
     'SetDocumentTitleTransaction.cpp',
     'SplitNodeTransaction.cpp',
     'StyleSheetTransactions.cpp',
+    'TextEditor.cpp',
+    'TextEditorDataTransfer.cpp',
     'TextEditorTest.cpp',
     'TextEditRules.cpp',
     'TextEditRulesBidi.cpp',
     'TextEditUtils.cpp',
     'TypeInState.cpp',
     'WSRunObject.cpp',
 ]
 
--- a/editor/libeditor/nsIEditRules.h
+++ b/editor/libeditor/nsIEditRules.h
@@ -7,20 +7,19 @@
 #define nsIEditRules_h_
 
 #define NS_IEDITRULES_IID \
 { 0x3836386d, 0x806a, 0x488d, \
   { 0x8b, 0xab, 0xaf, 0x42, 0xbb, 0x4c, 0x90, 0x66 } }
 
 #include "nsEditor.h" // for EditAction enum
 
-class nsPlaintextEditor;
-
 namespace mozilla {
 
+class TextEditor;
 namespace dom {
 class Selection;
 } // namespace dom
 
 /**
  * Base for an object to encapsulate any additional info needed to be passed
  * to rules system by the editor.
  */
@@ -43,17 +42,17 @@ public:
 class nsIEditRules : public nsISupports
 {
 public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IEDITRULES_IID)
 
 //Interfaces for addref and release and queryinterface
 //NOTE: Use   NS_DECL_ISUPPORTS_INHERITED in any class inherited from nsIEditRules
 
-  NS_IMETHOD Init(nsPlaintextEditor* aEditor) = 0;
+  NS_IMETHOD Init(mozilla::TextEditor* aTextEditor) = 0;
   NS_IMETHOD SetInitialValue(const nsAString& aValue) = 0;
   NS_IMETHOD DetachEditor() = 0;
   NS_IMETHOD BeforeEdit(EditAction action,
                         nsIEditor::EDirection aDirection) = 0;
   NS_IMETHOD AfterEdit(EditAction action,
                        nsIEditor::EDirection aDirection) = 0;
   NS_IMETHOD WillDoAction(mozilla::dom::Selection* aSelection,
                           mozilla::RulesInfo* aInfo, bool* aCancel,
--- a/layout/build/nsLayoutModule.cpp
+++ b/layout/build/nsLayoutModule.cpp
@@ -132,17 +132,16 @@ using mozilla::dom::PushNotifier;
 #endif
 
 #include "AudioChannelAgent.h"
 using mozilla::dom::AudioChannelAgent;
 
 // Editor stuff
 #include "nsEditorCID.h"
 #include "nsEditor.h"
-#include "nsPlaintextEditor.h"
 #include "mozilla/editor/EditorController.h" //CID
 #include "mozilla/editor/HTMLEditor.h"
 
 #include "nsTextServicesDocument.h"
 #include "nsTextServicesCID.h"
 
 #include "nsScriptSecurityManager.h"
 #include "nsPrincipal.h"
@@ -275,17 +274,17 @@ using mozilla::dom::NotificationTelemetr
 #define NS_EDITINGCOMMANDTABLE_CID \
 { 0xcb38a746, 0xbeb8, 0x43f3, \
   { 0x94, 0x29, 0x77, 0x96, 0xe1, 0xa9, 0x3f, 0xb4 } }
 
 #define NS_HAPTICFEEDBACK_CID \
 { 0x1f15dbc8, 0xbfaa, 0x45de, \
   { 0x8a, 0x46, 0x08, 0xe2, 0xe2, 0x63, 0x26, 0xb0 } }
 
-NS_GENERIC_FACTORY_CONSTRUCTOR(nsPlaintextEditor)
+NS_GENERIC_FACTORY_CONSTRUCTOR(TextEditor)
 
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsParserUtils)
 
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsTextServicesDocument)
 
 NS_GENERIC_FACTORY_CONSTRUCTOR(HTMLEditor)
 
 // Transformiix
@@ -1076,17 +1075,17 @@ static const mozilla::Module::CIDEntry k
   { &kNS_FORMDATA_CID, false, nullptr, FormDataConstructor },
   { &kNS_HOSTOBJECTURI_CID, false, nullptr, nsHostObjectURIConstructor },
   { &kNS_XMLHTTPREQUEST_CID, false, nullptr, nsXMLHttpRequestConstructor },
   { &kNS_DOMPARSER_CID, false, nullptr, DOMParserConstructor },
   { &kNS_XPCEXCEPTION_CID, false, nullptr, ExceptionConstructor },
   { &kNS_DOMSESSIONSTORAGEMANAGER_CID, false, nullptr, DOMSessionStorageManagerConstructor },
   { &kNS_DOMLOCALSTORAGEMANAGER_CID, false, nullptr, DOMLocalStorageManagerConstructor },
   { &kNS_DOMJSON_CID, false, nullptr, NS_NewJSON },
-  { &kNS_TEXTEDITOR_CID, false, nullptr, nsPlaintextEditorConstructor },
+  { &kNS_TEXTEDITOR_CID, false, nullptr, TextEditorConstructor },
   { &kDOMREQUEST_SERVICE_CID, false, nullptr, DOMRequestServiceConstructor },
   { &kQUOTAMANAGER_SERVICE_CID, false, nullptr, QuotaManagerServiceConstructor },
   { &kSERVICEWORKERMANAGER_CID, false, nullptr, ServiceWorkerManagerConstructor },
   { &kNOTIFICATIONTELEMETRYSERVICE_CID, false, nullptr, NotificationTelemetryServiceConstructor },
 #ifndef MOZ_SIMPLEPUSH
   { &kPUSHNOTIFIER_CID, false, nullptr, PushNotifierConstructor },
 #endif
   { &kWORKERDEBUGGERMANAGER_CID, true, nullptr, WorkerDebuggerManagerConstructor },