Makes ~InputMethodMus ack any in flight events

ui/aura/mus/input_method_mus.cc

 // Copyright (c) 2015 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/aura/mus/input_method_mus.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "services/ui/public/interfaces/constants.mojom.h"
@@ skipping 13 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // InputMethodMus, public:
 
 InputMethodMus::InputMethodMus(ui::internal::InputMethodDelegate* delegate,
                                Window* window)
     : window_(window) {
   SetDelegate(delegate);
 }
 
-InputMethodMus::~InputMethodMus() {}
+InputMethodMus::~InputMethodMus() {
+  // Mus won't dispatch the next key event until the existing one is acked. We
+  // may have KeyEvents sent to IME and awaiting the result, we need to ack
+  // them otherwise mus won't process the next event until it times out.
+  for (auto& callback_ptr : pending_callbacks_) {
+    if (callback_ptr)
+      callback_ptr->Run(EventResult::UNHANDLED);
+  }
+}
 
 void InputMethodMus::Init(service_manager::Connector* connector) {
   if (connector)
     connector->BindInterface(ui::mojom::kServiceName, &ime_server_);
 }
 
 void InputMethodMus::DispatchKeyEvent(
     ui::KeyEvent* event,
-    std::unique_ptr<base::Callback<void(EventResult)>> ack_callback) {
+    std::unique_ptr<EventResultCallback> ack_callback) {
   DCHECK(event->type() == ui::ET_KEY_PRESSED ||
          event->type() == ui::ET_KEY_RELEASED);
 
   // If no text input client, do nothing.
   if (!GetTextInputClient()) {
     ignore_result(DispatchKeyEventPostIME(event));
     if (ack_callback) {
       ack_callback->Run(event->handled() ? EventResult::HANDLED
                                          : EventResult::UNHANDLED);
     }
     return;
   }
 
-  // IME driver will notify us whether it handled the event or not by calling
-  // ProcessKeyEventCallback(), in which we will run the |ack_callback| to tell
-  // the window server if client handled the event or not.
-  input_method_->ProcessKeyEvent(
-      ui::Event::Clone(*event),
-      base::Bind(&InputMethodMus::ProcessKeyEventCallback,
-                 base::Unretained(this), *event, Passed(&ack_callback)));
+  SendKeyEventToInputMethod(*event, std::move(ack_callback));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // InputMethodMus, ui::InputMethod implementation:
 
 void InputMethodMus::OnFocus() {
   InputMethodBase::OnFocus();
   UpdateTextInputType();
 }
 
@@ skipping 36 matching lines @@
   // TODO(moshayedi): crbug.com/637418. Not supported in ChromeOS. Investigate
   // whether we want to support this or not.
 }
 
 bool InputMethodMus::IsCandidatePopupOpen() const {
   // TODO(moshayedi): crbug.com/637416. Implement this properly when we have a
   // mean for displaying candidate list popup.
   return false;
 }
 
+void InputMethodMus::SendKeyEventToInputMethod(
+    const ui::KeyEvent& event,
+    std::unique_ptr<EventResultCallback> ack_callback) {
+  // IME driver will notify us whether it handled the event or not by calling
+  // ProcessKeyEventCallback(), in which we will run the |ack_callback| to tell
+  // the window server if client handled the event or not.
+  pending_callbacks_.push_back(std::move(ack_callback));
+  input_method_->ProcessKeyEvent(
+      ui::Event::Clone(event),
+      base::Bind(&InputMethodMus::ProcessKeyEventCallback,
+                 base::Unretained(this), event));
+}
+
 void InputMethodMus::OnDidChangeFocusedClient(
     ui::TextInputClient* focused_before,
     ui::TextInputClient* focused) {
   InputMethodBase::OnDidChangeFocusedClient(focused_before, focused);
   UpdateTextInputType();
 
   // TODO(moshayedi): crbug.com/681563. Handle when there is no focused clients.
   if (!focused)
     return;
 
   text_input_client_ = base::MakeUnique<TextInputClientImpl>(focused);
   if (ime_server_) {
     ui::mojom::StartSessionDetailsPtr details =
         ui::mojom::StartSessionDetails::New();
     details->client = text_input_client_->CreateInterfacePtrAndBind();
-    details->input_method_request = MakeRequest(&input_method_);
+    details->input_method_request = MakeRequest(&input_method_ptr_);
+    input_method_ = input_method_ptr_.get();
     details->text_input_type = focused->GetTextInputType();
     details->text_input_mode = focused->GetTextInputMode();
     details->text_direction = focused->GetTextDirection();
     details->text_input_flags = focused->GetTextInputFlags();
     details->caret_bounds = focused->GetCaretBounds();
     ime_server_->StartSession(std::move(details));
   }
 }
 
 void InputMethodMus::UpdateTextInputType() {
   ui::TextInputType type = GetTextInputType();
   mojo::TextInputStatePtr state = mojo::TextInputState::New();
   state->type = mojo::ConvertTo<mojo::TextInputType>(type);
   if (window_) {
     WindowPortMus* window_impl_mus = WindowPortMus::Get(window_);
     if (type != ui::TEXT_INPUT_TYPE_NONE)
       window_impl_mus->SetImeVisibility(true, std::move(state));
     else
       window_impl_mus->SetTextInputState(std::move(state));
   }
 }
 
 void InputMethodMus::ProcessKeyEventCallback(
     const ui::KeyEvent& event,
-    std::unique_ptr<base::Callback<void(EventResult)>> ack_callback,
     bool handled) {
   EventResult event_result;
   if (!handled) {
     // If not handled by IME, try dispatching the event to delegate to see if
     // any client-side post-ime processing needs to be done. This includes cases
     // like backspace, return key, etc.
     std::unique_ptr<ui::Event> event_clone = ui::Event::Clone(event);
     ignore_result(DispatchKeyEventPostIME(event_clone->AsKeyEvent()));
     event_result =
         event_clone->handled() ? EventResult::HANDLED : EventResult::UNHANDLED;
   } else {
     event_result = EventResult::HANDLED;
   }
+  DCHECK(!pending_callbacks_.empty());
+  std::unique_ptr<EventResultCallback> ack_callback =
+      std::move(pending_callbacks_.front());
+  pending_callbacks_.pop_front();
   // |ack_callback| can be null if the standard form of DispatchKeyEvent() is
   // called instead of the version which provides a callback. In mus+ash we
   // use the version with callback, but some unittests use the standard form.
   if (ack_callback)
     ack_callback->Run(event_result);
 }
 
 }  // namespace aura