| // Copyright 2014 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/wm/core/nested_accelerator_controller.h" |
| |
| #include "base/bind.h" |
| #include "base/event_types.h" |
| #include "base/message_loop/message_loop.h" |
| #include "ui/aura/test/aura_test_base.h" |
| #include "ui/aura/test/test_windows.h" |
| #include "ui/aura/window.h" |
| #include "ui/aura/window_event_dispatcher.h" |
| #include "ui/base/accelerators/accelerator.h" |
| #include "ui/base/accelerators/accelerator.h" |
| #include "ui/base/accelerators/accelerator_manager.h" |
| #include "ui/events/event_constants.h" |
| #include "ui/events/event_utils.h" |
| #include "ui/events/platform/platform_event_dispatcher.h" |
| #include "ui/events/platform/platform_event_source.h" |
| #include "ui/events/platform/scoped_event_dispatcher.h" |
| #include "ui/wm/core/nested_accelerator_delegate.h" |
| #include "ui/wm/public/dispatcher_client.h" |
| |
| #if defined(USE_X11) |
| #include <X11/Xlib.h> |
| #include "ui/aura/test/x11_event_sender.h" |
| #include "ui/events/test/events_test_utils_x11.h" |
| #endif // USE_X11 |
| |
| namespace wm { |
| namespace test { |
| |
| namespace { |
| |
| class MockDispatcher : public ui::PlatformEventDispatcher { |
| public: |
| MockDispatcher() : num_key_events_dispatched_(0) {} |
| |
| int num_key_events_dispatched() { return num_key_events_dispatched_; } |
| |
| private: |
| // ui::PlatformEventDispatcher: |
| bool CanDispatchEvent(const ui::PlatformEvent& event) override { |
| return true; |
| } |
| uint32_t DispatchEvent(const ui::PlatformEvent& event) override { |
| if (ui::EventTypeFromNative(event) == ui::ET_KEY_RELEASED) |
| num_key_events_dispatched_++; |
| return ui::POST_DISPATCH_NONE; |
| } |
| |
| int num_key_events_dispatched_; |
| |
| DISALLOW_COPY_AND_ASSIGN(MockDispatcher); |
| }; |
| |
| class TestTarget : public ui::AcceleratorTarget { |
| public: |
| TestTarget() : accelerator_pressed_count_(0) {} |
| ~TestTarget() override {} |
| |
| int accelerator_pressed_count() const { return accelerator_pressed_count_; } |
| |
| // Overridden from ui::AcceleratorTarget: |
| bool AcceleratorPressed(const ui::Accelerator& accelerator) override { |
| accelerator_pressed_count_++; |
| return true; |
| } |
| bool CanHandleAccelerators() const override { return true; } |
| |
| private: |
| int accelerator_pressed_count_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TestTarget); |
| }; |
| |
| void DispatchKeyReleaseA(aura::Window* root_window) { |
| // Sending both keydown and keyup is necessary here because the accelerator |
| // manager only checks a keyup event following a keydown event. See |
| // ShouldHandle() in ui/base/accelerators/accelerator_manager.cc for details. |
| #if defined(OS_WIN) |
| aura::WindowTreeHost* host = root_window->GetHost(); |
| HWND hwnd = host->GetAcceleratedWidget(); |
| ::PostMessage(hwnd, WM_KEYDOWN, ui::VKEY_A, 0); |
| ::PostMessage(hwnd, WM_KEYUP, ui::VKEY_A, 0); |
| #elif defined(USE_X11) |
| ui::ScopedXI2Event native_event; |
| native_event.InitKeyEvent(ui::ET_KEY_PRESSED, ui::VKEY_A, 0); |
| aura::WindowTreeHost* host = root_window->GetHost(); |
| aura::test::PostEventToWindowTreeHost(*native_event, host); |
| native_event.InitKeyEvent(ui::ET_KEY_RELEASED, ui::VKEY_A, 0); |
| aura::test::PostEventToWindowTreeHost(*native_event, host); |
| #endif |
| // Make sure the inner message-loop terminates after dispatching the events. |
| base::MessageLoop::current()->PostTask( |
| FROM_HERE, base::MessageLoop::current()->QuitClosure()); |
| } |
| |
| class MockNestedAcceleratorDelegate : public NestedAcceleratorDelegate { |
| public: |
| MockNestedAcceleratorDelegate() |
| : accelerator_manager_(new ui::AcceleratorManager) {} |
| ~MockNestedAcceleratorDelegate() override {} |
| |
| // NestedAcceleratorDelegate: |
| Result ProcessAccelerator(const ui::Accelerator& accelerator) override { |
| return accelerator_manager_->Process(accelerator) ? |
| RESULT_PROCESSED : RESULT_NOT_PROCESSED; |
| } |
| |
| void Register(const ui::Accelerator& accelerator, |
| ui::AcceleratorTarget* target) { |
| accelerator_manager_->Register( |
| accelerator, ui::AcceleratorManager::kNormalPriority, target); |
| } |
| |
| private: |
| scoped_ptr<ui::AcceleratorManager> accelerator_manager_; |
| |
| DISALLOW_COPY_AND_ASSIGN(MockNestedAcceleratorDelegate); |
| }; |
| |
| class NestedAcceleratorTest : public aura::test::AuraTestBase { |
| public: |
| NestedAcceleratorTest() {} |
| ~NestedAcceleratorTest() override {} |
| |
| void SetUp() override { |
| AuraTestBase::SetUp(); |
| delegate_ = new MockNestedAcceleratorDelegate(); |
| nested_accelerator_controller_.reset( |
| new NestedAcceleratorController(delegate_)); |
| aura::client::SetDispatcherClient(root_window(), |
| nested_accelerator_controller_.get()); |
| } |
| |
| void TearDown() override { |
| aura::client::SetDispatcherClient(root_window(), NULL); |
| AuraTestBase::TearDown(); |
| delegate_ = NULL; |
| nested_accelerator_controller_.reset(); |
| } |
| |
| MockNestedAcceleratorDelegate* delegate() { return delegate_; } |
| |
| private: |
| scoped_ptr<NestedAcceleratorController> nested_accelerator_controller_; |
| MockNestedAcceleratorDelegate* delegate_; |
| |
| DISALLOW_COPY_AND_ASSIGN(NestedAcceleratorTest); |
| }; |
| |
| } // namespace |
| |
| // Aura window above lock screen in z order. |
| // http://crbug.com/396494 |
| TEST_F(NestedAcceleratorTest, DISABLED_AssociatedWindowAboveLockScreen) { |
| // TODO(oshima|sadrul): remove when Win implements PES. |
| if (!ui::PlatformEventSource::GetInstance()) |
| return; |
| MockDispatcher inner_dispatcher; |
| scoped_ptr<aura::Window> mock_lock_container( |
| CreateNormalWindow(0, root_window(), NULL)); |
| aura::test::CreateTestWindowWithId(1, mock_lock_container.get()); |
| |
| scoped_ptr<aura::Window> associated_window( |
| CreateNormalWindow(2, root_window(), NULL)); |
| EXPECT_TRUE(aura::test::WindowIsAbove(associated_window.get(), |
| mock_lock_container.get())); |
| |
| DispatchKeyReleaseA(root_window()); |
| scoped_ptr<ui::ScopedEventDispatcher> override_dispatcher = |
| ui::PlatformEventSource::GetInstance()->OverrideDispatcher( |
| &inner_dispatcher); |
| aura::client::DispatcherRunLoop run_loop( |
| aura::client::GetDispatcherClient(root_window()), NULL); |
| run_loop.Run(); |
| EXPECT_EQ(1, inner_dispatcher.num_key_events_dispatched()); |
| } |
| |
| // Test that the nested dispatcher handles accelerators. |
| // http://crbug.com/396494 |
| TEST_F(NestedAcceleratorTest, DISABLED_AcceleratorsHandled) { |
| // TODO(oshima|sadrul): remove when Win implements PES. |
| if (!ui::PlatformEventSource::GetInstance()) |
| return; |
| MockDispatcher inner_dispatcher; |
| ui::Accelerator accelerator(ui::VKEY_A, ui::EF_NONE); |
| accelerator.set_type(ui::ET_KEY_RELEASED); |
| TestTarget target; |
| delegate()->Register(accelerator, &target); |
| |
| DispatchKeyReleaseA(root_window()); |
| scoped_ptr<ui::ScopedEventDispatcher> override_dispatcher = |
| ui::PlatformEventSource::GetInstance()->OverrideDispatcher( |
| &inner_dispatcher); |
| aura::client::DispatcherRunLoop run_loop( |
| aura::client::GetDispatcherClient(root_window()), NULL); |
| run_loop.Run(); |
| EXPECT_EQ(0, inner_dispatcher.num_key_events_dispatched()); |
| EXPECT_EQ(1, target.accelerator_pressed_count()); |
| } |
| |
| } // namespace test |
| } // namespace wm |