[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/layout/HitTestResult.h"
 #include "core/layout/LayoutImage.h"
 #include "core/loader/EmptyClients.h"
 #include "core/loader/resource/ImageResourceContent.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"

[Xiaocheng, 2016/12/21 02:56:38]

What needs it?

[chongz, 2016/12/21 23:59:24]

My mistake, removed. It was added for |dispatchBeforeInput()| but then it was
moved back to "EditingUtilities.cpp".

 #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 {
 
 void dispatchInputEvent(Element* target,
                         InputEvent::InputType inputType,
                         const String& data,
                         InputEvent::EventIsComposing isComposing) {
   if (!RuntimeEnabledFeatures::inputEventEnabled())
     return;
-  if (!target)
+  if (!target || !target->isConnected())

[Xiaocheng, 2016/12/21 02:56:38]

This part doesn't seem relevant to beforeinput.

[chongz, 2016/12/21 23:59:24]

Moved to the end of 'EditingUtilities.cpp::dispatchBeforeInputEvent()', so we
don't apply the command if target was disconnected from the document.

     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(

[chongz, 2016/12/20 23:27:51]

Moved to |EditingUtilities.cpp::isComposingFromCommand()|.

-    const CompositeEditCommand* command) {
-  if (command->isTypingCommand() &&
-      toTypingCommand(command)->compositionType() !=
-          TypingCommand::TextCompositionNone)
-    return InputEvent::EventIsComposing::IsComposing;
-  return InputEvent::EventIsComposing::NotComposing;
-}
-
 }  // anonymous namespace
 
 Editor::RevealSelectionScope::RevealSelectionScope(Editor* editor)
     : m_editor(editor) {
   ++m_editor->m_preventRevealSelection;
 }
 
 Editor::RevealSelectionScope::~RevealSelectionScope() {
   DCHECK(m_editor->m_preventRevealSelection);
   --m_editor->m_preventRevealSelection;
@@ skipping 469 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(EditCommandSource::kMenuOrKeyBinding);
 }
 
-bool Editor::deleteSelectionAfterDraggingWithEvents(

[chongz, 2016/12/20 23:27:51]

See header file.

-    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(
-        EditCommandSource::kMenuOrKeyBinding, 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 369 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 == EditCommandSource::kMenuOrKeyBinding) {
-      if (dispatchBeforeInputDataTransfer(findEventTargetFromSelection(),

[chongz, 2016/12/20 23:27:51]

Removed, cut was covered by |DeleteSelectionCommand => willApplyEditing()|.

-                                          InputEvent::InputType::DeleteByCut,
-                                          nullptr, nullptr) !=
-          DispatchEventResult::NotCanceled)
-        return;
-      // 'beforeinput' event handler may destroy target frame.
-      if (m_frame->document()->frame() != m_frame)
-        return;
-    }
     deleteSelectionWithSmartDelete(
         source, canSmartCopyOrDelete() ? DeleteMode::Smart : DeleteMode::Simple,
         InputEvent::InputType::DeleteByCut);
   }
 }
 
 void Editor::copy() {
   if (tryDHTMLCopy())
     return;  // DHTML did the whole operation
   if (!canCopy())
@@ skipping 14 matching lines @@
     Document* document = frame().document();
     if (HTMLImageElement* imageElement =
             imageElementFromImageDocument(document))
       writeImageNodeToPasteboard(Pasteboard::generalPasteboard(), imageElement,
                                  document->title());
     else
       writeSelectionToPasteboard();
   }
 }
 
-void Editor::paste(EditCommandSource source) {
+// TODO(chongz): Pass |EditCommandSource| to |TextEvent| and don't fire
+// 'beforeinput' for JS triggered paste.
+void Editor::paste(EditCommandSource) {
   DCHECK(frame().document());
   if (tryDHTMLPaste(AllMimeTypes))
     return;  // DHTML did the whole operation
   if (!canPaste())
     return;
   spellChecker().updateMarkersForWordsAffectedByEditing(false);
   ResourceFetcher* loader = frame().document()->fetcher();
   ResourceCacheValidationSuppressor validationSuppressor(loader);
 
   PasteMode pasteMode = frame().selection().isContentRichlyEditable()
                             ? AllMimeTypes
                             : PlainTextOnly;
 
-  if (source == EditCommandSource::kMenuOrKeyBinding) {
-    DataTransfer* dataTransfer =
-        DataTransfer::create(DataTransfer::CopyAndPaste, DataTransferReadable,
-                             DataObject::createFromPasteboard(pasteMode));
-
-    if (dispatchBeforeInputDataTransfer(findEventTargetFromSelection(),

[chongz, 2016/12/20 23:27:51]

Removed, paste was covered by |ReplaceSelectionCommand => willApplyEditing()|.

-                                        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(EditCommandSource source) {
   if (tryDHTMLPaste(PlainTextOnly))
     return;
   if (!canPaste())
@@ skipping 134 matching lines @@
           : direction == RightToLeftWritingDirection ? "rtl" : "inherit",
       false);
   applyParagraphStyleToSelection(
       EditCommandSource::kMenuOrKeyBinding, style,
       InputEvent::InputType::FormatSetBlockTextDirection);
 }
 
 void Editor::revealSelectionAfterEditingOperation(
     const ScrollAlignment& alignment,
     RevealExtentOption revealExtentOption) {
-  if (m_preventRevealSelection)
+  if (m_preventRevealSelection || !m_frame->selection().isAvailable())

[Xiaocheng, 2016/12/21 02:56:38]

This part seems to be a bug fix. Does any test case reach here?

[chongz, 2016/12/21 23:59:24]

The test case is "fast/events/inputevents/beforeinput-remove-iframe-crash.html".

Originally we have |m_frame->document()->frame() != m_frame| check after every
'beforeinput', this CL moved the check into |dispatchBeforeInput()| and returns
false in this case.

Most callers was able to catch return value from |dispatchBeforeInput()| and
abort accordingly, but some callers such as |Editor::deleteWithDirection()| and
Drag&Drop won't use/pass the return value, so we need to check here.

     return;
   frame().selection().revealSelection(alignment, revealExtentOption);
 }
 
 void Editor::transpose(EditCommandSource source) {
   if (!canEdit())
     return;
 
   VisibleSelection selection = frame().selection().selection();
   if (!selection.isCaret())
@@ skipping 397 matching lines @@
 }
 
 DEFINE_TRACE(Editor) {
   visitor->trace(m_frame);
   visitor->trace(m_lastEditCommand);
   visitor->trace(m_undoStack);
   visitor->trace(m_mark);
 }
 
 }  // namespace blink