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

ui/aura/mus/window_tree_client.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/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 166 matching lines @@
 }
 
 // Set the |target| to be the target window of this |event| and send it to
 // the EventSink.
 void DispatchEventToTarget(ui::Event* event, WindowMus* target) {
   ui::Event::DispatcherApi dispatch_helper(event);
   dispatch_helper.set_target(target->GetWindow());
   GetWindowTreeHostMus(target)->SendEventToSink(event);
 }
 
+void IMEAckCallback(std::unique_ptr<EventResultCallback> result_callback,
+                    bool handled) {
+  result_callback->Run(handled ? ui::mojom::EventResult::HANDLED
+                               : ui::mojom::EventResult::UNHANDLED);
+}
+
 }  // namespace
 
 WindowTreeClient::WindowTreeClient(
     service_manager::Connector* connector,
     WindowTreeClientDelegate* delegate,
     WindowManagerDelegate* window_manager_delegate,
     mojo::InterfaceRequest<ui::mojom::WindowTreeClient> request,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
     bool create_discardable_memory)
     : connector_(connector),
@@ skipping 1031 matching lines @@
   DCHECK(event);
 
   WindowMus* window = GetWindowByServerId(window_id);  // May be null.
 
   if (event->IsKeyEvent()) {
     DCHECK(!matches_pointer_watcher);  // PointerWatcher isn't for key events.
     if (!window || !window->GetWindow()->GetHost()) {
       tree_->OnWindowInputEventAck(event_id, ui::mojom::EventResult::UNHANDLED);
       return;
     }
-    InputMethodMus* input_method = GetWindowTreeHostMus(window)->input_method();
-    input_method->DispatchKeyEvent(event->AsKeyEvent(),
-                                   CreateEventResultCallback(event_id));
+    GetWindowTreeHostMus(window)->DispatchEventToInputMethod(
+        event->AsKeyEvent(),
+        base::MakeUnique<InputMethodMus::AckCallback>(base::Bind(
+            &IMEAckCallback, Passed(CreateEventResultCallback(event_id)))));
     return;
   }
 
   if (matches_pointer_watcher && has_pointer_watcher_) {
     DCHECK(event->IsPointerEvent());
     std::unique_ptr<ui::Event> event_in_dip(ui::Event::Clone(*event));
     ConvertEventLocationToDip(display_id, event_in_dip->AsLocatedEvent());
     delegate_->OnPointerEventObserved(*event_in_dip->AsPointerEvent(),
                                       window ? window->GetWindow() : nullptr);
   }
@@ skipping 719 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura