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

ui/aura/mus/input_method_mus_unittest.cc

 // Copyright 2017 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 "services/ui/public/interfaces/ime/ime.mojom.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/mus/input_method_mus_test_api.h"
 #include "ui/aura/window.h"
@@ skipping 13 matching lines @@
   ui::EventDispatchDetails DispatchKeyEventPostIME(ui::KeyEvent* key) override {
     return ui::EventDispatchDetails();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestInputMethodDelegate);
 };
 
 using ProcessKeyEventCallback = base::Callback<void(bool)>;
 using ProcessKeyEventCallbacks = std::vector<ProcessKeyEventCallback>;
-using EventResultCallback = base::Callback<void(ui::mojom::EventResult)>;
 
 // InputMethod implementation that queues up the callbacks supplied to
 // ProcessKeyEvent().
 class TestInputMethod : public ui::mojom::InputMethod {
  public:
   TestInputMethod() {}
   ~TestInputMethod() override {}
 
   ProcessKeyEventCallbacks* process_key_event_callbacks() {
     return &process_key_event_callbacks_;
@@ skipping 14 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestInputMethod);
 };
 
 }  // namespace
 
 using InputMethodMusTest = test::AuraTestBaseMus;
 
 namespace {
 
 // Used in closure supplied to processing the event.
-void RunFunctionWithEventResult(bool* was_run, ui::mojom::EventResult result) {
+void RunFunctionWithHandled(bool* was_run, bool handled) {
   *was_run = true;
 }
 
 }  // namespace
 
 TEST_F(InputMethodMusTest, PendingCallbackRunFromDestruction) {
   aura::Window window(nullptr);
   window.Init(ui::LAYER_NOT_DRAWN);
   bool was_event_result_callback_run = false;
   // Create an InputMethodMus and foward an event to it.
   {
     TestInputMethodDelegate input_method_delegate;
     InputMethodMus input_method_mus(&input_method_delegate, &window);
     TestInputMethod test_input_method;
     InputMethodMusTestApi::SetInputMethod(&input_method_mus,
                                           &test_input_method);
-    std::unique_ptr<EventResultCallback> callback =
-        base::MakeUnique<EventResultCallback>(base::Bind(
-            &RunFunctionWithEventResult, &was_event_result_callback_run));
+    std::unique_ptr<InputMethodMus::AckCallback> callback =
+        base::MakeUnique<InputMethodMus::AckCallback>(base::Bind(
+            &RunFunctionWithHandled, &was_event_result_callback_run));
     InputMethodMusTestApi::CallSendKeyEventToInputMethod(
         &input_method_mus, ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_RETURN, 0),
         std::move(callback));
     // Add a null callback as well, to make sure null is deal with.
     InputMethodMusTestApi::CallSendKeyEventToInputMethod(
         &input_method_mus, ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_RETURN, 0),
         nullptr);
     // The event should have been queued.
     EXPECT_EQ(2u, test_input_method.process_key_event_callbacks()->size());
     // Callback should not have been run yet.
     EXPECT_FALSE(was_event_result_callback_run);
   }
 
   // When the destructor is run the callback should be run.
   EXPECT_TRUE(was_event_result_callback_run);
 }
 
 TEST_F(InputMethodMusTest, PendingCallbackRunFromOnDidChangeFocusedClient) {
   aura::Window window(nullptr);
   window.Init(ui::LAYER_NOT_DRAWN);
   bool was_event_result_callback_run = false;
   ui::DummyTextInputClient test_input_client;
   // Create an InputMethodMus and foward an event to it.
   TestInputMethodDelegate input_method_delegate;
   InputMethodMus input_method_mus(&input_method_delegate, &window);
   TestInputMethod test_input_method;
   InputMethodMusTestApi::SetInputMethod(&input_method_mus, &test_input_method);
-  std::unique_ptr<EventResultCallback> callback =
-      base::MakeUnique<EventResultCallback>(base::Bind(
-          &RunFunctionWithEventResult, &was_event_result_callback_run));
+  std::unique_ptr<InputMethodMus::AckCallback> callback =
+      base::MakeUnique<InputMethodMus::AckCallback>(
+          base::Bind(&RunFunctionWithHandled, &was_event_result_callback_run));
   InputMethodMusTestApi::CallSendKeyEventToInputMethod(
       &input_method_mus, ui::KeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_RETURN, 0),
       std::move(callback));
   // The event should have been queued.
   EXPECT_EQ(1u, test_input_method.process_key_event_callbacks()->size());
   // Callback should not have been run yet.
   EXPECT_FALSE(was_event_result_callback_run);
 
   InputMethodMusTestApi::CallOnDidChangeFocusedClient(
       &input_method_mus, nullptr, &test_input_client);
@@ skipping 40 matching lines @@
   window.Init(ui::LAYER_NOT_DRAWN);
   bool was_event_result_callback_run = false;
   ui::DummyTextInputClient test_input_client;
   // Create an InputMethodMus and foward an event to it.
   TestInputMethodDelegate2 input_method_delegate;
   InputMethodMus input_method_mus(&input_method_delegate, &window);
   input_method_delegate.SetInputMethodAndClient(&input_method_mus,
                                                 &test_input_client);
   TestInputMethod test_input_method;
   InputMethodMusTestApi::SetInputMethod(&input_method_mus, &test_input_method);
-  std::unique_ptr<EventResultCallback> callback =
-      base::MakeUnique<EventResultCallback>(base::Bind(
-          &RunFunctionWithEventResult, &was_event_result_callback_run));
+  std::unique_ptr<InputMethodMus::AckCallback> callback =
+      base::MakeUnique<InputMethodMus::AckCallback>(
+          base::Bind(&RunFunctionWithHandled, &was_event_result_callback_run));
   const ui::KeyEvent key_event(ui::ET_KEY_PRESSED, ui::VKEY_RETURN, 0);
   InputMethodMusTestApi::CallSendKeyEventToInputMethod(
       &input_method_mus, key_event, std::move(callback));
   // The event should have been queued.
   ASSERT_EQ(1u, test_input_method.process_key_event_callbacks()->size());
   // Callback should not have been run yet.
   EXPECT_FALSE(was_event_result_callback_run);
   (*test_input_method.process_key_event_callbacks())[0].Run(false);
 
   // Callback should have been run.
   EXPECT_TRUE(was_event_result_callback_run);
   EXPECT_TRUE(input_method_delegate.was_dispatch_key_event_post_ime_called());
 }
 
 }  // namespace aura