wip: Add ui::EventType parameter.

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 ReleaseAccelerator : public ui::Accelerator {
- public:
-  ReleaseAccelerator(ui::KeyboardCode keycode, int modifiers)
-      : ui::Accelerator(keycode, modifiers) {
-    set_type(ui::ET_KEY_RELEASED);
-  }
-};
-
 class DummyScreenshotDelegate : public ScreenshotDelegate {
  public:
   DummyScreenshotDelegate()
       : handle_take_screenshot_count_(0),
         handle_take_partial_screenshot_count_(0) {
   }
   virtual ~DummyScreenshotDelegate() {}
 
   // Overridden from ScreenshotDelegate:
   virtual void HandleTakeScreenshot(aura::Window* window) OVERRIDE {
@@ skipping 205 matching lines @@
   virtual ~AcceleratorControllerTest() {};
 
   static AcceleratorController* GetController();
 };
 
 AcceleratorController* AcceleratorControllerTest::GetController() {
   return Shell::GetInstance()->accelerator_controller();
 }
 
 TEST_F(AcceleratorControllerTest, Register) {
-  const ui::Accelerator accelerator_a(ui::VKEY_A, ui::EF_NONE);
+  const ui::Accelerator accelerator_a(ui::VKEY_A,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
   TestTarget target;
   GetController()->Register(accelerator_a, &target);
 
   // The registered accelerator is processed.
   EXPECT_TRUE(GetController()->Process(accelerator_a));
   EXPECT_EQ(1, target.accelerator_pressed_count());
 }
 
 TEST_F(AcceleratorControllerTest, RegisterMultipleTarget) {
-  const ui::Accelerator accelerator_a(ui::VKEY_A, ui::EF_NONE);
+  const ui::Accelerator accelerator_a(ui::VKEY_A,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
   TestTarget target1;
   GetController()->Register(accelerator_a, &target1);
   TestTarget target2;
   GetController()->Register(accelerator_a, &target2);
 
   // If multiple targets are registered with the same accelerator, the target
   // registered later processes the accelerator.
   EXPECT_TRUE(GetController()->Process(accelerator_a));
   EXPECT_EQ(0, target1.accelerator_pressed_count());
   EXPECT_EQ(1, target2.accelerator_pressed_count());
 }
 
 TEST_F(AcceleratorControllerTest, Unregister) {
-  const ui::Accelerator accelerator_a(ui::VKEY_A, ui::EF_NONE);
+  const ui::Accelerator accelerator_a(ui::VKEY_A,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
   TestTarget target;
   GetController()->Register(accelerator_a, &target);
-  const ui::Accelerator accelerator_b(ui::VKEY_B, ui::EF_NONE);
+  const ui::Accelerator accelerator_b(ui::VKEY_B,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
   GetController()->Register(accelerator_b, &target);
 
   // Unregistering a different accelerator does not affect the other
   // accelerator.
   GetController()->Unregister(accelerator_b, &target);
   EXPECT_TRUE(GetController()->Process(accelerator_a));
   EXPECT_EQ(1, target.accelerator_pressed_count());
 
   // The unregistered accelerator is no longer processed.
   target.set_accelerator_pressed_count(0);
   GetController()->Unregister(accelerator_a, &target);
   EXPECT_FALSE(GetController()->Process(accelerator_a));
   EXPECT_EQ(0, target.accelerator_pressed_count());
 }
 
 TEST_F(AcceleratorControllerTest, UnregisterAll) {
-  const ui::Accelerator accelerator_a(ui::VKEY_A, ui::EF_NONE);
+  const ui::Accelerator accelerator_a(ui::VKEY_A,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
   TestTarget target1;
   GetController()->Register(accelerator_a, &target1);
-  const ui::Accelerator accelerator_b(ui::VKEY_B, ui::EF_NONE);
+  const ui::Accelerator accelerator_b(ui::VKEY_B,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
   GetController()->Register(accelerator_b, &target1);
-  const ui::Accelerator accelerator_c(ui::VKEY_C, ui::EF_NONE);
+  const ui::Accelerator accelerator_c(ui::VKEY_C,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
   TestTarget target2;
   GetController()->Register(accelerator_c, &target2);
   GetController()->UnregisterAll(&target1);
 
   // All the accelerators registered for |target1| are no longer processed.
   EXPECT_FALSE(GetController()->Process(accelerator_a));
   EXPECT_FALSE(GetController()->Process(accelerator_b));
   EXPECT_EQ(0, target1.accelerator_pressed_count());
 
   // UnregisterAll with a different target does not affect the other target.
   EXPECT_TRUE(GetController()->Process(accelerator_c));
   EXPECT_EQ(1, target2.accelerator_pressed_count());
 }
 
 TEST_F(AcceleratorControllerTest, Process) {
-  const ui::Accelerator accelerator_a(ui::VKEY_A, ui::EF_NONE);
+  const ui::Accelerator accelerator_a(ui::VKEY_A,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
   TestTarget target1;
   GetController()->Register(accelerator_a, &target1);
 
   // The registered accelerator is processed.
   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, ui::EF_NONE);
+  const ui::Accelerator accelerator_b(ui::VKEY_B,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
   EXPECT_FALSE(GetController()->Process(accelerator_b));
 }
 
 TEST_F(AcceleratorControllerTest, IsRegistered) {
-  const ui::Accelerator accelerator_a(ui::VKEY_A, ui::EF_NONE);
-  const ui::Accelerator accelerator_shift_a(ui::VKEY_A, ui::EF_SHIFT_DOWN);
+  const ui::Accelerator accelerator_a(ui::VKEY_A,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
+  const ui::Accelerator accelerator_shift_a(ui::VKEY_A,
+                                            ui::EF_SHIFT_DOWN,
+                                            ui::ET_KEY_PRESSED);
   TestTarget target;
   GetController()->Register(accelerator_a, &target);
   EXPECT_TRUE(GetController()->IsRegistered(accelerator_a));
   EXPECT_FALSE(GetController()->IsRegistered(accelerator_shift_a));
   GetController()->UnregisterAll(&target);
   EXPECT_FALSE(GetController()->IsRegistered(accelerator_a));
 }
 
 #if defined(OS_WIN) || defined(USE_X11)
 TEST_F(AcceleratorControllerTest, ProcessOnce) {
-  ui::Accelerator accelerator_a(ui::VKEY_A, ui::EF_NONE);
+  ui::Accelerator accelerator_a(ui::VKEY_A,
+                                ui::EF_NONE,
+                                ui::ET_KEY_PRESSED);
   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 23 matching lines @@
   EXPECT_FALSE(Shell::GetRootWindow()->DispatchKeyEvent(&key_event3));
 #endif
   EXPECT_EQ(1, target.accelerator_pressed_count());
 }
 #endif
 
 // Disabled due to a real bug, see http://crbug.com/127538.
 TEST_F(AcceleratorControllerTest, DISABLED_GlobalAccelerators) {
   // CycleBackward
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_F5, ui::EF_CONTROL_DOWN)));
+      ui::Accelerator(ui::VKEY_F5, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED)));
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_TAB, ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN)));
+      ui::Accelerator(ui::VKEY_TAB,
+                      ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
+                      ui::ET_KEY_PRESSED)));
   // CycleForward
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_F5, ui::EF_NONE)));
+      ui::Accelerator(ui::VKEY_F5, ui::EF_NONE, ui::ET_KEY_PRESSED)));
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_TAB, ui::EF_ALT_DOWN)));
+      ui::Accelerator(ui::VKEY_TAB, ui::EF_ALT_DOWN, ui::ET_KEY_PRESSED)));
   // Take screenshot / partial screenshot
   // True should always be returned regardless of the existence of the delegate.
   {
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_F5, ui::EF_CONTROL_DOWN)));
+        ui::Accelerator(ui::VKEY_F5, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED)));
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_PRINT, ui::EF_NONE)));
+        ui::Accelerator(ui::VKEY_PRINT, ui::EF_NONE, ui::ET_KEY_PRESSED)));
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_F5, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN)));
+        ui::Accelerator(ui::VKEY_F5,
+                        ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
+                        ui::ET_KEY_PRESSED)));
     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(
-        ui::Accelerator(ui::VKEY_F5, ui::EF_CONTROL_DOWN)));
+        ui::Accelerator(ui::VKEY_F5, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED)));
     EXPECT_EQ(1, delegate->handle_take_screenshot_count());
     EXPECT_EQ(0, delegate->handle_take_partial_screenshot_count());
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_PRINT, ui::EF_NONE)));
+        ui::Accelerator(ui::VKEY_PRINT, ui::EF_NONE, ui::ET_KEY_PRESSED)));
     EXPECT_EQ(2, delegate->handle_take_screenshot_count());
     EXPECT_EQ(0, delegate->handle_take_partial_screenshot_count());
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_F5, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN)));
+        ui::Accelerator(ui::VKEY_F5,
+                        ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
+                        ui::ET_KEY_PRESSED)));
     EXPECT_EQ(2, delegate->handle_take_screenshot_count());
     EXPECT_EQ(1, delegate->handle_take_partial_screenshot_count());
   }
   // ToggleAppList
   {
     EXPECT_FALSE(ash::Shell::GetInstance()->GetAppListTargetVisibility());
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_LWIN, ui::EF_CONTROL_DOWN)));
+        ui::Accelerator(ui::VKEY_LWIN,
+                        ui::EF_CONTROL_DOWN,
+                        ui::ET_KEY_PRESSED)));
     EXPECT_TRUE(ash::Shell::GetInstance()->GetAppListTargetVisibility());
     EXPECT_TRUE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_LWIN, ui::EF_CONTROL_DOWN)));
+        ui::Accelerator(ui::VKEY_LWIN,
+                        ui::EF_CONTROL_DOWN,
+                        ui::ET_KEY_PRESSED)));
     EXPECT_FALSE(ash::Shell::GetInstance()->GetAppListTargetVisibility());
   }
   // ToggleCapsLock
   {
     EXPECT_FALSE(GetController()->Process(
-        ui::Accelerator(ui::VKEY_LWIN, ui::EF_SHIFT_DOWN)));
+        ui::Accelerator(ui::VKEY_LWIN, ui::EF_SHIFT_DOWN, ui::ET_KEY_PRESSED)));
     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, ui::EF_SHIFT_DOWN)));
+        ui::Accelerator(ui::VKEY_LWIN, ui::EF_SHIFT_DOWN, ui::ET_KEY_PRESSED)));
     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, ui::EF_SHIFT_DOWN)));
+        ui::Accelerator(ui::VKEY_LWIN, ui::EF_SHIFT_DOWN, ui::ET_KEY_PRESSED)));
     EXPECT_EQ(1, delegate->handle_caps_lock_count());
   }
   // Volume
-  const ui::Accelerator f8(ui::VKEY_F8, ui::EF_NONE);
-  const ui::Accelerator f9(ui::VKEY_F9, ui::EF_NONE);
-  const ui::Accelerator f10(ui::VKEY_F10, ui::EF_NONE);
+  const ui::Accelerator f8(ui::VKEY_F8, ui::EF_NONE, ui::ET_KEY_PRESSED);
+  const ui::Accelerator f9(ui::VKEY_F9, ui::EF_NONE, ui::ET_KEY_PRESSED);
+  const ui::Accelerator f10(ui::VKEY_F10, ui::EF_NONE, ui::ET_KEY_PRESSED);
   {
     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, ui::EF_NONE);
-  const ui::Accelerator volume_down(ui::VKEY_VOLUME_DOWN, ui::EF_NONE);
-  const ui::Accelerator volume_up(ui::VKEY_VOLUME_UP, ui::EF_NONE);
+  const ui::Accelerator volume_mute(ui::VKEY_VOLUME_MUTE,
+                                    ui::EF_NONE,
+                                    ui::ET_KEY_PRESSED);
+  const ui::Accelerator volume_down(ui::VKEY_VOLUME_DOWN,
+                                    ui::EF_NONE,
+                                    ui::ET_KEY_PRESSED);
+  const ui::Accelerator volume_up(ui::VKEY_VOLUME_UP,
+                                  ui::EF_NONE,
+                                  ui::ET_KEY_PRESSED);
   {
     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, ui::EF_NONE);
-  const ui::Accelerator f7(ui::VKEY_F7, ui::EF_NONE);
+  const ui::Accelerator f6(ui::VKEY_F6, ui::EF_NONE, ui::ET_KEY_PRESSED);
+  const ui::Accelerator f7(ui::VKEY_F7, ui::EF_NONE, ui::ET_KEY_PRESSED);
   {
     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(ui::VKEY_BRIGHTNESS_DOWN, ui::EF_NONE);
-  const ui::Accelerator brightness_up(ui::VKEY_BRIGHTNESS_UP, ui::EF_NONE);
+  const ui::Accelerator brightness_down(ui::VKEY_BRIGHTNESS_DOWN,
+                                        ui::EF_NONE,
+                                        ui::ET_KEY_PRESSED);
+  const ui::Accelerator brightness_up(ui::VKEY_BRIGHTNESS_UP,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
   {
     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());
     EXPECT_EQ(0, delegate->handle_brightness_up_count());
@@ skipping 12 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, ui::EF_CONTROL_DOWN)));
+      ui::Accelerator(ui::VKEY_HOME, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED)));
   // ToggleDesktopBackgroundMode
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_B, ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN)));
+      ui::Accelerator(ui::VKEY_B,
+                      ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN,
+                      ui::ET_KEY_PRESSED)));
 #if !defined(OS_LINUX)
   // ToggleDesktopFullScreen (not implemented yet on Linux)
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_F11, ui::EF_CONTROL_DOWN)));
+      ui::Accelerator(ui::VKEY_F11, ui::EF_CONTROL_DOWN, ui::ET_KEY_PRESSED)));
 #endif //  OS_LINUX
 #endif //  !NDEBUG
 
   // Exit
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_Q, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN)));
+      ui::Accelerator(ui::VKEY_Q,
+                      ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
+                      ui::ET_KEY_PRESSED)));
 
   // New incognito window
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_N, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN)));
+      ui::Accelerator(ui::VKEY_N,
+                      ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
+                      ui::ET_KEY_PRESSED)));
 
   // New window
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_N, ui::EF_CONTROL_DOWN)));
+      ui::Accelerator(ui::VKEY_N,
+                      ui::EF_CONTROL_DOWN,
+                      ui::ET_KEY_PRESSED)));
 
 #if defined(OS_CHROMEOS)
   EXPECT_TRUE(GetController()->Process(
-      ui::Accelerator(ui::VKEY_L, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN)));
+      ui::Accelerator(ui::VKEY_L,
+                      ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN,
+                      ui::ET_KEY_PRESSED)));
 #endif
 }
 
 TEST_F(AcceleratorControllerTest, ImeGlobalAccelerators) {
   // Test IME shortcuts.
   {
-    const ui::Accelerator control_space(ui::VKEY_SPACE, ui::EF_CONTROL_DOWN);
-    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);
-    const ui::Accelerator shift_space(ui::VKEY_SPACE, ui::EF_SHIFT_DOWN);
+    const ui::Accelerator control_space(ui::VKEY_SPACE,
+                                        ui::EF_CONTROL_DOWN,
+                                        ui::ET_KEY_PRESSED);
+    const ui::Accelerator convert(ui::VKEY_CONVERT,
+                                  ui::EF_NONE,
+                                  ui::ET_KEY_PRESSED);
+    const ui::Accelerator non_convert(ui::VKEY_NONCONVERT,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
+    const ui::Accelerator wide_half_1(ui::VKEY_DBE_SBCSCHAR,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
+    const ui::Accelerator wide_half_2(ui::VKEY_DBE_DBCSCHAR,
+                                      ui::EF_NONE,
+                                      ui::ET_KEY_PRESSED);
+    const ui::Accelerator hangul(ui::VKEY_HANGUL,
+                                 ui::EF_NONE,
+                                 ui::ET_KEY_PRESSED);
+    const ui::Accelerator shift_space(ui::VKEY_SPACE,
+                                      ui::EF_SHIFT_DOWN,
+                                      ui::ET_KEY_PRESSED);
     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());
@@ skipping 11 matching lines @@
     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());
   }
 
   // Test IME shortcuts that are triggered on key release.
   {
     const ui::Accelerator shift_alt_press(ui::VKEY_MENU,
-                                          ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
-    const ReleaseAccelerator shift_alt(ui::VKEY_MENU,
-                                       ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
+                                          ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
+                                          ui::ET_KEY_PRESSED);
+    const ui::Accelerator shift_alt(ui::VKEY_MENU,
+                                    ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
+                                    ui::ET_KEY_RELEASED);
     const ui::Accelerator alt_shift_press(ui::VKEY_SHIFT,
-                                          ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
-    const ReleaseAccelerator alt_shift(ui::VKEY_SHIFT,
-                                       ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN);
+                                          ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
+                                          ui::ET_KEY_PRESSED);
+    const ui::Accelerator alt_shift(ui::VKEY_SHIFT,
+                                    ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
+                                    ui::ET_KEY_RELEASED);
 
     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_TRUE(GetController()->Process(shift_alt));
     EXPECT_EQ(1, delegate->handle_next_ime_count());
     EXPECT_FALSE(GetController()->Process(alt_shift_press));
     EXPECT_TRUE(GetController()->Process(alt_shift));
     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 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);
+    const ui::Accelerator shift_alt_x_press(
+        ui::VKEY_X,
+        ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
+        ui::ET_KEY_PRESSED);
+    const ui::Accelerator shift_alt_x(ui::VKEY_X,
+                                      ui::EF_SHIFT_DOWN | ui::EF_ALT_DOWN,
+                                      ui::ET_KEY_RELEASED);
 
     EXPECT_FALSE(GetController()->Process(shift_alt_press));
     EXPECT_FALSE(GetController()->Process(shift_alt_x_press));
     EXPECT_FALSE(GetController()->Process(shift_alt_x));
     EXPECT_FALSE(GetController()->Process(shift_alt));
     EXPECT_EQ(2, delegate->handle_next_ime_count());
   }
 }
 
 }  // namespace test
 }  // namespace ash