Make DispatchKeyEventPostIME() asynchronous.

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 <stddef.h>
 
 #include <algorithm>
 #include <cstring>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/char_iterator.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/third_party/icu/icu_utf.h"
 #include "chromeos/system/devicemode.h"
 #include "ui/base/ime/chromeos/ime_keyboard.h"
 #include "ui/base/ime/chromeos/input_method_manager.h"
 #include "ui/base/ime/composition_text.h"
 #include "ui/base/ime/ime_bridge.h"
 #include "ui/base/ime/ime_engine_handler_interface.h"
+#include "ui/base/ime/input_method_delegate.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace {
 ui::IMEEngineHandlerInterface* GetEngine() {
   return ui::IMEBridge::Get()->GetCurrentEngineHandler();
 }
 }  // namespace
 
@@ skipping 30 matching lines @@
   // The Caps Lock toggling has been removed from here, because now it is
   // handled in accelerator controller.
   // (see https://bugs.chromium.org/p/chromium/issues/detail?id=700705).
 
   // If |context_| is not usable, then we can only dispatch the key event as is.
   // We only dispatch the key event to input method when the |context_| is an
   // normal input field (not a password field).
   // Note: We need to send the key event to ibus even if the |context_| is not
   // enabled, so that ibus can have a chance to enable the |context_|.
   if (!IsNonPasswordInputFieldFocused() || !GetEngine()) {
-    ui::EventDispatchDetails dispatch_details;
     if (event->type() == ET_KEY_PRESSED) {
       if (ExecuteCharacterComposer(*event)) {
         // Treating as PostIME event if character composer handles key event and
         // generates some IME event,
-        dispatch_details = ProcessKeyEventPostIME(event, true);
-        if (ack_callback)
-          ack_callback->Run(true);
-        return dispatch_details;
+        return ProcessKeyEventPostIME(event, std::move(ack_callback), false,
+                                      true);
       }
-      dispatch_details = ProcessUnfilteredKeyPressEvent(event);
-    } else {
-      dispatch_details = DispatchKeyEventPostIME(event);
+      return ProcessUnfilteredKeyPressEvent(event, std::move(ack_callback));
     }
-    if (ack_callback)
-      ack_callback->Run(false);
-    return dispatch_details;
+    return DispatchKeyEventPostIME(event, std::move(ack_callback));
   }
 
   handling_key_event_ = true;
   if (GetEngine()->IsInterestedInKeyEvent()) {
     ui::IMEEngineHandlerInterface::KeyEventDoneCallback callback = base::Bind(
         &InputMethodChromeOS::KeyEventDoneCallback,
         weak_ptr_factory_.GetWeakPtr(),
         // Pass the ownership of the new copied event.
         base::Owned(new ui::KeyEvent(*event)), Passed(&ack_callback));
     GetEngine()->ProcessKeyEvent(*event, callback);
@@ skipping 27 matching lines @@
       // IME event has a priority to be handled, so that character composer
       // should be reset.
       character_composer_.Reset();
     } else {
       // If IME does not handle key event, passes keyevent to character composer
       // to be able to compose complex characters.
       is_handled = ExecuteCharacterComposer(*event);
     }
   }
 
-  if (ack_callback)
-    ack_callback->Run(is_handled);
-
-  ui::EventDispatchDetails details;
-  if (event->type() == ET_KEY_PRESSED || event->type() == ET_KEY_RELEASED)
-    details = ProcessKeyEventPostIME(event, is_handled);
-
+  ui::EventDispatchDetails details =
+      ProcessKeyEventPostIME(event, std::move(ack_callback), false, is_handled);

[Shu Chen, 2017/07/07 01:01:11]

Here removes the original checks:
  if (event->type() == ET_KEY_PRESSED || event->type() == ET_KEY_RELEASED)

Is it intentional?

   handling_key_event_ = false;
   return details;
 }
 
 ui::EventDispatchDetails InputMethodChromeOS::DispatchKeyEvent(
     ui::KeyEvent* event) {
   return DispatchKeyEvent(event, nullptr);
 }
 
 void InputMethodChromeOS::OnTextInputTypeChanged(
@@ skipping 161 matching lines @@
   ui::IMEEngineHandlerInterface::InputContext context(
       GetTextInputType(), GetTextInputMode(), GetTextInputFlags());
   ui::IMEBridge::Get()->SetCurrentInputContext(context);
 
   if (!IsTextInputTypeNone())
     OnCaretBoundsChanged(GetTextInputClient());
 }
 
 ui::EventDispatchDetails InputMethodChromeOS::ProcessKeyEventPostIME(
     ui::KeyEvent* event,
+    std::unique_ptr<AckCallback> ack_callback,
+    bool skip_process_filtered,
     bool handled) {
   TextInputClient* client = GetTextInputClient();
   if (!client) {
     // As ibus works asynchronously, there is a chance that the focused client
     // loses focus before this method gets called.
-    return DispatchKeyEventPostIME(event);
+    return DispatchKeyEventPostIME(event, std::move(ack_callback));
   }
 
   ui::EventDispatchDetails dispatch_details;
-  if (event->type() == ET_KEY_PRESSED && handled) {
-    dispatch_details = ProcessFilteredKeyPressEvent(event);
-    if (event->stopped_propagation()) {
-      ResetContext();
-      return dispatch_details;
-    }
-    if (dispatch_details.dispatcher_destroyed ||
-        dispatch_details.target_destroyed)
-      return dispatch_details;
-  }
+  if (event->type() == ET_KEY_PRESSED && handled && !skip_process_filtered)
+    return ProcessFilteredKeyPressEvent(event, std::move(ack_callback));

[Shu Chen, 2017/07/07 01:24:26]

Is this a potential dead loop?

ProcessFilteredKeyPressEvent -> DispatchKeyEventPostIME ->
PostProcessFilteredKeyPressEvent -> ProcessKeyEventPostIME ->
ProcessFilteredKeyPressEvent...

 
   // In case the focus was changed by the key event. The |context_| should have
   // been reset when the focused window changed.
-  if (client != GetTextInputClient())
-    return dispatch_details;
+  if (client != GetTextInputClient()) {
+    if (ack_callback)
+      ack_callback->Run(false);
+    return ui::EventDispatchDetails();
+  }
 
   if (HasInputMethodResult())
     ProcessInputMethodResult(event, handled);
 
   // In case the focus was changed when sending input method results to the
   // focused window.
-  if (client != GetTextInputClient())
-    return dispatch_details;
+  if (client != GetTextInputClient()) {
+    if (ack_callback)
+      ack_callback->Run(false);
+    return ui::EventDispatchDetails();
+  }
 
-  if (handled)
-    return dispatch_details;  // IME handled the key event. do not forward.
+  if (handled) {
+    if (ack_callback)
+      ack_callback->Run(true);
+    return ui::EventDispatchDetails();  // IME handled the key event. do not
+                                        // forward.
+  }
 
   if (event->type() == ET_KEY_PRESSED)
-    return ProcessUnfilteredKeyPressEvent(event);
+    return ProcessUnfilteredKeyPressEvent(event, std::move(ack_callback));
 
-  if (event->type() == ET_KEY_RELEASED)
-    return DispatchKeyEventPostIME(event);
+  return DispatchKeyEventPostIME(event, std::move(ack_callback));
+}
 
-  return dispatch_details;
+ui::EventDispatchDetails InputMethodChromeOS::DispatchKeyEventPostIME(
+    ui::KeyEvent* event,
+    std::unique_ptr<AckCallback> ack_callback) const {
+  if (delegate_)
+    return delegate_->DispatchKeyEventPostIME(event, std::move(ack_callback));
+  if (ack_callback)
+    ack_callback->Run(false);
+  return ui::EventDispatchDetails();
 }
 
 ui::EventDispatchDetails InputMethodChromeOS::ProcessFilteredKeyPressEvent(
-    ui::KeyEvent* event) {
+    ui::KeyEvent* event,
+    std::unique_ptr<AckCallback> ack_callback) {
+  auto callback = base::MakeUnique<AckCallback>(base::Bind(
+      &InputMethodChromeOS::PostProcessFilteredKeyPressEvent,
+      weak_ptr_factory_.GetWeakPtr(), base::Owned(new ui::KeyEvent(*event)),
+      GetTextInputClient(), Passed(&ack_callback)));
+
   if (NeedInsertChar())
-    return DispatchKeyEventPostIME(event);
+    return DispatchKeyEventPostIME(event, std::move(callback));
 
   ui::KeyEvent fabricated_event(ET_KEY_PRESSED,
                                 VKEY_PROCESSKEY,
                                 event->code(),
                                 event->flags(),
                                 event->GetDomKey(),
                                 event->time_stamp());
-  ui::EventDispatchDetails dispatch_details =
-      DispatchKeyEventPostIME(&fabricated_event);
-  if (fabricated_event.stopped_propagation())
-    event->StopPropagation();
-  return dispatch_details;
+  return DispatchKeyEventPostIME(&fabricated_event, std::move(callback));

[Shu Chen, 2017/07/07 01:01:11]

Here skip the call to event->StopPropagation(), is it intentional?

+}
+
+void InputMethodChromeOS::PostProcessFilteredKeyPressEvent(
+    ui::KeyEvent* event,
+    TextInputClient* prev_client,
+    std::unique_ptr<AckCallback> ack_callback,
+    bool stopped_propagation) {
+  // In case the focus was changed by the key event.
+  if (GetTextInputClient() != prev_client)
+    return;
+
+  if (stopped_propagation) {
+    ResetContext();
+    if (ack_callback)
+      ack_callback->Run(true);
+    return;
+  }
+  ignore_result(
+      ProcessKeyEventPostIME(event, std::move(ack_callback), true, true));
 }
 
 ui::EventDispatchDetails InputMethodChromeOS::ProcessUnfilteredKeyPressEvent(
-    ui::KeyEvent* event) {
-  const TextInputClient* prev_client = GetTextInputClient();
-  ui::EventDispatchDetails dispatch_details = DispatchKeyEventPostIME(event);
-  if (event->stopped_propagation()) {
+    ui::KeyEvent* event,
+    std::unique_ptr<AckCallback> ack_callback) {
+  return DispatchKeyEventPostIME(
+      event,
+      base::MakeUnique<AckCallback>(base::Bind(
+          &InputMethodChromeOS::PostProcessUnfilteredKeyPressEvent,
+          weak_ptr_factory_.GetWeakPtr(), base::Owned(new ui::KeyEvent(*event)),
+          GetTextInputClient(), Passed(&ack_callback))));
+}
+
+void InputMethodChromeOS::PostProcessUnfilteredKeyPressEvent(
+    ui::KeyEvent* event,
+    TextInputClient* prev_client,
+    std::unique_ptr<AckCallback> ack_callback,
+    bool stopped_propagation) {
+  if (stopped_propagation) {
     ResetContext();
-    return dispatch_details;
+    if (ack_callback)
+      ack_callback->Run(false);
+    return;
   }
 
   // We shouldn't dispatch the character anymore if the key event dispatch
   // caused focus change. For example, in the following scenario,
   // 1. visit a web page which has a <textarea>.
   // 2. click Omnibox.
   // 3. enable Korean IME, press A, then press Tab to move the focus to the web
   //    page.
   // We should return here not to send the Tab key event to RWHV.
   TextInputClient* client = GetTextInputClient();
-  if (!client || client != prev_client)
-    return dispatch_details;
+  if (!client || client != prev_client) {
+    if (ack_callback)
+      ack_callback->Run(false);
+    return;
+  }
 
   // If a key event was not filtered by |context_| and |character_composer_|,
   // then it means the key event didn't generate any result text. So we need
   // to send corresponding character to the focused text input client.
   uint16_t ch = event->GetCharacter();
   if (ch)
     client->InsertChar(*event);
-  return dispatch_details;
+
+  if (ack_callback)
+    ack_callback->Run(false);
 }
 
 void InputMethodChromeOS::ProcessInputMethodResult(ui::KeyEvent* event,
                                                    bool handled) {
   TextInputClient* client = GetTextInputClient();
   DCHECK(client);
 
   if (result_text_.length()) {
     if (handled && NeedInsertChar()) {
       for (base::string16::const_iterator i = result_text_.begin();
@@ skipping 232 matching lines @@
 bool InputMethodChromeOS::IsNonPasswordInputFieldFocused() {
   TextInputType type = GetTextInputType();
   return (type != TEXT_INPUT_TYPE_NONE) && (type != TEXT_INPUT_TYPE_PASSWORD);
 }
 
 bool InputMethodChromeOS::IsInputFieldFocused() {
   return GetTextInputType() != TEXT_INPUT_TYPE_NONE;
 }
 
 }  // namespace ui