Allows ash accelerators in wrench menu

ash/accelerators/nested_dispatcher_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/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.h"
 #include "base/bind.h"
 #include "base/event_types.h"
 #include "base/message_loop.h"
 #include "ui/aura/client/dispatcher_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
+#include "ui/base/accelerators/accelerator.h"
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #include "ui/base/x/x11_util.h"
 #endif  // USE_X11
 
 namespace ash {
 namespace test {
 
 namespace {
@@ skipping 18 matching lines @@
       num_key_events_dispatched_++;
     return ui::IsNoopEvent(xev) ? MessagePumpDispatcher::EVENT_QUIT :
         MessagePumpDispatcher::EVENT_IGNORED;
   }
 #endif
 
  private:
   int num_key_events_dispatched_;
 };
 
-void DispatchKeyEvent() {
+class TestTarget : public ui::AcceleratorTarget {
+ public:
+  TestTarget() : accelerator_pressed_count_(0) {};

[sky, 2012/02/29 22:04:18]

nit: no ; here and next line.

+  virtual ~TestTarget() {};
+
+  int accelerator_pressed_count() const {
+    return accelerator_pressed_count_;
+  }
+
+  // Overridden from ui::AcceleratorTarget:
+  virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE {
+    accelerator_pressed_count_++;
+    return true;
+  }
+  virtual bool CanHandleAccelerators() const OVERRIDE {
+    return true;
+  }
+
+ private:
+  int accelerator_pressed_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestTarget);
+};
+
+void DispatchKeyReleaseA() {
 #if defined(OS_WIN)
   MSG native_event = { NULL, WM_KEYUP, ui::VKEY_A, 0 };
   ash::Shell::GetRootWindow()->PostNativeEvent(native_event);
 #elif defined(USE_X11)
   XEvent native_event;
   ui::InitXKeyEventForTesting(ui::ET_KEY_RELEASED,
                               ui::VKEY_A,
                               0,
                               &native_event);
   ash::Shell::GetRootWindow()->PostNativeEvent(&native_event);
 #endif
 
   // Send noop event to signal dispatcher to exit.
   ash::Shell::GetRootWindow()->PostNativeEvent(ui::CreateNoopEvent());
 }
 
 }  // namespace
 
 typedef AshTestBase NestedDispatcherTest;
 
 // Aura window below lock screen in z order.
 TEST_F(NestedDispatcherTest, AssociatedWindowBelowLockScreen) {
   MockDispatcher inner_dispatcher;
   aura::Window* default_container = Shell::GetInstance()->GetContainer(
-      ash::internal::kShellWindowId_DefaultContainer);
+      internal::kShellWindowId_DefaultContainer);
   scoped_ptr<aura::Window>associated_window(aura::test::CreateTestWindowWithId(
       0, default_container));
   scoped_ptr<aura::Window>mock_lock_container(
       aura::test::CreateTestWindowWithId(0, default_container));
   mock_lock_container->set_stops_event_propagation(true);
   aura::test::CreateTestWindowWithId(0, mock_lock_container.get());
   EXPECT_TRUE(aura::test::WindowIsAbove(mock_lock_container.get(),
       associated_window.get()));
   MessageLoop::current()->PostDelayedTask(
      FROM_HERE,
-     base::Bind(&DispatchKeyEvent),
+     base::Bind(&DispatchKeyReleaseA),
      base::TimeDelta::FromMilliseconds(100));
   aura::RootWindow* root_window = ash::Shell::GetInstance()->GetRootWindow();
   aura::client::GetDispatcherClient(root_window)->RunWithDispatcher(
       &inner_dispatcher,
       associated_window.get(),
       true /* nestable_tasks_allowed */);
   EXPECT_EQ(0, inner_dispatcher.num_key_events_dispatched());
 }
 
 // Aura window above lock screen in z order.
 TEST_F(NestedDispatcherTest, AssociatedWindowAboveLockScreen) {
   MockDispatcher inner_dispatcher;
 
   aura::Window* default_container = Shell::GetInstance()->GetContainer(
-      ash::internal::kShellWindowId_DefaultContainer);
+      internal::kShellWindowId_DefaultContainer);
   scoped_ptr<aura::Window>mock_lock_container(
       aura::test::CreateTestWindowWithId(0, default_container));
   mock_lock_container->set_stops_event_propagation(true);
   aura::test::CreateTestWindowWithId(0, mock_lock_container.get());
   scoped_ptr<aura::Window>associated_window(aura::test::CreateTestWindowWithId(
       0, default_container));
   EXPECT_TRUE(aura::test::WindowIsAbove(associated_window.get(),
       mock_lock_container.get()));
 
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&DispatchKeyEvent),
+      base::Bind(&DispatchKeyReleaseA),
       base::TimeDelta::FromMilliseconds(100));
   aura::RootWindow* root_window = ash::Shell::GetInstance()->GetRootWindow();
   aura::client::GetDispatcherClient(root_window)->RunWithDispatcher(
       &inner_dispatcher,
       associated_window.get(),
       true /* nestable_tasks_allowed */);
   EXPECT_EQ(1, inner_dispatcher.num_key_events_dispatched());
 }
 
+// Test that the nested dispatcher handles accelerators.
+TEST_F(NestedDispatcherTest, AcceleratorsHandled) {
+  MockDispatcher inner_dispatcher;
+  aura::RootWindow* root_window = ash::Shell::GetInstance()->GetRootWindow();
+
+  ui::Accelerator accelerator(ui::VKEY_A, false, false, false);
+  accelerator.set_type(ui::ET_TRANSLATED_KEY_RELEASE);
+  TestTarget target;
+  Shell::GetInstance()->accelerator_controller()->Register(accelerator,
+                                                           &target);
+
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&DispatchKeyReleaseA),
+      base::TimeDelta::FromMilliseconds(100));

[sky, 2012/02/29 22:04:18]

Why does this need to delay 100ms? Can't it use PostDelayedTask with no time?

[pkotwicz, 2012/03/01 23:56:37]

The delay is arbitrary. However, I beleive the delay is useful to avoid
flakiness. DispatchKeyReleaseA cannot occur before RunWithDispatch for the test
to be successful.
I don't know if posting a non delayed task guarantees this.

[oshima, 2012/03/02 00:12:21]

Sorry I missed this in first review.

On 2012/03/01 23:56:37, pkotwicz wrote:
 DispatchKeyReleaseA is already using PostNativeEvent so you should be able to
just call DispatchKeyReleaseA.
You don't even need to post task here. Or does this fail without it?

+  aura::client::GetDispatcherClient(root_window)->RunWithDispatcher(
+      &inner_dispatcher,
+      root_window,
+      true /* nestable_tasks_allowed */);
+  EXPECT_EQ(0, inner_dispatcher.num_key_events_dispatched());
+  EXPECT_EQ(1, target.accelerator_pressed_count());
+}
+
 } //  namespace test
 } //  namespace ash