--- a/editor/libeditor/EditAction.h
+++ b/editor/libeditor/EditAction.h
@@ -73,17 +73,20 @@ enum class EditSubAction : int32_t
   // 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,
 
-  align,
+  // eSetOrClearAlignment aligns content or clears alignment with align
+  // attribute or text-align.
+  eSetOrClearAlignment,
+
   makeBasicBlock,
   removeList,
   makeDefListItem,
   insertElement,
   insertQuotation,
 
   htmlPaste = 3012,
   loadHTML,

--- a/editor/libeditor/HTMLEditRules.cpp
+++ b/editor/libeditor/HTMLEditRules.cpp
@@ -84,17 +84,17 @@ enum
 static bool
 IsStyleCachePreservingSubAction(EditSubAction aEditSubAction)
 {
   return aEditSubAction == EditSubAction::eDeleteSelectedContent ||
          aEditSubAction == EditSubAction::eInsertParagraphSeparator ||
          aEditSubAction == EditSubAction::eCreateOrChangeList ||
          aEditSubAction == EditSubAction::eIndent ||
          aEditSubAction == EditSubAction::eOutdent ||
-         aEditSubAction == EditSubAction::align ||
+         aEditSubAction == EditSubAction::eSetOrClearAlignment ||
          aEditSubAction == EditSubAction::makeBasicBlock ||
          aEditSubAction == EditSubAction::removeList ||
          aEditSubAction == EditSubAction::makeDefListItem ||
          aEditSubAction == EditSubAction::insertElement ||
          aEditSubAction == EditSubAction::insertQuotation;
 }
 
 static nsAtom&
@@ -701,17 +701,17 @@ HTMLEditRules::WillDoAction(Selection* a
     case EditSubAction::eIndent:
       return WillIndent(aCancel, aHandled);
     case EditSubAction::eOutdent:
       return WillOutdent(aCancel, aHandled);
     case EditSubAction::setAbsolutePosition:
       return WillAbsolutePosition(aCancel, aHandled);
     case EditSubAction::removeAbsolutePosition:
       return WillRemoveAbsolutePosition(aCancel, aHandled);
-    case EditSubAction::align:
+    case EditSubAction::eSetOrClearAlignment:
       return WillAlign(*aInfo.alignType, aCancel, aHandled);
     case EditSubAction::makeBasicBlock:
       return WillMakeBasicBlock(*aInfo.blockType, aCancel, aHandled);
     case EditSubAction::removeList: {
       nsresult rv = WillRemoveList(aCancel, aHandled);
       if (NS_WARN_IF(rv == NS_ERROR_EDITOR_DESTROYED) ||
           NS_WARN_IF(!CanHandleEditAction())) {
         return NS_ERROR_EDITOR_DESTROYED;
@@ -761,17 +761,17 @@ HTMLEditRules::DidDoAction(Selection* aS
     case EditSubAction::eInsertParagraphSeparator:
     case EditSubAction::eInsertTextComingFromIME:
       return NS_OK;
     case EditSubAction::eDeleteSelectedContent:
       return DidDeleteSelection();
     case EditSubAction::makeBasicBlock:
     case EditSubAction::eIndent:
     case EditSubAction::eOutdent:
-    case EditSubAction::align:
+    case EditSubAction::eSetOrClearAlignment:
       return DidMakeBasicBlock();
     case EditSubAction::setAbsolutePosition: {
       nsresult rv = DidMakeBasicBlock();
       if (NS_WARN_IF(NS_FAILED(rv))) {
         return rv;
       }
       return DidAbsolutePosition();
     }
@@ -974,22 +974,23 @@ HTMLEditRules::GetAlignment(bool* aMixed
              atStartOfSelection.Offset() == static_cast<uint32_t>(rootOffset)) {
     // If we have selected the body, let's look at the first editable node
     nodeToExamine = HTMLEditorRef().GetNextEditableNode(atStartOfSelection);
     if (NS_WARN_IF(!nodeToExamine)) {
       return NS_ERROR_FAILURE;
     }
   } else {
     nsTArray<RefPtr<nsRange>> arrayOfRanges;
-    GetPromotedRanges(arrayOfRanges, EditSubAction::align);
+    GetPromotedRanges(arrayOfRanges, EditSubAction::eSetOrClearAlignment);
 
     // Use these ranges to construct a list of nodes to act on.
     nsTArray<OwningNonNull<nsINode>> arrayOfNodes;
     nsresult rv = GetNodesForOperation(arrayOfRanges, arrayOfNodes,
-                                       EditSubAction::align, TouchContent::no);
+                                       EditSubAction::eSetOrClearAlignment,
+                                       TouchContent::no);
     if (NS_WARN_IF(NS_FAILED(rv))) {
       return rv;
     }
     nodeToExamine = arrayOfNodes.SafeElementAt(0);
     if (NS_WARN_IF(!nodeToExamine)) {
       return NS_ERROR_FAILURE;
     }
   }
@@ -6187,17 +6188,18 @@ HTMLEditRules::AlignContentsAtSelection(
   AutoSelectionRestorer selectionRestorer(&SelectionRef(), &HTMLEditorRef());
 
   // Convert the selection ranges into "promoted" selection ranges: This
   // basically just expands the range to include the immediate block parent,
   // and then further expands to include any ancestors whose children are all
   // in the range
   nsTArray<OwningNonNull<nsINode>> nodeArray;
   nsresult rv =
-    GetNodesFromSelection(EditSubAction::align, nodeArray, TouchContent::yes);
+    GetNodesFromSelection(EditSubAction::eSetOrClearAlignment, nodeArray,
+                          TouchContent::yes);
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   // If we don't have any nodes, or we have only a single br, then we are
   // creating an empty alignment div.  We have to do some different things for
   // these.
   bool emptyDiv = nodeArray.IsEmpty();
@@ -7210,20 +7212,21 @@ HTMLEditRules::GetPromotedPoint(RulesEnd
           point.IsContainerHTMLElement(nsGkAtoms::blockquote)) {
         break;
       }
 
       // Don't walk past the editable section. Note that we need to check
       // before walking up to a parent because we need to return the parent
       // object, so the parent itself might not be in the editable area, but
       // it's OK if we're not performing a block-level action.
-      bool blockLevelAction = aEditSubAction == EditSubAction::eIndent ||
-                              aEditSubAction == EditSubAction::eOutdent ||
-                              aEditSubAction == EditSubAction::align ||
-                              aEditSubAction == EditSubAction::makeBasicBlock;
+      bool blockLevelAction =
+        aEditSubAction == EditSubAction::eIndent ||
+        aEditSubAction == EditSubAction::eOutdent ||
+        aEditSubAction == EditSubAction::eSetOrClearAlignment ||
+        aEditSubAction == EditSubAction::makeBasicBlock;
       if (!HTMLEditorRef().IsDescendantOfEditorRoot(
                              point.GetContainer()->GetParentNode()) &&
           (blockLevelAction ||
            !HTMLEditorRef().IsDescendantOfEditorRoot(point.GetContainer()))) {
         break;
       }
 
       point.Set(point.GetContainer());
@@ -7578,17 +7581,17 @@ HTMLEditRules::GetNodesForOperation(
     }
   }
 
 
   // Post-process the list to break up inline containers that contain br's, but
   // only for operations that might care, like making lists or paragraphs
   if (aEditSubAction == EditSubAction::makeBasicBlock ||
       aEditSubAction == EditSubAction::eCreateOrChangeList ||
-      aEditSubAction == EditSubAction::align ||
+      aEditSubAction == EditSubAction::eSetOrClearAlignment ||
       aEditSubAction == EditSubAction::setAbsolutePosition ||
       aEditSubAction == EditSubAction::eIndent ||
       aEditSubAction == EditSubAction::eOutdent) {
     for (int32_t i = aOutArrayOfNodes.Length() - 1; i >= 0; i--) {
       OwningNonNull<nsINode> node = aOutArrayOfNodes[i];
       // XXX Why do we run this loop even when aTouchContent is "no"?
       if (aTouchContent == TouchContent::yes && IsInlineNode(node) &&
           HTMLEditorRef().IsContainer(node) && !EditorBase::IsTextNode(node)) {

--- a/editor/libeditor/HTMLEditor.cpp
+++ b/editor/libeditor/HTMLEditor.cpp
@@ -2380,25 +2380,26 @@ HTMLEditor::Indent(const nsAString& aInd
 NS_IMETHODIMP
 HTMLEditor::Align(const nsAString& aAlignType)
 {
   // Protect the edit rules object from dying
   RefPtr<TextEditRules> rules(mRules);
 
   AutoPlaceholderBatch beginBatching(this);
   AutoTopLevelEditSubActionNotifier maybeTopLevelEditSubAction(
-                                      *this, EditSubAction::align,
+                                      *this,
+                                      EditSubAction::eSetOrClearAlignment,
                                       nsIEditor::eNext);
 
   bool cancel, handled;
 
   // Find out if the selection is collapsed:
   RefPtr<Selection> selection = GetSelection();
   NS_ENSURE_TRUE(selection, NS_ERROR_NULL_POINTER);
-  EditSubActionInfo subActionInfo(EditSubAction::align);
+  EditSubActionInfo subActionInfo(EditSubAction::eSetOrClearAlignment);
   subActionInfo.alignType = &aAlignType;
   nsresult rv =
    rules->WillDoAction(selection, subActionInfo, &cancel, &handled);
   if (cancel || NS_FAILED(rv)) {
     return rv;
   }
 
   return rules->DidDoAction(selection, subActionInfo, rv);

--- a/editor/libeditor/TextEditRules.h
+++ b/editor/libeditor/TextEditRules.h
@@ -550,17 +550,17 @@ public:
 
   // EditSubAction::removeList
   bool bOrdered;
 
   // EditSubAction::eCreateOrChangeList
   bool entireList;
   const nsAString* bulletType;
 
-  // EditSubAction::align
+  // EditSubAction::eSetOrClearAlignment
   const nsAString* alignType;
 
   // EditSubAction::makeBasicBlock
   const nsAString* blockType;
 };
 
 /**
  * Stack based helper class for managing TextEditRules::mLockRluesSniffing.