[InputEvent] Replace |EditAction| with |InputType|

third_party/WebKit/Source/core/editing/commands/CompositeEditCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 62 matching lines @@
 #include "core/layout/LayoutListItem.h"
 #include "core/layout/LayoutText.h"
 #include "core/layout/line/InlineTextBox.h"
 #include <algorithm>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 EditCommandComposition* EditCommandComposition::create(Document* document,
-    const VisibleSelection& startingSelection, const VisibleSelection& endingSelection, EditAction editAction)
+    const VisibleSelection& startingSelection, const VisibleSelection& endingSelection, InputEvent::InputType inputType)
 {
-    return new EditCommandComposition(document, startingSelection, endingSelection, editAction);
+    return new EditCommandComposition(document, startingSelection, endingSelection, inputType);
 }
 
-EditCommandComposition::EditCommandComposition(Document* document, const VisibleSelection& startingSelection, const VisibleSelection& endingSelection, EditAction editAction)
+EditCommandComposition::EditCommandComposition(Document* document, const VisibleSelection& startingSelection, const VisibleSelection& endingSelection, InputEvent::InputType inputType)
     : m_document(document)
     , m_startingSelection(startingSelection)
     , m_endingSelection(endingSelection)
     , m_startingRootEditableElement(startingSelection.rootEditableElement())
     , m_endingRootEditableElement(endingSelection.rootEditableElement())
-    , m_editAction(editAction)
+    , m_inputType(inputType)
 {
 }
 
 bool EditCommandComposition::belongsTo(const LocalFrame& frame) const
 {
     DCHECK(m_document);
     return m_document->frame() == &frame;
 }
 
 void EditCommandComposition::unapply()
@@ skipping 28 matching lines @@
     m_document->updateStyleAndLayoutIgnorePendingStylesheets();
 
     {
         for (const auto& command : m_commands)
             command->doReapply();
     }
 
     frame->editor().reappliedEditing(this);
 }
 
+InputEvent::InputType EditCommandComposition::inputType() const
+{
+    return m_inputType;
+}
+
 void EditCommandComposition::append(SimpleEditCommand* command)
 {
     m_commands.append(command);
 }
 
 void EditCommandComposition::setStartingSelection(const VisibleSelection& selection)
 {
     m_startingSelection = selection;
     m_startingRootEditableElement = selection.rootEditableElement();
 }
@@ skipping 21 matching lines @@
 }
 
 CompositeEditCommand::~CompositeEditCommand()
 {
     DCHECK(isTopLevelCommand() || !m_composition);
 }
 
 bool CompositeEditCommand::apply()
 {
     if (!endingSelection().isContentRichlyEditable()) {
-        switch (editingAction()) {
-        case EditActionTyping:
-        case EditActionPaste:
-        case EditActionDrag:
-        case EditActionSetWritingDirection:
-        case EditActionCut:
-        case EditActionUnspecified:
+        switch (inputType()) {
+        case InputEvent::InputType::InsertText:
+        case InputEvent::InputType::InsertLineBreak:
+        case InputEvent::InputType::InsertParagraph:
+        case InputEvent::InputType::DeleteComposedCharacterForward:
+        case InputEvent::InputType::DeleteComposedCharacterBackward:
+        case InputEvent::InputType::DeleteWordBackward:
+        case InputEvent::InputType::DeleteWordForward:
+        case InputEvent::InputType::DeleteLineBackward:
+        case InputEvent::InputType::DeleteLineForward:
+        case InputEvent::InputType::DeleteContentBackward:
+        case InputEvent::InputType::DeleteContentForward:
+        case InputEvent::InputType::Paste:
+        case InputEvent::InputType::Drag:
+        case InputEvent::InputType::SetWritingDirection:
+        case InputEvent::InputType::Cut:
+        case InputEvent::InputType::None:
             break;
         default:
             NOTREACHED();
             return false;
         }
     }
     ensureComposition();
 
     // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
     // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
@@ skipping 15 matching lines @@
     setShouldRetainAutocorrectionIndicator(false);
     return !editingState.isAborted();
 }
 
 EditCommandComposition* CompositeEditCommand::ensureComposition()
 {
     CompositeEditCommand* command = this;
     while (command && command->parent())
         command = command->parent();
     if (!command->m_composition)
-        command->m_composition = EditCommandComposition::create(&document(), startingSelection(), endingSelection(), editingAction());
+        command->m_composition = EditCommandComposition::create(&document(), startingSelection(), endingSelection(), inputType());
     return command->m_composition.get();
 }
 
 bool CompositeEditCommand::preservesTypingStyle() const
 {
     return false;
 }
 
 bool CompositeEditCommand::isTypingCommand() const
 {
@@ skipping 34 matching lines @@
         command->setStartingSelection(selection);
         command->setEndingSelection(selection);
     }
     command->doApply(editingState);
     if (!editingState->isAborted())
         m_commands.append(command);
 }
 
 void CompositeEditCommand::applyStyle(const EditingStyle* style, EditingState* editingState)
 {
-    applyCommandToComposite(ApplyStyleCommand::create(document(), style, EditActionChangeAttributes), editingState);
+    applyCommandToComposite(ApplyStyleCommand::create(document(), style, InputEvent::InputType::ChangeAttributes), editingState);
 }
 
 void CompositeEditCommand::applyStyle(const EditingStyle* style, const Position& start, const Position& end, EditingState* editingState)
 {
     applyCommandToComposite(ApplyStyleCommand::create(document(), style, start, end), editingState);
 }
 
 void CompositeEditCommand::applyStyledElement(Element* element, EditingState* editingState)
 {
     applyCommandToComposite(ApplyStyleCommand::create(element, false), editingState);
@@ skipping 1331 matching lines @@
 }
 
 DEFINE_TRACE(CompositeEditCommand)
 {
     visitor->trace(m_commands);
     visitor->trace(m_composition);
     EditCommand::trace(visitor);
 }
 
 } // namespace blink