Index: athena/screen/screen_manager_unittest.cc |
diff --git a/athena/screen/screen_manager_unittest.cc b/athena/screen/screen_manager_unittest.cc |
deleted file mode 100644 |
index 5fcbb3cad0865402a801c7a4218b08f5d02821e2..0000000000000000000000000000000000000000 |
--- a/athena/screen/screen_manager_unittest.cc |
+++ /dev/null |
@@ -1,405 +0,0 @@ |
-// 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 <algorithm> |
-#include <string> |
- |
-#include "athena/screen/screen_manager_impl.h" |
-#include "athena/test/base/athena_test_base.h" |
-#include "athena/test/base/test_windows.h" |
-#include "athena/util/container_priorities.h" |
-#include "ui/aura/test/test_window_delegate.h" |
-#include "ui/aura/window.h" |
-#include "ui/aura/window_targeter.h" |
-#include "ui/events/test/event_generator.h" |
-#include "ui/wm/core/window_util.h" |
- |
-using ScreenManagerTest = athena::test::AthenaTestBase; |
-using AthenaFocusRuleTest = athena::test::AthenaTestBase; |
- |
-namespace athena { |
-namespace { |
- |
-const int kTestZOrderPriority = 10; |
- |
-aura::Window* Create(const std::string& name, int z_order_priority) { |
- ScreenManager::ContainerParams params(name, z_order_priority); |
- return ScreenManager::Get()->CreateContainer(params); |
-} |
- |
-aura::Window* CreateWindow(aura::Window* container, |
- aura::WindowDelegate* delegate, |
- const gfx::Rect& bounds) { |
- aura::Window* window = new aura::Window(delegate); |
- window->SetType(ui::wm::WINDOW_TYPE_NORMAL); |
- window->Init(aura::WINDOW_LAYER_TEXTURED); |
- container->AddChild(window); |
- window->Show(); |
- window->SetBounds(bounds); |
- return window; |
-} |
- |
-void CheckZOrder(aura::Window* w1, aura::Window* w2) { |
- aura::Window* parent = w1->parent(); |
- const aura::Window::Windows& children = parent->children(); |
- aura::Window::Windows::const_iterator begin_iter = children.begin(); |
- aura::Window::Windows::const_iterator end_iter = children.end(); |
- |
- aura::Window::Windows::const_iterator w1_iter = |
- std::find(begin_iter, end_iter, w1); |
- aura::Window::Windows::const_iterator w2_iter = |
- std::find(begin_iter, end_iter, w2); |
- EXPECT_NE(end_iter, w1_iter); |
- EXPECT_NE(end_iter, w2_iter); |
- EXPECT_TRUE(w1_iter < w2_iter); |
-} |
- |
-} // namespace |
- |
-TEST_F(ScreenManagerTest, CreateContainer) { |
- size_t num_containers = root_window()->children().size(); |
- |
- aura::Window* container = Create("test", kTestZOrderPriority); |
- EXPECT_EQ("test", container->name()); |
- |
- const aura::Window::Windows& containers = root_window()->children(); |
- EXPECT_EQ(num_containers + 1, containers.size()); |
- EXPECT_NE(containers.end(), |
- std::find(containers.begin(), containers.end(), container)); |
-} |
- |
-TEST_F(ScreenManagerTest, Zorder) { |
- aura::Window* window_10 = Create("test10", 10); |
- aura::Window* window_11 = Create("test11", 11); |
- aura::Window* window_12 = Create("test12", 12); |
- |
- { |
- SCOPED_TRACE("Init"); |
- CheckZOrder(window_10, window_11); |
- CheckZOrder(window_11, window_12); |
- } |
- { |
- SCOPED_TRACE("Delete"); |
- delete window_11; |
- CheckZOrder(window_10, window_12); |
- } |
- { |
- SCOPED_TRACE("Insert"); |
- window_11 = Create("test11", 11); |
- CheckZOrder(window_10, window_11); |
- CheckZOrder(window_11, window_12); |
- } |
-} |
- |
-TEST_F(ScreenManagerTest, NonActivatableContainer) { |
- ScreenManager::ContainerParams non_activatable( |
- "non_activatable", kTestZOrderPriority); |
- non_activatable.can_activate_children = false; |
- aura::Window* no_activatable_container = |
- ScreenManager::Get()->CreateContainer(non_activatable); |
- |
- ScreenManager::ContainerParams activatable( |
- "activatable", kTestZOrderPriority + 1); |
- activatable.can_activate_children = true; |
- aura::Window* activatable_container = |
- ScreenManager::Get()->CreateContainer(activatable); |
- |
- scoped_ptr<aura::Window> window(CreateWindow( |
- no_activatable_container, nullptr, gfx::Rect(0, 0, 100, 100))); |
- EXPECT_FALSE(wm::CanActivateWindow(window.get())); |
- |
- activatable_container->AddChild(window.get()); |
- EXPECT_TRUE(wm::CanActivateWindow(window.get())); |
-} |
- |
-TEST_F(ScreenManagerTest, BlockInputsShouldNotBlockVirtualKeyboard) { |
- ScreenManager::ContainerParams block_params("blocking", kTestZOrderPriority); |
- block_params.can_activate_children = true; |
- block_params.block_events = true; |
- aura::Window* block_container = |
- ScreenManager::Get()->CreateContainer(block_params); |
- |
- aura::test::EventCountDelegate block_delegate; |
- scoped_ptr<aura::Window> block_window(CreateWindow( |
- block_container, &block_delegate, gfx::Rect(0, 0, 100, 100))); |
- EXPECT_TRUE(wm::CanActivateWindow(block_window.get())); |
- |
- // Create a normal container appearing over the |block_container|. This is |
- // essentially the case of virtual keyboard. |
- ScreenManager::ContainerParams vk_params("virtual keyboard", |
- kTestZOrderPriority + 1); |
- vk_params.can_activate_children = true; |
- aura::Window* vk_container = ScreenManager::Get()->CreateContainer(vk_params); |
- |
- aura::test::EventCountDelegate vk_delegate; |
- scoped_ptr<aura::Window> vk_window( |
- CreateWindow(vk_container, &vk_delegate, gfx::Rect(0, 20, 100, 80))); |
- EXPECT_TRUE(wm::CanActivateWindow(vk_window.get())); |
- |
- ui::test::EventGenerator event_generator(root_window()); |
- event_generator.MoveMouseTo(10, 25); |
- event_generator.ClickLeftButton(); |
- EXPECT_EQ("0 0", block_delegate.GetMouseButtonCountsAndReset()); |
- EXPECT_EQ("1 1", vk_delegate.GetMouseButtonCountsAndReset()); |
-} |
- |
-TEST_F(ScreenManagerTest, DefaultContainer) { |
- ScreenManagerImpl* impl = |
- static_cast<ScreenManagerImpl*>(ScreenManager::Get()); |
- aura::Window* original_default = impl->FindContainerByPriority(CP_DEFAULT); |
- aura::Window* parent = original_default->parent(); |
- // Temporarily remove the original default container from tree. |
- parent->RemoveChild(original_default); |
- |
- ScreenManager::ContainerParams params("new_default", CP_END + 1); |
- params.default_parent = true; |
- params.modal_container_priority = CP_END + 2; |
- aura::Window* new_default = ScreenManager::Get()->CreateContainer(params); |
- aura::Window* w = test::CreateNormalWindow(nullptr, nullptr).release(); |
- EXPECT_EQ(new_default, w->parent()); |
- delete new_default; |
- |
- // Add the original back to shutdown properly. |
- parent->AddChild(original_default); |
-} |
- |
-TEST_F(AthenaFocusRuleTest, FocusTravarsalFromSameContainer) { |
- ScreenManager::ContainerParams params("contaier", kTestZOrderPriority); |
- params.can_activate_children = true; |
- scoped_ptr<aura::Window> |
- container(ScreenManager::Get()->CreateContainer(params)); |
- |
- scoped_ptr<aura::Window> w1(CreateWindow( |
- container.get(), nullptr, gfx::Rect(0, 0, 100, 100))); |
- wm::ActivateWindow(w1.get()); |
- EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
- |
- scoped_ptr<aura::Window> w2(CreateWindow( |
- container.get(), nullptr, gfx::Rect(0, 0, 100, 100))); |
- EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
- |
- container->RemoveChild(w1.get()); |
- EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
-} |
- |
-TEST_F(AthenaFocusRuleTest, FocusTravarsalFromOtherContainer) { |
- ScreenManager::ContainerParams params2("contaier2", kTestZOrderPriority + 1); |
- params2.can_activate_children = true; |
- scoped_ptr<aura::Window> |
- container2(ScreenManager::Get()->CreateContainer(params2)); |
- scoped_ptr<aura::Window> w2(CreateWindow( |
- container2.get(), nullptr, gfx::Rect(0, 0, 100, 100))); |
- wm::ActivateWindow(w2.get()); |
- EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
- |
- ScreenManager::ContainerParams params1("contaier1", kTestZOrderPriority); |
- params1.can_activate_children = true; |
- scoped_ptr<aura::Window> |
- container1(ScreenManager::Get()->CreateContainer(params1)); |
- ScreenManager::ContainerParams params3("contaier3", kTestZOrderPriority + 2); |
- params3.can_activate_children = true; |
- scoped_ptr<aura::Window> |
- container3(ScreenManager::Get()->CreateContainer(params3)); |
- scoped_ptr<aura::Window> w1(CreateWindow( |
- container1.get(), nullptr, gfx::Rect(0, 0, 100, 100))); |
- scoped_ptr<aura::Window> w3(CreateWindow( |
- container3.get(), nullptr, gfx::Rect(0, 0, 100, 100))); |
- |
- EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
- |
- container2->RemoveChild(w2.get()); |
- // Focus moves to a window in the front contaier. |
- EXPECT_TRUE(wm::IsActiveWindow(w3.get())); |
- |
- container3->RemoveChild(w3.get()); |
- // Focus moves to a window in the back contaier. |
- EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
-} |
- |
-TEST_F(AthenaFocusRuleTest, FocusTravarsalFromEventBlockedContainer) { |
- ScreenManager::ContainerParams params1("contaier1", kTestZOrderPriority + 1); |
- params1.can_activate_children = true; |
- scoped_ptr<aura::Window> |
- container1(ScreenManager::Get()->CreateContainer(params1)); |
- |
- ScreenManager::ContainerParams params2("contaier2", kTestZOrderPriority + 2); |
- params2.can_activate_children = true; |
- params2.block_events = true; |
- scoped_ptr<aura::Window> |
- container2(ScreenManager::Get()->CreateContainer(params2)); |
- |
- scoped_ptr<aura::Window> w1(CreateWindow( |
- container1.get(), nullptr, gfx::Rect(0, 0, 100, 100))); |
- scoped_ptr<aura::Window> w2(CreateWindow( |
- container2.get(), nullptr, gfx::Rect(0, 0, 100, 100))); |
- |
- wm::ActivateWindow(w2.get()); |
- EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
- |
- // Confirm that w1 can't get the focus. |
- wm::ActivateWindow(w1.get()); |
- EXPECT_FALSE(wm::IsActiveWindow(w1.get())); |
- EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
- |
- container2->Hide(); |
- w2.reset(); |
- container2.reset(); |
- |
- EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
-} |
- |
-TEST_F(AthenaFocusRuleTest, FocusTravarsalFromModalWindow) { |
- ScreenManagerImpl* screen_manager = |
- static_cast<ScreenManagerImpl*>(ScreenManager::Get()); |
- |
- ScreenManager::ContainerParams params1("contaier1", kTestZOrderPriority + 1); |
- params1.can_activate_children = true; |
- scoped_ptr<aura::Window> |
- container1(ScreenManager::Get()->CreateContainer(params1)); |
- |
- scoped_ptr<aura::Window> normal(CreateWindow( |
- container1.get(), nullptr, gfx::Rect(0, 0, 100, 100))); |
- wm::ActivateWindow(normal.get()); |
- EXPECT_TRUE(wm::IsActiveWindow(normal.get())); |
- |
- aura::test::EventCountDelegate delegate; |
- scoped_ptr<aura::Window> modal(test::CreateTransientWindow( |
- &delegate, nullptr, ui::MODAL_TYPE_SYSTEM, false)); |
- |
- aura::Window* modal_container = |
- screen_manager->FindContainerByPriority(CP_SYSTEM_MODAL); |
- EXPECT_TRUE(modal_container); |
- |
- modal->Show(); |
- wm::ActivateWindow(modal.get()); |
- EXPECT_TRUE(wm::IsActiveWindow(modal.get())); |
- EXPECT_FALSE(wm::IsActiveWindow(normal.get())); |
- |
- // Closes the modal window and confirms the normal window gets the focus. |
- modal.reset(); |
- EXPECT_TRUE(wm::IsActiveWindow(normal.get())); |
-} |
- |
-namespace { |
- |
-class ScreenManagerTargeterTest |
- : public athena::test::AthenaTestBase, |
- public testing::WithParamInterface<bool> { |
- public: |
- ScreenManagerTargeterTest() |
- : targeter_(GetParam() ? nullptr : new aura::WindowTargeter) {} |
- ~ScreenManagerTargeterTest() override {} |
- |
- protected: |
- scoped_ptr<ui::EventTargeter> targeter_; |
- |
- private: |
- DISALLOW_COPY_AND_ASSIGN(ScreenManagerTargeterTest); |
-}; |
- |
-} // namespace |
- |
-TEST_P(ScreenManagerTargeterTest, BlockContainer) { |
- ScreenManager::ContainerParams normal_params( |
- "normal", kTestZOrderPriority); |
- normal_params.can_activate_children = true; |
- aura::Window* normal_container = |
- ScreenManager::Get()->CreateContainer(normal_params); |
- normal_container->SetEventTargeter(targeter_.Pass()); |
- |
- aura::test::EventCountDelegate normal_delegate; |
- scoped_ptr<aura::Window> normal_window(CreateWindow( |
- normal_container, &normal_delegate, gfx::Rect(0, 0, 100, 100))); |
- |
- EXPECT_TRUE(wm::CanActivateWindow(normal_window.get())); |
- wm::ActivateWindow(normal_window.get()); |
- ui::test::EventGenerator event_generator(root_window()); |
- event_generator.MoveMouseTo(0, 0); |
- event_generator.ClickLeftButton(); |
- EXPECT_EQ("1 1", normal_delegate.GetMouseButtonCountsAndReset()); |
- event_generator.PressKey(ui::VKEY_A, ui::EF_NONE); |
- event_generator.ReleaseKey(ui::VKEY_A, ui::EF_NONE); |
- EXPECT_EQ("1 1", normal_delegate.GetKeyCountsAndReset()); |
- |
- ScreenManager::ContainerParams block_params("blocking", |
- kTestZOrderPriority + 1); |
- block_params.can_activate_children = true; |
- block_params.block_events = true; |
- aura::Window* block_container = |
- ScreenManager::Get()->CreateContainer(block_params); |
- |
- EXPECT_FALSE(wm::CanActivateWindow(normal_window.get())); |
- |
- aura::test::EventCountDelegate block_delegate; |
- scoped_ptr<aura::Window> block_window(CreateWindow( |
- block_container, &block_delegate, gfx::Rect(10, 10, 100, 100))); |
- EXPECT_TRUE(wm::CanActivateWindow(block_window.get())); |
- |
- wm::ActivateWindow(block_window.get()); |
- |
- // (0, 0) is still on normal_window, but the event should not go there |
- // because blockbing_container prevents it. |
- event_generator.MoveMouseTo(0, 0); |
- event_generator.ClickLeftButton(); |
- EXPECT_EQ("0 0", normal_delegate.GetMouseButtonCountsAndReset()); |
- EXPECT_EQ("0 0", block_delegate.GetMouseButtonCountsAndReset()); |
- event_generator.MoveMouseWheel(0, 10); |
- // EXPECT_EQ(0, normal_event_counter.num_scroll_events()); |
- |
- event_generator.MoveMouseTo(20, 20); |
- event_generator.ClickLeftButton(); |
- EXPECT_EQ("1 1", block_delegate.GetMouseButtonCountsAndReset()); |
- |
- event_generator.PressKey(ui::VKEY_A, ui::EF_NONE); |
- event_generator.ReleaseKey(ui::VKEY_A, ui::EF_NONE); |
- EXPECT_EQ("0 0", normal_delegate.GetKeyCountsAndReset()); |
- EXPECT_EQ("1 1", block_delegate.GetKeyCountsAndReset()); |
-} |
- |
-TEST_P(ScreenManagerTargeterTest, BlockAndMouseCapture) { |
- ScreenManager::ContainerParams normal_params( |
- "normal", kTestZOrderPriority); |
- normal_params.can_activate_children = true; |
- aura::Window* normal_container = |
- ScreenManager::Get()->CreateContainer(normal_params); |
- normal_container->SetEventTargeter(targeter_.Pass()); |
- |
- aura::test::EventCountDelegate normal_delegate; |
- scoped_ptr<aura::Window> normal_window(CreateWindow( |
- normal_container, &normal_delegate, gfx::Rect(0, 0, 100, 100))); |
- |
- ui::test::EventGenerator event_generator(root_window()); |
- event_generator.MoveMouseTo(0, 0); |
- event_generator.PressLeftButton(); |
- |
- // Creating blocking container while mouse pressing. |
- ScreenManager::ContainerParams block_params("blocking", |
- kTestZOrderPriority + 1); |
- block_params.can_activate_children = true; |
- block_params.block_events = true; |
- aura::Window* block_container = |
- ScreenManager::Get()->CreateContainer(block_params); |
- |
- aura::test::EventCountDelegate block_delegate; |
- scoped_ptr<aura::Window> block_window(CreateWindow( |
- block_container, &block_delegate, gfx::Rect(10, 10, 100, 100))); |
- |
- // Release event should be sent to |normal_window| because it captures the |
- // mouse event. |
- event_generator.ReleaseLeftButton(); |
- EXPECT_EQ("1 1", normal_delegate.GetMouseButtonCountsAndReset()); |
- EXPECT_EQ("0 0", block_delegate.GetMouseButtonCountsAndReset()); |
- |
- // After release, further mouse events should not be sent to |normal_window| |
- // because block_container blocks the input. |
- event_generator.ClickLeftButton(); |
- EXPECT_EQ("0 0", normal_delegate.GetMouseButtonCountsAndReset()); |
- EXPECT_EQ("0 0", block_delegate.GetMouseButtonCountsAndReset()); |
-} |
- |
-INSTANTIATE_TEST_CASE_P(WithOrWithoutTargeter, |
- ScreenManagerTargeterTest, |
- testing::Values(false, true)); |
- |
-} // namespace athena |