[InputEvent] Replace |EditAction| with |InputType|

third_party/WebKit/Source/core/editing/Editor.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 100 matching lines @@
 }
 
 void dispatchInputEventEditableContentChanged(Element* startRoot, Element* endRoot, InputEvent::InputType inputType, const String& data, InputEvent::EventIsComposing isComposing)
 {
     if (startRoot)
         dispatchInputEvent(startRoot, inputType, data, isComposing);
     if (endRoot && endRoot != startRoot)
         dispatchInputEvent(endRoot, inputType, data, isComposing);
 }
 
-InputEvent::InputType inputTypeFromCommand(const CompositeEditCommand* command)
-{
-    if (command->isTypingCommand()) {
-        const TypingCommand* typingCommand = toTypingCommand(command);
-        // TODO(chongz): Separate command types into more detailed InputType.
-        switch (typingCommand->commandTypeOfOpenCommand()) {
-        case TypingCommand::DeleteSelection:
-        case TypingCommand::DeleteKey:
-        case TypingCommand::ForwardDeleteKey:
-            return InputEvent::InputType::DeleteContent;
-        case TypingCommand::InsertText:
-        case TypingCommand::InsertLineBreak:
-        case TypingCommand::InsertParagraphSeparator:
-        case TypingCommand::InsertParagraphSeparatorInQuotedContent:
-            return InputEvent::InputType::InsertText;
-        default:
-            return InputEvent::InputType::None;
-        }
-    }
-
-    switch (command->editingAction()) {
-    // TODO(chongz): Handle remaining edit actions.
-    case EditActionBold:
-        return InputEvent::InputType::Bold;
-    case EditActionItalics:
-        return InputEvent::InputType::Italic;
-    case EditActionUnderline:
-        return InputEvent::InputType::Underline;
-    case EditActionStrikeThrough:
-        return InputEvent::InputType::StrikeThrough;
-    case EditActionSuperscript:
-        return InputEvent::InputType::Superscript;
-    case EditActionSubscript:
-        return InputEvent::InputType::Subscript;
-    default:
-        return InputEvent::InputType::None;
-    }
-}
-
 InputEvent::EventIsComposing isComposingFromCommand(const CompositeEditCommand* command)
 {
     if (command->isTypingCommand() && toTypingCommand(command)->compositionType() != TypingCommand::TextCompositionNone)
         return InputEvent::EventIsComposing::IsComposing;
     return InputEvent::EventIsComposing::NotComposing;
 }
 
 } // anonymous namespace
 
 Editor::RevealSelectionScope::RevealSelectionScope(Editor* editor)
@@ skipping 403 matching lines @@
         return;
 
     ReplaceSelectionCommand::CommandOptions options = ReplaceSelectionCommand::PreventNesting | ReplaceSelectionCommand::SanitizeFragment;
     if (selectReplacement)
         options |= ReplaceSelectionCommand::SelectReplacement;
     if (smartReplace)
         options |= ReplaceSelectionCommand::SmartReplace;
     if (matchStyle)
         options |= ReplaceSelectionCommand::MatchStyle;
     DCHECK(frame().document());
-    ReplaceSelectionCommand::create(*frame().document(), fragment, options, EditActionPaste)->apply();
+    ReplaceSelectionCommand::create(*frame().document(), fragment, options, InputEvent::InputType::Paste)->apply();
     revealSelectionAfterEditingOperation();
 }
 
 void Editor::replaceSelectionWithText(const String& text, bool selectReplacement, bool smartReplace)
 {
     replaceSelectionWithFragment(createFragmentFromText(selectedRange(), text), selectReplacement, smartReplace, true);
 }
 
 // TODO(xiaochengh): Merge it with |replaceSelectionWithFragment()|.
 void Editor::replaceSelectionAfterDragging(DocumentFragment* fragment, bool smartReplace, bool plainText)
 {
     ReplaceSelectionCommand::CommandOptions options = ReplaceSelectionCommand::SelectReplacement | ReplaceSelectionCommand::PreventNesting;
     if (smartReplace)
         options |= ReplaceSelectionCommand::SmartReplace;
     if (plainText)
         options |= ReplaceSelectionCommand::MatchStyle;
     DCHECK(frame().document());
-    ReplaceSelectionCommand::create(*frame().document(), fragment, options, EditActionDrag)->apply();
+    ReplaceSelectionCommand::create(*frame().document(), fragment, options, InputEvent::InputType::Drag)->apply();
 }
 
 void Editor::moveSelectionAfterDragging(DocumentFragment* fragment, const Position& pos, bool smartInsert, bool smartDelete)
 {
     MoveSelectionCommand::create(fragment, pos, smartInsert, smartDelete)->apply();
 }
 
 EphemeralRange Editor::selectedRange()
 {
     return frame().selection().selection().toNormalizedEphemeralRange();
@@ skipping 43 matching lines @@
         target = frame().document()->body();
 
     return target;
 }
 
 Element* Editor::findEventTargetFromSelection() const
 {
     return findEventTargetFrom(frame().selection().selection());
 }
 
-void Editor::applyStyle(StylePropertySet* style, EditAction editingAction)
+void Editor::applyStyle(StylePropertySet* style, InputEvent::InputType inputType)
 {
     switch (frame().selection().getSelectionType()) {
     case NoSelection:
         // do nothing
         break;
     case CaretSelection:
-        computeAndSetTypingStyle(style, editingAction);
+        computeAndSetTypingStyle(style, inputType);
         break;
     case RangeSelection:
         if (style) {
             DCHECK(frame().document());
-            ApplyStyleCommand::create(*frame().document(), EditingStyle::create(style), editingAction)->apply();
+            ApplyStyleCommand::create(*frame().document(), EditingStyle::create(style), inputType)->apply();
         }
         break;
     }
 }
 
-void Editor::applyParagraphStyle(StylePropertySet* style, EditAction editingAction)
+void Editor::applyParagraphStyle(StylePropertySet* style, InputEvent::InputType inputType)
 {
     if (frame().selection().isNone() || !style)
         return;
     DCHECK(frame().document());
-    ApplyStyleCommand::create(*frame().document(), EditingStyle::create(style), editingAction, ApplyStyleCommand::ForceBlockProperties)->apply();
+    ApplyStyleCommand::create(*frame().document(), EditingStyle::create(style), inputType, ApplyStyleCommand::ForceBlockProperties)->apply();
 }
 
-void Editor::applyStyleToSelection(StylePropertySet* style, EditAction editingAction)
+void Editor::applyStyleToSelection(StylePropertySet* style, InputEvent::InputType inputType)
 {
     if (!style || style->isEmpty() || !canEditRichly())
         return;
 
-    applyStyle(style, editingAction);
+    applyStyle(style, inputType);
 }
 
-void Editor::applyParagraphStyleToSelection(StylePropertySet* style, EditAction editingAction)
+void Editor::applyParagraphStyleToSelection(StylePropertySet* style, InputEvent::InputType inputType)
 {
     if (!style || style->isEmpty() || !canEditRichly())
         return;
 
-    applyParagraphStyle(style, editingAction);
+    applyParagraphStyle(style, inputType);
 }
 
 bool Editor::selectionStartHasStyle(CSSPropertyID propertyID, const String& value) const
 {
     EditingStyle* styleToCheck = EditingStyle::create(propertyID, value);
     EditingStyle* styleAtStart = EditingStyle::styleAtSelectionStart(frame().selection().selection(),
         propertyID == CSSPropertyBackgroundColor, styleToCheck->style());
     return styleToCheck->triStateOfStyle(styleAtStart);
 }
 
@@ skipping 20 matching lines @@
         startRoot->dispatchEvent(Event::create(EventTypeNames::webkitEditableContentChanged));
     if (endRoot && endRoot != startRoot)
         endRoot->dispatchEvent(Event::create(EventTypeNames::webkitEditableContentChanged));
 }
 
 void Editor::requestSpellcheckingAfterApplyingCommand(CompositeEditCommand* cmd)
 {
     // Note: Request spell checking for and only for |ReplaceSelectionCommand|s
     // created in |Editor::replaceSelectionWithFragment()|.
     // TODO(xiaochengh): May also need to do this after dragging crbug.com/298046.
-    if (cmd->editingAction() != EditActionPaste)
+    if (cmd->inputType() != InputEvent::InputType::Paste)
         return;
     if (!spellChecker().isContinuousSpellCheckingEnabled())
         return;
     if (!SpellChecker::isSpellCheckingEnabledFor(cmd->endingSelection()))
         return;
     DCHECK(cmd->isReplaceSelectionCommand());
     const EphemeralRange& insertedRange = toReplaceSelectionCommand(cmd)->insertedRange();
     if (insertedRange.isNull())
         return;
     spellChecker().chunkAndMarkAllMisspellingsAndBadGrammar(cmd->endingSelection().rootEditableElement(), insertedRange);
 }
 
 void Editor::appliedEditing(CompositeEditCommand* cmd)
 {
     EventQueueScope scope;
     frame().document()->updateStyleAndLayout();
 
     // Request spell checking after pasting before any further DOM change.
     requestSpellcheckingAfterApplyingCommand(cmd);
 
     EditCommandComposition* composition = cmd->composition();
     DCHECK(composition);
     dispatchEditableContentChangedEvents(composition->startingRootEditableElement(), composition->endingRootEditableElement());
     // TODO(chongz): Filter empty InputType after spec is finalized.
-    dispatchInputEventEditableContentChanged(composition->startingRootEditableElement(), composition->endingRootEditableElement(), inputTypeFromCommand(cmd), cmd->textDataForInputEvent(), isComposingFromCommand(cmd));
+    dispatchInputEventEditableContentChanged(composition->startingRootEditableElement(), composition->endingRootEditableElement(), cmd->inputType(), cmd->textDataForInputEvent(), isComposingFromCommand(cmd));
     VisibleSelection newSelection(cmd->endingSelection());
 
     // Don't clear the typing style with this selection change. We do those things elsewhere if necessary.
     changeSelectionAfterCommand(newSelection, 0);
 
     if (!cmd->preservesTypingStyle())
         frame().selection().clearTypingStyle();
 
     // Command will be equal to last edit command only in the case of typing
     if (m_lastEditCommand.get() == cmd) {
@@ skipping 316 matching lines @@
         if (direction == NaturalWritingDirection)
             return;
         focusedElement->setAttribute(dirAttr, direction == LeftToRightWritingDirection ? "ltr" : "rtl");
         focusedElement->dispatchInputEvent();
         frame().document()->updateStyleAndLayoutTree();
         return;
     }
 
     MutableStylePropertySet* style = MutableStylePropertySet::create(HTMLQuirksMode);
     style->setProperty(CSSPropertyDirection, direction == LeftToRightWritingDirection ? "ltr" : direction == RightToLeftWritingDirection ? "rtl" : "inherit", false);
-    applyParagraphStyleToSelection(style, EditActionSetWritingDirection);
+    applyParagraphStyleToSelection(style, InputEvent::InputType::SetWritingDirection);
 }
 
 void Editor::revealSelectionAfterEditingOperation(const ScrollAlignment& alignment, RevealExtentOption revealExtentOption)
 {
     if (m_preventRevealSelection)
         return;
 
     frame().selection().revealSelection(alignment, revealExtentOption);
 }
 
@@ skipping 92 matching lines @@
         startCaretRect.width() + extraWidthToEndOfLine,
         startCaretRect.height());
 }
 
 IntRect Editor::firstRectForRange(const Range* range) const
 {
     DCHECK(range);
     return firstRectForRange(EphemeralRange(range));
 }
 
-void Editor::computeAndSetTypingStyle(StylePropertySet* style, EditAction editingAction)
+void Editor::computeAndSetTypingStyle(StylePropertySet* style, InputEvent::InputType inputType)
 {
     if (!style || style->isEmpty()) {
         frame().selection().clearTypingStyle();
         return;
     }
 
     // Calculate the current typing style.
     EditingStyle* typingStyle = nullptr;
     if (frame().selection().typingStyle()) {
         typingStyle = frame().selection().typingStyle()->copy();
         typingStyle->overrideWithStyle(style);
     } else {
         typingStyle = EditingStyle::create(style);
     }
 
     typingStyle->prepareToApplyAt(frame().selection().selection().visibleStart().deepEquivalent(), EditingStyle::PreserveWritingDirection);
 
     // Handle block styles, substracting these from the typing style.
     EditingStyle* blockStyle = typingStyle->extractAndRemoveBlockProperties();
     if (!blockStyle->isEmpty()) {
         DCHECK(frame().document());
-        ApplyStyleCommand::create(*frame().document(), blockStyle, editingAction)->apply();
+        ApplyStyleCommand::create(*frame().document(), blockStyle, inputType)->apply();
     }
 
     // Set the remaining style as the typing style.
     frame().selection().setTypingStyle(typingStyle);
 }
 
 bool Editor::findString(const String& target, FindOptions options)
 {
     VisibleSelection selection = frame().selection().selection();
 
@@ skipping 189 matching lines @@
 
 DEFINE_TRACE(Editor)
 {
     visitor->trace(m_frame);
     visitor->trace(m_lastEditCommand);
     visitor->trace(m_undoStack);
     visitor->trace(m_mark);
 }
 
 } // namespace blink