[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 247 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)
+bool Editor::deleteSelectionAfterDraggingWithEvents(Element* dragSource, SmartDelete smartDelete, const Position& referenceMovePosition)
 {
-    MoveSelectionCommand::create(fragment, pos, smartInsert, smartDelete)->apply();
+    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(smartDelete == SmartDelete::Yes, InputEvent::InputType::DeleteByDrag, referenceMovePosition);
+
+    return true;
+}
+
+bool Editor::replaceSelectionAfterDraggingWithEvents(Element* dropTarget, DragData* dragData, DocumentFragment* fragment, Range* dropCaretRange, SmartInsert smartInsert, ChosePlainText chosePlainText)
+{
+    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, smartInsert == SmartInsert::Yes, chosePlainText == ChosePlainText::Yes);
+
+    return true;
 }
 
 EphemeralRange Editor::selectedRange()
 {
     return frame().selection().selection().toNormalizedEphemeralRange();
 }
 
 bool Editor::canDeleteRange(const EphemeralRange& range) const
 {
     if (range.isCollapsed())
@@ skipping 24 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();
@@ skipping 76 matching lines @@
 static void dispatchEditableContentChangedEvents(Element* startRoot, 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 685 matching lines @@
 
 DEFINE_TRACE(Editor)
 {
     visitor->trace(m_frame);
     visitor->trace(m_lastEditCommand);
     visitor->trace(m_undoStack);
     visitor->trace(m_mark);
 }
 
 } // namespace blink