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

third_party/WebKit/Source/core/editing/commands/CompositeEditCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 38 matching lines @@
 #include "core/editing/commands/MergeIdenticalElementsCommand.h"
 #include "core/editing/commands/RemoveCSSPropertyCommand.h"
 #include "core/editing/commands/RemoveNodeCommand.h"
 #include "core/editing/commands/RemoveNodePreservingChildrenCommand.h"
 #include "core/editing/commands/ReplaceNodeWithSpanCommand.h"
 #include "core/editing/commands/ReplaceSelectionCommand.h"
 #include "core/editing/commands/SetNodeAttributeCommand.h"
 #include "core/editing/commands/SplitElementCommand.h"
 #include "core/editing/commands/SplitTextNodeCommand.h"
 #include "core/editing/commands/SplitTextNodeContainingElementCommand.h"
+#include "core/editing/commands/TypingCommand.h"
 #include "core/editing/commands/WrapContentsInDummySpanCommand.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/editing/serializers/Serialization.h"
 #include "core/editing/spellcheck/SpellChecker.h"
 #include "core/events/ScopedEventQueue.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/HTMLDivElement.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLLIElement.h"
 #include "core/html/HTMLQuoteElement.h"
 #include "core/html/HTMLSpanElement.h"
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutListItem.h"
 #include "core/layout/LayoutText.h"
 #include "core/layout/line/InlineTextBox.h"
 #include <algorithm>
 
 namespace blink {
 
 using namespace HTMLNames;
 
 EditCommandComposition* EditCommandComposition::create(
     Document* document,
     const VisibleSelection& startingSelection,
-    const VisibleSelection& endingSelection,
-    InputEvent::InputType inputType) {
+    const VisibleSelection& endingSelection) {
   return new EditCommandComposition(document, startingSelection,
-                                    endingSelection, inputType);
+                                    endingSelection);
 }
 
 EditCommandComposition::EditCommandComposition(
     Document* document,
     const VisibleSelection& startingSelection,
-    const VisibleSelection& endingSelection,
-    InputEvent::InputType inputType)
+    const VisibleSelection& endingSelection)
     : m_document(document),
       m_startingSelection(startingSelection),
       m_endingSelection(endingSelection),
       m_startingRootEditableElement(startingSelection.rootEditableElement()),
-      m_endingRootEditableElement(endingSelection.rootEditableElement()),
-      m_inputType(inputType) {}
+      m_endingRootEditableElement(endingSelection.rootEditableElement()) {}
 
 bool EditCommandComposition::belongsTo(const LocalFrame& frame) const {
   DCHECK(m_document);
   return m_document->frame() == &frame;
 }
 
 void EditCommandComposition::unapply(EditCommandSource source) {
   DCHECK(m_document);
   LocalFrame* frame = m_document->frame();
   DCHECK(frame);
@@ skipping 33 matching lines @@
   m_document->updateStyleAndLayoutIgnorePendingStylesheets();
 
   {
     for (const auto& command : m_commands)
       command->doReapply();
   }
 
   frame->editor().reappliedEditing(this);
 }
 
-bool EditCommandComposition::willUnapply(EditCommandSource) {
-  // TODO(chongz): Fire 'beforeinput' for 'historyUndo'.
-  return true;
+bool EditCommandComposition::willUnapply(EditCommandSource source) {
+  return dispatchBeforeInputEvent(source, m_document->frame(), m_document,
+                                  InputEvent::InputType::HistoryUndo, nullAtom,
+                                  nullptr, InputEvent::IsCancelable,
+                                  InputEvent::NotComposing, nullptr);
 }
 
-bool EditCommandComposition::willReapply(EditCommandSource) {
-  // TODO(chongz): Fire 'beforeinput' for 'historyRedo'.
-  return true;
-}
-
-InputEvent::InputType EditCommandComposition::inputType() const {
-  return m_inputType;
+bool EditCommandComposition::willReapply(EditCommandSource source) {
+  return dispatchBeforeInputEvent(source, m_document->frame(), m_document,
+                                  InputEvent::InputType::HistoryRedo, nullAtom,
+                                  nullptr, InputEvent::IsCancelable,
+                                  InputEvent::NotComposing, nullptr);
 }
 
 void EditCommandComposition::append(SimpleEditCommand* command) {
   m_commands.push_back(command);
 }
 
 void EditCommandComposition::append(EditCommandComposition* composition) {
   m_commands.appendVector(composition->m_commands);
 }
 
@@ skipping 48 matching lines @@
       case InputEvent::InputType::DeleteByDrag:
       case InputEvent::InputType::None:
         break;
       default:
         NOTREACHED();
         return false;
     }
   }
   ensureComposition();
 
+  // Covers the initial TypingCommand and other top-level commands.
+  // TypingCommand::willAddTypingToOpenCommand() also calls willApplyEditing().
+  if (!willApplyEditing(source))

[Xiaocheng, 2016/12/20 05:49:57]

Yeah, this should be the right place to fire the event.

Thanks for catching it.

+    return false;
+
   // Changes to the document may have been made since the last editing operation
   // that require a layout, as in <rdar://problem/5658603>. Low level
   // operations, like RemoveNodeCommand, don't require a layout because the high
   // level operations that use them perform one if one is necessary (like for
   // the creation of VisiblePositions).
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
-  if (!willApplyEditing(source))
-    return false;
-
   LocalFrame* frame = document().frame();
   DCHECK(frame);
   EditingState editingState;
   {
     EventQueueScope eventQueueScope;
     doApply(&editingState);
   }
 
   // Only need to call appliedEditing for top-level commands, and TypingCommands
   // do it on their own (see TypingCommand::typingAddedToOpenCommand).
   if (!isTypingCommand())
     frame->editor().appliedEditing(this);
   setShouldRetainAutocorrectionIndicator(false);
   return !editingState.isAborted();
 }
 
 EditCommandComposition* CompositeEditCommand::ensureComposition() {
   CompositeEditCommand* command = this;
   while (command && command->parent())
     command = command->parent();
-  if (!command->m_composition)
+  if (!command->m_composition) {
     command->m_composition = EditCommandComposition::create(
-        &document(), startingSelection(), endingSelection(), inputType());
+        &document(), startingSelection(), endingSelection());
+  }
   return command->m_composition.get();
 }
 
-bool CompositeEditCommand::willApplyEditing(EditCommandSource) {
-  // TODO(chongz): Move all the 'beforeinput' dispatching logic here.
-  return true;
+bool CompositeEditCommand::willApplyEditing(EditCommandSource source) {
+  // TODO(chongz): Remove the following code after we have ensured it's OK to
+  // fire 'beforeinput' after 'compositionupdate'.
+  // https://crbug.com/675820
+  if (isTypingCommand() && (toTypingCommand(this)->compositionType() ==
+                                TypingCommand::TextCompositionUpdate ||
+                            toTypingCommand(this)->compositionType() ==
+                                TypingCommand::TextCompositionConfirm))
+    return true;
+  return dispatchBeforeInputEvent(
+      source, document().frame(), eventTargetNodeForDocument(&document()),
+      inputType(), textDataForInputEvent(), dataTransferForInputEvent(),
+      isCancelableFromCommand(this), isComposingFromCommand(this),
+      targetRangesForInputEvent());
+}
+
+InputEvent::InputType CompositeEditCommand::inputType() const {
+  return InputEvent::InputType::None;
+}
+
+String CompositeEditCommand::textDataForInputEvent() const {
+  return nullAtom;
+}
+
+DataTransfer* CompositeEditCommand::dataTransferForInputEvent() const {
+  return nullptr;
+}
+
+RangeVector* CompositeEditCommand::targetRangesForInputEvent() const {
+  if (!document().frame()->editor().canEditRichly())
+    return nullptr;
+  return new RangeVector(1, document().frame()->selection().firstRange());
 }
 
 bool CompositeEditCommand::preservesTypingStyle() const {
   return false;
 }
 
 bool CompositeEditCommand::isTypingCommand() const {
   return false;
 }
 
@@ skipping 1769 matching lines @@
   return node;
 }
 
 DEFINE_TRACE(CompositeEditCommand) {
   visitor->trace(m_commands);
   visitor->trace(m_composition);
   EditCommand::trace(visitor);
 }
 
 }  // namespace blink