Deprecate Shift+Alt to switch IME and use Ctrl+Shift+Space instead.

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/ash_switches.h"
 #include "ash/display/display_manager.h"
@@ skipping 212 matching lines @@
   ~AcceleratorControllerTest() override {}
 
  protected:
   void EnableInternalDisplay() {
     test::DisplayManagerTestApi().SetFirstDisplayAsInternalDisplay();
   }
 
   static AcceleratorController* GetController();
 
   static bool ProcessInController(const ui::Accelerator& accelerator) {
+    if (accelerator.type() == ui::ET_KEY_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);
+      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 845 matching lines @@
     // released.
     const ui::Accelerator shift_alt_x_press(
         ui::VKEY_X,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
     const ReleaseAccelerator shift_alt_x(ui::VKEY_X,
                                          ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
 
     EXPECT_FALSE(ProcessInController(shift_alt_press));
     EXPECT_FALSE(ProcessInController(shift_alt_x_press));
     EXPECT_FALSE(ProcessInController(shift_alt_x));
-    EXPECT_FALSE(ProcessInController(shift_alt));
-    EXPECT_EQ(2, delegate->handle_next_ime_count());
+    EXPECT_TRUE(ProcessInController(shift_alt));
+    EXPECT_EQ(3, delegate->handle_next_ime_count());
 
     // But we _should_ if X is either VKEY_RETURN or VKEY_SPACE.
     // TODO(nona|mazda): Remove this when crbug.com/139556 in a better way.
     const ui::Accelerator shift_alt_return_press(
         ui::VKEY_RETURN,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
     const ReleaseAccelerator shift_alt_return(
         ui::VKEY_RETURN,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
 
     EXPECT_FALSE(ProcessInController(shift_alt_press));
     EXPECT_FALSE(ProcessInController(shift_alt_return_press));
     EXPECT_FALSE(ProcessInController(shift_alt_return));
     EXPECT_TRUE(ProcessInController(shift_alt));
-    EXPECT_EQ(3, delegate->handle_next_ime_count());
+    EXPECT_EQ(4, delegate->handle_next_ime_count());
 
     const ui::Accelerator shift_alt_space_press(
         ui::VKEY_SPACE,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
     const ReleaseAccelerator shift_alt_space(
         ui::VKEY_SPACE,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
 
     EXPECT_FALSE(ProcessInController(shift_alt_press));
     EXPECT_FALSE(ProcessInController(shift_alt_space_press));
     EXPECT_FALSE(ProcessInController(shift_alt_space));
     EXPECT_TRUE(ProcessInController(shift_alt));
-    EXPECT_EQ(4, delegate->handle_next_ime_count());
+    EXPECT_EQ(5, delegate->handle_next_ime_count());
   }
 
 #if defined(OS_CHROMEOS)
   // Test IME shortcuts again with unnormalized accelerators (Chrome OS only).
   {
     const ui::Accelerator shift_alt_press(ui::VKEY_MENU, ui::EF_SHIFT_DOWN);
     const ReleaseAccelerator shift_alt(ui::VKEY_MENU, ui::EF_SHIFT_DOWN);
     const ui::Accelerator alt_shift_press(ui::VKEY_SHIFT, ui::EF_ALT_DOWN);
     const ReleaseAccelerator alt_shift(ui::VKEY_SHIFT, ui::EF_ALT_DOWN);
 
@@ skipping 12 matching lines @@
     // released.
     const ui::Accelerator shift_alt_x_press(
         ui::VKEY_X,
         ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
     const ReleaseAccelerator shift_alt_x(ui::VKEY_X,
                                          ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
 
     EXPECT_FALSE(ProcessInController(shift_alt_press));
     EXPECT_FALSE(ProcessInController(shift_alt_x_press));
     EXPECT_FALSE(ProcessInController(shift_alt_x));
-    EXPECT_FALSE(ProcessInController(shift_alt));
-    EXPECT_EQ(2, delegate->handle_next_ime_count());
+    EXPECT_TRUE(ProcessInController(shift_alt));
+    EXPECT_EQ(3, delegate->handle_next_ime_count());
   }
 #endif
 }
 
 // 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,
@@ skipping 301 matching lines @@
 
 #if defined(OS_CHROMEOS)
 namespace {
 
 // defines a class to test the behavior of deprecated accelerators.
 class DeprecatedAcceleratorTester : public AcceleratorControllerTest {
  public:
   DeprecatedAcceleratorTester() {}
   ~DeprecatedAcceleratorTester() override {}
 
+  void SetUp() override {
+    AcceleratorControllerTest::SetUp();
+
+    // For testing the deprecated and new IME shortcuts.
+    DummyImeControlDelegate* delegate = new DummyImeControlDelegate;
+    GetController()->SetImeControlDelegate(
+        scoped_ptr<ImeControlDelegate>(delegate).Pass());
+  }
+
   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);
     return result;
   }
 
   void ResetStateIfNeeded() {
     Shell* shell = Shell::GetInstance();
     if (shell->session_state_delegate()->IsScreenLocked() ||
@@ skipping 19 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeprecatedAcceleratorTester);
 };
 
 }  // namespace
 
 TEST_F(DeprecatedAcceleratorTester, TestDeprecatedAcceleratorsBehavior) {
   for (size_t i = 0; i < kDeprecatedAcceleratorsLength; ++i) {
-    const DeprecatedAcceleratorData& data = kDeprecatedAccelerators[i];
+    const AcceleratorData& entry = kDeprecatedAccelerators[i];
+
+    auto itr = GetController()->actions_with_deprecations_.find(entry.action);
+    ASSERT_TRUE(itr != GetController()->actions_with_deprecations_.end());
+    const DeprecatedAcceleratorData* data = itr->second;
 
     EXPECT_TRUE(IsMessageCenterEmpty());
-
-    ui::Accelerator deprecated_accelerator =
-        CreateAccelerator(data.deprecated_accelerator);
-    if (data.deprecated_enabled)
+    ui::Accelerator deprecated_accelerator = CreateAccelerator(entry);
+    if (data->deprecated_enabled)
       EXPECT_TRUE(ProcessInController(deprecated_accelerator));
     else
       EXPECT_FALSE(ProcessInController(deprecated_accelerator));
 
     // We expect to see a notification in the message center.
     EXPECT_TRUE(
-        ContainsDeprecatedAcceleratorNotification(data.uma_histogram_name));
+        ContainsDeprecatedAcceleratorNotification(data->uma_histogram_name));
     RemoveAllNotifications();
 
     // If the action is LOCK_SCREEN, we must reset the state by unlocking the
     // screen before we proceed testing the rest of accelerators.
     ResetStateIfNeeded();
   }
 }
 
 TEST_F(DeprecatedAcceleratorTester, TestNewAccelerators) {
   // Add below the new accelerators that replaced the deprecated ones (if any).
   const AcceleratorData kNewAccelerators[] = {
       {true, ui::VKEY_L, ui::EF_COMMAND_DOWN, LOCK_SCREEN},
+      {true, ui::VKEY_SPACE, ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN, NEXT_IME},
       {true, ui::VKEY_ESCAPE, ui::EF_COMMAND_DOWN, SHOW_TASK_MANAGER},
   };
 
   EXPECT_TRUE(IsMessageCenterEmpty());
 
   for (auto data : kNewAccelerators) {
     EXPECT_TRUE(ProcessInController(CreateAccelerator(data)));
 
     // 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();
   }
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace ash