[InputEvent] Support |deleteByDrag| and |insertFromDrop|

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 84 matching lines @@
 using namespace HTMLNames;
 using namespace WTF;
 using namespace Unicode;
 
 namespace {
 
 void dispatchInputEvent(Element* target, InputEvent::InputType inputType, const String& data, InputEvent::EventIsComposing isComposing)
 {
     if (!RuntimeEnabledFeatures::inputEventEnabled())
         return;
-    if (!target)
+    if (!target || !target->isConnected())

[yosin_UTC9, 2016/09/08 04:34:40]

One more.
Could you make |disaptchInputEvent()| to take |const Document&
originateDocument| and check or DCEHCK |target->ownerDocument() ==
originateDocument|
to catch source and destination still in document starting drag-and-drop.

[chongz, 2016/09/08 22:37:50]

I've added check for |ownerDocument()| but I don't really understand why...
  1. Drag&drop could happen from one iframe to another, so I assume their
document are not necessarily to be the same.
  2. If we want to make sure |ownerDocument()| for one target doesn't change
during the drag&drop, we should record |originalDocument| before 'beforeinput'
and check here, but |Editor::appliedEditing()| doesn't seem to have that
information?
  3. If we just want to make sure 'input' handler for |startRoot| doesn't do
anything bad, we already have |dispatchScopedEvent()| which only dispatch events
when safe, or did I misunderstood something?

Thanks!

[chongz, 2016/09/13 17:17:12]

dtapuska@ I'm not sure if I understood the issue correctly, can you take a look
please? thanks!

[dtapuska, 2016/09/13 17:27:50]

Ya this change seems odd to me. The old code use to ensure that only one
inputEvent was dispatched. That is why it was checking the endRoot didn't
matched the startRoot. But with the type of the event changing both events need
to be dispatched. And I find passing the originateDocument into the
dispatchInputEvent confusing. If you wanted to assert that the endRoot's
document matched the startRoot's document then you should do it on line 116. 

[yosin_UTC9, 2016/09/14 01:57:37]

I changed mind, we should verify source and target aren't removed from originate
document.

* Event order: (See [1] [2])
  1. 'drop'
  2. 'beforeinput' InputType=|deleteByDrag|
Verify source and target aren't removed.

  3. 'beforeinput' InputType=|insertFromDrop|
Verify source and target arent' removed.
  4. (DOM update)
Both source and target are modified, we don't care source and target anymore.
But, we don't dispatch events for source and target if they aren't connected.
  5. 'input' InputType=|deleteByDrag|
  6. 'input' InputType=|insertFromDrop|
  7. 'dragend'

Given that, |Editor| should observe nodeWillBeRemoved and nodeChildrenRemoved()
to stop drag-and-drop process when either source or target removed.
Is it better to introduce DragAndDropEventDispatcher class and make |Editor| to
hold it during drag-and-drop?

         return;
-    // TODO(chongz): Pass appreciate |ranges| after it's defined on spec.
-    // http://w3c.github.io/editing/input-events.html#dom-inputevent-inputtype
     InputEvent* inputEvent = InputEvent::createInput(inputType, data, isComposing, nullptr);
     target->dispatchScopedEvent(inputEvent);
 }
 
 void dispatchInputEventEditableContentChanged(Element* startRoot, Element* endRoot, InputEvent::InputType inputType, const String& data, InputEvent::EventIsComposing isComposing)
 {
-    if (startRoot)
-        dispatchInputEvent(startRoot, inputType, data, isComposing);
-    if (endRoot && endRoot != startRoot)
+    if (inputType == InputEvent::InputType::MoveByDragDrop) {
+        // Drag&Drop will be combined into one |MoveSelectionCommand|, we need to split it into |DeleteByDrag| and |InsertFromDrop|.
+        dispatchInputEvent(startRoot, InputEvent::InputType::DeleteByDrag, data, isComposing);
+        dispatchInputEvent(endRoot, InputEvent::InputType::InsertFromDrop, data, isComposing);
+        return;
+    }
+
+    dispatchInputEvent(startRoot, inputType, data, isComposing);
+    if (endRoot != startRoot)
         dispatchInputEvent(endRoot, inputType, data, isComposing);
 }
 
 InputEvent::EventIsComposing isComposingFromCommand(const CompositeEditCommand* command)
 {
     if (command->isTypingCommand() && toTypingCommand(command)->compositionType() != TypingCommand::TextCompositionNone)
         return InputEvent::EventIsComposing::IsComposing;
     return InputEvent::EventIsComposing::NotComposing;
 }
 
@@ skipping 425 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 844 matching lines @@
 
 DEFINE_TRACE(Editor)
 {
     visitor->trace(m_frame);
     visitor->trace(m_lastEditCommand);
     visitor->trace(m_undoStack);
     visitor->trace(m_mark);
 }
 
 } // namespace blink