Enable Config::MUS to use classic IME instead of servicified IME.

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 27 matching lines @@
   AckPendingCallbacksUnhandled();
 }
 
 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<EventResultCallback> ack_callback) {
+    std::unique_ptr<AckCallback> ack_callback) {
   DCHECK(event->type() == ui::ET_KEY_PRESSED ||
          event->type() == ui::ET_KEY_RELEASED);
 
   // If no text input client, do nothing.
   if (!GetTextInputClient()) {
     DispatchKeyEventPostIME(event);
-    if (ack_callback) {
-      ack_callback->Run(event->handled() ? EventResult::HANDLED
-                                         : EventResult::UNHANDLED);
-    }
+    if (ack_callback)
+      ack_callback->Run(event->handled());
     return;
   }
 
   SendKeyEventToInputMethod(*event, std::move(ack_callback));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // InputMethodMus, ui::InputMethod implementation:
 
 void InputMethodMus::OnFocus() {
@@ skipping 45 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) {
+    std::unique_ptr<AckCallback> 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.
@@ skipping 45 matching lines @@
     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::AckPendingCallbacksUnhandled() {
   for (auto& callback_ptr : pending_callbacks_) {
     if (callback_ptr)
-      callback_ptr->Run(EventResult::UNHANDLED);
+      callback_ptr->Run(false);
   }
   pending_callbacks_.clear();
 }
 
 void InputMethodMus::ProcessKeyEventCallback(
     const ui::KeyEvent& event,
     bool handled) {
   // Remove the callback as DispatchKeyEventPostIME() may lead to calling
   // AckPendingCallbacksUnhandled(), which mutates |pending_callbacks_|.
   DCHECK(!pending_callbacks_.empty());
-  std::unique_ptr<EventResultCallback> ack_callback =
+  std::unique_ptr<AckCallback> ack_callback =
       std::move(pending_callbacks_.front());
   pending_callbacks_.pop_front();
-  EventResult event_result;
+  bool event_result = handled;
   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);
     DispatchKeyEventPostIME(event_clone->AsKeyEvent());
-    event_result =
-        event_clone->handled() ? EventResult::HANDLED : EventResult::UNHANDLED;
-  } else {
-    event_result = EventResult::HANDLED;
+    event_result = event_clone->handled();
   }
   // |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