Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 862 insertions, 0 deletions

diff --git a/editor/libeditor/EditAction.h b/editor/libeditor/EditAction.h
new file mode 100644
index 0000000000..27f6fb1a7f
--- /dev/null
+++ b/editor/libeditor/EditAction.h
@@ -0,0 +1,862 @@
+/* -*- 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_EditAction_h
+#define mozilla_EditAction_h
+
+#include "mozilla/EventForwards.h"
+#include "mozilla/StaticPrefs_dom.h"
+
+namespace mozilla {
+
+/**
+ * EditAction indicates which operation or command causes running the methods
+ * of editors.
+ */
+enum class EditAction {
+  // eNone indicates no edit action is being handled.
+  eNone,
+
+  // eNotEditing indicates that something is retrieved, doing something at
+  // destroying or focus move etc, i.e., not edit action is being handled but
+  // editor is doing something.
+  eNotEditing,
+
+  // eInitializing indicates that the editor instance is being initialized.
+  eInitializing,
+
+  // eInsertText indicates to insert some characters.
+  eInsertText,
+
+  // eInsertParagraphSeparator indicates to insert a paragraph separator such
+  // as <p>, <div>.
+  eInsertParagraphSeparator,
+
+  // eInsertLineBreak indicates to insert \n into TextEditor or a <br> element
+  // in HTMLEditor.
+  eInsertLineBreak,
+
+  // eDeleteSelection indicates to delete selected content or content around
+  // caret if selection is collapsed.
+  eDeleteSelection,
+
+  // eDeleteBackward indicates to remove previous character element of caret.
+  // This may be set even when Selection is not collapsed.
+  eDeleteBackward,
+
+  // eDeleteForward indicates to remove next character or element of caret.
+  // This may be set even when Selection is not collapsed.
+  eDeleteForward,
+
+  // eDeleteWordBackward indicates to remove previous word.  If caret is in
+  // a word, remove characters between word start and caret.
+  // This may be set even when Selection is not collapsed.
+  eDeleteWordBackward,
+
+  // eDeleteWordForward indicates to remove next word.  If caret is in a
+  // word, remove characters between caret and word end.
+  // This may be set even when Selection is not collapsed.
+  eDeleteWordForward,
+
+  // eDeleteToBeginningOfSoftLine indicates to remove characters between
+  // caret and previous visual line break.
+  // This may be set even when Selection is not collapsed.
+  eDeleteToBeginningOfSoftLine,
+
+  // eDeleteToEndOfSoftLine indicates to remove characters between caret and
+  // next visual line break.
+  // This may be set even when Selection is not collapsed.
+  eDeleteToEndOfSoftLine,
+
+  // eDeleteByDrag indicates to remove selection by dragging the content
+  // to different place.
+  eDeleteByDrag,
+
+  // eStartComposition indicates that user starts composition.
+  eStartComposition,
+
+  // eUpdateComposition indicates that user updates composition with
+  // new non-empty composition string and IME selections.
+  eUpdateComposition,
+
+  // eCommitComposition indicates that user commits composition.
+  eCommitComposition,
+
+  // eCancelComposition indicates that user cancels composition.
+  eCancelComposition,
+
+  // eDeleteByComposition indicates that user starts composition with
+  // empty string and there was selected content.
+  eDeleteByComposition,
+
+  // eUndo/eRedo indicate to undo/redo a transaction.
+  eUndo,
+  eRedo,
+
+  // eSetTextDirection indicates that setting text direction (LTR or RTL).
+  eSetTextDirection,
+
+  // eCut indicates to delete selected content and copy it to the clipboard.
+  eCut,
+
+  // eCopy indicates to copy selected content to the clipboard.
+  eCopy,
+
+  // ePaste indicates to paste clipboard data.
+  ePaste,
+
+  // ePasteAsQuotation indicates to paste clipboard data as quotation.
+  ePasteAsQuotation,
+
+  // eDrop indicates that user drops dragging item into the editor.
+  eDrop,
+
+  // eIndent indicates that to indent selected line(s).
+  eIndent,
+
+  // eOutdent indicates that to outdent selected line(s).
+  eOutdent,
+
+  // eReplaceText indicates to replace a part of range in editor with
+  // specific text.  For example, user select a correct word in suggestions
+  // of spellchecker or a suggestion in list of autocomplete.
+  eReplaceText,
+
+  // eInsertTableRowElement indicates to insert table rows (i.e., <tr>
+  // elements).
+  eInsertTableRowElement,
+
+  // eRemoveTableRowElement indicates to remove table row elements.
+  eRemoveTableRowElement,
+
+  // eInsertTableColumn indicates to insert cell elements to each row.
+  eInsertTableColumn,
+
+  // eRemoveTableColumn indicates to remove cell elements from each row.
+  eRemoveTableColumn,
+
+  // eResizingElement indicates that user starts to resize or keep resizing
+  // with dragging a resizer which is provided by Gecko.
+  eResizingElement,
+
+  // eResizeElement indicates that user resizes an element size with finishing
+  // dragging a resizer which is provided by Gecko.
+  eResizeElement,
+
+  // eMovingElement indicates that user starts to move or keep moving an
+  // element with grabber which is provided by Gecko.
+  eMovingElement,
+
+  // eMoveElement indicates that user finishes moving an element with grabber
+  // which is provided by Gecko.
+  eMoveElement,
+
+  // The following edit actions are not user's operation.  They are caused
+  // by if UI does something or web apps does something with JS.
+
+  // eUnknown indicates some special edit actions, e.g., batching of some
+  // nsI*Editor method calls.  This shouldn't be set while handling a user
+  // operation.
+  eUnknown,
+
+  // eSetAttribute indicates to set attribute value of an element node.
+  eSetAttribute,
+
+  // eRemoveAttribute indicates to remove attribute from an element node.
+  eRemoveAttribute,
+
+  // eInsertNode indicates to insert a node into the tree.
+  eInsertNode,
+
+  // eDeleteNode indicates to remove a node form the tree.
+  eRemoveNode,
+
+  // eInsertBlockElement indicates to insert a block-level element like <div>,
+  // <pre>, <li>, <dd> etc.
+  eInsertBlockElement,
+
+  // eInsertHorizontalRuleElement indicates to insert a <hr> element.
+  eInsertHorizontalRuleElement,
+
+  // eInsertLinkElement indicates to insert an anchor element which has
+  // href attribute.
+  eInsertLinkElement,
+
+  // eInsertUnorderedListElement and eInsertOrderedListElement indicate to
+  // insert <ul> or <ol> element.
+  eInsertUnorderedListElement,
+  eInsertOrderedListElement,
+
+  // eRemoveUnorderedListElement and eRemoveOrderedListElement indicate to
+  // remove <ul> or <ol> element.
+  eRemoveUnorderedListElement,
+  eRemoveOrderedListElement,
+
+  // eRemoveListElement indicates to remove <ul>, <ol> and/or <dl> element.
+  eRemoveListElement,
+
+  // eInsertBlockquoteElement indicates to insert a <blockquote> element.
+  eInsertBlockquoteElement,
+
+  // eNormalizeTable indicates to normalize table.  E.g., if a row does
+  // not have enough number of cells, inserts empty cells.
+  eNormalizeTable,
+
+  // eRemoveTableElement indicates to remove <table> element.
+  eRemoveTableElement,
+
+  // eRemoveTableCellContents indicates to remove any children in a table
+  // cell element.
+  eDeleteTableCellContents,
+
+  // eInsertTableCellElement indicates to insert table cell elements (i.e.,
+  // <td> or <th>).
+  eInsertTableCellElement,
+
+  // eRemoveTableCellEelement indicates to remove table cell elements.
+  eRemoveTableCellElement,
+
+  // eJoinTableCellElements indicates to join table cell elements.
+  eJoinTableCellElements,
+
+  // eSplitTableCellElement indicates to split table cell elements.
+  eSplitTableCellElement,
+
+  // eSetTableCellElementType indicates to set table cell element type to
+  // <td> or <th>.
+  eSetTableCellElementType,
+
+  // Those edit actions are mapped to the methods in nsITableEditor which
+  // access table layout information.
+  eSelectTableCell,
+  eSelectTableRow,
+  eSelectTableColumn,
+  eSelectTable,
+  eSelectAllTableCells,
+  eGetCellIndexes,
+  eGetTableSize,
+  eGetCellAt,
+  eGetCellDataAt,
+  eGetFirstRow,
+  eGetSelectedOrParentTableElement,
+  eGetSelectedCellsType,
+  eGetFirstSelectedCellInTable,
+  eGetSelectedCells,
+
+  // eSetInlineStyleProperty indicates to set CSS another inline style property
+  // which is not defined below.
+  eSetInlineStyleProperty,
+
+  // eRemoveInlineStyleProperty indicates to remove a CSS text property which
+  // is not defined below.
+  eRemoveInlineStyleProperty,
+
+  // <b> or font-weight.
+  eSetFontWeightProperty,
+  eRemoveFontWeightProperty,
+
+  // <i> or text-style: italic/oblique.
+  eSetTextStyleProperty,
+  eRemoveTextStyleProperty,
+
+  // <u> or text-decoration: underline.
+  eSetTextDecorationPropertyUnderline,
+  eRemoveTextDecorationPropertyUnderline,
+
+  // <strike> or text-decoration: line-through.
+  eSetTextDecorationPropertyLineThrough,
+  eRemoveTextDecorationPropertyLineThrough,
+
+  // <sup> or text-align: super.
+  eSetVerticalAlignPropertySuper,
+  eRemoveVerticalAlignPropertySuper,
+
+  // <sub> or text-align: sub.
+  eSetVerticalAlignPropertySub,
+  eRemoveVerticalAlignPropertySub,
+
+  // <font face="foo"> or font-family.
+  eSetFontFamilyProperty,
+  eRemoveFontFamilyProperty,
+
+  // <font color="foo"> or color.
+  eSetColorProperty,
+  eRemoveColorProperty,
+
+  // <span style="background-color: foo">
+  eSetBackgroundColorPropertyInline,
+  eRemoveBackgroundColorPropertyInline,
+
+  // eRemoveAllInlineStyleProperties indicates to remove all CSS inline
+  // style properties.
+  eRemoveAllInlineStyleProperties,
+
+  // eIncrementFontSize indicates to increment font-size.
+  eIncrementFontSize,
+
+  // eDecrementFontSize indicates to decrement font-size.
+  eDecrementFontSize,
+
+  // eSetAlignment indicates to set alignment of selected content but different
+  // from the following.
+  eSetAlignment,
+
+  // eAlign* and eJustify indicates to align contents in block with left
+  // edge, right edge, center or justify the text.
+  eAlignLeft,
+  eAlignRight,
+  eAlignCenter,
+  eJustify,
+
+  // eSetBackgroundColor indicates to set background color.
+  eSetBackgroundColor,
+
+  // eSetPositionToAbsoluteOrStatic indicates to set position property value
+  // to "absolute" or "static".
+  eSetPositionToAbsoluteOrStatic,
+
+  // eIncreaseOrDecreaseZIndex indicates to change z-index of an element.
+  eIncreaseOrDecreaseZIndex,
+
+  // eEnableOrDisableCSS indicates to enable or disable CSS mode of HTMLEditor.
+  eEnableOrDisableCSS,
+
+  // eEnableOrDisableAbsolutePositionEditor indicates to enable or disable
+  // absolute positioned element editing UI.
+  eEnableOrDisableAbsolutePositionEditor,
+
+  // eEnableOrDisableResizer indicates to enable or disable resizers of
+  // <img>, <table> and absolutely positioned element.
+  eEnableOrDisableResizer,
+
+  // eEnableOrDisableInlineTableEditingUI indicates to enable or disable
+  // inline table editing UI.
+  eEnableOrDisableInlineTableEditingUI,
+
+  // eSetCharacterSet indicates to set character-set of the document.
+  eSetCharacterSet,
+
+  // eSetWrapWidth indicates to set wrap width.
+  eSetWrapWidth,
+
+  // eRewrap indicates to rewrap for current wrap width.
+  eRewrap,
+
+  // eSetText indicates to set new text of TextEditor, e.g., setting
+  // HTMLInputElement.value.
+  eSetText,
+
+  // eSetHTML indicates to set body of HTMLEditor.
+  eSetHTML,
+
+  // eInsertHTML indicates to insert HTML source code.
+  eInsertHTML,
+
+  // eHidePassword indicates that editor hides password with mask characters.
+  eHidePassword,
+
+  // eCreatePaddingBRElementForEmptyEditor indicates that editor wants to
+  // create a padding <br> element for empty editor after it modifies its
+  // content.
+  eCreatePaddingBRElementForEmptyEditor,
+};
+
+// This is int32_t instead of int16_t because nsIInlineSpellChecker.idl's
+// spellCheckAfterEditorChange is defined to take it as a long.
+// TODO: Make each name eFoo and investigate whether the numeric values
+//       still have some meaning.
+enum class EditSubAction : int32_t {
+  // eNone indicates not edit sub-action is being handled.  This is useful
+  // of initial value of member variables.
+  eNone,
+
+  // eUndo and eRedo indicate entire actions of undo/redo operation.
+  eUndo,
+  eRedo,
+
+  // eInsertNode indicates to insert a new node into the DOM tree.
+  eInsertNode,
+
+  // eCreateNode indicates to create a new node and insert it into the DOM tree.
+  eCreateNode,
+
+  // eDeleteNode indicates to remove a node from the DOM tree.
+  eDeleteNode,
+
+  // eMoveNode indicates to move a node connected in the DOM tree to different
+  // place.
+  eMoveNode,
+
+  // eSplitNode indicates to split a node to 2 nodes.
+  eSplitNode,
+
+  // eJoinNodes indicates to join 2 nodes.
+  eJoinNodes,
+
+  // eDeleteText indicates to delete some characters form a text node.
+  eDeleteText,
+
+  // eInsertText indicates to insert some characters.
+  eInsertText,
+
+  // eInsertTextComingFromIME indicates to insert or update composition string
+  // with new text which is new composition string or commit string.
+  eInsertTextComingFromIME,
+
+  // eDeleteSelectedContent indicates to remove selected content.
+  eDeleteSelectedContent,
+
+  // eSetTextProperty indicates to set a style from text.
+  eSetTextProperty,
+
+  // eRemoveTextProperty indicates to remove a style from text.
+  eRemoveTextProperty,
+
+  // eRemoveAllTextProperties indicate to remove all styles from text.
+  eRemoveAllTextProperties,
+
+  // eComputeTextToOutput indicates to compute the editor value as plain text
+  // or something requested format.
+  eComputeTextToOutput,
+
+  // eSetText indicates to set editor value to new value.
+  eSetText,
+
+  // eInsertLineBreak indicates to insert a line break, <br> or \n to break
+  // current line.
+  eInsertLineBreak,
+
+  // eInsertParagraphSeparator indicates to insert paragraph separator, <br> or
+  // \n at least to break current line in HTMLEditor.
+  eInsertParagraphSeparator,
+
+  // eCreateOrChangeList indicates to create new list or change existing list
+  // type.
+  eCreateOrChangeList,
+
+  // eIndent and eOutdent indicates to indent or outdent the target with
+  // using <blockquote>, <ul>, <ol> or just margin of start edge.
+  eIndent,
+  eOutdent,
+
+  // eSetOrClearAlignment aligns content or clears alignment with align
+  // attribute or text-align.
+  eSetOrClearAlignment,
+
+  // eCreateOrRemoveBlock creates new block or removes existing block and
+  // move its descendants to where the block was.
+  eCreateOrRemoveBlock,
+
+  // eMergeBlockContents is not an actual sub-action, but this is used by
+  // HTMLEditor::MoveBlock() to request special handling in
+  // HTMLEditor::MaybeSplitElementsAtEveryBRElement().
+  eMergeBlockContents,
+
+  // eRemoveList removes specific type of list but keep its content.
+  eRemoveList,
+
+  // eCreateOrChangeDefinitionListItem indicates to format current hard line(s)
+  // `<dd>` or `<dt>`.  This may cause creating or changing existing list
+  // element to new `<dl>` element.
+  eCreateOrChangeDefinitionListItem,
+
+  // eInsertElement indicates to insert an element.
+  eInsertElement,
+
+  // eInsertQuotation indicates to insert an element and make it "quoted text".
+  eInsertQuotation,
+
+  // eInsertQuotedText indicates to insert text which has already been quoted.
+  eInsertQuotedText,
+
+  // ePasteHTMLContent indicates to paste HTML content in clipboard.
+  ePasteHTMLContent,
+
+  // eInsertHTMLSource indicates to create a document fragment from given HTML
+  // source and insert into the DOM tree.  So, this is similar to innerHTML.
+  eInsertHTMLSource,
+
+  // eReplaceHeadWithHTMLSource indicates to create a document fragment from
+  // given HTML source and replace content of <head> with it.
+  eReplaceHeadWithHTMLSource,
+
+  // eSetPositionToAbsolute and eSetPositionToStatic indicates to set position
+  // property to absolute or static.
+  eSetPositionToAbsolute,
+  eSetPositionToStatic,
+
+  // eDecreaseZIndex and eIncreaseZIndex indicate to decrease and increase
+  // z-index value.
+  eDecreaseZIndex,
+  eIncreaseZIndex,
+
+  // eCreatePaddingBRElementForEmptyEditor indicates to create a padding <br>
+  // element for empty editor.
+  eCreatePaddingBRElementForEmptyEditor,
+};
+
+// You can use this macro as:
+//   case NS_EDIT_ACTION_CASES_ACCESSING_TABLE_DATA_WITHOUT_EDITING:
+// clang-format off
+#define NS_EDIT_ACTION_CASES_ACCESSING_TABLE_DATA_WITHOUT_EDITING \
+       mozilla::EditAction::eSelectTableCell:                     \
+  case mozilla::EditAction::eSelectTableRow:                      \
+  case mozilla::EditAction::eSelectTableColumn:                   \
+  case mozilla::EditAction::eSelectTable:                         \
+  case mozilla::EditAction::eSelectAllTableCells:                 \
+  case mozilla::EditAction::eGetCellIndexes:                      \
+  case mozilla::EditAction::eGetTableSize:                        \
+  case mozilla::EditAction::eGetCellAt:                           \
+  case mozilla::EditAction::eGetCellDataAt:                       \
+  case mozilla::EditAction::eGetFirstRow:                         \
+  case mozilla::EditAction::eGetSelectedOrParentTableElement:     \
+  case mozilla::EditAction::eGetSelectedCellsType:                \
+  case mozilla::EditAction::eGetFirstSelectedCellInTable:         \
+  case mozilla::EditAction::eGetSelectedCells
+// clang-format on
+
+inline EditorInputType ToInputType(EditAction aEditAction) {
+  switch (aEditAction) {
+    case EditAction::eInsertText:
+      return EditorInputType::eInsertText;
+    case EditAction::eReplaceText:
+      return EditorInputType::eInsertReplacementText;
+    case EditAction::eInsertLineBreak:
+      return EditorInputType::eInsertLineBreak;
+    case EditAction::eInsertParagraphSeparator:
+      return EditorInputType::eInsertParagraph;
+    case EditAction::eInsertOrderedListElement:
+    case EditAction::eRemoveOrderedListElement:
+      return EditorInputType::eInsertOrderedList;
+    case EditAction::eInsertUnorderedListElement:
+    case EditAction::eRemoveUnorderedListElement:
+      return EditorInputType::eInsertUnorderedList;
+    case EditAction::eInsertHorizontalRuleElement:
+      return EditorInputType::eInsertHorizontalRule;
+    case EditAction::eDrop:
+      return EditorInputType::eInsertFromDrop;
+    case EditAction::ePaste:
+      return EditorInputType::eInsertFromPaste;
+    case EditAction::ePasteAsQuotation:
+      return EditorInputType::eInsertFromPasteAsQuotation;
+    case EditAction::eUpdateComposition:
+      return EditorInputType::eInsertCompositionText;
+    case EditAction::eCommitComposition:
+      if (StaticPrefs::dom_input_events_conform_to_level_1()) {
+        return EditorInputType::eInsertCompositionText;
+      }
+      return EditorInputType::eInsertFromComposition;
+    case EditAction::eCancelComposition:
+      if (StaticPrefs::dom_input_events_conform_to_level_1()) {
+        return EditorInputType::eInsertCompositionText;
+      }
+      return EditorInputType::eDeleteCompositionText;
+    case EditAction::eDeleteByComposition:
+      if (StaticPrefs::dom_input_events_conform_to_level_1()) {
+        // XXX Or EditorInputType::eDeleteContent?  I don't know which IME may
+        //     causes this situation.
+        return EditorInputType::eInsertCompositionText;
+      }
+      return EditorInputType::eDeleteByComposition;
+    case EditAction::eInsertLinkElement:
+      return EditorInputType::eInsertLink;
+    case EditAction::eDeleteWordBackward:
+      return EditorInputType::eDeleteWordBackward;
+    case EditAction::eDeleteWordForward:
+      return EditorInputType::eDeleteWordForward;
+    case EditAction::eDeleteToBeginningOfSoftLine:
+      return EditorInputType::eDeleteSoftLineBackward;
+    case EditAction::eDeleteToEndOfSoftLine:
+      return EditorInputType::eDeleteSoftLineForward;
+    case EditAction::eDeleteByDrag:
+      return EditorInputType::eDeleteByDrag;
+    case EditAction::eCut:
+      return EditorInputType::eDeleteByCut;
+    case EditAction::eDeleteSelection:
+    case EditAction::eRemoveTableRowElement:
+    case EditAction::eRemoveTableColumn:
+    case EditAction::eRemoveTableElement:
+    case EditAction::eDeleteTableCellContents:
+    case EditAction::eRemoveTableCellElement:
+      return EditorInputType::eDeleteContent;
+    case EditAction::eDeleteBackward:
+      return EditorInputType::eDeleteContentBackward;
+    case EditAction::eDeleteForward:
+      return EditorInputType::eDeleteContentForward;
+    case EditAction::eUndo:
+      return EditorInputType::eHistoryUndo;
+    case EditAction::eRedo:
+      return EditorInputType::eHistoryRedo;
+    case EditAction::eSetFontWeightProperty:
+    case EditAction::eRemoveFontWeightProperty:
+      return EditorInputType::eFormatBold;
+    case EditAction::eSetTextStyleProperty:
+    case EditAction::eRemoveTextStyleProperty:
+      return EditorInputType::eFormatItalic;
+    case EditAction::eSetTextDecorationPropertyUnderline:
+    case EditAction::eRemoveTextDecorationPropertyUnderline:
+      return EditorInputType::eFormatUnderline;
+    case EditAction::eSetTextDecorationPropertyLineThrough:
+    case EditAction::eRemoveTextDecorationPropertyLineThrough:
+      return EditorInputType::eFormatStrikeThrough;
+    case EditAction::eSetVerticalAlignPropertySuper:
+    case EditAction::eRemoveVerticalAlignPropertySuper:
+      return EditorInputType::eFormatSuperscript;
+    case EditAction::eSetVerticalAlignPropertySub:
+    case EditAction::eRemoveVerticalAlignPropertySub:
+      return EditorInputType::eFormatSubscript;
+    case EditAction::eJustify:
+      return EditorInputType::eFormatJustifyFull;
+    case EditAction::eAlignCenter:
+      return EditorInputType::eFormatJustifyCenter;
+    case EditAction::eAlignRight:
+      return EditorInputType::eFormatJustifyRight;
+    case EditAction::eAlignLeft:
+      return EditorInputType::eFormatJustifyLeft;
+    case EditAction::eIndent:
+      return EditorInputType::eFormatIndent;
+    case EditAction::eOutdent:
+      return EditorInputType::eFormatOutdent;
+    case EditAction::eRemoveAllInlineStyleProperties:
+      return EditorInputType::eFormatRemove;
+    case EditAction::eSetTextDirection:
+      return EditorInputType::eFormatSetBlockTextDirection;
+    case EditAction::eSetBackgroundColorPropertyInline:
+    case EditAction::eRemoveBackgroundColorPropertyInline:
+      return EditorInputType::eFormatBackColor;
+    case EditAction::eSetColorProperty:
+    case EditAction::eRemoveColorProperty:
+      return EditorInputType::eFormatFontColor;
+    case EditAction::eSetFontFamilyProperty:
+    case EditAction::eRemoveFontFamilyProperty:
+      return EditorInputType::eFormatFontName;
+    default:
+      return EditorInputType::eUnknown;
+  }
+}
+
+inline bool MayEditActionDeleteAroundCollapsedSelection(
+    const EditAction aEditAction) {
+  switch (aEditAction) {
+    case EditAction::eDeleteSelection:
+    case EditAction::eDeleteBackward:
+    case EditAction::eDeleteForward:
+    case EditAction::eDeleteWordBackward:
+    case EditAction::eDeleteWordForward:
+    case EditAction::eDeleteToBeginningOfSoftLine:
+    case EditAction::eDeleteToEndOfSoftLine:
+      return true;
+    default:
+      return false;
+  }
+}
+
+inline bool IsEditActionInOrderToEditSomething(const EditAction aEditAction) {
+  switch (aEditAction) {
+    case EditAction::eNotEditing:
+    case NS_EDIT_ACTION_CASES_ACCESSING_TABLE_DATA_WITHOUT_EDITING:
+      return false;
+    default:
+      return true;
+  }
+}
+
+inline bool IsEditActionTableEditing(const EditAction aEditAction) {
+  switch (aEditAction) {
+    case EditAction::eInsertTableRowElement:
+    case EditAction::eRemoveTableRowElement:
+    case EditAction::eInsertTableColumn:
+    case EditAction::eRemoveTableColumn:
+    case EditAction::eRemoveTableElement:
+    case EditAction::eRemoveTableCellElement:
+    case EditAction::eDeleteTableCellContents:
+    case EditAction::eInsertTableCellElement:
+    case EditAction::eJoinTableCellElements:
+    case EditAction::eSplitTableCellElement:
+    case EditAction::eSetTableCellElementType:
+      return true;
+    default:
+      return false;
+  }
+}
+
+inline bool MayEditActionDeleteSelection(const EditAction aEditAction) {
+  switch (aEditAction) {
+    case EditAction::eNone:
+    case EditAction::eNotEditing:
+    case EditAction::eInitializing:
+    case NS_EDIT_ACTION_CASES_ACCESSING_TABLE_DATA_WITHOUT_EDITING:
+      return false;
+
+    // EditActions modifying around selection.
+    case EditAction::eInsertText:
+    case EditAction::eInsertParagraphSeparator:
+    case EditAction::eInsertLineBreak:
+    case EditAction::eDeleteSelection:
+    case EditAction::eDeleteBackward:
+    case EditAction::eDeleteForward:
+    case EditAction::eDeleteWordBackward:
+    case EditAction::eDeleteWordForward:
+    case EditAction::eDeleteToBeginningOfSoftLine:
+    case EditAction::eDeleteToEndOfSoftLine:
+    case EditAction::eDeleteByDrag:
+      return true;
+
+    case EditAction::eStartComposition:
+      return false;
+
+    case EditAction::eUpdateComposition:
+    case EditAction::eCommitComposition:
+    case EditAction::eCancelComposition:
+    case EditAction::eDeleteByComposition:
+      return true;
+
+    case EditAction::eUndo:
+    case EditAction::eRedo:
+    case EditAction::eSetTextDirection:
+      return false;
+
+    case EditAction::eCut:
+      return true;
+
+    case EditAction::eCopy:
+      return false;
+
+    case EditAction::ePaste:
+    case EditAction::ePasteAsQuotation:
+      return true;
+
+    case EditAction::eDrop:
+      return false;  // Not deleting selection at drop.
+
+    // EditActions changing format around selection.
+    case EditAction::eIndent:
+    case EditAction::eOutdent:
+      return false;
+
+    // EditActions inserting or deleting something at specified position.
+    case EditAction::eInsertTableRowElement:
+    case EditAction::eRemoveTableRowElement:
+    case EditAction::eInsertTableColumn:
+    case EditAction::eRemoveTableColumn:
+    case EditAction::eResizingElement:
+    case EditAction::eResizeElement:
+    case EditAction::eMovingElement:
+    case EditAction::eMoveElement:
+    case EditAction::eUnknown:
+    case EditAction::eSetAttribute:
+    case EditAction::eRemoveAttribute:
+    case EditAction::eRemoveNode:
+    case EditAction::eInsertBlockElement:
+      return false;
+
+    // EditActions inserting someting around selection or replacing selection
+    // with something.
+    case EditAction::eReplaceText:
+    case EditAction::eInsertNode:
+    case EditAction::eInsertHorizontalRuleElement:
+      return true;
+
+    // EditActions changing format around selection or inserting or deleting
+    // something at specific position.
+    case EditAction::eInsertLinkElement:
+    case EditAction::eInsertUnorderedListElement:
+    case EditAction::eInsertOrderedListElement:
+    case EditAction::eRemoveUnorderedListElement:
+    case EditAction::eRemoveOrderedListElement:
+    case EditAction::eRemoveListElement:
+    case EditAction::eInsertBlockquoteElement:
+    case EditAction::eNormalizeTable:
+    case EditAction::eRemoveTableElement:
+    case EditAction::eRemoveTableCellElement:
+    case EditAction::eDeleteTableCellContents:
+    case EditAction::eInsertTableCellElement:
+    case EditAction::eJoinTableCellElements:
+    case EditAction::eSplitTableCellElement:
+    case EditAction::eSetTableCellElementType:
+    case EditAction::eSetInlineStyleProperty:
+    case EditAction::eRemoveInlineStyleProperty:
+    case EditAction::eSetFontWeightProperty:
+    case EditAction::eRemoveFontWeightProperty:
+    case EditAction::eSetTextStyleProperty:
+    case EditAction::eRemoveTextStyleProperty:
+    case EditAction::eSetTextDecorationPropertyUnderline:
+    case EditAction::eRemoveTextDecorationPropertyUnderline:
+    case EditAction::eSetTextDecorationPropertyLineThrough:
+    case EditAction::eRemoveTextDecorationPropertyLineThrough:
+    case EditAction::eSetVerticalAlignPropertySuper:
+    case EditAction::eRemoveVerticalAlignPropertySuper:
+    case EditAction::eSetVerticalAlignPropertySub:
+    case EditAction::eRemoveVerticalAlignPropertySub:
+    case EditAction::eSetFontFamilyProperty:
+    case EditAction::eRemoveFontFamilyProperty:
+    case EditAction::eSetColorProperty:
+    case EditAction::eRemoveColorProperty:
+    case EditAction::eSetBackgroundColorPropertyInline:
+    case EditAction::eRemoveBackgroundColorPropertyInline:
+    case EditAction::eRemoveAllInlineStyleProperties:
+    case EditAction::eIncrementFontSize:
+    case EditAction::eDecrementFontSize:
+    case EditAction::eSetAlignment:
+    case EditAction::eAlignLeft:
+    case EditAction::eAlignRight:
+    case EditAction::eAlignCenter:
+    case EditAction::eJustify:
+    case EditAction::eSetBackgroundColor:
+    case EditAction::eSetPositionToAbsoluteOrStatic:
+    case EditAction::eIncreaseOrDecreaseZIndex:
+      return false;
+
+    // EditActions controlling editor feature or state.
+    case EditAction::eEnableOrDisableCSS:
+    case EditAction::eEnableOrDisableAbsolutePositionEditor:
+    case EditAction::eEnableOrDisableResizer:
+    case EditAction::eEnableOrDisableInlineTableEditingUI:
+    case EditAction::eSetCharacterSet:
+    case EditAction::eSetWrapWidth:
+      return false;
+
+    case EditAction::eRewrap:
+    case EditAction::eSetText:
+    case EditAction::eSetHTML:
+    case EditAction::eInsertHTML:
+      return true;
+
+    case EditAction::eHidePassword:
+    case EditAction::eCreatePaddingBRElementForEmptyEditor:
+      return false;
+  }
+  return false;
+}
+
+inline bool MayEditActionRequireLayout(const EditAction aEditAction) {
+  switch (aEditAction) {
+    // Table editing require layout information for referring table cell data
+    // such as row/column number and rowspan/colspan.
+    case EditAction::eInsertTableRowElement:
+    case EditAction::eRemoveTableRowElement:
+    case EditAction::eInsertTableColumn:
+    case EditAction::eRemoveTableColumn:
+    case EditAction::eRemoveTableElement:
+    case EditAction::eRemoveTableCellElement:
+    case EditAction::eDeleteTableCellContents:
+    case EditAction::eInsertTableCellElement:
+    case EditAction::eJoinTableCellElements:
+    case EditAction::eSplitTableCellElement:
+    case EditAction::eSetTableCellElementType:
+    case NS_EDIT_ACTION_CASES_ACCESSING_TABLE_DATA_WITHOUT_EDITING:
+      return true;
+    default:
+      return false;
+  }
+}
+
+}  // namespace mozilla
+
+inline bool operator!(const mozilla::EditSubAction& aEditSubAction) {
+  return aEditSubAction == mozilla::EditSubAction::eNone;
+}
+
+#endif  // #ifdef mozilla_EditAction_h