chromeos: Makes InputMethodMus dispatch immediately if no server

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 36 matching lines @@
 }
 
 void InputMethodMus::DispatchKeyEvent(
     ui::KeyEvent* event,
     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));
+    DispatchKeyEventPostIME(event);
     if (ack_callback) {
       ack_callback->Run(event->handled() ? EventResult::HANDLED
                                          : EventResult::UNHANDLED);
     }
     return;
   }
 
   SendKeyEventToInputMethod(*event, std::move(ack_callback));
 }
 
@@ skipping 47 matching lines @@
 
 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) {
+  if (!input_method_) {
+    // This code path is hit in tests that don't connect to the server.
+    DCHECK(!ack_callback);
+    std::unique_ptr<ui::Event> event_clone = ui::Event::Clone(event);
+    DispatchKeyEventPostIME(event_clone->AsKeyEvent());
+    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.
   pending_callbacks_.push_back(std::move(ack_callback));
   input_method_->ProcessKeyEvent(
       ui::Event::Clone(event),
       base::Bind(&InputMethodMus::ProcessKeyEventCallback,
                  base::Unretained(this), event));
 }
 
@@ skipping 38 matching lines @@
 
 void InputMethodMus::ProcessKeyEventCallback(
     const ui::KeyEvent& event,
     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()));
+    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