[InputEvent] Move 'beforeinput' logic into |CompositeEditCommand::willApplyEditing()| (3/3)

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 68 matching lines @@
 #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/clipboard/ClipboardMimeTypes.h"
 #include "platform/weborigin/KURL.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/CharacterNames.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 using namespace WTF;
 using namespace Unicode;
 
 namespace {
 
+DispatchEventResult dispatchBeforeInputEvent(
+    Node* target,
+    InputEvent::InputType inputType,
+    const String& data,
+    DataTransfer* dataTransfer,
+    InputEvent::EventCancelable isCancelable,
+    InputEvent::EventIsComposing isComposing,
+    const RangeVector* ranges) {
+  if (!RuntimeEnabledFeatures::inputEventEnabled())
+    return DispatchEventResult::NotCanceled;
+  if (!target || !target->isConnected())
+    return DispatchEventResult::NotCanceled;
+
+  if (!hasRichlyEditableStyle(*target)) {
+    // Plain-text only elements (<input>, <textarea>, etc.) don't support
+    // DataTransfer or Range.
+    dataTransfer = nullptr;
+    ranges = nullptr;
+  }
+
+  InputEvent* beforeInputEvent;
+
+  if (dataTransfer) {
+    beforeInputEvent = InputEvent::createBeforeInput(
+        inputType, dataTransfer, isCancelable, isComposing, ranges);
+  } else {
+    beforeInputEvent = InputEvent::createBeforeInput(
+        inputType, data, isCancelable, isComposing, ranges);
+  }
+  return target->dispatchEvent(beforeInputEvent);
+}
+
 void dispatchInputEvent(Element* target,
                         InputEvent::InputType inputType,
                         const String& data,
                         InputEvent::EventIsComposing isComposing) {
   if (!RuntimeEnabledFeatures::inputEventEnabled())
     return;
-  if (!target)
+  if (!target || !target->isConnected())
     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);
+      InputEvent::createInput(inputType, data, isComposing);
   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)
     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;
+    return InputEvent::IsComposing;
+  return InputEvent::NotComposing;
+}
+
+InputEvent::EventCancelable isCancelableFromCommand(
+    const CompositeEditCommand* command) {
+  if (command->isTypingCommand() &&
+      toTypingCommand(command)->compositionType() ==
+          TypingCommand::TextCompositionUpdate)
+    return InputEvent::NotCancelable;
+  return InputEvent::IsCancelable;
 }
 
 }  // anonymous namespace
 
 Editor::RevealSelectionScope::RevealSelectionScope(Editor* editor)
     : m_editor(editor) {
   ++m_editor->m_preventRevealSelection;
 }
 
 Editor::RevealSelectionScope::~RevealSelectionScope() {
@@ skipping 458 matching lines @@
   if (insertMode == InsertMode::Smart)
     options |= ReplaceSelectionCommand::SmartReplace;
   if (dragSourceType == DragSourceType::PlainTextSource)
     options |= ReplaceSelectionCommand::MatchStyle;
   DCHECK(frame().document());
   ReplaceSelectionCommand::create(*frame().document(), fragment, options,
                                   InputEvent::InputType::InsertFromDrop)
       ->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;
 
   Node* startContainer = range.startPosition().computeContainerNode();
   Node* endContainer = range.endPosition().computeContainerNode();
@@ skipping 116 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));
 }
 
+bool Editor::willApplyEditing(CompositeEditCommand* cmd) {
+  // Don't fire 'beforeinput', return true to continue.
+  if (m_executingCommandFromDOM ||
+      cmd->inputType() == InputEvent::InputType::None)
+    return true;
+
+  DispatchEventResult result = dispatchBeforeInputEvent(
+      eventTargetNodeForDocument(m_frame->document()), cmd->inputType(),
+      cmd->textDataForInputEvent(), cmd->dataTransferForInputEvent(),
+      isCancelableFromCommand(cmd), isComposingFromCommand(cmd),
+      cmd->targetRangesForInputEvent());
+
+  // 'beforeinput' event handler may destroy target frame.
+  if (m_frame->document()->frame() != m_frame)
+    return false;
+  return result == DispatchEventResult::NotCanceled;
+}
+
 void Editor::appliedEditing(CompositeEditCommand* cmd) {
   DCHECK(!cmd->isCommandGroupWrapper());
   EventQueueScope scope;
 
   // Request spell checking before any further DOM change.
   spellChecker().markMisspellingsAfterApplyingCommand(*cmd);
 
   EditCommandComposition* composition = cmd->composition();
   DCHECK(composition);
   dispatchEditableContentChangedEvents(
@@ skipping 111 matching lines @@
     : m_frame(&frame),
       m_undoStack(UndoStack::create()),
       m_preventRevealSelection(0),
       m_shouldStartNewKillRingSequence(false),
       // This is off by default, since most editors want this behavior (this
       // matches IE but not FF).
       m_shouldStyleWithCSS(false),
       m_killRing(wrapUnique(new KillRing)),
       m_areMarkedTextMatchesHighlighted(false),
       m_defaultParagraphSeparator(EditorParagraphSeparatorIsDiv),
-      m_overwriteModeEnabled(false) {}
+      m_overwriteModeEnabled(false),
+      m_executingCommandFromDOM(false) {}
 
 Editor::~Editor() {}
 
 void Editor::clear() {
   frame().inputMethodController().clear();
   m_shouldStyleWithCSS = false;
   m_defaultParagraphSeparator = EditorParagraphSeparatorIsDiv;
   m_undoStack->clear();
 }
 
@@ skipping 88 matching lines @@
     spellChecker().updateMarkersForWordsAffectedByEditing(true);
     if (enclosingTextControl(frame().selection().start())) {
       String plainText = frame().selectedTextForClipboard();
       Pasteboard::generalPasteboard()->writePlainText(
           plainText, canSmartCopyOrDelete() ? Pasteboard::CanSmartReplace
                                             : Pasteboard::CannotSmartReplace);
     } else {
       writeSelectionToPasteboard();
     }
 
-    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() ? DeleteMode::Smart : DeleteMode::Simple,
         InputEvent::InputType::DeleteByCut);
   }
 }
 
 void Editor::copy() {
   if (tryDHTMLCopy())
     return;  // DHTML did the whole operation
   if (!canCopy())
@@ skipping 28 matching lines @@
   if (!canPaste())
     return;
   spellChecker().updateMarkersForWordsAffectedByEditing(false);
   ResourceFetcher* loader = frame().document()->fetcher();
   ResourceCacheValidationSuppressor validationSuppressor(loader);
 
   PasteMode pasteMode = frame().selection().isContentRichlyEditable()
                             ? AllMimeTypes
                             : PlainTextOnly;
 
-  if (source == CommandFromMenuOrKeyBinding) {
-    DataTransfer* dataTransfer =
-        DataTransfer::create(DataTransfer::CopyAndPaste, DataTransferReadable,
-                             DataObject::createFromPasteboard(pasteMode));
-
-    if (dispatchBeforeInputDataTransfer(findEventTargetFromSelection(),
-                                        InputEvent::InputType::InsertFromPaste,
-                                        dataTransfer, nullptr) !=
-        DispatchEventResult::NotCanceled)
-      return;
-    // 'beforeinput' event handler may destroy target frame.
-    if (m_frame->document()->frame() != m_frame)
-      return;
-  }
-
   if (pasteMode == AllMimeTypes)
     pasteWithPasteboard(Pasteboard::generalPasteboard());
   else
     pasteAsPlainTextWithPasteboard(Pasteboard::generalPasteboard());
 }
 
 void Editor::pasteAsPlainText(EditorCommandSource source) {
   if (tryDHTMLPaste(PlainTextOnly))
     return;
   if (!canPaste())
@@ skipping 96 matching lines @@
   writeImageNodeToPasteboard(Pasteboard::generalPasteboard(),
                              result.innerNodeOrImageMapImage(),
                              result.altDisplayString());
 }
 
 bool Editor::canUndo() {
   return m_undoStack->canUndo();
 }
 
 void Editor::undo() {
+  if (!m_executingCommandFromDOM) {
+    if (dispatchBeforeInputEvent(
+            m_frame->document(), InputEvent::InputType::HistoryUndo, nullAtom,
+            nullptr, InputEvent::IsCancelable, InputEvent::NotComposing,
+            nullptr) != DispatchEventResult::NotCanceled)
+      return;
+
+    // 'beforeinput' event handler may destroy target frame.
+    if (m_frame->document()->frame() != m_frame)
+      return;
+  }
   m_undoStack->undo();
 }
 
 bool Editor::canRedo() {
   return m_undoStack->canRedo();
 }
 
 void Editor::redo() {
+  if (!m_executingCommandFromDOM) {
+    if (dispatchBeforeInputEvent(
+            m_frame->document(), InputEvent::InputType::HistoryRedo, nullAtom,
+            nullptr, InputEvent::IsCancelable, InputEvent::NotComposing,
+            nullptr) != DispatchEventResult::NotCanceled)
+      return;
+
+    // 'beforeinput' event handler may destroy target frame.
+    if (m_frame->document()->frame() != m_frame)
+      return;
+  }
   m_undoStack->redo();
 }
 
 void Editor::setBaseWritingDirection(WritingDirection direction) {
   Element* focusedElement = frame().document()->focusedElement();
   if (isTextControlElement(focusedElement)) {
     if (direction == NaturalWritingDirection)
       return;
     focusedElement->setAttribute(
         dirAttr, direction == LeftToRightWritingDirection ? "ltr" : "rtl");
     focusedElement->dispatchInputEvent();
     return;
   }
 
   MutableStylePropertySet* style =
       MutableStylePropertySet::create(HTMLQuirksMode);
   style->setProperty(
       CSSPropertyDirection,
       direction == LeftToRightWritingDirection
           ? "ltr"
           : direction == RightToLeftWritingDirection ? "rtl" : "inherit",
       false);
   applyParagraphStyleToSelection(
       style, InputEvent::InputType::FormatSetBlockTextDirection);
 }
 
 void Editor::revealSelectionAfterEditingOperation(
     const ScrollAlignment& alignment,
     RevealExtentOption revealExtentOption) {
-  if (m_preventRevealSelection)
+  if (m_preventRevealSelection || !m_frame->selection().isAvailable())
     return;
   frame().selection().revealSelection(alignment, revealExtentOption);
 }
 
 void Editor::transpose() {
   if (!canEdit())
     return;
 
   VisibleSelection selection = frame().selection().selection();
   if (!selection.isCaret())
@@ skipping 378 matching lines @@
 }
 
 DEFINE_TRACE(Editor) {
   visitor->trace(m_frame);
   visitor->trace(m_lastEditCommand);
   visitor->trace(m_undoStack);
   visitor->trace(m_mark);
 }
 
 }  // namespace blink