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 {
+  if (!GetTextInputClient())
+    return;
+  KeyEvent evt(pressed ? ET_KEY_PRESSED : ET_KEY_RELEASED,
+               pressed ? VKEY_PROCESSKEY : VKEY_UNKNOWN,
+               EF_IME_FABRICATED_KEY,
+               false);  // is_char
+  Event::DispatcherApi dispatch_helper(&evt);
+  dispatch_helper.set_target(reinterpret_cast<EventTarget*>(
+      GetTextInputClient()->GetAttachedWindow()));

[oshima, 2014/06/05 15:03:13]

As I said, it is my understanding that DispatherApi is meant to be used by a
dispatcher. You should check with sadrul. Note that this reinterpret cast isn't
safe either.

My recommendations are one of:

a) pass TextInputClient to delegate's DispatchKeyEventPostIME, and
 then
 
TextInputClient::GetAttachedWindow()->GetHost()->dispatcher()->OnEventFromSource(event);

b) in InputMethodEventFilter, just use ActivationClient->GetActiveWindow()
  You can get it once from root window in SetInputMethodPropertyInRootWindow. 
No need to listen to activation change event.


I still recommend a), but b) should work too. [ b) requires assumption that the
dispatcher client for the input method event filter will never change over time,
but this is true]

[sadrul, 2014/06/05 15:46:28]

Indeed. You should not use this here.
Good suggestions. I too prefer (a) over (b).

[Shu Chen, 2014/06/05 16:26:54]

Done.

[Shu Chen, 2014/06/05 16:26:54]

Done.

+  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);
     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