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

IMF now assumes the IME composing happens with a physical key being pressed.
That assumption is not true for on-screen keyboard scenario.
For on-screen keyboard, when user touch a key button on the screen, the JS
code will call IME API like chrome.input.ime.setComposition(). IMF then should
generate events as:
  keydown(229), compositionstart, compositionupdate, input, keyup.
The events compositionstart, compositionupdate and input are generated by
RenderWidgetHostViewAura::SetCompositionText(). So we need to send fake key
events to generate keydown(229) and keyup.

The other part of this change is to make InputMethodEventFilter not depend on
physical key events. Originally, InputMethodEventFilter relies on key events
to find the root window and then get the EventProcessor. It will break
on-screen scenario, because without a physical key being pressed,
target_dispatcher_ will be NULL.
This cl is to let InputMethodEventFilter to always get the EventProcessor from
input_method_->GetTextInputClient()->GetAttachedWindow()->GetRootWindow()...

BUG=376183
TEST=Verified on Pixel device.

Review URL: https://codereview.chromium.org/298893003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@275422 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 121 insertions, 57 deletions

diff --git a/ui/base/ime/input_method_chromeos.cc b/ui/base/ime/input_method_chromeos.cc
index c951b43..be946ed 100644
--- a/ui/base/ime/input_method_chromeos.cc
+++ b/ui/base/ime/input_method_chromeos.cc
@@ -438,6 +438,16 @@ 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
+  DispatchKeyEventPostIME(evt);
+}
+
 void InputMethodChromeOS::AbandonAllPendingKeyEvents() {
   pending_key_events_.clear();
 }
@@ -463,7 +473,9 @@ void InputMethodChromeOS::CommitText(const std::string& 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();
   }
 }
@@ -505,7 +517,9 @@ void InputMethodChromeOS::UpdateCompositionText(
   // 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();
   }
@@ -521,8 +535,11 @@ void InputMethodChromeOS::HidePreeditText() {
 
   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;
   }
 }
diff --git a/ui/base/ime/input_method_chromeos.h b/ui/base/ime/input_method_chromeos.h
index 3c4794b..98b42ae 100644
--- a/ui/base/ime/input_method_chromeos.h
+++ b/ui/base/ime/input_method_chromeos.h
@@ -88,6 +88,9 @@ class UI_BASE_EXPORT InputMethodChromeOS
   // Checks if there is pending input method result.
   bool HasInputMethodResult() const;
 
+  // Sends a fake key event for IME composing without physical key events.
+  void SendFakeProcessKeyEvent(bool pressed) const;
+
   // Abandons all pending key events. It usually happends when we lose keyboard
   // focus, the text input type is changed or we are destroyed.
   void AbandonAllPendingKeyEvents();
diff --git a/ui/wm/core/input_method_event_filter.cc b/ui/wm/core/input_method_event_filter.cc
index 65bd5b5..3488e4a 100644
--- a/ui/wm/core/input_method_event_filter.cc
+++ b/ui/wm/core/input_method_event_filter.cc
@@ -8,6 +8,7 @@
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/input_method_factory.h"
+#include "ui/base/ime/text_input_client.h"
 #include "ui/events/event.h"
 #include "ui/events/event_processor.h"
 
@@ -17,8 +18,7 @@ namespace wm {
 // InputMethodEventFilter, public:
 
 InputMethodEventFilter::InputMethodEventFilter(gfx::AcceleratedWidget widget)
-    : input_method_(ui::CreateInputMethod(this, widget)),
-      target_dispatcher_(NULL) {
+    : input_method_(ui::CreateInputMethod(this, widget)) {
   // TODO(yusukes): Check if the root window is currently focused and pass the
   // result to Init().
   input_method_->Init(true);
@@ -63,11 +63,6 @@ void InputMethodEventFilter::OnKeyEvent(ui::KeyEvent* event) {
     // IME again.  Just let the event dispatcher continue to dispatch the event.
     event->SetTranslated(false);
   } else {
-    // If the focused window is changed, all requests to IME will be
-    // discarded so it's safe to update the target_dispatcher_ here.
-    aura::Window* target = static_cast<aura::Window*>(event->target());
-    target_dispatcher_ = target->GetRootWindow()->GetHost()->event_processor();
-    DCHECK(target_dispatcher_);
     if (input_method_->DispatchKeyEvent(*event))
       event->StopPropagation();
   }
@@ -86,10 +81,23 @@ bool InputMethodEventFilter::DispatchKeyEventPostIME(
   // This time we have to skip dispatching the event to the IME, we mark the
   // event as TRANSLATED so we can distinguish this event as a second time
   // dispatched event.
+  // For the target where to dispatch the event, always tries the current
+  // focused text input client's attached window. And fallback to the target
+  // carried by event.
+  aura::Window* target_window = NULL;
+  ui::TextInputClient* input = input_method_->GetTextInputClient();
+  if (input)
+    target_window = input->GetAttachedWindow();
+  if (!target_window)
+    target_window = static_cast<aura::Window*>(event.target());
+  if (!target_window)
+    return false;
+  ui::EventProcessor* target_dispatcher =
+      target_window->GetRootWindow()->GetHost()->event_processor();
   ui::KeyEvent aura_event(event);
   aura_event.SetTranslated(true);
   ui::EventDispatchDetails details =
-      target_dispatcher_->OnEventFromSource(&aura_event);
+      target_dispatcher->OnEventFromSource(&aura_event);
   CHECK(!details.dispatcher_destroyed);
   return aura_event.handled();
 }
diff --git a/ui/wm/core/input_method_event_filter.h b/ui/wm/core/input_method_event_filter.h
index c4033d1..af82308 100644
--- a/ui/wm/core/input_method_event_filter.h
+++ b/ui/wm/core/input_method_event_filter.h
@@ -42,9 +42,6 @@ class WM_EXPORT InputMethodEventFilter
 
   scoped_ptr<ui::InputMethod> input_method_;
 
-  // The target dispatcher that will receive translated key events from the IME.
-  ui::EventProcessor* target_dispatcher_;
-
   DISALLOW_COPY_AND_ASSIGN(InputMethodEventFilter);
 };
 
diff --git a/ui/wm/core/input_method_event_filter_unittest.cc b/ui/wm/core/input_method_event_filter_unittest.cc
index c5daa67..8e531a3b3 100644
--- a/ui/wm/core/input_method_event_filter_unittest.cc
+++ b/ui/wm/core/input_method_event_filter_unittest.cc
@@ -10,6 +10,8 @@
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window_event_dispatcher.h"
+#include "ui/base/ime/dummy_text_input_client.h"
+#include "ui/base/ime/input_method.h"
 #include "ui/events/test/test_event_handler.h"
 #include "ui/wm/core/compound_event_filter.h"
 #include "ui/wm/core/default_activation_client.h"
@@ -25,70 +27,107 @@ DISABLED_TestInputMethodKeyEventPropagation
 
 namespace wm {
 
-typedef aura::test::AuraTestBase InputMethodEventFilterTest;
+class TestTextInputClient : public ui::DummyTextInputClient {
+ public:
+  explicit TestTextInputClient(aura::Window* window) : window_(window) {}
+
+  virtual aura::Window* GetAttachedWindow() const OVERRIDE { return window_; }
+
+ private:
+  aura::Window* window_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestTextInputClient);
+};
+
+class InputMethodEventFilterTest : public aura::test::AuraTestBase {
+ public:
+  InputMethodEventFilterTest() {}
+  virtual ~InputMethodEventFilterTest() {}
+
+  // testing::Test overrides:
+  virtual void SetUp() OVERRIDE {
+    aura::test::AuraTestBase::SetUp();
+
+    root_window()->AddPreTargetHandler(&root_filter_);
+    input_method_event_filter_.reset(
+        new InputMethodEventFilter(host()->GetAcceleratedWidget()));
+    input_method_event_filter_->SetInputMethodPropertyInRootWindow(
+        root_window());
+    root_filter_.AddHandler(input_method_event_filter_.get());
+    root_filter_.AddHandler(&test_filter_);
+
+    test_window_.reset(aura::test::CreateTestWindowWithDelegate(
+        &test_window_delegate_, -1, gfx::Rect(), root_window()));
+    test_input_client_.reset(new TestTextInputClient(test_window_.get()));
+
+    input_method_event_filter_->input_method()->SetFocusedTextInputClient(
+        test_input_client_.get());
+  }
+
+  virtual void TearDown() OVERRIDE {
+    test_window_.reset();
+    root_filter_.RemoveHandler(&test_filter_);
+    root_filter_.RemoveHandler(input_method_event_filter_.get());
+    root_window()->RemovePreTargetHandler(&root_filter_);
+
+    input_method_event_filter_.reset();
+    test_input_client_.reset();
+    aura::test::AuraTestBase::TearDown();
+  }
+
+ protected:
+  CompoundEventFilter root_filter_;
+  ui::test::TestEventHandler test_filter_;
+  scoped_ptr<InputMethodEventFilter> input_method_event_filter_;
+  aura::test::TestWindowDelegate test_window_delegate_;
+  scoped_ptr<aura::Window> test_window_;
+  scoped_ptr<TestTextInputClient> test_input_client_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(InputMethodEventFilterTest);
+};
 
 TEST_F(InputMethodEventFilterTest, TestInputMethodProperty) {
-  CompoundEventFilter root_filter;
-  root_window()->AddPreTargetHandler(&root_filter);
-
-  InputMethodEventFilter input_method_event_filter(
-      host()->GetAcceleratedWidget());
-  root_filter.AddHandler(&input_method_event_filter);
-
   // Tests if InputMethodEventFilter adds a window property on its
   // construction.
   EXPECT_TRUE(root_window()->GetProperty(
       aura::client::kRootWindowInputMethodKey));
-
-  root_filter.RemoveHandler(&input_method_event_filter);
-  root_window()->RemovePreTargetHandler(&root_filter);
 }
 
 // Tests if InputMethodEventFilter dispatches a ui::ET_TRANSLATED_KEY_* event to
 // the root window.
 TEST_F(InputMethodEventFilterTest, TestInputMethodKeyEventPropagation) {
-  new wm::DefaultActivationClient(root_window());
-
-  CompoundEventFilter root_filter;
-  root_window()->AddPreTargetHandler(&root_filter);
-
-  // Add the InputMethodEventFilter before the TestEventFilter.
-  InputMethodEventFilter input_method_event_filter(
-      host()->GetAcceleratedWidget());
-  root_filter.AddHandler(&input_method_event_filter);
-
-  // Add TestEventFilter to the RootWindow.
-  ui::test::TestEventHandler test_filter;
-  root_filter.AddHandler(&test_filter);
-
-  // We need an active window. Otherwise, the root window will not forward a key
-  // event to event filters.
-  aura::test::TestWindowDelegate test_delegate;
-  scoped_ptr<aura::Window> window(aura::test::CreateTestWindowWithDelegate(
-      &test_delegate,
-      -1,
-      gfx::Rect(),
-      root_window()));
-  aura::client::GetActivationClient(root_window())->ActivateWindow(
-      window.get());
-
   // Send a fake key event to the root window. InputMethodEventFilter, which is
   // automatically set up by AshTestBase, consumes it and sends a new
   // ui::ET_TRANSLATED_KEY_* event to the root window, which will be consumed by
   // the test event filter.
   aura::test::EventGenerator generator(root_window());
-  EXPECT_EQ(0, test_filter.num_key_events());
+  EXPECT_EQ(0, test_filter_.num_key_events());
   generator.PressKey(ui::VKEY_SPACE, 0);
-  EXPECT_EQ(1, test_filter.num_key_events());
+  EXPECT_EQ(1, test_filter_.num_key_events());
   generator.ReleaseKey(ui::VKEY_SPACE, 0);
-  EXPECT_EQ(2, test_filter.num_key_events());
-
-  root_filter.RemoveHandler(&input_method_event_filter);
-  root_filter.RemoveHandler(&test_filter);
+  EXPECT_EQ(2, test_filter_.num_key_events());
+}
 
-  // Reset window before |test_delegate| gets deleted.
-  window.reset();
-  root_window()->RemovePreTargetHandler(&root_filter);
+TEST_F(InputMethodEventFilterTest, TestEventDispatching) {
+  ui::KeyEvent evt(ui::ET_KEY_PRESSED,
+                   ui::VKEY_PROCESSKEY,
+                   ui::EF_IME_FABRICATED_KEY,
+                   false);
+  // Calls DispatchKeyEventPostIME() without a focused text input client.
+  input_method_event_filter_->input_method()->SetFocusedTextInputClient(NULL);
+  input_method_event_filter_->input_method()->DispatchKeyEvent(evt);
+  // Verifies 0 key event happened because InputMethodEventFilter::
+  // DispatchKeyEventPostIME() returns false.
+  EXPECT_EQ(0, test_filter_.num_key_events());
+
+  // Calls DispatchKeyEventPostIME() with a focused text input client.
+  input_method_event_filter_->input_method()->SetFocusedTextInputClient(
+      test_input_client_.get());
+  input_method_event_filter_->input_method()->DispatchKeyEvent(evt);
+  // Verifies 1 key event happened because InputMethodEventFilter::
+  // DispatchKeyEventPostIME() returns true.
+  EXPECT_EQ(1, test_filter_.num_key_events());
 }
 
 }  // namespace wm