[InputEvent] Support |deleteByCut|&|insertFromPaste| with |dataTransfer| field

third_party/WebKit/Source/core/events/InputEvent.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/events/InputEvent.h"
 
 #include "core/dom/Range.h"
 #include "core/events/EventDispatcher.h"
 #include "public/platform/WebEditingCommandType.h"
 
 namespace blink {
 
 namespace {
 
 const struct {
     InputEvent::InputType inputType;
     const char* stringName;
 } kInputTypeStringNameMap[] = {
     { InputEvent::InputType::None, "" },
     { InputEvent::InputType::InsertText, "insertText" },
     { InputEvent::InputType::InsertNonText, "insertNonText" },
     { InputEvent::InputType::InsertLineBreak, "insertLineBreak" },
     { InputEvent::InputType::InsertParagraph, "insertParagraph" },
     { InputEvent::InputType::InsertOrderedList, "insertOrderedList" },
     { InputEvent::InputType::InsertUnorderedList, "insertUnorderedList" },
     { InputEvent::InputType::InsertHorizontalRule, "insertHorizontalRule" },
+    { InputEvent::InputType::InsertFromPaste, "insertFromPaste" },
     { InputEvent::InputType::DeleteComposedCharacterForward, "deleteComposedCharacterForward" },
     { InputEvent::InputType::DeleteComposedCharacterBackward, "deleteComposedCharacterBackward" },
     { InputEvent::InputType::DeleteWordBackward, "deleteWordBackward" },
     { InputEvent::InputType::DeleteWordForward, "deleteWordForward" },
     { InputEvent::InputType::DeleteLineBackward, "deleteLineBackward" },
     { InputEvent::InputType::DeleteLineForward, "deleteLineForward" },
     { InputEvent::InputType::DeleteContentBackward, "deleteContentBackward" },
     { InputEvent::InputType::DeleteContentForward, "deleteContentForward" },
+    { InputEvent::InputType::DeleteByCut, "deleteByCut" },
     { InputEvent::InputType::Undo, "undo" },
     { InputEvent::InputType::Redo, "redo" },
-    { InputEvent::InputType::Copy, "copy" },
-    { InputEvent::InputType::Cut, "cut" },
-    { InputEvent::InputType::Paste, "paste" },
     { InputEvent::InputType::Bold, "bold" },
     { InputEvent::InputType::Italic, "italic" },
     { InputEvent::InputType::Underline, "underline" },
     { InputEvent::InputType::StrikeThrough, "strikeThrough" },
     { InputEvent::InputType::Superscript, "superscript" },
     { InputEvent::InputType::Subscript, "subscript" },
     { InputEvent::InputType::JustifyCenter, "justifyCenter" },
     { InputEvent::InputType::JustifyRight, "justifyRight" },
     { InputEvent::InputType::JustifyLeft, "justifyLeft" },
     { InputEvent::InputType::Indent, "indent" },
@@ skipping 37 matching lines @@
 
 InputEvent::InputEvent(const AtomicString& type, const InputEventInit& initializer)
     : UIEvent(type, initializer)
 {
     // TODO(ojan): We should find a way to prevent conversion like String->enum->String just in order to use initializer.
     // See InputEvent::createBeforeInput() for the first conversion.
     if (initializer.hasInputType())
         m_inputType = convertStringToInputType(initializer.inputType());
     if (initializer.hasData())
         m_data = initializer.data();
+    if (initializer.hasDataTransfer())
+        m_dataTransfer = initializer.dataTransfer();
     if (initializer.hasIsComposing())
         m_isComposing = initializer.isComposing();
     if (initializer.hasRanges())
         m_ranges = initializer.ranges();
 }
 
 /* static */
 InputEvent* InputEvent::createBeforeInput(InputType inputType, const String& data, EventCancelable cancelable, EventIsComposing isComposing, const RangeVector* ranges)
 {
     InputEventInit inputEventInit;
 
     inputEventInit.setBubbles(true);
     inputEventInit.setCancelable(cancelable == IsCancelable);
     // TODO(ojan): We should find a way to prevent conversion like String->enum->String just in order to use initializer.
     // See InputEvent::InputEvent() for the second conversion.
     inputEventInit.setInputType(convertInputTypeToString(inputType));
     inputEventInit.setData(data);
     inputEventInit.setIsComposing(isComposing == IsComposing);
     if (ranges)
         inputEventInit.setRanges(*ranges);
 
     return InputEvent::create(EventTypeNames::beforeinput, inputEventInit);
 }
 
 /* static */
+InputEvent* InputEvent::createBeforeInput(InputType inputType, DataTransfer* dataTransfer, EventCancelable cancelable, EventIsComposing isComposing, const RangeVector* ranges)
+{
+    InputEventInit inputEventInit;
+
+    inputEventInit.setBubbles(true);
+    inputEventInit.setCancelable(cancelable == IsCancelable);
+    inputEventInit.setInputType(convertInputTypeToString(inputType));
+    inputEventInit.setDataTransfer(dataTransfer);
+    inputEventInit.setIsComposing(isComposing == IsComposing);
+    if (ranges)
+        inputEventInit.setRanges(*ranges);
+
+    return InputEvent::create(EventTypeNames::beforeinput, inputEventInit);
+}
+
+/* static */
 InputEvent* InputEvent::createInput(InputType inputType, const String& data, EventIsComposing isComposing, const RangeVector* ranges)
 {
     InputEventInit inputEventInit;
 
     inputEventInit.setBubbles(true);
     inputEventInit.setCancelable(false);
     // TODO(ojan): We should find a way to prevent conversion like String->enum->String just in order to use initializer.
     // See InputEvent::InputEvent() for the second conversion.
     inputEventInit.setInputType(convertInputTypeToString(inputType));
     inputEventInit.setData(data);
@@ skipping 25 matching lines @@
 // TODO(chongz): We should get rid of this |EventDispatchMediator| pattern and introduce
 // simpler interface such as |beforeDispatchEvent()| and |afterDispatchEvent()| virtual methods.
 EventDispatchMediator* InputEvent::createMediator()
 {
     return InputEventDispatchMediator::create(this);
 }
 
 DEFINE_TRACE(InputEvent)
 {
     UIEvent::trace(visitor);
+    visitor->trace(m_dataTransfer);
     visitor->trace(m_ranges);
 }
 
 InputEventDispatchMediator* InputEventDispatchMediator::create(InputEvent* inputEvent)
 {
     return new InputEventDispatchMediator(inputEvent);
 }
 
 InputEventDispatchMediator::InputEventDispatchMediator(InputEvent* inputEvent)
     : EventDispatchMediator(inputEvent)
@@ skipping 17 matching lines @@
     //   3. We don't want authors to hold live |Range| indefinitely by holding |InputEvent|, so we
     //      clear them after dispatch.
     // Authors should explicitly call |getRanges()|->|toRange()| if they want to keep a copy of |Range|.
     // See Editing TF meeting notes:
     // https://docs.google.com/document/d/1hCj6QX77NYIVY0RWrMHT1Yra6t8_Qu8PopaWLG0AM58/edit?usp=sharing
     event().m_ranges.clear();
     return result;
 }
 
 } // namespace blink