Supports fake key events for setComposition/commitText by on-screen keyboards.

ui/base/ime/input_method_chromeos.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/base/ime/input_method_chromeos.h"
 
 #include <algorithm>
 #include <cstring>
 #include <set>
 #include <vector>
@@ skipping 420 matching lines @@
 bool InputMethodChromeOS::NeedInsertChar() const {
   return GetTextInputClient() &&
       (IsTextInputTypeNone() ||
        (!composing_text_ && result_text_.length() == 1));
 }
 
 bool InputMethodChromeOS::HasInputMethodResult() const {
   return result_text_.length() || composition_changed_;
 }
 
+void InputMethodChromeOS::SendFakeProcessKeyEvent(bool pressed) const {
+  KeyEvent evt(pressed ? ET_KEY_PRESSED : ET_KEY_RELEASED,
+               VKEY_PROCESSKEY,
+               0,
+               false);
+  DispatchKeyEventPostIME(evt);
+}
+
 void InputMethodChromeOS::AbandonAllPendingKeyEvents() {
   pending_key_events_.clear();
 }
 
 void InputMethodChromeOS::CommitText(const std::string& text) {
   if (text.empty())
     return;
 
   // We need to receive input method result even if the text input type is
   // TEXT_INPUT_TYPE_NONE, to make sure we can always send correct
   // character for each key event to the focused text input client.
   if (!GetTextInputClient())
     return;
 
   const base::string16 utf16_text = base::UTF8ToUTF16(text);
   if (utf16_text.empty())
     return;
 
   // Append the text to the buffer, because commit signal might be fired
   // multiple times when processing a key event.
   result_text_.append(utf16_text);
 
   // If we are not handling key event, do not bother sending text result if the
   // focused text input client does not support text input.
   if (pending_key_events_.empty() && !IsTextInputTypeNone()) {
+    SendFakeProcessKeyEvent(true);
     GetTextInputClient()->InsertText(utf16_text);
+    SendFakeProcessKeyEvent(false);

[Yuki, 2014/05/26 06:29:29]

Do we really want to send a PROCESSKEY event for keyup?
IIUC, DOM Level3 Events Sepc doesn't require it and no other browsers send such
events.

[Shu Chen, 2014/05/26 06:35:59]

I think it would be better to keep the events sequence as the IME composing by
physical keyboard.
Otherwise, there is potential risks to break certain web apps. WDYT?

[Yuki, 2014/05/26 06:56:08]

http://www.w3.org/TR/DOM-Level-3-Events/
6.5.2 Legacy key models
If an Input Method Editor is processing key input and the event is keydown,
return 229.

Following the standard, you must not send 229 event for keyup.  The spec
explicitly says "If the event is keydown".

In addition, there are many Japanese articles that says "229 event is send only
for keydown, never for keyup", and web developers expect 229 keydown, and never
expect 229 keyup.

I didn't find an English article, but it should be because there is no (or very
minor) IME for English.  Probably you find many Chinese articles that says the
same thing.

I highly recommend that you don't break the existing behavior or custom.

     result_text_.clear();
   }
 }
 
 void InputMethodChromeOS::UpdateCompositionText(
     const chromeos::CompositionText& text,
     uint32 cursor_pos,
     bool visible) {
   if (IsTextInputTypeNone())
     return;
@@ skipping 21 matching lines @@
 
   composition_changed_ = true;
 
   // In case OnShowPreeditText() is not called.
   if (composition_.text.length())
     composing_text_ = true;
 
   // If we receive a composition text without pending key event, then we need to
   // send it to the focused text input client directly.
   if (pending_key_events_.empty()) {
+    SendFakeProcessKeyEvent(true);
     GetTextInputClient()->SetCompositionText(composition_);
+    SendFakeProcessKeyEvent(false);
     composition_changed_ = false;
     composition_.Clear();
   }
 }
 
 void InputMethodChromeOS::HidePreeditText() {
   if (composition_.text.empty() || IsTextInputTypeNone())
     return;
 
   // Intentionally leaves |composing_text_| unchanged.
   composition_changed_ = true;
   composition_.Clear();
 
   if (pending_key_events_.empty()) {
     TextInputClient* client = GetTextInputClient();
-    if (client && client->HasCompositionText())
+    if (client && client->HasCompositionText()) {
+      SendFakeProcessKeyEvent(true);
       client->ClearCompositionText();
+      SendFakeProcessKeyEvent(false);
+    }
     composition_changed_ = false;
   }
 }
 
 void InputMethodChromeOS::DeleteSurroundingText(int32 offset, uint32 length) {
   if (!composition_.text.empty())
     return;  // do nothing if there is ongoing composition.
   if (offset < 0 && static_cast<uint32>(-1 * offset) != length)
     return;  // only preceding text can be deletable.
   if (GetTextInputClient())
@@ skipping 94 matching lines @@
         0, length, SK_ColorBLACK, false /* thick */));
   }
 }
 
 bool InputMethodChromeOS::IsInputFieldFocused() {
   TextInputType type = GetTextInputType();
   return (type != TEXT_INPUT_TYPE_NONE) && (type != TEXT_INPUT_TYPE_PASSWORD);
 }
 
 }  // namespace ui