[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 63 matching lines @@
 #include "core/html/HTMLHtmlElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/input/EventHandler.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutImage.h"
 #include "core/loader/EmptyClients.h"
+#include "core/page/DragData.h"
 #include "core/page/EditorClient.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/svg/SVGImageElement.h"
 #include "platform/KillRing.h"
 #include "platform/weborigin/KURL.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/CharacterNames.h"
 
 namespace blink {
@@ skipping 227 matching lines @@
     if (isTypingAction) {
       DCHECK(frame().document());
       TypingCommand::deleteKeyPressed(
           *frame().document(),
           canSmartCopyOrDelete() ? TypingCommand::SmartDelete : 0, granularity);
       revealSelectionAfterEditingOperation();
     } else {
       if (killRing)
         addToKillRing(selectedRange());
       deleteSelectionWithSmartDelete(
-          canSmartCopyOrDelete(),
+          canSmartCopyOrDelete() ? DeleteMode::Smart : DeleteMode::Simple,
           deletionInputTypeFromTextGranularity(direction, granularity));
       // Implicitly calls revealSelectionAfterEditingOperation().
     }
   } else {
     TypingCommand::Options options = 0;
     if (canSmartCopyOrDelete())
       options |= TypingCommand::SmartDelete;
     if (killRing)
       options |= TypingCommand::KillRing;
     switch (direction) {
@@ skipping 15 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(
+    DeleteMode deleteMode,
+    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)
+      *frame().document(), deleteMode == DeleteMode::Smart,
+      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 183 matching lines @@
 
 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) {
+                                           InsertMode insertMode,
+                                           DragSourceType dragSourceType) {
   ReplaceSelectionCommand::CommandOptions options =
       ReplaceSelectionCommand::SelectReplacement |
       ReplaceSelectionCommand::PreventNesting;
-  if (smartReplace)
+  if (insertMode == InsertMode::Smart)
     options |= ReplaceSelectionCommand::SmartReplace;
-  if (plainText)
+  if (dragSourceType == DragSourceType::PlainTextSource)
     options |= ReplaceSelectionCommand::MatchStyle;
   DCHECK(frame().document());
   ReplaceSelectionCommand::create(*frame().document(), fragment, options,
-                                  InputEvent::InputType::Drag)
+                                  InputEvent::InputType::InsertFromDrop)
       ->apply();
 }
 
-void Editor::moveSelectionAfterDragging(DocumentFragment* fragment,
-                                        const Position& pos,
-                                        bool smartInsert,
-                                        bool smartDelete) {
-  MoveSelectionCommand::create(fragment, pos, smartInsert, smartDelete)
-      ->apply();
+bool Editor::deleteSelectionAfterDraggingWithEvents(
+    Element* dragSource,
+    DeleteMode deleteMode,
+    const Position& referenceMovePosition) {
+  if (!dragSource || !dragSource->isConnected())
+    return true;
+
+  // Dispatch 'beforeinput'.
+  const bool shouldDelete = dispatchBeforeInputEditorCommand(
+                                dragSource, InputEvent::InputType::DeleteByDrag,
+                                nullptr) == DispatchEventResult::NotCanceled;
+
+  // 'beforeinput' event handler may destroy frame, return false to cancel remaining actions;
+  if (m_frame->document()->frame() != m_frame)
+    return false;
+
+  if (shouldDelete && dragSource->isConnected()) {
+    deleteSelectionWithSmartDelete(
+        deleteMode, InputEvent::InputType::DeleteByDrag, referenceMovePosition);
+  }
+
+  return true;
+}
+
+bool Editor::replaceSelectionAfterDraggingWithEvents(
+    Element* dropTarget,
+    DragData* dragData,
+    DocumentFragment* fragment,
+    Range* dropCaretRange,
+    InsertMode insertMode,
+    DragSourceType dragSourceType) {
+  if (!dropTarget || !dropTarget->isConnected())
+    return true;
+
+  // Dispatch 'beforeinput'.
+  DataTransfer* dataTransfer =
+      DataTransfer::create(DataTransfer::DragAndDrop, DataTransferReadable,
+                           dragData->platformData());
+  dataTransfer->setSourceOperation(dragData->draggingSourceOperationMask());
+  const bool shouldInsert =
+      dispatchBeforeInputDataTransfer(
+          dropTarget, InputEvent::InputType::InsertFromDrop, dataTransfer,
+          nullptr) == DispatchEventResult::NotCanceled;
+
+  // 'beforeinput' event handler may destroy frame, return false to cancel remaining actions;
+  if (m_frame->document()->frame() != m_frame)
+    return false;
+
+  if (shouldInsert && dropTarget->isConnected())
+    replaceSelectionAfterDragging(fragment, insertMode, dragSourceType);
+
+  return true;
 }
 
 EphemeralRange Editor::selectedRange() {
   return frame().selection().selection().toNormalizedEphemeralRange();
 }
 
 bool Editor::canDeleteRange(const EphemeralRange& range) const {
   if (range.isCollapsed())
     return false;
 
@@ skipping 20 matching lines @@
 
   spellChecker().updateMarkersForWordsAffectedByEditing(true);
   client().respondToChangedContents();
 }
 
 void Editor::removeFormattingAndStyle() {
   DCHECK(frame().document());
   RemoveFormatCommand::create(*frame().document())->apply();
 }
 
+void Editor::registerCommandGroup(CompositeEditCommand* commandGroupWrapper) {
+  DCHECK(commandGroupWrapper->isCommandGroupWrapper());
+  m_lastEditCommand = commandGroupWrapper;
+}
+
 void Editor::clearLastEditCommand() {
   m_lastEditCommand.clear();
 }
 
 Element* Editor::findEventTargetFrom(const VisibleSelection& selection) const {
   Element* target = associatedElementOf(selection.start());
   if (!target)
     target = frame().document()->body();
 
   return target;
@@ skipping 80 matching lines @@
                                                  Element* endRoot) {
   if (startRoot)
     startRoot->dispatchEvent(
         Event::create(EventTypeNames::webkitEditableContentChanged));
   if (endRoot && endRoot != startRoot)
     endRoot->dispatchEvent(
         Event::create(EventTypeNames::webkitEditableContentChanged));
 }
 
 void Editor::appliedEditing(CompositeEditCommand* cmd) {
+  DCHECK(!cmd->isCommandGroupWrapper());
   EventQueueScope scope;
   frame().document()->updateStyleAndLayout();
 
   // Request spell checking before any further DOM change.
   spellChecker().markMisspellingsAfterApplyingCommand(*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(), 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) {
     DCHECK(cmd->isTypingCommand());
+  } else if (m_lastEditCommand && m_lastEditCommand->isDragAndDropCommand() &&
+             (cmd->inputType() == InputEvent::InputType::DeleteByDrag ||
+              cmd->inputType() == InputEvent::InputType::InsertFromDrop)) {
+    // Only register undo entry when combined with other commands.
+    if (!m_lastEditCommand->composition())
+      m_undoStack->registerUndoStep(m_lastEditCommand->ensureComposition());
+    m_lastEditCommand->appendCommandToComposite(cmd);
   } 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 174 matching lines @@
     if (source == CommandFromMenuOrKeyBinding) {
       if (dispatchBeforeInputDataTransfer(findEventTargetFromSelection(),
                                           InputEvent::InputType::DeleteByCut,
                                           nullptr, nullptr) !=
           DispatchEventResult::NotCanceled)
         return;
       // 'beforeinput' event handler may destroy target frame.
       if (m_frame->document()->frame() != m_frame)
         return;
     }
-    deleteSelectionWithSmartDelete(canSmartCopyOrDelete(),
-                                   InputEvent::InputType::DeleteByCut);
+    deleteSelectionWithSmartDelete(
+        canSmartCopyOrDelete() ? DeleteMode::Smart : DeleteMode::Simple,
+        InputEvent::InputType::DeleteByCut);
   }
 }
 
 void Editor::copy() {
   if (tryDHTMLCopy())
     return;  // DHTML did the whole operation
   if (!canCopy())
     return;
   if (enclosingTextFormControl(frame().selection().start())) {
     Pasteboard::generalPasteboard()->writePlainText(
@@ skipping 54 matching lines @@
   spellChecker().updateMarkersForWordsAffectedByEditing(false);
   pasteAsPlainTextWithPasteboard(Pasteboard::generalPasteboard());
 }
 
 void Editor::performDelete() {
   if (!canDelete())
     return;
   addToKillRing(selectedRange());
   // TODO(chongz): |Editor::performDelete()| has no direction.
   // https://github.com/w3c/editing/issues/130
-  deleteSelectionWithSmartDelete(canSmartCopyOrDelete(),
-                                 InputEvent::InputType::DeleteContentBackward);
+  deleteSelectionWithSmartDelete(
+      canSmartCopyOrDelete() ? DeleteMode::Smart : DeleteMode::Simple,
+      InputEvent::InputType::DeleteContentBackward);
 
   // clear the "start new kill ring sequence" setting, because it was set to true
   // when the selection was updated by deleting the range
   setStartNewKillRingSequence(false);
 }
 
 static void countEditingEvent(ExecutionContext* executionContext,
                               const Event* event,
                               UseCounter::Feature featureOnInput,
                               UseCounter::Feature featureOnTextArea,
@@ skipping 495 matching lines @@
 }
 
 DEFINE_TRACE(Editor) {
   visitor->trace(m_frame);
   visitor->trace(m_lastEditCommand);
   visitor->trace(m_undoStack);
   visitor->trace(m_mark);
 }
 
 }  // namespace blink