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

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 330 matching lines @@
 
     // FIXME: We should to move this down into deleteKeyPressed.
     // clear the "start new kill ring sequence" setting, because it was set to true
     // when the selection was updated by deleting the range
     if (killRing)
         setStartNewKillRingSequence(false);
 
     return true;
 }
 
-void Editor::deleteSelectionWithSmartDelete(bool smartDelete, InputEvent::InputType inputType)
+void Editor::deleteSelectionWithSmartDelete(bool smartDelete, InputEvent::InputType inputType, const Position& referenceMovePosition)
 {
     if (frame().selection().isNone())
         return;
 
     const bool kMergeBlocksAfterDelete = true;
     const bool kExpandForSpecialElements = false;
     const bool kSanitizeMarkup = true;
     DCHECK(frame().document());
-    DeleteSelectionCommand::create(*frame().document(), smartDelete, kMergeBlocksAfterDelete, kExpandForSpecialElements, kSanitizeMarkup, inputType)->apply();
+    DeleteSelectionCommand::create(*frame().document(), smartDelete, kMergeBlocksAfterDelete, kExpandForSpecialElements, kSanitizeMarkup, inputType, referenceMovePosition)->apply();
 }
 
 void Editor::pasteAsPlainText(const String& pastingText, bool smartReplace)
 {
     Element* target = findEventTargetFromSelection();
     if (!target)
         return;
     target->dispatchEvent(TextEvent::createForPlainTextPaste(frame().domWindow(), pastingText, smartReplace));
 }
 
@@ skipping 173 matching lines @@
 
 // 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, InputEvent::InputType::Drag)->apply();
+    ReplaceSelectionCommand::create(*frame().document(), fragment, options, InputEvent::InputType::InsertFromDrop)->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 147 matching lines @@
 
     // 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) {
         DCHECK(cmd->isTypingCommand());
+    } else if (m_lastEditCommand && m_lastEditCommand->inputType() == InputEvent::InputType::DeleteByDrag && cmd->inputType() == InputEvent::InputType::InsertFromDrop) {
+        m_lastEditCommand->appendCommandToComposite(cmd);
+        m_lastEditCommand = cmd;

[chongz, 2016/09/28 02:19:26]

Has potential issue. These 2 commands might be created from 2 separate
Drag&Drop, but I don't have a better solution for this...

[yosin_UTC9, 2016/09/28 04:19:03]

How about having DragAndDropCommand, derived from CompositeEditCommand, which
hold DeleteByDrag and InputFromDrop, if they aren't canceled?
We hold DragAndDropCommand in m_lastEditCommand and check here like:

if (m_lastEditCommand && m_lastEditCommand->isDragAndDropCommand()) {
  if (cmd is DeleteByDrag or cmd is InsertFromDrag)
   m_lastEditCOmamnd->appendCommandToComposite(cmd);
}

In this way, it seems we don't need to introduce CompositeEditCommand::append()
and append for vector of EditCommand

[chongz, 2016/09/29 02:36:22]

Added command group wrapper |DragAndDropCommand|, which doesn't do anything by
itself, but could catch following |DeleteByDrag| and |InsertFromDrop|, and
combine into a single undo entry.
I'm not sure what this means, do you mean we don't need
|EditCommandComposition::append(EditCommandComposition*)|?

     } else {
         // Only register a new undo command if the command passed in is
         // different from the last command
         m_lastEditCommand = cmd;
         m_undoStack->registerUndoStep(m_lastEditCommand->ensureComposition());
     }
 
     respondToChangedContents(newSelection);
 }
 
@@ skipping 685 matching lines @@
 
 DEFINE_TRACE(Editor)
 {
     visitor->trace(m_frame);
     visitor->trace(m_lastEditCommand);
     visitor->trace(m_undoStack);
     visitor->trace(m_mark);
 }
 
 } // namespace blink