Move IME shortcut keys from X to Aura [part 1 of 3].

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/brightness_control_delegate.h"
 #include "ash/caps_lock_delegate.h"
 #include "ash/ime/event.h"
+#include "ash/ime_control_delegate.h"
 #include "ash/screenshot_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/aura_shell_test_base.h"
 #include "ash/volume_control_delegate.h"
 #include "ash/wm/window_util.h"
 #include "ui/aura/event.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
@@ skipping 25 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 {
+ 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 DummyScreenshotDelegate : public ScreenshotDelegate {
  public:
   DummyScreenshotDelegate() : handle_take_screenshot_count_(0) {
   }
   virtual ~DummyScreenshotDelegate() {}
 
   // Overridden from ScreenshotDelegate:
   virtual void HandleTakeScreenshot(aura::Window* window) OVERRIDE {
     if (window != NULL)
       ++handle_take_screenshot_count_;
@@ skipping 120 matching lines @@
 
  private:
   const bool consume_;
   int handle_brightness_down_count_;
   int handle_brightness_up_count_;
   ui::Accelerator last_accelerator_;
 
   DISALLOW_COPY_AND_ASSIGN(DummyBrightnessControlDelegate);
 };
 
+class DummyImeControlDelegate : public ImeControlDelegate {
+ public:
+  explicit DummyImeControlDelegate(bool consume)
+      : consume_(consume),
+        handle_next_ime_count_(0),
+        handle_previous_ime_count_(0),
+        handle_switch_ime_count_(0) {
+  }
+  virtual ~DummyImeControlDelegate() {}
+
+  virtual bool HandleNextIme() OVERRIDE {
+    ++handle_next_ime_count_;
+    return consume_;
+  }
+  virtual bool HandlePreviousIme() OVERRIDE {
+    ++handle_previous_ime_count_;
+    return consume_;
+  }
+  virtual bool HandleSwitchIme(const ui::Accelerator& accelerator) OVERRIDE {
+    ++handle_switch_ime_count_;
+    last_accelerator_ = accelerator;
+    return consume_;
+  }
+
+  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_;
+  }
+  const ui::Accelerator& last_accelerator() const {
+    return last_accelerator_;
+  }
+
+ private:
+  const bool consume_;
+  int handle_next_ime_count_;
+  int handle_previous_ime_count_;
+  int handle_switch_ime_count_;
+  ui::Accelerator last_accelerator_;
+
+  DISALLOW_COPY_AND_ASSIGN(DummyImeControlDelegate);
+};
+
 bool TestTarget::AcceleratorPressed(const ui::Accelerator& accelerator) {
   ++accelerator_pressed_count_;
   return true;
 }
 
 bool TestTarget::CanHandleAccelerators() const {
   return true;
 }
 
 }  // namespace
@@ skipping 84 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) {
-  const ui::Accelerator accelerator_a(ui::VKEY_A, false, false, false);
+  PostImeAccelerator 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 };
   TranslatedKeyEvent key_event1(msg1, false);
   EXPECT_TRUE(aura::RootWindow::GetInstance()->DispatchKeyEvent(&key_event1));
 
   MSG msg2 = { NULL, WM_CHAR, L'A', 0 };
@@ skipping 22 matching lines @@
   TranslatedKeyEvent key_event3(&key_event, false);
   EXPECT_FALSE(aura::RootWindow::GetInstance()->DispatchKeyEvent(&key_event3));
 #endif
   EXPECT_EQ(1, target.accelerator_pressed_count());
 }
 #endif
 
 TEST_F(AcceleratorControllerTest, GlobalAccelerators) {
   // CycleBackward
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_F5, true, false, false)));
+      PostImeAccelerator(ui::VKEY_F5, true, false, false)));
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_TAB, true, false, true)));
+      PostImeAccelerator(ui::VKEY_TAB, true, false, true)));
   // CycleForward
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_F5, false, false, false)));
+      PostImeAccelerator(ui::VKEY_F5, false, false, false)));
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_TAB, false, false, true)));
+      PostImeAccelerator(ui::VKEY_TAB, false, false, true)));
   // TakeScreenshot
   // True should always be returned regardless of the existence of the delegate.
   {
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_F5, false, true, false)));
+        PostImeAccelerator(ui::VKEY_F5, false, true, false)));
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_PRINT, false, false, false)));
+        PostImeAccelerator(ui::VKEY_PRINT, false, false, false)));
     DummyScreenshotDelegate* delegate = new DummyScreenshotDelegate;
     GetController()->SetScreenshotDelegate(
         scoped_ptr<ScreenshotDelegate>(delegate).Pass());
     EXPECT_EQ(0, delegate->handle_take_screenshot_count());
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_F5, false, true, false)));
+        PostImeAccelerator(ui::VKEY_F5, false, true, false)));
     EXPECT_EQ(1, delegate->handle_take_screenshot_count());
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_PRINT, false, false, false)));
+        PostImeAccelerator(ui::VKEY_PRINT, false, false, false)));
     EXPECT_EQ(2, delegate->handle_take_screenshot_count());
   }
   // TakePartialScreenshot
   // So far, we just want to make sure the keybind is trapped here.
   {
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_F5, true, true, false)));
+        PostImeAccelerator(ui::VKEY_F5, true, true, false)));
   }
   // ToggleCapsLock
   {
     EXPECT_FALSE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_LWIN, true, false, false)));
+        PostImeAccelerator(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(
-        ui::Accelerator(ui::VKEY_LWIN, true, false, false)));
+        PostImeAccelerator(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(
-        ui::Accelerator(ui::VKEY_LWIN, true, false, false)));
+        PostImeAccelerator(ui::VKEY_LWIN, true, false, false)));
     EXPECT_EQ(1, delegate->handle_caps_lock_count());
   }
   // Volume
-  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);
+  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);
   {
     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 ui::Accelerator volume_mute(ui::VKEY_VOLUME_MUTE, false, false, false);
-  const ui::Accelerator volume_down(ui::VKEY_VOLUME_DOWN, false, false, false);
-  const ui::Accelerator volume_up(ui::VKEY_VOLUME_UP, false, false, false);
+  const PostImeAccelerator volume_mute(
+      ui::VKEY_VOLUME_MUTE, false, false, false);
+  const PostImeAccelerator volume_down(
+      ui::VKEY_VOLUME_DOWN, false, false, false);
+  const PostImeAccelerator 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 ui::Accelerator f6(ui::VKEY_F6, false, false, false);
-  const ui::Accelerator f7(ui::VKEY_F7, false, false, false);
+  const PostImeAccelerator f6(ui::VKEY_F6, false, false, false);
+  const PostImeAccelerator 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 ui::Accelerator brightness_down(
+  const PostImeAccelerator brightness_down(
       ui::VKEY_BRIGHTNESS_DOWN, false, false, false);
-  const ui::Accelerator brightness_up(
+  const PostImeAccelerator 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(
-      ui::Accelerator(ui::VKEY_HOME, false, true, false)));
+      PostImeAccelerator(ui::VKEY_HOME, false, true, false)));
   // ToggleCompactWindowMode
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_A, false, true, true)));
+      PostImeAccelerator(ui::VKEY_A, false, true, true)));
 #if !defined(OS_LINUX)
   // ToggleDesktopFullScreen (not implemented yet on Linux)
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_F11, false, true, false)));
+      PostImeAccelerator(ui::VKEY_F11, false, true, false)));
 #endif
 
   // Exit
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_Q, true, true ,false)));
+      PostImeAccelerator(ui::VKEY_Q, true, true ,false)));
 #endif
 
 #if defined(OS_CHROMEOS)
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_L, true, true, false)));
+      PostImeAccelerator(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 IME shortcuts.
+  {
+    // TODO(yusukes): Add a test for Alt+Shift+Release.
+    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);
+    const ui::Accelerator shift_space(ui::VKEY_SPACE, true, false, false);
+    EXPECT_FALSE(GetController()->Process(control_space));
+    EXPECT_FALSE(GetController()->Process(convert));
+    EXPECT_FALSE(GetController()->Process(non_convert));
+    EXPECT_FALSE(GetController()->Process(wide_half_1));
+    EXPECT_FALSE(GetController()->Process(wide_half_2));
+    EXPECT_FALSE(GetController()->Process(hangul));
+    EXPECT_FALSE(GetController()->Process(shift_space));
+    DummyImeControlDelegate* delegate = new DummyImeControlDelegate(true);
+    GetController()->SetImeControlDelegate(
+        scoped_ptr<ImeControlDelegate>(delegate).Pass());
+    EXPECT_EQ(0, delegate->handle_previous_ime_count());
+    EXPECT_TRUE(GetController()->Process(control_space));
+    EXPECT_EQ(1, delegate->handle_previous_ime_count());
+    EXPECT_EQ(0, delegate->handle_switch_ime_count());
+    EXPECT_TRUE(GetController()->Process(convert));
+    EXPECT_EQ(1, delegate->handle_switch_ime_count());
+    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());
+  }
+}
+
 }  // namespace test
 }  // namespace ash