Revert of chromeos: Remove some IME methods from ash::SystemTrayDelegate

ash/accelerators/accelerator_controller_unittest.cc

 // Copyright (c) 2012 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 "ash/accelerators/accelerator_controller.h"
 
 #include "ash/accelerators/accelerator_table.h"
 #include "ash/accessibility_delegate.h"
 #include "ash/accessibility_types.h"
 #include "ash/ash_switches.h"
+#include "ash/ime_control_delegate.h"
 #include "ash/public/cpp/config.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/session/session_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/system/brightness_control_delegate.h"
 #include "ash/system/keyboard_brightness_control_delegate.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/lock_state_controller_test_api.h"
@@ skipping 25 matching lines @@
 #include "ui/events/event_sink.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/message_center/message_center.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/events/test/events_test_utils_x11.h"
 #endif
 
-using chromeos::input_method::InputMethodManager;
-
 namespace ash {
 
 namespace {
 
 class TestTarget : public ui::AcceleratorTarget {
  public:
   TestTarget() : accelerator_pressed_count_(0), accelerator_repeat_count_(0) {}
   ~TestTarget() override {}
 
   int accelerator_pressed_count() const { return accelerator_pressed_count_; }
@@ skipping 50 matching lines @@
   const ui::Accelerator& last_accelerator() const { return last_accelerator_; }
 
  private:
   int handle_brightness_down_count_;
   int handle_brightness_up_count_;
   ui::Accelerator last_accelerator_;
 
   DISALLOW_COPY_AND_ASSIGN(DummyBrightnessControlDelegate);
 };
 
-class TestInputMethodManagerState
-    : public chromeos::input_method::MockInputMethodManager::State {
+class DummyImeControlDelegate : public ImeControlDelegate {
  public:
-  TestInputMethodManagerState() = default;
+  DummyImeControlDelegate()
+      : handle_next_ime_count_(0),
+        handle_previous_ime_count_(0),
+        handle_switch_ime_count_(0) {}
+  ~DummyImeControlDelegate() override {}
 
-  // InputMethodManager::State:
-  bool CanCycleInputMethod() override { return can_change_input_method_; }
-  void SwitchToNextInputMethod() override { next_ime_count_++; }
-  void SwitchToPreviousInputMethod() override { previous_ime_count_++; }
-  bool CanSwitchInputMethod(const ui::Accelerator& accelerator) override {
-    return can_change_input_method_;
+  bool CanCycleIme() override { return true; }
+  void HandleNextIme() override { ++handle_next_ime_count_; }
+  void HandlePreviousIme() override { ++handle_previous_ime_count_; }
+  bool CanSwitchIme(const ui::Accelerator& accelerator) override {
+    return true;
   }
-  void SwitchInputMethod(const ui::Accelerator& accelerator) override {
-    switch_ime_count_++;
+  void HandleSwitchIme(const ui::Accelerator& accelerator) override {
+    ++handle_switch_ime_count_;
   }
 
-  bool can_change_input_method_ = true;
-  int next_ime_count_ = 0;
-  int previous_ime_count_ = 0;
-  int switch_ime_count_ = 0;
+  int handle_next_ime_count() const { return handle_next_ime_count_; }
+  int handle_previous_ime_count() const { return handle_previous_ime_count_; }
+  int handle_switch_ime_count() const { return handle_switch_ime_count_; }
 
  private:
-  // Base class is ref-counted.
-  ~TestInputMethodManagerState() override = default;
+  int handle_next_ime_count_;
+  int handle_previous_ime_count_;
+  int handle_switch_ime_count_;
 
-  DISALLOW_COPY_AND_ASSIGN(TestInputMethodManagerState);
-};
-
-class TestInputMethodManager
-    : public chromeos::input_method::MockInputMethodManager {
- public:
-  TestInputMethodManager() : state_(new TestInputMethodManagerState) {}
-  ~TestInputMethodManager() override = default;
-
-  void SetCanChangeInputMethod(bool can_change) {
-    state_->can_change_input_method_ = can_change;
-  }
-
-  // MockInputMethodManager:
-  chromeos::input_method::ImeKeyboard* GetImeKeyboard() override {
-    return &keyboard_;
-  }
-  scoped_refptr<InputMethodManager::State> GetActiveIMEState() override {
-    return state_;
-  }
-
-  chromeos::input_method::FakeImeKeyboard keyboard_;
-  scoped_refptr<TestInputMethodManagerState> state_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestInputMethodManager);
+  DISALLOW_COPY_AND_ASSIGN(DummyImeControlDelegate);
 };
 
 class DummyKeyboardBrightnessControlDelegate
     : public KeyboardBrightnessControlDelegate {
  public:
   DummyKeyboardBrightnessControlDelegate()
       : handle_keyboard_brightness_down_count_(0),
         handle_keyboard_brightness_up_count_(0) {}
   ~DummyKeyboardBrightnessControlDelegate() override {}
 
@@ skipping 35 matching lines @@
 }
 
 bool TestTarget::CanHandleAccelerators() const {
   return true;
 }
 
 }  // namespace
 
 class AcceleratorControllerTest : public test::AshTestBase {
  public:
-  AcceleratorControllerTest() = default;
-  ~AcceleratorControllerTest() override = default;
-
-  void SetUp() override {
-    test::AshTestBase::SetUp();
-    test_input_method_manager_ = new TestInputMethodManager;
-    // Takes ownership.
-    InputMethodManager::Initialize(test_input_method_manager_);
-  }
-
-  void TearDown() override {
-    InputMethodManager::Shutdown();
-    test::AshTestBase::TearDown();
-  }
+  AcceleratorControllerTest() {}
+  ~AcceleratorControllerTest() override {}
 
  protected:
   static AcceleratorController* GetController();
 
   static bool ProcessInController(const ui::Accelerator& accelerator) {
     if (accelerator.key_state() == ui::Accelerator::KeyState::RELEASED) {
       // If the |accelerator| should trigger on release, then we store the
       // pressed version of it first in history then the released one to
       // simulate what happens in reality.
       ui::Accelerator pressed_accelerator = accelerator;
@@ skipping 35 matching lines @@
   void SetBrightnessControlDelegate(
       std::unique_ptr<BrightnessControlDelegate> delegate) {
     Shell::Get()->brightness_control_delegate_ = std::move(delegate);
   }
 
   void SetKeyboardBrightnessControlDelegate(
       std::unique_ptr<KeyboardBrightnessControlDelegate> delegate) {
     Shell::Get()->keyboard_brightness_control_delegate_ = std::move(delegate);
   }
 
-  // Owned by InputMethodManager.
-  TestInputMethodManager* test_input_method_manager_ = nullptr;
-
  private:
   DISALLOW_COPY_AND_ASSIGN(AcceleratorControllerTest);
 };
 
 AcceleratorController* AcceleratorControllerTest::GetController() {
   return Shell::Get()->accelerator_controller();
 }
 
 // Double press of exit shortcut => exiting
 TEST_F(AcceleratorControllerTest, ExitWarningHandlerTestDoublePress) {
@@ skipping 565 matching lines @@
       ui::Accelerator(ui::VKEY_BROWSER_SEARCH, ui::EF_NONE)));
   RunAllPendingInMessageLoop();
   EXPECT_EQ(3u, test_app_list_presenter.toggle_count());
   EXPECT_FALSE(ProcessInController(
       CreateReleaseAccelerator(ui::VKEY_BROWSER_SEARCH, ui::EF_NONE)));
   RunAllPendingInMessageLoop();
   EXPECT_EQ(3u, test_app_list_presenter.toggle_count());
 }
 
 TEST_F(AcceleratorControllerTest, ImeGlobalAccelerators) {
-  TestInputMethodManagerState* test_state =
-      test_input_method_manager_->state_.get();
-
-  // Test IME shortcuts when cycling IME is blocked.
-  test_state->can_change_input_method_ = false;
+  // Test IME shortcuts.
   ui::Accelerator control_space_down(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
   ui::Accelerator control_space_up(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
   control_space_up.set_key_state(ui::Accelerator::KeyState::RELEASED);
   const ui::Accelerator convert(ui::VKEY_CONVERT, ui::EF_NONE);
   const ui::Accelerator non_convert(ui::VKEY_NONCONVERT, ui::EF_NONE);
   const ui::Accelerator wide_half_1(ui::VKEY_DBE_SBCSCHAR, ui::EF_NONE);
   const ui::Accelerator wide_half_2(ui::VKEY_DBE_DBCSCHAR, ui::EF_NONE);
   const ui::Accelerator hangul(ui::VKEY_HANGUL, ui::EF_NONE);
   EXPECT_FALSE(ProcessInController(control_space_down));
   EXPECT_FALSE(ProcessInController(control_space_up));
   EXPECT_FALSE(ProcessInController(convert));
   EXPECT_FALSE(ProcessInController(non_convert));
   EXPECT_FALSE(ProcessInController(wide_half_1));
   EXPECT_FALSE(ProcessInController(wide_half_2));
   EXPECT_FALSE(ProcessInController(hangul));
-
-  // Test IME shortcuts when cycling IME is allowed.
-  test_state->can_change_input_method_ = true;
-  EXPECT_EQ(0, test_state->previous_ime_count_);
+  DummyImeControlDelegate* delegate = new DummyImeControlDelegate;
+  GetController()->SetImeControlDelegate(
+      std::unique_ptr<ImeControlDelegate>(delegate));
+  EXPECT_EQ(0, delegate->handle_previous_ime_count());
   EXPECT_TRUE(ProcessInController(control_space_down));
-  EXPECT_EQ(1, test_state->previous_ime_count_);
+  EXPECT_EQ(1, delegate->handle_previous_ime_count());
   EXPECT_TRUE(ProcessInController(control_space_up));
-  EXPECT_EQ(1, test_state->previous_ime_count_);
-  EXPECT_EQ(0, test_state->switch_ime_count_);
+  EXPECT_EQ(1, delegate->handle_previous_ime_count());
+  EXPECT_EQ(0, delegate->handle_switch_ime_count());
   EXPECT_TRUE(ProcessInController(convert));
-  EXPECT_EQ(1, test_state->switch_ime_count_);
+  EXPECT_EQ(1, delegate->handle_switch_ime_count());
   EXPECT_TRUE(ProcessInController(non_convert));
-  EXPECT_EQ(2, test_state->switch_ime_count_);
+  EXPECT_EQ(2, delegate->handle_switch_ime_count());
   EXPECT_TRUE(ProcessInController(wide_half_1));
-  EXPECT_EQ(3, test_state->switch_ime_count_);
+  EXPECT_EQ(3, delegate->handle_switch_ime_count());
   EXPECT_TRUE(ProcessInController(wide_half_2));
-  EXPECT_EQ(4, test_state->switch_ime_count_);
+  EXPECT_EQ(4, delegate->handle_switch_ime_count());
   EXPECT_TRUE(ProcessInController(hangul));
-  EXPECT_EQ(5, test_state->switch_ime_count_);
+  EXPECT_EQ(5, delegate->handle_switch_ime_count());
 }
 
 // TODO(nona|mazda): Remove this when crbug.com/139556 in a better way.
 TEST_F(AcceleratorControllerTest, ImeGlobalAcceleratorsWorkaround139556) {
   // The workaround for crbug.com/139556 depends on the fact that we don't
   // use Shift+Alt+Enter/Space with ET_KEY_PRESSED as an accelerator. Test it.
   const ui::Accelerator shift_alt_return_press(
       ui::VKEY_RETURN, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
   EXPECT_FALSE(ProcessInController(shift_alt_return_press));
   const ui::Accelerator shift_alt_space_press(
@@ skipping 28 matching lines @@
   EXPECT_FALSE(
       GetController()->IsPreferred(ui::Accelerator(ui::VKEY_TAB, ui::EF_NONE)));
   EXPECT_FALSE(
       GetController()->IsReserved(ui::Accelerator(ui::VKEY_A, ui::EF_NONE)));
   EXPECT_FALSE(
       GetController()->IsPreferred(ui::Accelerator(ui::VKEY_A, ui::EF_NONE)));
 }
 
 namespace {
 
+class TestInputMethodManager
+    : public chromeos::input_method::MockInputMethodManager {
+ public:
+  TestInputMethodManager() = default;
+  ~TestInputMethodManager() override = default;
+
+  // MockInputMethodManager:
+  chromeos::input_method::ImeKeyboard* GetImeKeyboard() override {
+    return &keyboard_;
+  }
+
+ private:
+  chromeos::input_method::FakeImeKeyboard keyboard_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestInputMethodManager);
+};
+
+class ToggleCapsLockTest : public AcceleratorControllerTest {
+ public:
+  ToggleCapsLockTest() = default;
+  ~ToggleCapsLockTest() override = default;
+
+  void SetUp() override {
+    AcceleratorControllerTest::SetUp();
+    chromeos::input_method::InputMethodManager::Initialize(
+        new TestInputMethodManager);
+  }
+
+  void TearDown() override {
+    chromeos::input_method::InputMethodManager::Shutdown();
+    AcceleratorControllerTest::TearDown();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ToggleCapsLockTest);
+};
+
 // Tests the five combinations of the TOGGLE_CAPS_LOCK accelerator.
-TEST_F(AcceleratorControllerTest, ToggleCapsLockAccelerators) {
+TEST_F(ToggleCapsLockTest, ToggleCapsLockAccelerators) {
   chromeos::input_method::InputMethodManager* input_method_manager =
       chromeos::input_method::InputMethodManager::Get();
   ASSERT_TRUE(input_method_manager);
   EXPECT_FALSE(input_method_manager->GetImeKeyboard()->CapsLockIsEnabled());
 
   // 1. Press Alt, Press Search, Release Search, Release Alt.
   // Note when you press Alt then press search, the key_code at this point is
   // VKEY_LWIN (for search) and Alt is the modifier.
   const ui::Accelerator press_alt_then_search(ui::VKEY_LWIN, ui::EF_ALT_DOWN);
   EXPECT_FALSE(ProcessInController(press_alt_then_search));
@@ skipping 271 matching lines @@
     GetController()->PerformActionIfEnabled(kActionsNeedingWindow[i]);
     EXPECT_NE(delegate->GetLastAccessibilityAlert(), A11Y_ALERT_WINDOW_NEEDED);
   }
 }
 
 namespace {
 
 // defines a class to test the behavior of deprecated accelerators.
 class DeprecatedAcceleratorTester : public AcceleratorControllerTest {
  public:
-  DeprecatedAcceleratorTester() = default;
-  ~DeprecatedAcceleratorTester() override = default;
+  DeprecatedAcceleratorTester() {}
+  ~DeprecatedAcceleratorTester() override {}
+
+  void SetUp() override {
+    AcceleratorControllerTest::SetUp();
+
+    // For testing the deprecated and new IME shortcuts.
+    DummyImeControlDelegate* delegate = new DummyImeControlDelegate;
+    GetController()->SetImeControlDelegate(
+        std::unique_ptr<ImeControlDelegate>(delegate));
+  }
 
   ui::Accelerator CreateAccelerator(const AcceleratorData& data) const {
     ui::Accelerator result(data.keycode, data.modifiers);
     result.set_key_state(data.trigger_on_press
                              ? ui::Accelerator::KeyState::PRESSED
                              : ui::Accelerator::KeyState::RELEASED);
     return result;
   }
 
   void ResetStateIfNeeded() {
@@ skipping 74 matching lines @@
     // Expect no notifications from the new accelerators.
     EXPECT_TRUE(IsMessageCenterEmpty());
 
     // If the action is LOCK_SCREEN, we must reset the state by unlocking the
     // screen before we proceed testing the rest of accelerators.
     ResetStateIfNeeded();
   }
 }
 
 }  // namespace ash