Trigger compositionstart/end on commitText

third_party/WebKit/Source/core/editing/InputMethodController.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 64 matching lines @@
 bool InputMethodController::hasComposition() const
 {
     return m_hasComposition;
 }
 
 inline Editor& InputMethodController::editor() const
 {
     return frame().editor();
 }
 
+static void dispatchCompositionEvent(LocalFrame& frame, const AtomicString& type, const String& text)

[aelias_OOO_until_Jul13, 2016/01/16 01:48:50]

nit: Could you position this method where the previous one was in the file, to
make the diff more readable?

+{
+    // We should send this event before sending a TextEvent as written in
+    // Section 6.2.2 and 6.2.3 of the DOM Event specification.
+    Element* target = frame.document()->focusedElement();
+    if (!target)
+        return;
+
+    RefPtrWillBeRawPtr<CompositionEvent> event =
+        CompositionEvent::create(EventTypeNames::compositionend, frame.domWindow(), text);

[aelias_OOO_until_Jul13, 2016/01/16 01:48:50]

Looks like you intended to use "type" here, instead of still hardcoding
EventTypeNames::compositionend.

+    target->dispatchEvent(event);
+}
+
 void InputMethodController::clear()
 {
     m_hasComposition = false;
     if (m_compositionRange) {
         m_compositionRange->setStart(frame().document(), 0);
         m_compositionRange->collapse(true);
     }
     frame().document()->markers().removeMarkers(DocumentMarker::Composition);
     m_isDirty = false;
 }
@@ skipping 20 matching lines @@
     VisibleSelection selection;
     selection.setWithoutValidation(range.startPosition(), range.endPosition());
     frame().selection().setSelection(selection, 0);
 }
 
 bool InputMethodController::confirmComposition()
 {
     return confirmComposition(composingText());
 }
 
-static void dispatchCompositionEndEvent(LocalFrame& frame, const String& text)
-{
-    // We should send this event before sending a TextEvent as written in
-    // Section 6.2.2 and 6.2.3 of the DOM Event specification.
-    Element* target = frame.document()->focusedElement();
-    if (!target)
-        return;
-
-    RefPtrWillBeRawPtr<CompositionEvent> event =
-        CompositionEvent::create(EventTypeNames::compositionend, frame.domWindow(), text);
-    target->dispatchEvent(event);
-}
-
 bool InputMethodController::confirmComposition(const String& text)
 {
+#if OS(ANDROID)

[aelias_OOO_until_Jul13, 2016/01/16 01:48:50]

Let's avoid introducing any OS(ANDROID) in Blink.

+    // On Android, we want to trigger compositionstart/end even for
+    // confirmComposition since it does not accompany actual keycodes.
+    if (!hasComposition() && text.isEmpty())
+        return false;
+#else
     if (!hasComposition())
         return false;
+#endif
 
     Editor::RevealSelectionScope revealSelectionScope(&editor());
 
     // If the composition was set from existing text and didn't change, then
     // there's nothing to do here (and we should avoid doing anything as that
     // may clobber multi-node styled text).
     if (!m_isDirty && composingText() == text) {
         clear();
         return true;
     }
 
     // Select the text that will be deleted or replaced.
     selectComposition();
 
     if (frame().selection().isNone())
         return false;
 
-    dispatchCompositionEndEvent(frame(), text);
+    if (!hasComposition())
+        dispatchCompositionEvent(frame(), EventTypeNames::compositionstart, frame().selectedText());
+    dispatchCompositionEvent(frame(), EventTypeNames::compositionend, text);
 
     if (!frame().document())
         return false;
 
     // If text is empty, then delete the old composition here. If text is
     // non-empty, InsertTextCommand::input will delete the old composition with
     // an optimized replace operation.
     if (text.isEmpty())
         TypingCommand::deleteSelection(*frame().document(), 0);
 
     clear();
 
     insertTextForConfirmedComposition(text);
 
     return true;
 }
 
 bool InputMethodController::confirmCompositionOrInsertText(const String& text, ConfirmCompositionBehavior confirmBehavior)
 {
     if (!hasComposition()) {
         if (!text.length())
             return false;
+#if !OS(ANDROID)
         editor().insertText(text, 0);

[aelias_OOO_until_Jul13, 2016/01/16 01:48:50]

Hmm, wouldn't it work just as well to add the compositionstart and
compositionend events around this, and not make any of the code-flow changes?

Currently, the method confirmCompositionOrInsertText() is defined to either
confirm an ongoing composition or insert text, whereas confirmComposition() only
confirms ongoing compositions and does nothing otherwise.  This patch muddles
their roles, and I'm afraid it may have some unintended consequences such as
spamming unnecessary compositionStart/compositionEnd when the text didn't
change.

         return true;
+#endif
     }
 
     if (text.length()) {
         confirmComposition(text);
         return true;
     }
 
     if (confirmBehavior != KeepSelection)
         return confirmComposition();
 
     SelectionOffsetsScope selectionOffsetsScope(this);
     return confirmComposition();
 }
 
 void InputMethodController::cancelComposition()
 {
     if (!hasComposition())
         return;
 
     Editor::RevealSelectionScope revealSelectionScope(&editor());
 
     if (frame().selection().isNone())
         return;
 
-    dispatchCompositionEndEvent(frame(), emptyString());
+    dispatchCompositionEvent(frame(), EventTypeNames::compositionend, emptyString());
     clear();
     insertTextForConfirmedComposition(emptyString());
 
     // An open typing command that disagrees about current selection would cause
     // issues with typing later on.
     TypingCommand::closeTyping(m_frame);
 }
 
 void InputMethodController::cancelCompositionIfSelectionIsInvalid()
 {
@@ skipping 234 matching lines @@
     TypingCommand::deleteSelection(*frame().document());
 }
 
 DEFINE_TRACE(InputMethodController)
 {
     visitor->trace(m_frame);
     visitor->trace(m_compositionRange);
 }
 
 } // namespace blink