Register global accelerators and add placeholders for handling them.

ui/aura_shell/shell_accelerator_controller_unittest.cc

Index: ui/aura_shell/shell_accelerator_controller_unittest.cc
diff --git a/ui/aura_shell/shell_accelerator_controller_unittest.cc b/ui/aura_shell/shell_accelerator_controller_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..39e1c6486045eaf07d07bb42a8dc6f985242abfb
--- /dev/null
+++ b/ui/aura_shell/shell_accelerator_controller_unittest.cc
@@ -0,0 +1,171 @@
+// Copyright (c) 2011 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 "ui/aura_shell/shell.h"
+#include "ui/aura_shell/shell_accelerator_controller.h"
+#include "ui/aura_shell/test/aura_shell_test_base.h"
+
+namespace aura_shell {
+namespace test {
+
+namespace {
+class TestTarget : public ui::AcceleratorTarget {
+ public:
+  TestTarget() : accelerator_pressed_(false) {};
+  virtual ~TestTarget() {};
+
+  bool accelerator_pressed() const {
+    return accelerator_pressed_;
+  }
+
+  void set_accelerator_pressed(bool accelerator_pressed) {
+    accelerator_pressed_ = accelerator_pressed;
+  }
+
+  // Overridden from ui::AcceleratorTarget:
+  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
+
+ private:
+  bool accelerator_pressed_;
+};
+
+bool TestTarget::AcceleratorPressed(const ui::Accelerator& accelerator) {
+  set_accelerator_pressed(true);
+  return true;
+}
+
+}  // namespace
+
+class ShellAcceleratorControllerTest : public AuraShellTestBase {
+ public:
+  ShellAcceleratorControllerTest() {};
+  virtual ~ShellAcceleratorControllerTest() {};
+
+  static ShellAcceleratorController* GetController();
+
+  // testing::Test:
+  // virtual void SetUp() OVERRIDE;
+  // virtual void TearDown() OVERRIDE;
+};
+
+ShellAcceleratorController* ShellAcceleratorControllerTest::GetController() {
+  return Shell::GetInstance()->accelerator_controller();
+}
+
+// void ShellAcceleratorControllerTest::SetUp() {
+//   AuraShellTestBase::SetUp();
+// }
+
+// void ShellAcceleratorControllerTest::TearDown() {
+//   AuraShellTestBase::TearDown();
+// }
+
+TEST_F(ShellAcceleratorControllerTest, Register) {
+  const ui::Accelerator accelerator_a(ui::VKEY_A, false, false, false);
+  TestTarget target;
+  GetController()->Register(accelerator_a, &target);
+
+  // The registered accelerator is processed.
+  EXPECT_TRUE(GetController()->Process(accelerator_a));
+  EXPECT_TRUE(target.accelerator_pressed());
+}
+
+TEST_F(ShellAcceleratorControllerTest, RegisterMultipleTarget) {
+  const ui::Accelerator accelerator_a(ui::VKEY_A, false, false, false);
+  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_FALSE(target1.accelerator_pressed());
+  EXPECT_TRUE(target2.accelerator_pressed());
+}
+
+TEST_F(ShellAcceleratorControllerTest, Unregister) {
+  const ui::Accelerator accelerator_a(ui::VKEY_A, false, false, false);
+  TestTarget target;
+  GetController()->Register(accelerator_a, &target);
+  const ui::Accelerator accelerator_b(ui::VKEY_B, false, false, false);
+  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_TRUE(target.accelerator_pressed());
+
+  // The unregistered accelerator is no longer processed.
+  target.set_accelerator_pressed(false);
+  GetController()->Unregister(accelerator_a, &target);
+  EXPECT_FALSE(GetController()->Process(accelerator_a));
+  EXPECT_FALSE(target.accelerator_pressed());
+}
+
+TEST_F(ShellAcceleratorControllerTest, UnregisterAll) {
+  const ui::Accelerator accelerator_a(ui::VKEY_A, false, false, false);
+  TestTarget target1;
+  GetController()->Register(accelerator_a, &target1);
+  const ui::Accelerator accelerator_b(ui::VKEY_B, false, false, false);
+  GetController()->Register(accelerator_b, &target1);
+  const ui::Accelerator accelerator_c(ui::VKEY_C, false, false, false);
+  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_FALSE(target1.accelerator_pressed());
+
+  // UnregisterAll with a different target does not affect the other target.
+  EXPECT_TRUE(GetController()->Process(accelerator_c));
+  EXPECT_TRUE(target2.accelerator_pressed());
+}
+
+TEST_F(ShellAcceleratorControllerTest, Process) {
+  const ui::Accelerator accelerator_a(ui::VKEY_A, false, false, false);
+  TestTarget target1;
+  GetController()->Register(accelerator_a, &target1);
+
+  // The registered accelerator is processed.
+  EXPECT_TRUE(GetController()->Process(accelerator_a));
+  EXPECT_TRUE(target1.accelerator_pressed());
+
+  // The non-registered accelerator is not processed.
+  const ui::Accelerator accelerator_b(ui::VKEY_B, false, false, false);
+  EXPECT_FALSE(GetController()->Process(accelerator_b));
+}
+
+TEST_F(ShellAcceleratorControllerTest, GlobalAccelerators) {
+  // TODO(mazda): Uncomment the followings once they are implemented.
+  // CycleBackward
+  // EXPECT_TRUE(GetController()->Process(
+  //     ui::Accelerator(ui::VKEY_TAB, true, false, true)));
+  // CycleForwrard
+  // EXPECT_TRUE(GetController()->Process(
+  //     ui::Accelerator(ui::VKEY_TAB, false, false, true)));
+  // TakeScreenshot
+  // EXPECT_TRUE(GetController()->Process(
+  //     ui::Accelerator(ui::VKEY_F5, false, true, false)));
+  // EXPECT_TRUE(GetController()->Process(
+  //     ui::Accelerator(ui::VKEY_PRINT, false, false, false)));
+#if !defined(NDEBUG)
+  // TODO(mazda): Callig RotateScreen in unit test causes a crash because of
+  // "pure virtual method called" for some reasons. Need to investigate.
+  // RotateScreen
+  // EXPECT_TRUE(GetController()->Process(
+  //     ui::Accelerator(ui::VKEY_HOME, false, true, false)));
+#if !defined(OS_LINUX)
+  // ToggleDesktopFullScreen (not implemented yet on Linux)
+  EXPECT_TRUE(GetController()->Process(
+      ui::Accelerator(ui::VKEY_F11, false, true, false)));
+#endif
+#endif
+}
+
+}  // namespace test
+}  // namespace aura_shell