[InputEvent] Dispatch 'input' event for ContentEditable and typing on Input element

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 78 matching lines @@
 #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)
+        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);

[chongz, 2016/06/22 05:16:52]

I have to check |FrameSelection::isAvailable()| if I'm using |dispatchEvent()|,
but I guess it should be fine with |dispatchScopedEvent()|?

[yosin_UTC9, 2016/06/22 06:29:25]

Not sure. Why should we need to check |FrameSelection::isAvailable()|? Selection
availability and event dispatch aren't related.

[chongz, 2016/06/23 00:32:06]

It's about test "editing/pasteboard/paste-removing-iframe.html", but never-mind
I've figured out how |EventQueueScope| works. :)

+}
+
+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::InputType inputTypeFromCommand(CompositeEditCommand* command)

[tkent, 2016/06/22 06:53:21]

The argument type should be |const CompositeEditCommand*| or |const
CompositeEditCommand&|.

[chongz, 2016/06/23 00:32:06]

Done.

+{
+    if (command->isTypingCommand()) {
+        TypingCommand* typingCommand = static_cast<TypingCommand*>(command);

[tkent, 2016/06/22 06:53:21]

Please avoid bare static_cast<>.  TypingCommand should have
DEFINE_TYPE_CAST(TypingCommand, CompositeEditCommand, command,
command->isTypingCommand(), command.isTypingCommad()), and we should use
toTypingCommand(command) here.

[chongz, 2016/06/23 00:32:06]

Done.

+        // TODO(chongz): Separate command types into more detailed InputType.
+        switch (typingCommand->commandTypeOfOpenCommand()) {
+        case TypingCommand::DeleteSelection:
+        case TypingCommand::DeleteKey:
+        case TypingCommand::ForwardDeleteKey:
+            return InputEvent::InputType::DeleteContent;
+        case TypingCommand::InsertText:
+        case TypingCommand::InsertLineBreak:
+        case TypingCommand::InsertParagraphSeparator:
+        case TypingCommand::InsertParagraphSeparatorInQuotedContent:
+            return InputEvent::InputType::InsertText;
+        default:
+            return InputEvent::InputType::None;
+        }
+    }
+
+    switch (command->editingAction()) {
+    // TODO(chongz): Handle other edit actions.
+    case EditActionBold:
+        return InputEvent::InputType::Bold;

[chongz, 2016/06/23 00:32:06]

Actually text styling commands are a little bit complex, so I will add them
later.

+    default:
+        return InputEvent::InputType::None;
+    }
+}
+
+InputEvent::EventIsComposing isComposingFromCommand(CompositeEditCommand* command)

[tkent, 2016/06/22 06:53:21]

The argument type should be |const CompositeEditCommand*| or |const
CompositeEditCommand&|.

[chongz, 2016/06/23 00:32:06]

Done.

+{
+    if (command->isTypingCommand() && static_cast<TypingCommand*>(command)->compositionType() != TypingCommand::TextCompositionNone)

[tkent, 2016/06/22 06:53:21]

We should use toTypingCommand(command).

[chongz, 2016/06/23 00:32:06]

Done.

+        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 586 matching lines @@
 {
     EventQueueScope scope;
     frame().document()->updateStyleAndLayout();
 
     // Request spell checking after pasting before any further DOM change.
     requestSpellcheckingAfterApplyingCommand(cmd);
 
     EditCommandComposition* composition = cmd->composition();
     DCHECK(composition);
     dispatchEditableContentChangedEvents(composition->startingRootEditableElement(), composition->endingRootEditableElement());
+    // TODO(chongz): Filter empty InputType after spec is finalized.
+    // TODO(chongz): Fill in |data| field.
+    dispatchInputEventEditableContentChanged(composition->startingRootEditableElement(), composition->endingRootEditableElement(), inputTypeFromCommand(cmd), emptyString(), isComposingFromCommand(cmd));
     VisibleSelection newSelection(cmd->endingSelection());
 
     // Don't clear the typing style with this selection change. We do those things elsewhere if necessary.
     changeSelectionAfterCommand(newSelection, 0);
 
     if (!cmd->preservesTypingStyle())
         frame().selection().clearTypingStyle();
 
     // Command will be equal to last edit command only in the case of typing
     if (m_lastEditCommand.get() == cmd) {
         DCHECK(cmd->isTypingCommand());
     } else {
         // Only register a new undo command if the command passed in is
         // different from the last command
         m_lastEditCommand = cmd;
         if (UndoStack* undoStack = this->undoStack())
             undoStack->registerUndoStep(m_lastEditCommand->ensureComposition());
     }
 
     respondToChangedContents(newSelection);
 }
 
 void Editor::unappliedEditing(EditCommandComposition* cmd)
 {
     EventQueueScope scope;
     frame().document()->updateStyleAndLayout();
 
     dispatchEditableContentChangedEvents(cmd->startingRootEditableElement(), cmd->endingRootEditableElement());
+    dispatchInputEventEditableContentChanged(cmd->startingRootEditableElement(), cmd->endingRootEditableElement(), InputEvent::InputType::Undo, emptyString(), InputEvent::EventIsComposing::NotComposing);
 
     VisibleSelection newSelection(cmd->startingSelection());
     newSelection.validatePositionsIfNeeded();
     if (newSelection.start().document() == frame().document() && newSelection.end().document() == frame().document())
         changeSelectionAfterCommand(newSelection, FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle);
 
     m_lastEditCommand = nullptr;
     if (UndoStack* undoStack = this->undoStack())
         undoStack->registerRedoStep(cmd);
     respondToChangedContents(newSelection);
 }
 
 void Editor::reappliedEditing(EditCommandComposition* cmd)
 {
     EventQueueScope scope;
     frame().document()->updateStyleAndLayout();
 
     dispatchEditableContentChangedEvents(cmd->startingRootEditableElement(), cmd->endingRootEditableElement());
+    dispatchInputEventEditableContentChanged(cmd->startingRootEditableElement(), cmd->endingRootEditableElement(), InputEvent::InputType::Redo, emptyString(), InputEvent::EventIsComposing::NotComposing);
 
     VisibleSelection newSelection(cmd->endingSelection());
     changeSelectionAfterCommand(newSelection, FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle);
 
     m_lastEditCommand = nullptr;
     if (UndoStack* undoStack = this->undoStack())
         undoStack->registerUndoStep(cmd);
     respondToChangedContents(newSelection);
 }
 
@@ skipping 609 matching lines @@
 }
 
 DEFINE_TRACE(Editor)
 {
     visitor->trace(m_frame);
     visitor->trace(m_lastEditCommand);
     visitor->trace(m_mark);
 }
 
 } // namespace blink