[InputEvent] Support |deleteByDrag|, |insertFromDrop| and fire in sequential order

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 132 matching lines @@
 }
 
 InputEvent::InputType EditCommandComposition::inputType() const {
   return m_inputType;
 }
 
 void EditCommandComposition::append(SimpleEditCommand* command) {
   m_commands.append(command);
 }
 
+void EditCommandComposition::append(EditCommandComposition* composition) {
+  m_commands.appendVector(composition->m_commands);
+}
+
 void EditCommandComposition::setStartingSelection(
     const VisibleSelection& selection) {
   m_startingSelection = selection;
   m_startingRootEditableElement = selection.rootEditableElement();
 }
 
 void EditCommandComposition::setEndingSelection(
     const VisibleSelection& selection) {
   m_endingSelection = selection;
   m_endingRootEditableElement = selection.rootEditableElement();
@@ skipping 10 matching lines @@
 }
 
 CompositeEditCommand::CompositeEditCommand(Document& document)
     : EditCommand(document) {}
 
 CompositeEditCommand::~CompositeEditCommand() {
   DCHECK(isTopLevelCommand() || !m_composition);
 }
 
 bool CompositeEditCommand::apply() {
+  DCHECK(!isCommandGroupWrapper());
   if (!endingSelection().isContentRichlyEditable()) {
     switch (inputType()) {
       case InputEvent::InputType::InsertText:
       case InputEvent::InputType::InsertLineBreak:
       case InputEvent::InputType::InsertParagraph:
       case InputEvent::InputType::InsertFromPaste:
+      case InputEvent::InputType::InsertFromDrop:
       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::DeleteByCut:
-      case InputEvent::InputType::Drag:
+      case InputEvent::InputType::DeleteByDrag:
       case InputEvent::InputType::SetWritingDirection:
       case InputEvent::InputType::None:
         break;
       default:
         NOTREACHED();
         return false;
     }
   }
   ensureComposition();
 
@@ skipping 29 matching lines @@
 }
 
 bool CompositeEditCommand::preservesTypingStyle() const {
   return false;
 }
 
 bool CompositeEditCommand::isTypingCommand() const {
   return false;
 }
 
+bool CompositeEditCommand::isCommandGroupWrapper() const {
+  return false;
+}
+
+bool CompositeEditCommand::isDragAndDropCommand() const {
+  return false;
+}
+
 bool CompositeEditCommand::isReplaceSelectionCommand() const {
   return false;
 }
 
 void CompositeEditCommand::setShouldRetainAutocorrectionIndicator(bool) {}
 
 //
 // sugary-sweet convenience functions to help create and apply edit commands in composite commands
 //
 void CompositeEditCommand::applyCommandToComposite(EditCommand* command,
@@ skipping 18 matching lines @@
   command->setParent(this);
   if (selection != command->endingSelection()) {
     command->setStartingSelection(selection);
     command->setEndingSelection(selection);
   }
   command->doApply(editingState);
   if (!editingState->isAborted())
     m_commands.append(command);
 }
 
+void CompositeEditCommand::appendCommandToComposite(
+    CompositeEditCommand* command) {
+  ensureComposition()->append(command->ensureComposition());
+  command->setParent(this);
+  m_commands.append(command);
+}
+
 void CompositeEditCommand::applyStyle(const EditingStyle* style,
                                       EditingState* editingState) {
   applyCommandToComposite(
       ApplyStyleCommand::create(document(), style,
                                 InputEvent::InputType::ChangeAttributes),
       editingState);
 }
 
 void CompositeEditCommand::applyStyle(const EditingStyle* style,
                                       const Position& start,
@@ skipping 1624 matching lines @@
   return node;
 }
 
 DEFINE_TRACE(CompositeEditCommand) {
   visitor->trace(m_commands);
   visitor->trace(m_composition);
   EditCommand::trace(visitor);
 }
 
 }  // namespace blink