Converts ui::Accelerator::type to an enum

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/common/accelerators/accelerator_controller.h"
 
 #include "ash/common/accelerators/accelerator_table.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/accessibility_types.h"
 #include "ash/common/ash_switches.h"
@@ skipping 66 matching lines @@
   bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
   bool CanHandleAccelerators() const override;
 
  private:
   int accelerator_pressed_count_;
   int accelerator_repeat_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTarget);
 };
 
-class ReleaseAccelerator : public ui::Accelerator {
- public:
-  ReleaseAccelerator(ui::KeyboardCode keycode, int modifiers)
-      : ui::Accelerator(keycode, modifiers) {
-    set_type(ui::ET_KEY_RELEASED);
-  }
-};
+ui::Accelerator CreateReleaseAccelerator(ui::KeyboardCode key_code,
+                                         int modifiers) {
+  ui::Accelerator accelerator(key_code, modifiers);
+  accelerator.set_key_state(ui::Accelerator::KeyState::RELEASED);
+  return accelerator;
+}
 
 class DummyBrightnessControlDelegate : public BrightnessControlDelegate {
  public:
   DummyBrightnessControlDelegate()
       : handle_brightness_down_count_(0), handle_brightness_up_count_(0) {}
   ~DummyBrightnessControlDelegate() override {}
 
   void HandleBrightnessDown(const ui::Accelerator& accelerator) override {
     ++handle_brightness_down_count_;
     last_accelerator_ = accelerator;
@@ skipping 105 matching lines @@
 
 class AcceleratorControllerTest : public test::AshTestBase {
  public:
   AcceleratorControllerTest() {}
   ~AcceleratorControllerTest() override {}
 
  protected:
   static AcceleratorController* GetController();
 
   static bool ProcessInController(const ui::Accelerator& accelerator) {
-    if (accelerator.type() == ui::ET_KEY_RELEASED) {
+    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;
-      pressed_accelerator.set_type(ui::ET_KEY_PRESSED);
+      pressed_accelerator.set_key_state(ui::Accelerator::KeyState::PRESSED);
       GetController()->accelerator_history()->StoreCurrentAccelerator(
           pressed_accelerator);
     }
     GetController()->accelerator_history()->StoreCurrentAccelerator(
         accelerator);
     return GetController()->Process(accelerator);
   }
 
   static const ui::Accelerator& GetPreviousAccelerator() {
     return GetController()->accelerator_history()->previous_accelerator();
@@ skipping 44 matching lines @@
 };
 
 AcceleratorController* AcceleratorControllerTest::GetController() {
   return WmShell::Get()->accelerator_controller();
 }
 
 // Double press of exit shortcut => exiting
 TEST_F(AcceleratorControllerTest, ExitWarningHandlerTestDoublePress) {
   ui::Accelerator press(ui::VKEY_Q, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN);
   ui::Accelerator release(press);
-  release.set_type(ui::ET_KEY_RELEASED);
+  release.set_key_state(ui::Accelerator::KeyState::RELEASED);
   ExitWarningHandler* ewh = GetController()->GetExitWarningHandlerForTest();
   ASSERT_TRUE(ewh);
   StubForTest(ewh);
   EXPECT_TRUE(is_idle(ewh));
   EXPECT_FALSE(is_ui_shown(ewh));
   EXPECT_TRUE(ProcessInController(press));
   EXPECT_FALSE(ProcessInController(release));
   EXPECT_FALSE(is_idle(ewh));
   EXPECT_TRUE(is_ui_shown(ewh));
   EXPECT_TRUE(ProcessInController(press));  // second press before timer.
   EXPECT_FALSE(ProcessInController(release));
   SimulateTimerExpired(ewh);
   EXPECT_TRUE(is_exiting(ewh));
   EXPECT_FALSE(is_ui_shown(ewh));
   Reset(ewh);
 }
 
 // Single press of exit shortcut before timer => idle
 TEST_F(AcceleratorControllerTest, ExitWarningHandlerTestSinglePress) {
   ui::Accelerator press(ui::VKEY_Q, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN);
   ui::Accelerator release(press);
-  release.set_type(ui::ET_KEY_RELEASED);
+  release.set_key_state(ui::Accelerator::KeyState::RELEASED);
   ExitWarningHandler* ewh = GetController()->GetExitWarningHandlerForTest();
   ASSERT_TRUE(ewh);
   StubForTest(ewh);
   EXPECT_TRUE(is_idle(ewh));
   EXPECT_FALSE(is_ui_shown(ewh));
   EXPECT_TRUE(ProcessInController(press));
   EXPECT_FALSE(ProcessInController(release));
   EXPECT_FALSE(is_idle(ewh));
   EXPECT_TRUE(is_ui_shown(ewh));
   SimulateTimerExpired(ewh);
@@ skipping 418 matching lines @@
 
   gfx::Rect docked_bounds = window->GetBoundsInScreen();
   GetController()->PerformActionIfEnabled(WINDOW_POSITION_CENTER);
   // It should not get centered and should remain docked.
   EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id());
   EXPECT_EQ(docked_bounds.ToString(), window->GetBoundsInScreen().ToString());
 }
 
 TEST_F(AcceleratorControllerTest, AutoRepeat) {
   ui::Accelerator accelerator_a(ui::VKEY_A, ui::EF_CONTROL_DOWN);
-  accelerator_a.set_type(ui::ET_KEY_PRESSED);
   TestTarget target_a;
   GetController()->Register({accelerator_a}, &target_a);
   ui::Accelerator accelerator_b(ui::VKEY_B, ui::EF_CONTROL_DOWN);
-  accelerator_b.set_type(ui::ET_KEY_PRESSED);
   TestTarget target_b;
   GetController()->Register({accelerator_b}, &target_b);
 
   ui::test::EventGenerator& generator = GetEventGenerator();
   generator.PressKey(ui::VKEY_A, ui::EF_CONTROL_DOWN);
   generator.ReleaseKey(ui::VKEY_A, ui::EF_CONTROL_DOWN);
 
   EXPECT_EQ(1, target_a.accelerator_pressed_count());
   EXPECT_EQ(0, target_a.accelerator_repeat_count());
 
@@ skipping 260 matching lines @@
   AccessibilityDelegate* delegate =
       Shell::GetInstance()->accessibility_delegate();
 
   // The press event should not toggle the AppList, the release should instead.
   EXPECT_FALSE(
       ProcessInController(ui::Accelerator(ui::VKEY_LWIN, ui::EF_NONE)));
   RunAllPendingInMessageLoop();
   EXPECT_EQ(ui::VKEY_LWIN, GetCurrentAccelerator().key_code());
   EXPECT_EQ(0u, test_app_list_presenter.toggle_count());
 
-  EXPECT_TRUE(
-      ProcessInController(ReleaseAccelerator(ui::VKEY_LWIN, ui::EF_NONE)));
+  EXPECT_TRUE(ProcessInController(
+      CreateReleaseAccelerator(ui::VKEY_LWIN, ui::EF_NONE)));
   RunAllPendingInMessageLoop();
   EXPECT_EQ(1u, test_app_list_presenter.toggle_count());
   EXPECT_EQ(ui::VKEY_LWIN, GetPreviousAccelerator().key_code());
 
   // When spoken feedback is on, the AppList should not toggle.
   delegate->ToggleSpokenFeedback(A11Y_NOTIFICATION_NONE);
   EXPECT_FALSE(
       ProcessInController(ui::Accelerator(ui::VKEY_LWIN, ui::EF_NONE)));
-  EXPECT_FALSE(
-      ProcessInController(ReleaseAccelerator(ui::VKEY_LWIN, ui::EF_NONE)));
+  EXPECT_FALSE(ProcessInController(
+      CreateReleaseAccelerator(ui::VKEY_LWIN, ui::EF_NONE)));
   delegate->ToggleSpokenFeedback(A11Y_NOTIFICATION_NONE);
   RunAllPendingInMessageLoop();
   EXPECT_EQ(1u, test_app_list_presenter.toggle_count());
 
   // Turning off spoken feedback should allow the AppList to toggle again.
   EXPECT_FALSE(
       ProcessInController(ui::Accelerator(ui::VKEY_LWIN, ui::EF_NONE)));
-  EXPECT_TRUE(
-      ProcessInController(ReleaseAccelerator(ui::VKEY_LWIN, ui::EF_NONE)));
+  EXPECT_TRUE(ProcessInController(
+      CreateReleaseAccelerator(ui::VKEY_LWIN, ui::EF_NONE)));
   RunAllPendingInMessageLoop();
   EXPECT_EQ(2u, test_app_list_presenter.toggle_count());
 
   // The press of VKEY_BROWSER_SEARCH should toggle the AppList
   EXPECT_TRUE(ProcessInController(
       ui::Accelerator(ui::VKEY_BROWSER_SEARCH, ui::EF_NONE)));
   RunAllPendingInMessageLoop();
   EXPECT_EQ(3u, test_app_list_presenter.toggle_count());
   EXPECT_FALSE(ProcessInController(
-      ReleaseAccelerator(ui::VKEY_BROWSER_SEARCH, ui::EF_NONE)));
+      CreateReleaseAccelerator(ui::VKEY_BROWSER_SEARCH, ui::EF_NONE)));
   RunAllPendingInMessageLoop();
   EXPECT_EQ(3u, test_app_list_presenter.toggle_count());
 }
 
 TEST_F(AcceleratorControllerTest, ImeGlobalAccelerators) {
   // Test IME shortcuts.
   ui::Accelerator control_space_down(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
-  control_space_down.set_type(ui::ET_KEY_PRESSED);
   ui::Accelerator control_space_up(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
-  control_space_up.set_type(ui::ET_KEY_RELEASED);
+  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));
@@ skipping 110 matching lines @@
   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));
   // When you release Search before Alt, the key_code is still VKEY_LWIN and
   // Alt is still the modifier.
-  const ReleaseAccelerator release_search_before_alt(ui::VKEY_LWIN,
-                                                     ui::EF_ALT_DOWN);
+  const ui::Accelerator release_search_before_alt(
+      CreateReleaseAccelerator(ui::VKEY_LWIN, ui::EF_ALT_DOWN));
   EXPECT_TRUE(ProcessInController(release_search_before_alt));
   EXPECT_TRUE(input_method_manager->GetImeKeyboard()->CapsLockIsEnabled());
   input_method_manager->GetImeKeyboard()->SetCapsLockEnabled(false);
 
   // 2. Press Search, Press Alt, Release Search, Release Alt.
   const ui::Accelerator press_search_then_alt(ui::VKEY_MENU,
                                               ui::EF_COMMAND_DOWN);
   EXPECT_FALSE(ProcessInController(press_search_then_alt));
   EXPECT_TRUE(ProcessInController(release_search_before_alt));
   EXPECT_TRUE(input_method_manager->GetImeKeyboard()->CapsLockIsEnabled());
   input_method_manager->GetImeKeyboard()->SetCapsLockEnabled(false);
 
   // 3. Press Alt, Press Search, Release Alt, Release Search.
   EXPECT_FALSE(ProcessInController(press_alt_then_search));
-  const ReleaseAccelerator release_alt_before_search(ui::VKEY_MENU,
-                                                     ui::EF_COMMAND_DOWN);
+  const ui::Accelerator release_alt_before_search(
+      CreateReleaseAccelerator(ui::VKEY_MENU, ui::EF_COMMAND_DOWN));
   EXPECT_TRUE(ProcessInController(release_alt_before_search));
   EXPECT_TRUE(input_method_manager->GetImeKeyboard()->CapsLockIsEnabled());
   input_method_manager->GetImeKeyboard()->SetCapsLockEnabled(false);
 
   // 4. Press Search, Press Alt, Release Alt, Release Search.
   EXPECT_FALSE(ProcessInController(press_search_then_alt));
   EXPECT_TRUE(ProcessInController(release_alt_before_search));
   EXPECT_TRUE(input_method_manager->GetImeKeyboard()->CapsLockIsEnabled());
 }
 
@@ skipping 246 matching lines @@
     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_type(data.trigger_on_press ? ui::ET_KEY_PRESSED
-                                          : ui::ET_KEY_RELEASED);
+    result.set_key_state(data.trigger_on_press
+                             ? ui::Accelerator::KeyState::PRESSED
+                             : ui::Accelerator::KeyState::RELEASED);
     return result;
   }
 
   void ResetStateIfNeeded() {
     if (WmShell::Get()->GetSessionStateDelegate()->IsScreenLocked() ||
         WmShell::Get()->GetSessionStateDelegate()->IsUserSessionBlocked()) {
       UnblockUserSession();
     }
   }
 
@@ skipping 66 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