Process all global shortcuts for Ash after InputMethodEventFilter

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/caps_lock_delegate.h"
 #include "ash/ime_control_delegate.h"
 #include "ash/screenshot_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
@@ skipping 33 matching lines @@
   // Overridden from ui::AcceleratorTarget:
   virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
   virtual bool CanHandleAccelerators() const OVERRIDE;
 
  private:
   int accelerator_pressed_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestTarget);
 };
 
-class PostImeAccelerator : public ui::Accelerator {
+class ReleaseAccelerator : public ui::Accelerator {
  public:
-  PostImeAccelerator(ui::KeyboardCode keycode,
-                     bool shift_pressed, bool ctrl_pressed, bool alt_pressed)
-      : ui::Accelerator(keycode, shift_pressed, ctrl_pressed, alt_pressed) {
-    set_type(ui::ET_TRANSLATED_KEY_PRESS);
-  }
-};
-typedef ui::Accelerator PreImeAccelerator;
-
-class PostImeReleaseAccelerator : public ui::Accelerator {
- public:
-  PostImeReleaseAccelerator(ui::KeyboardCode keycode,
-                           bool shift_pressed,
-                           bool ctrl_pressed,
-                           bool alt_pressed)
-      : ui::Accelerator(keycode, shift_pressed, ctrl_pressed, alt_pressed) {
-    set_type(ui::ET_TRANSLATED_KEY_RELEASE);
-  }
-};
-class PreImeReleaseAccelerator : public ui::Accelerator {
- public:
-  PreImeReleaseAccelerator(ui::KeyboardCode keycode,
-                           bool shift_pressed,
-                           bool ctrl_pressed,
-                           bool alt_pressed)
+  ReleaseAccelerator(ui::KeyboardCode keycode,
+                     bool shift_pressed,
+                     bool ctrl_pressed,
+                     bool alt_pressed)
       : ui::Accelerator(keycode, shift_pressed, ctrl_pressed, alt_pressed) {
     set_type(ui::ET_KEY_RELEASED);
   }
 };
 
 class DummyScreenshotDelegate : public ScreenshotDelegate {
  public:
   DummyScreenshotDelegate()
       : handle_take_screenshot_count_(0),
         handle_take_partial_screenshot_count_(0) {
@@ skipping 288 matching lines @@
   EXPECT_TRUE(GetController()->Process(accelerator_a));
   EXPECT_EQ(1, target1.accelerator_pressed_count());
 
   // The non-registered accelerator is not processed.
   const ui::Accelerator accelerator_b(ui::VKEY_B, false, false, false);
   EXPECT_FALSE(GetController()->Process(accelerator_b));
 }
 
 #if defined(OS_WIN) || defined(USE_X11)
 TEST_F(AcceleratorControllerTest, ProcessOnce) {
-  PostImeAccelerator accelerator_a(ui::VKEY_A, false, false, false);
+  ui::Accelerator accelerator_a(ui::VKEY_A, false, false, false);
   TestTarget target;
   GetController()->Register(accelerator_a, &target);
 
   // The accelerator is processed only once.
 #if defined(OS_WIN)
   MSG msg1 = { NULL, WM_KEYDOWN, ui::VKEY_A, 0 };
   aura::TranslatedKeyEvent key_event1(msg1, false);
   EXPECT_TRUE(Shell::GetRootWindow()->DispatchKeyEvent(&key_event1));
 
   MSG msg2 = { NULL, WM_CHAR, L'A', 0 };
@@ skipping 22 matching lines @@
   aura::TranslatedKeyEvent key_event3(&key_event, false);
   EXPECT_FALSE(Shell::GetRootWindow()->DispatchKeyEvent(&key_event3));
 #endif
   EXPECT_EQ(1, target.accelerator_pressed_count());
 }
 #endif
 
 TEST_F(AcceleratorControllerTest, GlobalAccelerators) {
   // CycleBackward
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_F5, true, false, false)));
+      ui::Accelerator(ui::VKEY_F5, true, false, false)));
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_TAB, true, false, true)));
+      ui::Accelerator(ui::VKEY_TAB, true, false, true)));
   // CycleForward
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_F5, false, false, false)));
+      ui::Accelerator(ui::VKEY_F5, false, false, false)));
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_TAB, false, false, true)));
+      ui::Accelerator(ui::VKEY_TAB, false, false, true)));
   // Take screenshot / partial screenshot
   // True should always be returned regardless of the existence of the delegate.
   {
     EXPECT_TRUE(GetController()->Process(
-        PostImeAccelerator(ui::VKEY_F5, false, true, false)));
+        ui::Accelerator(ui::VKEY_F5, false, true, false)));
     EXPECT_TRUE(GetController()->Process(
-        PostImeAccelerator(ui::VKEY_PRINT, false, false, false)));
+        ui::Accelerator(ui::VKEY_PRINT, false, false, false)));
     EXPECT_TRUE(GetController()->Process(
-        PostImeAccelerator(ui::VKEY_F5, true, true, false)));
+        ui::Accelerator(ui::VKEY_F5, true, true, false)));
     DummyScreenshotDelegate* delegate = new DummyScreenshotDelegate;
     GetController()->SetScreenshotDelegate(
         scoped_ptr<ScreenshotDelegate>(delegate).Pass());
     EXPECT_EQ(0, delegate->handle_take_screenshot_count());
     EXPECT_EQ(0, delegate->handle_take_partial_screenshot_count());
     EXPECT_TRUE(GetController()->Process(
-        PostImeAccelerator(ui::VKEY_F5, false, true, false)));
+        ui::Accelerator(ui::VKEY_F5, false, true, false)));
     EXPECT_EQ(1, delegate->handle_take_screenshot_count());
     EXPECT_EQ(0, delegate->handle_take_partial_screenshot_count());
     EXPECT_TRUE(GetController()->Process(
-        PostImeAccelerator(ui::VKEY_PRINT, false, false, false)));
+        ui::Accelerator(ui::VKEY_PRINT, false, false, false)));
     EXPECT_EQ(2, delegate->handle_take_screenshot_count());
     EXPECT_EQ(0, delegate->handle_take_partial_screenshot_count());
     EXPECT_TRUE(GetController()->Process(
-        PostImeAccelerator(ui::VKEY_F5, true, true, false)));
+        ui::Accelerator(ui::VKEY_F5, true, true, false)));
     EXPECT_EQ(2, delegate->handle_take_screenshot_count());
     EXPECT_EQ(1, delegate->handle_take_partial_screenshot_count());
   }
   // ToggleCapsLock
   {
     EXPECT_FALSE(GetController()->Process(
-        PostImeAccelerator(ui::VKEY_LWIN, true, false, false)));
+        ui::Accelerator(ui::VKEY_LWIN, true, false, false)));
     DummyCapsLockDelegate* delegate = new DummyCapsLockDelegate(false);
     GetController()->SetCapsLockDelegate(
         scoped_ptr<CapsLockDelegate>(delegate).Pass());
     EXPECT_EQ(0, delegate->handle_caps_lock_count());
     EXPECT_FALSE(GetController()->Process(
-        PostImeAccelerator(ui::VKEY_LWIN, true, false, false)));
+        ui::Accelerator(ui::VKEY_LWIN, true, false, false)));
     EXPECT_EQ(1, delegate->handle_caps_lock_count());
   }
   {
     DummyCapsLockDelegate* delegate = new DummyCapsLockDelegate(true);
     GetController()->SetCapsLockDelegate(
         scoped_ptr<CapsLockDelegate>(delegate).Pass());
     EXPECT_EQ(0, delegate->handle_caps_lock_count());
     EXPECT_TRUE(GetController()->Process(
-        PostImeAccelerator(ui::VKEY_LWIN, true, false, false)));
+        ui::Accelerator(ui::VKEY_LWIN, true, false, false)));
     EXPECT_EQ(1, delegate->handle_caps_lock_count());
   }
   // Volume
-  const PostImeAccelerator f8(ui::VKEY_F8, false, false, false);
-  const PostImeAccelerator f9(ui::VKEY_F9, false, false, false);
-  const PostImeAccelerator f10(ui::VKEY_F10, false, false, false);
+  const ui::Accelerator f8(ui::VKEY_F8, false, false, false);
+  const ui::Accelerator f9(ui::VKEY_F9, false, false, false);
+  const ui::Accelerator f10(ui::VKEY_F10, false, false, false);
   {
     EXPECT_FALSE(GetController()->Process(f8));
     EXPECT_FALSE(GetController()->Process(f9));
     EXPECT_FALSE(GetController()->Process(f10));
     DummyVolumeControlDelegate* delegate =
         new DummyVolumeControlDelegate(false);
     GetController()->SetVolumeControlDelegate(
         scoped_ptr<VolumeControlDelegate>(delegate).Pass());
     EXPECT_EQ(0, delegate->handle_volume_mute_count());
     EXPECT_FALSE(GetController()->Process(f8));
@@ skipping 18 matching lines @@
     EXPECT_EQ(f8, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_volume_down_count());
     EXPECT_TRUE(GetController()->Process(f9));
     EXPECT_EQ(1, delegate->handle_volume_down_count());
     EXPECT_EQ(f9, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_volume_up_count());
     EXPECT_TRUE(GetController()->Process(f10));
     EXPECT_EQ(1, delegate->handle_volume_up_count());
     EXPECT_EQ(f10, delegate->last_accelerator());
   }
-  const PostImeAccelerator volume_mute(
+  const ui::Accelerator volume_mute(
       ui::VKEY_VOLUME_MUTE, false, false, false);
-  const PostImeAccelerator volume_down(
+  const ui::Accelerator volume_down(
       ui::VKEY_VOLUME_DOWN, false, false, false);
-  const PostImeAccelerator volume_up(ui::VKEY_VOLUME_UP, false, false, false);
+  const ui::Accelerator volume_up(ui::VKEY_VOLUME_UP, false, false, false);
   {
     DummyVolumeControlDelegate* delegate =
         new DummyVolumeControlDelegate(false);
     GetController()->SetVolumeControlDelegate(
         scoped_ptr<VolumeControlDelegate>(delegate).Pass());
     EXPECT_EQ(0, delegate->handle_volume_mute_count());
     EXPECT_FALSE(GetController()->Process(volume_mute));
     EXPECT_EQ(1, delegate->handle_volume_mute_count());
     EXPECT_EQ(volume_mute, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_volume_down_count());
@@ skipping 16 matching lines @@
     EXPECT_EQ(0, delegate->handle_volume_down_count());
     EXPECT_TRUE(GetController()->Process(volume_down));
     EXPECT_EQ(1, delegate->handle_volume_down_count());
     EXPECT_EQ(volume_down, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_volume_up_count());
     EXPECT_TRUE(GetController()->Process(volume_up));
     EXPECT_EQ(1, delegate->handle_volume_up_count());
     EXPECT_EQ(volume_up, delegate->last_accelerator());
   }
   // Brightness
-  const PostImeAccelerator f6(ui::VKEY_F6, false, false, false);
-  const PostImeAccelerator f7(ui::VKEY_F7, false, false, false);
+  const ui::Accelerator f6(ui::VKEY_F6, false, false, false);
+  const ui::Accelerator f7(ui::VKEY_F7, false, false, false);
   {
     EXPECT_FALSE(GetController()->Process(f6));
     EXPECT_FALSE(GetController()->Process(f7));
     DummyBrightnessControlDelegate* delegate =
         new DummyBrightnessControlDelegate(false);
     GetController()->SetBrightnessControlDelegate(
         scoped_ptr<BrightnessControlDelegate>(delegate).Pass());
     EXPECT_EQ(0, delegate->handle_brightness_down_count());
     EXPECT_FALSE(GetController()->Process(f6));
     EXPECT_EQ(1, delegate->handle_brightness_down_count());
@@ skipping 12 matching lines @@
     EXPECT_TRUE(GetController()->Process(f6));
     EXPECT_EQ(1, delegate->handle_brightness_down_count());
     EXPECT_EQ(f6, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_brightness_up_count());
     EXPECT_TRUE(GetController()->Process(f7));
     EXPECT_EQ(1, delegate->handle_brightness_up_count());
     EXPECT_EQ(f7, delegate->last_accelerator());
   }
 #if defined(OS_CHROMEOS)
   // ui::VKEY_BRIGHTNESS_DOWN/UP are not defined on Windows.
-  const PostImeAccelerator brightness_down(
+  const ui::Accelerator brightness_down(
       ui::VKEY_BRIGHTNESS_DOWN, false, false, false);
-  const PostImeAccelerator brightness_up(
+  const ui::Accelerator brightness_up(
       ui::VKEY_BRIGHTNESS_UP, false, false, false);
   {
     DummyBrightnessControlDelegate* delegate =
         new DummyBrightnessControlDelegate(false);
     GetController()->SetBrightnessControlDelegate(
         scoped_ptr<BrightnessControlDelegate>(delegate).Pass());
     EXPECT_EQ(0, delegate->handle_brightness_down_count());
     EXPECT_FALSE(GetController()->Process(brightness_down));
     EXPECT_EQ(1, delegate->handle_brightness_down_count());
     EXPECT_EQ(brightness_down, delegate->last_accelerator());
@@ skipping 13 matching lines @@
     EXPECT_EQ(brightness_down, delegate->last_accelerator());
     EXPECT_EQ(0, delegate->handle_brightness_up_count());
     EXPECT_TRUE(GetController()->Process(brightness_up));
     EXPECT_EQ(1, delegate->handle_brightness_up_count());
     EXPECT_EQ(brightness_up, delegate->last_accelerator());
   }
 #endif
 #if !defined(NDEBUG)
   // RotateScreen
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_HOME, false, true, false)));
+      ui::Accelerator(ui::VKEY_HOME, false, true, false)));
   // ToggleDesktopBackgroundMode
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_B, false, true, true)));
+      ui::Accelerator(ui::VKEY_B, false, true, true)));
 #if !defined(OS_LINUX)
   // ToggleDesktopFullScreen (not implemented yet on Linux)
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_F11, false, true, false)));
+      ui::Accelerator(ui::VKEY_F11, false, true, false)));
 #endif //  OS_LINUX
 #endif //  !NDEBUG
 
   // Exit
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_Q, true, true ,false)));
+      ui::Accelerator(ui::VKEY_Q, true, true ,false)));
 
   // New incognito window
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_N, true, true, false)));
+      ui::Accelerator(ui::VKEY_N, true, true, false)));
 
   // New window
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_N, false, true, false)));
+      ui::Accelerator(ui::VKEY_N, false, true, false)));
 
 #if defined(OS_CHROMEOS)
   EXPECT_TRUE(GetController()->Process(
-      PostImeAccelerator(ui::VKEY_L, true, true, false)));
+      ui::Accelerator(ui::VKEY_L, true, true, false)));
 #endif
 }
 
-TEST_F(AcceleratorControllerTest, GlobalAcceleratorsPreIme) {
-  // Make sure post-IME shortcuts are ignored in the pre-IME phase.
-  {
-    const PreImeAccelerator f8(ui::VKEY_F8, false, false, false);
-    const PostImeAccelerator f8_post(ui::VKEY_F8, false, false, false);
-    DummyVolumeControlDelegate* delegate = new DummyVolumeControlDelegate(true);
-    GetController()->SetVolumeControlDelegate(
-        scoped_ptr<VolumeControlDelegate>(delegate).Pass());
-    EXPECT_EQ(0, delegate->handle_volume_mute_count());
-    EXPECT_FALSE(GetController()->Process(f8));
-    EXPECT_EQ(0, delegate->handle_volume_mute_count());
-    EXPECT_TRUE(GetController()->Process(f8_post));
-    EXPECT_EQ(1, delegate->handle_volume_mute_count());
-  }
-
+TEST_F(AcceleratorControllerTest, ImeGlobalAccelerators) {
   // Test IME shortcuts.
   {
     const ui::Accelerator control_space(ui::VKEY_SPACE, false, true, false);
     const ui::Accelerator convert(ui::VKEY_CONVERT, false, false, false);
     const ui::Accelerator non_convert(ui::VKEY_NONCONVERT, false, false, false);
     const ui::Accelerator wide_half_1(
         ui::VKEY_DBE_SBCSCHAR, false, false, false);
     const ui::Accelerator wide_half_2(
         ui::VKEY_DBE_DBCSCHAR, false, false, false);
     const ui::Accelerator hangul(ui::VKEY_HANGUL, false, false, false);
@@ skipping 17 matching lines @@
     EXPECT_TRUE(GetController()->Process(non_convert));
     EXPECT_EQ(2, delegate->handle_switch_ime_count());
     EXPECT_TRUE(GetController()->Process(wide_half_1));
     EXPECT_EQ(3, delegate->handle_switch_ime_count());
     EXPECT_TRUE(GetController()->Process(wide_half_2));
     EXPECT_EQ(4, delegate->handle_switch_ime_count());
     EXPECT_TRUE(GetController()->Process(hangul));
     EXPECT_EQ(5, delegate->handle_switch_ime_count());
     EXPECT_TRUE(GetController()->Process(shift_space));
     EXPECT_EQ(6, delegate->handle_switch_ime_count());
-
-    // Make sure pre-IME shortcuts are ignored in the post-IME phase.
-    const PostImeAccelerator control_space_post(
-        ui::VKEY_SPACE, false, true, false);
-    const PostImeAccelerator convert_post(
-        ui::VKEY_CONVERT, false, false, false);
-    const PostImeAccelerator non_convert_post(
-        ui::VKEY_NONCONVERT, false, false, false);
-    const PostImeAccelerator wide_half_1_post(
-        ui::VKEY_DBE_SBCSCHAR, false, false, false);
-    const PostImeAccelerator wide_half_2_post(
-        ui::VKEY_DBE_DBCSCHAR, false, false, false);
-    const PostImeAccelerator hangul_post(ui::VKEY_HANGUL, false, false, false);
-    const PostImeAccelerator shift_space_post(
-        ui::VKEY_SPACE, true, false, false);
-    EXPECT_EQ(1, delegate->handle_previous_ime_count());
-    EXPECT_FALSE(GetController()->Process(control_space_post));
-    EXPECT_EQ(1, delegate->handle_previous_ime_count());
-    EXPECT_EQ(6, delegate->handle_switch_ime_count());
-    EXPECT_FALSE(GetController()->Process(convert_post));
-    EXPECT_EQ(6, delegate->handle_switch_ime_count());
-    EXPECT_FALSE(GetController()->Process(non_convert_post));
-    EXPECT_EQ(6, delegate->handle_switch_ime_count());
-    EXPECT_FALSE(GetController()->Process(wide_half_1_post));
-    EXPECT_EQ(6, delegate->handle_switch_ime_count());
-    EXPECT_FALSE(GetController()->Process(wide_half_2_post));
-    EXPECT_EQ(6, delegate->handle_switch_ime_count());
-    EXPECT_FALSE(GetController()->Process(hangul_post));
-    EXPECT_EQ(6, delegate->handle_switch_ime_count());
-    EXPECT_FALSE(GetController()->Process(shift_space_post));
-    EXPECT_EQ(6, delegate->handle_switch_ime_count());
   }
 
   // Test IME shortcuts that are triggered on key release.
   {
-    const PreImeAccelerator shift_alt_press(ui::VKEY_MENU, true, false, true);
-    const PostImeAccelerator shift_alt_press_post(
-        ui::VKEY_MENU, true, false, true);
-    const PreImeReleaseAccelerator shift_alt(ui::VKEY_MENU, true, false, true);
-
-    const PreImeAccelerator alt_shift_press(ui::VKEY_SHIFT, true, false, true);
-    const PostImeAccelerator alt_shift_press_post(
-        ui::VKEY_SHIFT, true, false, true);
-    const PreImeReleaseAccelerator alt_shift(ui::VKEY_SHIFT, true, false, true);
+    const ui::Accelerator shift_alt_press(ui::VKEY_MENU, true, false, true);
+    const ReleaseAccelerator shift_alt(ui::VKEY_MENU, true, false, true);
+    const ui::Accelerator alt_shift_press(ui::VKEY_SHIFT, true, false, true);
+    const ReleaseAccelerator alt_shift(ui::VKEY_SHIFT, true, false, true);
 
     DummyImeControlDelegate* delegate = new DummyImeControlDelegate(true);
     GetController()->SetImeControlDelegate(
         scoped_ptr<ImeControlDelegate>(delegate).Pass());
     EXPECT_EQ(0, delegate->handle_next_ime_count());
     EXPECT_FALSE(GetController()->Process(shift_alt_press));
-    EXPECT_FALSE(GetController()->Process(shift_alt_press_post));
     EXPECT_FALSE(GetController()->Process(shift_alt));  // crbug.com/123720
     EXPECT_EQ(1, delegate->handle_next_ime_count());
     EXPECT_FALSE(GetController()->Process(alt_shift_press));
-    EXPECT_FALSE(GetController()->Process(alt_shift_press_post));
     EXPECT_FALSE(GetController()->Process(alt_shift));  // crbug.com/123720
     EXPECT_EQ(2, delegate->handle_next_ime_count());
 
     // We should NOT switch IME when e.g. Shift+Alt+X is pressed and X is
     // released.
-    const PreImeAccelerator shift_alt_x_press(ui::VKEY_X, true, false, true);
-    const PostImeAccelerator shift_alt_x_press_post(
-        ui::VKEY_X, true, false, true);
-    const PreImeReleaseAccelerator shift_alt_x(ui::VKEY_X, true, false, true);
-    const PostImeReleaseAccelerator shift_alt_x_post(
-        ui::VKEY_X, true, false, true);
+    const ui::Accelerator shift_alt_x_press(ui::VKEY_X, true, false, true);
+    const ReleaseAccelerator shift_alt_x(ui::VKEY_X, true, false, true);
 
     EXPECT_FALSE(GetController()->Process(shift_alt_press));
-    EXPECT_FALSE(GetController()->Process(shift_alt_press_post));
     EXPECT_FALSE(GetController()->Process(shift_alt_x_press));
-    EXPECT_FALSE(GetController()->Process(shift_alt_x_press_post));
     EXPECT_FALSE(GetController()->Process(shift_alt_x));
-    EXPECT_FALSE(GetController()->Process(shift_alt_x_post));
     EXPECT_FALSE(GetController()->Process(shift_alt));
     EXPECT_EQ(2, delegate->handle_next_ime_count());
   }
 }
 
 }  // namespace test
 }  // namespace ash