Add m-esr52 at 52.6.0

1 files changed, 1046 insertions, 0 deletions

diff --git a/editor/libeditor/EditorBase.h b/editor/libeditor/EditorBase.h
new file mode 100644
index 000000000..dd4b9695e
--- /dev/null
+++ b/editor/libeditor/EditorBase.h
@@ -0,0 +1,1046 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_EditorBase_h
+#define mozilla_EditorBase_h
+
+#include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc.
+#include "mozFlushType.h"               // for mozFlushType enum
+#include "mozilla/OwningNonNull.h"      // for OwningNonNull
+#include "mozilla/SelectionState.h"     // for RangeUpdater, etc.
+#include "mozilla/StyleSheet.h"   // for StyleSheet
+#include "mozilla/dom/Text.h"
+#include "nsCOMPtr.h"                   // for already_AddRefed, nsCOMPtr
+#include "nsCycleCollectionParticipant.h"
+#include "nsGkAtoms.h"
+#include "nsIEditor.h"                  // for nsIEditor::EDirection, etc.
+#include "nsIEditorIMESupport.h"        // for NS_DECL_NSIEDITORIMESUPPORT, etc.
+#include "nsIObserver.h"                // for NS_DECL_NSIOBSERVER, etc.
+#include "nsIPhonetic.h"                // for NS_DECL_NSIPHONETIC, etc.
+#include "nsIPlaintextEditor.h"         // for nsIPlaintextEditor, etc.
+#include "nsISelectionController.h"     // for nsISelectionController constants
+#include "nsISupportsImpl.h"            // for EditorBase::Release, etc.
+#include "nsIWeakReferenceUtils.h"      // for nsWeakPtr
+#include "nsLiteralString.h"            // for NS_LITERAL_STRING
+#include "nsString.h"                   // for nsCString
+#include "nsWeakReference.h"            // for nsSupportsWeakReference
+#include "nscore.h"                     // for nsresult, nsAString, etc.
+
+class nsIAtom;
+class nsIContent;
+class nsIDOMDocument;
+class nsIDOMEvent;
+class nsIDOMEventListener;
+class nsIDOMEventTarget;
+class nsIDOMKeyEvent;
+class nsIDOMNode;
+class nsIDocument;
+class nsIDocumentStateListener;
+class nsIEditActionListener;
+class nsIEditorObserver;
+class nsIInlineSpellChecker;
+class nsINode;
+class nsIPresShell;
+class nsISupports;
+class nsITransaction;
+class nsIWidget;
+class nsRange;
+class nsString;
+class nsTransactionManager;
+
+// This is int32_t instead of int16_t because nsIInlineSpellChecker.idl's
+// spellCheckAfterEditorChange is defined to take it as a long.
+// XXX EditAction causes unnecessary include of EditorBase from some places.
+//     Why don't you move this to nsIEditor.idl?
+enum class EditAction : int32_t
+{
+  ignore = -1,
+  none = 0,
+  undo,
+  redo,
+  insertNode,
+  createNode,
+  deleteNode,
+  splitNode,
+  joinNode,
+  deleteText = 1003,
+
+  // text commands
+  insertText         = 2000,
+  insertIMEText      = 2001,
+  deleteSelection    = 2002,
+  setTextProperty    = 2003,
+  removeTextProperty = 2004,
+  outputText         = 2005,
+
+  // html only action
+  insertBreak         = 3000,
+  makeList            = 3001,
+  indent              = 3002,
+  outdent             = 3003,
+  align               = 3004,
+  makeBasicBlock      = 3005,
+  removeList          = 3006,
+  makeDefListItem     = 3007,
+  insertElement       = 3008,
+  insertQuotation     = 3009,
+  htmlPaste           = 3012,
+  loadHTML            = 3013,
+  resetTextProperties = 3014,
+  setAbsolutePosition = 3015,
+  removeAbsolutePosition = 3016,
+  decreaseZIndex      = 3017,
+  increaseZIndex      = 3018
+};
+
+inline bool operator!(const EditAction& aOp)
+{
+  return aOp == EditAction::none;
+}
+
+namespace mozilla {
+class AddStyleSheetTransaction;
+class AutoRules;
+class AutoSelectionRestorer;
+class AutoTransactionsConserveSelection;
+class ChangeAttributeTransaction;
+class CompositionTransaction;
+class CreateElementTransaction;
+class DeleteNodeTransaction;
+class DeleteTextTransaction;
+class EditAggregateTransaction;
+class ErrorResult;
+class InsertNodeTransaction;
+class InsertTextTransaction;
+class JoinNodeTransaction;
+class RemoveStyleSheetTransaction;
+class SplitNodeTransaction;
+class TextComposition;
+struct EditorDOMPoint;
+
+namespace dom {
+class DataTransfer;
+class Element;
+class EventTarget;
+class Selection;
+class Text;
+} // namespace dom
+
+namespace widget {
+struct IMEState;
+} // namespace widget
+
+#define kMOZEditorBogusNodeAttrAtom nsGkAtoms::mozeditorbogusnode
+#define kMOZEditorBogusNodeValue NS_LITERAL_STRING("TRUE")
+
+/**
+ * Implementation of an editor object.  it will be the controller/focal point
+ * for the main editor services. i.e. the GUIManager, publishing, transaction
+ * manager, event interfaces. the idea for the event interfaces is to have them
+ * delegate the actual commands to the editor independent of the XPFE
+ * implementation.
+ */
+class EditorBase : public nsIEditor
+                 , public nsIEditorIMESupport
+                 , public nsSupportsWeakReference
+                 , public nsIPhonetic
+{
+public:
+  typedef dom::Element Element;
+  typedef dom::Selection Selection;
+  typedef dom::Text Text;
+
+  enum IterDirection
+  {
+    kIterForward,
+    kIterBackward
+  };
+
+  /**
+   * The default constructor. This should suffice. the setting of the
+   * interfaces is done after the construction of the editor class.
+   */
+  EditorBase();
+
+protected:
+  /**
+   * The default destructor. This should suffice. Should this be pure virtual
+   * for someone to derive from the EditorBase later? I don't believe so.
+   */
+  virtual ~EditorBase();
+
+public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(EditorBase, nsIEditor)
+
+  already_AddRefed<nsIDOMDocument> GetDOMDocument();
+  already_AddRefed<nsIDocument> GetDocument();
+  already_AddRefed<nsIPresShell> GetPresShell();
+  already_AddRefed<nsIWidget> GetWidget();
+  enum NotificationForEditorObservers
+  {
+    eNotifyEditorObserversOfEnd,
+    eNotifyEditorObserversOfBefore,
+    eNotifyEditorObserversOfCancel
+  };
+  void NotifyEditorObservers(NotificationForEditorObservers aNotification);
+
+  // nsIEditor methods
+  NS_DECL_NSIEDITOR
+
+  // nsIEditorIMESupport methods
+  NS_DECL_NSIEDITORIMESUPPORT
+
+  // nsIPhonetic
+  NS_DECL_NSIPHONETIC
+
+public:
+  virtual bool IsModifiableNode(nsINode* aNode);
+
+  virtual nsresult InsertTextImpl(const nsAString& aStringToInsert,
+                                  nsCOMPtr<nsINode>* aInOutNode,
+                                  int32_t* aInOutOffset,
+                                  nsIDocument* aDoc);
+  nsresult InsertTextIntoTextNodeImpl(const nsAString& aStringToInsert,
+                                      Text& aTextNode, int32_t aOffset,
+                                      bool aSuppressIME = false);
+  NS_IMETHOD DeleteSelectionImpl(EDirection aAction,
+                                 EStripWrappers aStripWrappers);
+
+  already_AddRefed<Element> DeleteSelectionAndCreateElement(nsIAtom& aTag);
+
+  /**
+   * Helper routines for node/parent manipulations.
+   */
+  nsresult DeleteNode(nsINode* aNode);
+  nsresult InsertNode(nsIContent& aNode, nsINode& aParent, int32_t aPosition);
+  enum ECloneAttributes { eDontCloneAttributes, eCloneAttributes };
+  already_AddRefed<Element> ReplaceContainer(Element* aOldContainer,
+                                             nsIAtom* aNodeType,
+                                             nsIAtom* aAttribute = nullptr,
+                                             const nsAString* aValue = nullptr,
+                                             ECloneAttributes aCloneAttributes
+                                             = eDontCloneAttributes);
+  void CloneAttributes(Element* aDest, Element* aSource);
+
+  nsresult RemoveContainer(nsIContent* aNode);
+  already_AddRefed<Element> InsertContainerAbove(nsIContent* aNode,
+                                                 nsIAtom* aNodeType,
+                                                 nsIAtom* aAttribute = nullptr,
+                                                 const nsAString* aValue =
+                                                 nullptr);
+  nsIContent* SplitNode(nsIContent& aNode, int32_t aOffset,
+                        ErrorResult& aResult);
+  nsresult JoinNodes(nsINode& aLeftNode, nsINode& aRightNode);
+  nsresult MoveNode(nsIContent* aNode, nsINode* aParent, int32_t aOffset);
+
+  /**
+   * Method to replace certain CreateElementNS() calls.
+   *
+   * @param aTag        Tag you want.
+   */
+  already_AddRefed<Element> CreateHTMLContent(nsIAtom* aTag);
+
+  /**
+   * IME event handlers.
+   */
+  virtual nsresult BeginIMEComposition(WidgetCompositionEvent* aEvent);
+  virtual nsresult UpdateIMEComposition(nsIDOMEvent* aDOMTextEvent) = 0;
+  void EndIMEComposition();
+
+  void SwitchTextDirectionTo(uint32_t aDirection);
+
+protected:
+  nsresult DetermineCurrentDirection();
+  void FireInputEvent();
+
+  /**
+   * Create a transaction for setting aAttribute to aValue on aElement.  Never
+   * returns null.
+   */
+  already_AddRefed<ChangeAttributeTransaction>
+    CreateTxnForSetAttribute(Element& aElement, nsIAtom& aAttribute,
+                             const nsAString& aValue);
+
+  /**
+   * Create a transaction for removing aAttribute on aElement.  Never returns
+   * null.
+   */
+  already_AddRefed<ChangeAttributeTransaction>
+    CreateTxnForRemoveAttribute(Element& aElement, nsIAtom& aAttribute);
+
+  /**
+   * Create a transaction for creating a new child node of aParent of type aTag.
+   */
+  already_AddRefed<CreateElementTransaction>
+    CreateTxnForCreateElement(nsIAtom& aTag,
+                              nsINode& aParent,
+                              int32_t aPosition);
+
+  already_AddRefed<Element> CreateNode(nsIAtom* aTag, nsINode* aParent,
+                                       int32_t aPosition);
+
+  /**
+   * Create a transaction for inserting aNode as a child of aParent.
+   */
+  already_AddRefed<InsertNodeTransaction>
+    CreateTxnForInsertNode(nsIContent& aNode, nsINode& aParent,
+                           int32_t aOffset);
+
+  /**
+   * Create a transaction for removing aNode from its parent.
+   */
+  nsresult CreateTxnForDeleteNode(nsINode* aNode,
+                                  DeleteNodeTransaction** aTransaction);
+
+  nsresult CreateTxnForDeleteSelection(
+             EDirection aAction,
+             EditAggregateTransaction** aTransaction,
+             nsINode** aNode,
+             int32_t* aOffset,
+             int32_t* aLength);
+
+  nsresult CreateTxnForDeleteInsertionPoint(
+             nsRange* aRange,
+             EDirection aAction,
+             EditAggregateTransaction* aTransaction,
+             nsINode** aNode,
+             int32_t* aOffset,
+             int32_t* aLength);
+
+
+  /**
+   * Create a transaction for inserting aStringToInsert into aTextNode.  Never
+   * returns null.
+   */
+  already_AddRefed<mozilla::InsertTextTransaction>
+    CreateTxnForInsertText(const nsAString& aStringToInsert, Text& aTextNode,
+                           int32_t aOffset);
+
+  /**
+   * Never returns null.
+   */
+  already_AddRefed<mozilla::CompositionTransaction>
+    CreateTxnForComposition(const nsAString& aStringToInsert);
+
+  /**
+   * Create a transaction for adding a style sheet.
+   */
+  NS_IMETHOD CreateTxnForAddStyleSheet(
+               StyleSheet* aSheet,
+               AddStyleSheetTransaction** aTransaction);
+
+  /**
+   * Create a transaction for removing a style sheet.
+   */
+  NS_IMETHOD CreateTxnForRemoveStyleSheet(
+               StyleSheet* aSheet,
+               RemoveStyleSheetTransaction** aTransaction);
+
+  nsresult DeleteText(nsGenericDOMDataNode& aElement,
+                      uint32_t aOffset, uint32_t aLength);
+
+  already_AddRefed<DeleteTextTransaction>
+    CreateTxnForDeleteText(nsGenericDOMDataNode& aElement,
+                           uint32_t aOffset, uint32_t aLength);
+
+  already_AddRefed<DeleteTextTransaction>
+    CreateTxnForDeleteCharacter(nsGenericDOMDataNode& aData, uint32_t aOffset,
+                                EDirection aDirection);
+
+  already_AddRefed<SplitNodeTransaction>
+    CreateTxnForSplitNode(nsIContent& aNode, uint32_t aOffset);
+
+  already_AddRefed<JoinNodeTransaction>
+    CreateTxnForJoinNode(nsINode& aLeftNode, nsINode& aRightNode);
+
+  /**
+   * This method first deletes the selection, if it's not collapsed.  Then if
+   * the selection lies in a CharacterData node, it splits it.  If the
+   * selection is at this point collapsed in a CharacterData node, it's
+   * adjusted to be collapsed right before or after the node instead (which is
+   * always possible, since the node was split).
+   */
+  nsresult DeleteSelectionAndPrepareToCreateNode();
+
+  /**
+   * Called after a transaction is done successfully.
+   */
+  void DoAfterDoTransaction(nsITransaction *aTxn);
+
+  /**
+   * Called after a transaction is undone successfully.
+   */
+
+  void DoAfterUndoTransaction();
+
+  /**
+   * Called after a transaction is redone successfully.
+   */
+  void DoAfterRedoTransaction();
+
+  enum TDocumentListenerNotification
+  {
+    eDocumentCreated,
+    eDocumentToBeDestroyed,
+    eDocumentStateChanged
+  };
+
+  /**
+   * Tell the doc state listeners that the doc state has changed.
+   */
+  NS_IMETHOD NotifyDocumentListeners(
+               TDocumentListenerNotification aNotificationType);
+
+  /**
+   * Make the given selection span the entire document.
+   */
+  virtual nsresult SelectEntireDocument(Selection* aSelection);
+
+  /**
+   * Helper method for scrolling the selection into view after
+   * an edit operation. aScrollToAnchor should be true if you
+   * want to scroll to the point where the selection was started.
+   * If false, it attempts to scroll the end of the selection into view.
+   *
+   * Editor methods *should* call this method instead of the versions
+   * in the various selection interfaces, since this version makes sure
+   * that the editor's sync/async settings for reflowing, painting, and
+   * scrolling match.
+   */
+  NS_IMETHOD ScrollSelectionIntoView(bool aScrollToAnchor);
+
+  virtual bool IsBlockNode(nsINode* aNode);
+
+  /**
+   * Helper for GetPriorNode() and GetNextNode().
+   */
+  nsIContent* FindNextLeafNode(nsINode* aCurrentNode,
+                               bool aGoForward,
+                               bool bNoBlockCrossing);
+
+  virtual nsresult InstallEventListeners();
+  virtual void CreateEventListeners();
+  virtual void RemoveEventListeners();
+
+  /**
+   * Return true if spellchecking should be enabled for this editor.
+   */
+  bool GetDesiredSpellCheckState();
+
+  bool CanEnableSpellCheck()
+  {
+    // Check for password/readonly/disabled, which are not spellchecked
+    // regardless of DOM. Also, check to see if spell check should be skipped
+    // or not.
+    return !IsPasswordEditor() && !IsReadonly() && !IsDisabled() &&
+           !ShouldSkipSpellCheck();
+  }
+
+  /**
+   * EnsureComposition() should be called by composition event handlers.  This
+   * tries to get the composition for the event and set it to mComposition.
+   * However, this may fail because the composition may be committed before
+   * the event comes to the editor.
+   *
+   * @return            true if there is a composition.  Otherwise, for example,
+   *                    a composition event handler in web contents moved focus
+   *                    for committing the composition, returns false.
+   */
+  bool EnsureComposition(WidgetCompositionEvent* aCompositionEvent);
+
+  nsresult GetSelection(SelectionType aSelectionType,
+                        nsISelection** aSelection);
+
+public:
+  /**
+   * All editor operations which alter the doc should be prefaced
+   * with a call to StartOperation, naming the action and direction.
+   */
+  NS_IMETHOD StartOperation(EditAction opID,
+                            nsIEditor::EDirection aDirection);
+
+  /**
+   * All editor operations which alter the doc should be followed
+   * with a call to EndOperation.
+   */
+  NS_IMETHOD EndOperation();
+
+  /**
+   * Routines for managing the preservation of selection across
+   * various editor actions.
+   */
+  bool ArePreservingSelection();
+  void PreserveSelectionAcrossActions(Selection* aSel);
+  nsresult RestorePreservedSelection(Selection* aSel);
+  void StopPreservingSelection();
+
+  /**
+   * SplitNode() creates a new node identical to an existing node, and split
+   * the contents between the two nodes
+   * @param aExistingRightNode  The node to split.  It will become the new
+   *                            node's next sibling.
+   * @param aOffset             The offset of aExistingRightNode's
+   *                            content|children to do the split at
+   * @param aNewLeftNode        The new node resulting from the split, becomes
+   *                            aExistingRightNode's previous sibling.
+   */
+  nsresult SplitNodeImpl(nsIContent& aExistingRightNode,
+                         int32_t aOffset,
+                         nsIContent& aNewLeftNode);
+
+  /**
+   * JoinNodes() takes 2 nodes and merge their content|children.
+   * @param aNodeToKeep   The node that will remain after the join.
+   * @param aNodeToJoin   The node that will be joined with aNodeToKeep.
+   *                      There is no requirement that the two nodes be of the
+   *                      same type.
+   * @param aParent       The parent of aNodeToKeep
+   */
+  nsresult JoinNodesImpl(nsINode* aNodeToKeep,
+                         nsINode* aNodeToJoin,
+                         nsINode* aParent);
+
+  /**
+   * Return the offset of aChild in aParent.  Asserts fatally if parent or
+   * child is null, or parent is not child's parent.
+   */
+  static int32_t GetChildOffset(nsIDOMNode* aChild,
+                                nsIDOMNode* aParent);
+
+  /**
+   * Set outOffset to the offset of aChild in the parent.
+   * Returns the parent of aChild.
+   */
+  static already_AddRefed<nsIDOMNode> GetNodeLocation(nsIDOMNode* aChild,
+                                                      int32_t* outOffset);
+  static nsINode* GetNodeLocation(nsINode* aChild, int32_t* aOffset);
+
+  /**
+   * Returns the number of things inside aNode in the out-param aCount.
+   * @param  aNode is the node to get the length of.
+   *         If aNode is text, returns number of characters.
+   *         If not, returns number of children nodes.
+   * @param  aCount [OUT] the result of the above calculation.
+   */
+  static nsresult GetLengthOfDOMNode(nsIDOMNode *aNode, uint32_t &aCount);
+
+  /**
+   * Get the node immediately prior to aCurrentNode.
+   * @param aCurrentNode   the node from which we start the search
+   * @param aEditableNode  if true, only return an editable node
+   * @param aResultNode    [OUT] the node that occurs before aCurrentNode in
+   *                             the tree, skipping non-editable nodes if
+   *                             aEditableNode is true.  If there is no prior
+   *                             node, aResultNode will be nullptr.
+   * @param bNoBlockCrossing If true, don't move across "block" nodes,
+   *                         whatever that means.
+   */
+  nsIContent* GetPriorNode(nsINode* aCurrentNode, bool aEditableNode,
+                           bool aNoBlockCrossing = false);
+
+  /**
+   * And another version that takes a {parent,offset} pair rather than a node.
+   */
+  nsIContent* GetPriorNode(nsINode* aParentNode,
+                           int32_t aOffset,
+                           bool aEditableNode,
+                           bool aNoBlockCrossing = false);
+
+
+  /**
+   * Get the node immediately after to aCurrentNode.
+   * @param aCurrentNode   the node from which we start the search
+   * @param aEditableNode  if true, only return an editable node
+   * @param aResultNode    [OUT] the node that occurs after aCurrentNode in the
+   *                             tree, skipping non-editable nodes if
+   *                             aEditableNode is true.  If there is no prior
+   *                             node, aResultNode will be nullptr.
+   */
+  nsIContent* GetNextNode(nsINode* aCurrentNode,
+                          bool aEditableNode,
+                          bool bNoBlockCrossing = false);
+
+  /**
+   * And another version that takes a {parent,offset} pair rather than a node.
+   */
+  nsIContent* GetNextNode(nsINode* aParentNode,
+                          int32_t aOffset,
+                          bool aEditableNode,
+                          bool aNoBlockCrossing = false);
+
+  /**
+   * Helper for GetNextNode() and GetPriorNode().
+   */
+  nsIContent* FindNode(nsINode* aCurrentNode,
+                       bool aGoForward,
+                       bool aEditableNode,
+                       bool bNoBlockCrossing);
+  /**
+   * Get the rightmost child of aCurrentNode;
+   * return nullptr if aCurrentNode has no children.
+   */
+  nsIContent* GetRightmostChild(nsINode* aCurrentNode,
+                                bool bNoBlockCrossing = false);
+
+  /**
+   * Get the leftmost child of aCurrentNode;
+   * return nullptr if aCurrentNode has no children.
+   */
+  nsIContent* GetLeftmostChild(nsINode *aCurrentNode,
+                               bool bNoBlockCrossing = false);
+
+  /**
+   * Returns true if aNode is of the type implied by aTag.
+   */
+  static inline bool NodeIsType(nsIDOMNode* aNode, nsIAtom* aTag)
+  {
+    return GetTag(aNode) == aTag;
+  }
+
+  /**
+   * Returns true if aParent can contain a child of type aTag.
+   */
+  bool CanContain(nsINode& aParent, nsIContent& aChild);
+  bool CanContainTag(nsINode& aParent, nsIAtom& aTag);
+  bool TagCanContain(nsIAtom& aParentTag, nsIContent& aChild);
+  virtual bool TagCanContainTag(nsIAtom& aParentTag, nsIAtom& aChildTag);
+
+  /**
+   * Returns true if aNode is our root node.
+   */
+  bool IsRoot(nsIDOMNode* inNode);
+  bool IsRoot(nsINode* inNode);
+  bool IsEditorRoot(nsINode* aNode);
+
+  /**
+   * Returns true if aNode is a descendant of our root node.
+   */
+  bool IsDescendantOfRoot(nsIDOMNode* inNode);
+  bool IsDescendantOfRoot(nsINode* inNode);
+  bool IsDescendantOfEditorRoot(nsINode* aNode);
+
+  /**
+   * Returns true if aNode is a container.
+   */
+  virtual bool IsContainer(nsINode* aNode);
+  virtual bool IsContainer(nsIDOMNode* aNode);
+
+  /**
+   * returns true if aNode is an editable node.
+   */
+  bool IsEditable(nsIDOMNode* aNode);
+  virtual bool IsEditable(nsINode* aNode);
+
+  /**
+   * Returns true if aNode is a MozEditorBogus node.
+   */
+  bool IsMozEditorBogusNode(nsINode* aNode);
+
+  /**
+   * Counts number of editable child nodes.
+   */
+  uint32_t CountEditableChildren(nsINode* aNode);
+
+  /**
+   * Find the deep first and last children.
+   */
+  nsINode* GetFirstEditableNode(nsINode* aRoot);
+
+  /**
+   * Returns current composition.
+   */
+  TextComposition* GetComposition() const;
+
+  /**
+   * Returns true if there is composition string and not fixed.
+   */
+  bool IsIMEComposing() const;
+
+  /**
+   * Returns true when inserting text should be a part of current composition.
+   */
+  bool ShouldHandleIMEComposition() const;
+
+  /**
+   * From html rules code - migration in progress.
+   */
+  static nsresult GetTagString(nsIDOMNode* aNode, nsAString& outString);
+  static nsIAtom* GetTag(nsIDOMNode* aNode);
+
+  bool NodesSameType(nsIDOMNode* aNode1, nsIDOMNode* aNode2);
+  virtual bool AreNodesSameType(nsIContent* aNode1, nsIContent* aNode2);
+
+  static bool IsTextNode(nsIDOMNode* aNode);
+  static bool IsTextNode(nsINode* aNode);
+
+  static nsCOMPtr<nsIDOMNode> GetChildAt(nsIDOMNode* aParent, int32_t aOffset);
+  static nsIContent* GetNodeAtRangeOffsetPoint(nsIDOMNode* aParentOrNode,
+                                               int32_t aOffset);
+
+  static nsresult GetStartNodeAndOffset(Selection* aSelection,
+                                        nsIDOMNode** outStartNode,
+                                        int32_t* outStartOffset);
+  static nsresult GetStartNodeAndOffset(Selection* aSelection,
+                                        nsINode** aStartNode,
+                                        int32_t* aStartOffset);
+  static nsresult GetEndNodeAndOffset(Selection* aSelection,
+                                      nsIDOMNode** outEndNode,
+                                      int32_t* outEndOffset);
+  static nsresult GetEndNodeAndOffset(Selection* aSelection,
+                                      nsINode** aEndNode,
+                                      int32_t* aEndOffset);
+#if DEBUG_JOE
+  static void DumpNode(nsIDOMNode* aNode, int32_t indent = 0);
+#endif
+  Selection* GetSelection(SelectionType aSelectionType =
+                                          SelectionType::eNormal);
+
+  /**
+   * Helpers to add a node to the selection.
+   * Used by table cell selection methods.
+   */
+  nsresult CreateRange(nsIDOMNode* aStartParent, int32_t aStartOffset,
+                       nsIDOMNode* aEndParent, int32_t aEndOffset,
+                       nsRange** aRange);
+
+  /**
+   * Creates a range with just the supplied node and appends that to the
+   * selection.
+   */
+  nsresult AppendNodeToSelectionAsRange(nsIDOMNode *aNode);
+
+  /**
+   * When you are using AppendNodeToSelectionAsRange(), call this first to
+   * start a new selection.
+   */
+  nsresult ClearSelection();
+
+  nsresult IsPreformatted(nsIDOMNode* aNode, bool* aResult);
+
+  enum class EmptyContainers { no, yes };
+  int32_t SplitNodeDeep(nsIContent& aNode, nsIContent& aSplitPointParent,
+                        int32_t aSplitPointOffset,
+                        EmptyContainers aEmptyContainers =
+                          EmptyContainers::yes,
+                        nsIContent** outLeftNode = nullptr,
+                        nsIContent** outRightNode = nullptr);
+  EditorDOMPoint JoinNodeDeep(nsIContent& aLeftNode,
+                              nsIContent& aRightNode);
+
+  nsresult GetString(const nsAString& name, nsAString& value);
+
+  void BeginUpdateViewBatch();
+  virtual nsresult EndUpdateViewBatch();
+
+  bool GetShouldTxnSetSelection();
+
+  virtual nsresult HandleKeyPressEvent(nsIDOMKeyEvent* aKeyEvent);
+
+  nsresult HandleInlineSpellCheck(EditAction action,
+                                  Selection* aSelection,
+                                  nsIDOMNode* previousSelectedNode,
+                                  int32_t previousSelectedOffset,
+                                  nsIDOMNode* aStartNode,
+                                  int32_t aStartOffset,
+                                  nsIDOMNode* aEndNode,
+                                  int32_t aEndOffset);
+
+  virtual already_AddRefed<dom::EventTarget> GetDOMEventTarget() = 0;
+
+  /**
+   * Fast non-refcounting editor root element accessor
+   */
+  Element* GetRoot();
+
+  /**
+   * Likewise, but gets the editor's root instead, which is different for HTML
+   * editors.
+   */
+  virtual Element* GetEditorRoot();
+
+  /**
+   * Likewise, but gets the text control element instead of the root for
+   * plaintext editors.
+   */
+  Element* GetExposedRoot();
+
+  /**
+   * Accessor methods to flags.
+   */
+  bool IsPlaintextEditor() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorPlaintextMask) != 0;
+  }
+
+  bool IsSingleLineEditor() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorSingleLineMask) != 0;
+  }
+
+  bool IsPasswordEditor() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorPasswordMask) != 0;
+  }
+
+  bool IsReadonly() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorReadonlyMask) != 0;
+  }
+
+  bool IsDisabled() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorDisabledMask) != 0;
+  }
+
+  bool IsInputFiltered() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorFilterInputMask) != 0;
+  }
+
+  bool IsMailEditor() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorMailMask) != 0;
+  }
+
+  bool IsWrapHackEnabled() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorEnableWrapHackMask) != 0;
+  }
+
+  bool IsFormWidget() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorWidgetMask) != 0;
+  }
+
+  bool NoCSS() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorNoCSSMask) != 0;
+  }
+
+  bool IsInteractionAllowed() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorAllowInteraction) != 0;
+  }
+
+  bool DontEchoPassword() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorDontEchoPassword) != 0;
+  }
+
+  bool ShouldSkipSpellCheck() const
+  {
+    return (mFlags & nsIPlaintextEditor::eEditorSkipSpellCheck) != 0;
+  }
+
+  bool IsTabbable() const
+  {
+    return IsSingleLineEditor() || IsPasswordEditor() || IsFormWidget() ||
+           IsInteractionAllowed();
+  }
+
+  bool HasIndependentSelection() const
+  {
+    return !!mSelConWeak;
+  }
+
+  /**
+   * Get the input event target. This might return null.
+   */
+  virtual already_AddRefed<nsIContent> GetInputEventTargetContent() = 0;
+
+  /**
+   * Get the focused content, if we're focused.  Returns null otherwise.
+   */
+  virtual already_AddRefed<nsIContent> GetFocusedContent();
+
+  /**
+   * Get the focused content for the argument of some IMEStateManager's
+   * methods.
+   */
+  virtual already_AddRefed<nsIContent> GetFocusedContentForIME();
+
+  /**
+   * Whether the editor is active on the DOM window.  Note that when this
+   * returns true but GetFocusedContent() returns null, it means that this editor was
+   * focused when the DOM window was active.
+   */
+  virtual bool IsActiveInDOMWindow();
+
+  /**
+   * Whether the aEvent should be handled by this editor or not.  When this
+   * returns FALSE, The aEvent shouldn't be handled on this editor,
+   * i.e., The aEvent should be handled by another inner editor or ancestor
+   * elements.
+   */
+  virtual bool IsAcceptableInputEvent(nsIDOMEvent* aEvent);
+
+  /**
+   * FindSelectionRoot() returns a selection root of this editor when aNode
+   * gets focus.  aNode must be a content node or a document node.  When the
+   * target isn't a part of this editor, returns nullptr.  If this is for
+   * designMode, you should set the document node to aNode except that an
+   * element in the document has focus.
+   */
+  virtual already_AddRefed<nsIContent> FindSelectionRoot(nsINode* aNode);
+
+  /**
+   * Initializes selection and caret for the editor.  If aEventTarget isn't
+   * a host of the editor, i.e., the editor doesn't get focus, this does
+   * nothing.
+   */
+  nsresult InitializeSelection(nsIDOMEventTarget* aFocusEventTarget);
+
+  /**
+   * This method has to be called by EditorEventListener::Focus.
+   * All actions that have to be done when the editor is focused needs to be
+   * added here.
+   */
+  void OnFocus(nsIDOMEventTarget* aFocusEventTarget);
+
+  /**
+   * Used to insert content from a data transfer into the editable area.
+   * This is called for each item in the data transfer, with the index of
+   * each item passed as aIndex.
+   */
+  virtual nsresult InsertFromDataTransfer(dom::DataTransfer* aDataTransfer,
+                                          int32_t aIndex,
+                                          nsIDOMDocument* aSourceDoc,
+                                          nsIDOMNode* aDestinationNode,
+                                          int32_t aDestOffset,
+                                          bool aDoDeleteSelection) = 0;
+
+  virtual nsresult InsertFromDrop(nsIDOMEvent* aDropEvent) = 0;
+
+  virtual already_AddRefed<nsIDOMNode> FindUserSelectAllNode(nsIDOMNode* aNode)
+  {
+    return nullptr;
+  }
+
+  /**
+   * GetIMESelectionStartOffsetIn() returns the start offset of IME selection in
+   * the aTextNode.  If there is no IME selection, returns -1.
+   */
+  int32_t GetIMESelectionStartOffsetIn(nsINode* aTextNode);
+
+  /**
+   * FindBetterInsertionPoint() tries to look for better insertion point which
+   * is typically the nearest text node and offset in it.
+   */
+  void FindBetterInsertionPoint(nsCOMPtr<nsIDOMNode>& aNode,
+                                int32_t& aOffset);
+  void FindBetterInsertionPoint(nsCOMPtr<nsINode>& aNode,
+                                int32_t& aOffset);
+
+  /**
+   * HideCaret() hides caret with nsCaret::AddForceHide() or may show carent
+   * with nsCaret::RemoveForceHide().  This does NOT set visibility of
+   * nsCaret.  Therefore, this is stateless.
+   */
+  void HideCaret(bool aHide);
+
+  void FlushFrames()
+  {
+    nsCOMPtr<nsIDocument> doc = GetDocument();
+    if (doc) {
+      doc->FlushPendingNotifications(Flush_Frames);
+    }
+  }
+
+protected:
+  enum Tristate
+  {
+    eTriUnset,
+    eTriFalse,
+    eTriTrue
+  };
+
+  // MIME type of the doc we are editing.
+  nsCString mContentMIMEType;
+
+  nsCOMPtr<nsIInlineSpellChecker> mInlineSpellChecker;
+
+  RefPtr<nsTransactionManager> mTxnMgr;
+  // Cached root node.
+  nsCOMPtr<Element> mRootElement;
+  // Current IME text node.
+  RefPtr<Text> mIMETextNode;
+  // The form field as an event receiver.
+  nsCOMPtr<dom::EventTarget> mEventTarget;
+  nsCOMPtr<nsIDOMEventListener> mEventListener;
+  // Weak reference to the nsISelectionController.
+  nsWeakPtr mSelConWeak;
+  // Weak reference to placeholder for begin/end batch purposes.
+  nsWeakPtr mPlaceHolderTxn;
+  // Weak reference to the nsIDOMDocument.
+  nsWeakPtr mDocWeak;
+  // Name of placeholder transaction.
+  nsIAtom* mPlaceHolderName;
+  // Saved selection state for placeholder transaction batching.
+  SelectionState* mSelState;
+  nsString* mPhonetic;
+  // IME composition this is not null between compositionstart and
+  // compositionend.
+  RefPtr<TextComposition> mComposition;
+
+  // Listens to all low level actions on the doc.
+  nsTArray<OwningNonNull<nsIEditActionListener>> mActionListeners;
+  // Just notify once per high level change.
+  nsTArray<OwningNonNull<nsIEditorObserver>> mEditorObservers;
+  // Listen to overall doc state (dirty or not, just created, etc.).
+  nsTArray<OwningNonNull<nsIDocumentStateListener>> mDocStateListeners;
+
+  // Cached selection for AutoSelectionRestorer.
+  SelectionState mSavedSel;
+  // Utility class object for maintaining preserved ranges.
+  RangeUpdater mRangeUpdater;
+
+  // Number of modifications (for undo/redo stack).
+  uint32_t mModCount;
+  // Behavior flags. See nsIPlaintextEditor.idl for the flags we use.
+  uint32_t mFlags;
+
+  int32_t mUpdateCount;
+
+  // Nesting count for batching.
+  int32_t mPlaceHolderBatch;
+  // The current editor action.
+  EditAction mAction;
+
+  // Offset in text node where IME comp string begins.
+  uint32_t mIMETextOffset;
+  // The Length of the composition string or commit string.  If this is length
+  // of commit string, the length is truncated by maxlength attribute.
+  uint32_t mIMETextLength;
+
+  // The current direction of editor action.
+  EDirection mDirection;
+  // -1 = not initialized
+  int8_t mDocDirtyState;
+  // A Tristate value.
+  uint8_t mSpellcheckCheckboxState;
+
+  // Turn off for conservative selection adjustment by transactions.
+  bool mShouldTxnSetSelection;
+  // Whether PreDestroy has been called.
+  bool mDidPreDestroy;
+  // Whether PostCreate has been called.
+  bool mDidPostCreate;
+  bool mDispatchInputEvent;
+  // True while the instance is handling an edit action.
+  bool mIsInEditAction;
+  // Whether caret is hidden forcibly.
+  bool mHidingCaret;
+
+  friend bool NSCanUnload(nsISupports* serviceMgr);
+  friend class AutoRules;
+  friend class AutoSelectionRestorer;
+  friend class AutoTransactionsConserveSelection;
+  friend class RangeUpdater;
+};
+
+} // namespace mozilla
+
+#endif // #ifndef mozilla_EditorBase_h