| // 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/wm/activation_controller.h" |
| |
| #include "ash/shell.h" |
| #include "ash/shell_window_ids.h" |
| #include "ash/test/ash_test_base.h" |
| #include "ash/test/test_activation_delegate.h" |
| #include "ash/wm/window_util.h" |
| #include "ui/aura/client/aura_constants.h" |
| #include "ui/aura/root_window.h" |
| #include "ui/aura/test/event_generator.h" |
| #include "ui/aura/test/test_window_delegate.h" |
| #include "ui/aura/test/test_windows.h" |
| #include "ui/compositor/layer.h" |
| #include "ui/views/corewm/corewm_switches.h" |
| |
| #if defined(OS_WIN) |
| // Windows headers define macros for these function names which screw with us. |
| #if defined(CreateWindow) |
| #undef CreateWindow |
| #endif |
| #endif |
| |
| namespace { |
| |
| // Containers used for the tests. |
| const int kDefaultContainerID = -1; // Used to identify the default container. |
| const int c2 = ash::internal::kShellWindowId_AlwaysOnTopContainer; |
| const int c3 = ash::internal::kShellWindowId_LockScreenContainer; |
| |
| } // namespace |
| |
| namespace ash { |
| namespace test { |
| |
| typedef test::AshTestBase ActivationControllerTest; |
| |
| // Utilities for a set of tests that test |
| // ActivationController::GetTopmostWindowToActivate(). |
| class GetTopmostWindowToActivateTest : public ActivationControllerTest { |
| public: |
| GetTopmostWindowToActivateTest() : ad_1_(false), ad_3_(false) {} |
| virtual ~GetTopmostWindowToActivateTest() {} |
| |
| // Overridden from ActivationControllerTest: |
| virtual void SetUp() OVERRIDE { |
| ActivationControllerTest::SetUp(); |
| CreateWindows(); |
| } |
| virtual void TearDown() OVERRIDE { |
| DestroyWindows(); |
| ActivationControllerTest::TearDown(); |
| } |
| |
| protected: |
| aura::Window* w1() { return w1_.get(); } |
| aura::Window* w2() { return w2_.get(); } |
| aura::Window* w3() { return w3_.get(); } |
| aura::Window* w4() { return w4_.get(); } |
| aura::Window* w5() { return w5_.get(); } |
| aura::Window* w6() { return w6_.get(); } |
| aura::Window* w7() { return w7_.get(); } |
| |
| void DestroyWindow2() { |
| w2_.reset(); |
| } |
| |
| private: |
| void CreateWindows() { |
| // Create four windows, the first and third are not activatable, the second |
| // and fourth are. |
| w1_.reset(CreateWindowInShell(1, &ad_1_)); |
| w2_.reset(CreateWindowInShell(2, &ad_2_)); |
| w3_.reset(CreateWindowInShell(3, &ad_3_)); |
| w4_.reset(CreateWindowInShell(4, &ad_4_)); |
| w5_.reset(CreateWindowWithID(5, &ad_5_, c2)); |
| w6_.reset(CreateWindowWithID(6, &ad_6_, c2)); |
| w7_.reset(CreateWindowWithID(7, &ad_7_, c3)); |
| } |
| |
| aura::Window* CreateWindowInShell(int id, |
| TestActivationDelegate* delegate) { |
| aura::Window* window = CreateTestWindowInShellWithDelegate( |
| &delegate_, |
| id, |
| gfx::Rect()); |
| delegate->SetWindow(window); |
| return window; |
| } |
| |
| aura::Window* CreateWindowWithID(int id, |
| TestActivationDelegate* delegate, |
| int container_id) { |
| aura::Window* parent = |
| Shell::GetContainer(Shell::GetPrimaryRootWindow(), container_id); |
| aura::Window* window = aura::test::CreateTestWindowWithDelegate( |
| &delegate_, |
| id, |
| gfx::Rect(), |
| parent); |
| delegate->SetWindow(window); |
| return window; |
| } |
| |
| void DestroyWindows() { |
| w1_.reset(); |
| w2_.reset(); |
| w3_.reset(); |
| w4_.reset(); |
| w5_.reset(); |
| w6_.reset(); |
| w7_.reset(); |
| } |
| |
| aura::test::TestWindowDelegate delegate_; |
| TestActivationDelegate ad_1_; |
| TestActivationDelegate ad_2_; |
| TestActivationDelegate ad_3_; |
| TestActivationDelegate ad_4_; |
| TestActivationDelegate ad_5_; |
| TestActivationDelegate ad_6_; |
| TestActivationDelegate ad_7_; |
| scoped_ptr<aura::Window> w1_; // Non-activatable. |
| scoped_ptr<aura::Window> w2_; // Activatable. |
| scoped_ptr<aura::Window> w3_; // Non-activatable. |
| scoped_ptr<aura::Window> w4_; // Activatable. |
| scoped_ptr<aura::Window> w5_; // Activatable - Always on top. |
| scoped_ptr<aura::Window> w6_; // Activatable - Always on top. |
| scoped_ptr<aura::Window> w7_; // Activatable - Lock screen window. |
| |
| DISALLOW_COPY_AND_ASSIGN(GetTopmostWindowToActivateTest); |
| }; |
| |
| // Hiding the active window should activate the next valid activatable window. |
| TEST_F(GetTopmostWindowToActivateTest, HideActivatesNext) { |
| wm::ActivateWindow(w2()); |
| EXPECT_TRUE(wm::IsActiveWindow(w2())); |
| |
| w2()->Hide(); |
| EXPECT_TRUE(wm::IsActiveWindow(w4())); |
| } |
| |
| // Destroying the active window should activate the next valid activatable |
| // window. |
| TEST_F(GetTopmostWindowToActivateTest, DestroyActivatesNext) { |
| wm::ActivateWindow(w2()); |
| EXPECT_TRUE(wm::IsActiveWindow(w2())); |
| |
| DestroyWindow2(); |
| EXPECT_EQ(NULL, w2()); |
| EXPECT_TRUE(wm::IsActiveWindow(w4())); |
| } |
| |
| // Deactivating the active window should activate the next valid activatable |
| // window. |
| TEST_F(GetTopmostWindowToActivateTest, DeactivateActivatesNext) { |
| wm::ActivateWindow(w2()); |
| EXPECT_TRUE(wm::IsActiveWindow(w2())); |
| |
| wm::DeactivateWindow(w2()); |
| EXPECT_TRUE(wm::IsActiveWindow(w4())); |
| } |
| |
| // Test that hiding a window in a higher container will activate another window |
| // in that container. |
| TEST_F(GetTopmostWindowToActivateTest, HideActivatesSameContainer) { |
| wm::ActivateWindow(w6()); |
| EXPECT_TRUE(wm::IsActiveWindow(w6())); |
| |
| w6()->Hide(); |
| EXPECT_TRUE(wm::IsActiveWindow(w5())); |
| } |
| |
| // Test that hiding the lock window will activate a window from the next highest |
| // container. |
| TEST_F(GetTopmostWindowToActivateTest, UnlockActivatesNextHighestContainer) { |
| wm::ActivateWindow(w7()); |
| EXPECT_TRUE(wm::IsActiveWindow(w7())); |
| |
| w7()->Hide(); |
| EXPECT_TRUE(wm::IsActiveWindow(w6())); |
| } |
| |
| // Test that hiding a window in a higher container with no other windows will |
| // activate a window in a lower container. |
| TEST_F(GetTopmostWindowToActivateTest, HideActivatesNextHighestContainer) { |
| w5()->Hide(); |
| wm::ActivateWindow(w6()); |
| EXPECT_TRUE(wm::IsActiveWindow(w6())); |
| |
| w6()->Hide(); |
| EXPECT_TRUE(wm::IsActiveWindow(w4())); |
| } |
| |
| // Test if the clicking on a menu picks the transient parent as activatable |
| // window. |
| TEST_F(ActivationControllerTest, ClickOnMenu) { |
| aura::test::TestWindowDelegate wd; |
| TestActivationDelegate ad1; |
| TestActivationDelegate ad2(false); |
| |
| scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate( |
| &wd, 1, gfx::Rect(100, 100))); |
| ad1.SetWindow(w1.get()); |
| EXPECT_EQ(NULL, wm::GetActiveWindow()); |
| |
| // Clicking on an activatable window activates the window. |
| aura::test::EventGenerator& generator(GetEventGenerator()); |
| generator.MoveMouseToCenterOf(w1.get()); |
| generator.ClickLeftButton(); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| |
| // Creates a menu that covers the transient parent. |
| scoped_ptr<aura::Window> menu(CreateTestWindowInShellWithDelegateAndType( |
| &wd, aura::client::WINDOW_TYPE_MENU, 2, gfx::Rect(100, 100))); |
| ad2.SetWindow(menu.get()); |
| w1->AddTransientChild(menu.get()); |
| |
| // Clicking on a menu whose transient parent is active window shouldn't |
| // change the active window. |
| generator.ClickLeftButton(); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| } |
| |
| // Various assertions for activating/deactivating. |
| TEST_F(ActivationControllerTest, Deactivate) { |
| aura::test::TestWindowDelegate d1; |
| aura::test::TestWindowDelegate d2; |
| scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate( |
| &d1, 1, gfx::Rect())); |
| scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegate( |
| &d2, 2, gfx::Rect())); |
| aura::Window* parent = w1->parent(); |
| parent->Show(); |
| ASSERT_TRUE(parent); |
| ASSERT_EQ(2u, parent->children().size()); |
| // Activate w2 and make sure it's active and frontmost. |
| wm::ActivateWindow(w2.get()); |
| EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
| EXPECT_FALSE(wm::IsActiveWindow(w1.get())); |
| EXPECT_EQ(w2.get(), parent->children()[1]); |
| |
| // Activate w1 and make sure it's active and frontmost. |
| wm::ActivateWindow(w1.get()); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| EXPECT_FALSE(wm::IsActiveWindow(w2.get())); |
| EXPECT_EQ(w1.get(), parent->children()[1]); |
| |
| // Deactivate w1 and make sure w2 becomes active and frontmost. |
| wm::DeactivateWindow(w1.get()); |
| EXPECT_FALSE(wm::IsActiveWindow(w1.get())); |
| EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
| EXPECT_EQ(w2.get(), parent->children()[1]); |
| } |
| |
| // Verifies that when WindowDelegate::OnLostActive is invoked the window is not |
| // active. |
| TEST_F(ActivationControllerTest, NotActiveInLostActive) { |
| // TODO(beng): remove this test once the new focus controller is on. |
| if (views::corewm::UseFocusController()) |
| return; |
| |
| TestActivationDelegate ad1; |
| aura::test::TestWindowDelegate wd; |
| scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate( |
| &wd, 1, gfx::Rect(10, 10, 50, 50))); |
| ad1.SetWindow(w1.get()); |
| scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegate( |
| NULL, 1, gfx::Rect(10, 10, 50, 50))); |
| |
| // Activate w1. |
| wm::ActivateWindow(w1.get()); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| EXPECT_EQ(1, ad1.activated_count()); |
| // Should not have gotten a OnLostActive yet. |
| EXPECT_EQ(0, ad1.lost_active_count()); |
| |
| // Deactivate the active window. |
| wm::DeactivateWindow(w1.get()); |
| EXPECT_FALSE(wm::IsActiveWindow(w1.get())); |
| EXPECT_EQ(1, ad1.lost_active_count()); |
| EXPECT_FALSE(ad1.window_was_active()); |
| |
| // Activate w1 again. w1 should have gotten OnActivated. |
| wm::ActivateWindow(w1.get()); |
| EXPECT_EQ(2, ad1.activated_count()); |
| EXPECT_EQ(1, ad1.lost_active_count()); |
| |
| // Reset the delegate. |
| ad1.Clear(); |
| |
| // Now activate another window. |
| wm::ActivateWindow(w2.get()); |
| |
| // Should have gotten OnLostActive and w1 shoouldn't have been |
| // active window in OnLostActive. |
| EXPECT_EQ(0, ad1.activated_count()); |
| EXPECT_EQ(1, ad1.lost_active_count()); |
| EXPECT_FALSE(ad1.window_was_active()); |
| } |
| |
| // Verifies that focusing another window or its children causes it to become |
| // active. |
| TEST_F(ActivationControllerTest, FocusTriggersActivation) { |
| aura::test::TestWindowDelegate wd; |
| scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate( |
| &wd, -1, gfx::Rect(50, 50))); |
| scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegate( |
| &wd, -2, gfx::Rect(50, 50))); |
| scoped_ptr<aura::Window> w21(aura::test::CreateTestWindowWithDelegate( |
| &wd, -21, gfx::Rect(50, 50), w2.get())); |
| |
| wm::ActivateWindow(w1.get()); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| EXPECT_TRUE(w1->HasFocus()); |
| |
| w2->Focus(); |
| EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
| EXPECT_TRUE(w2->HasFocus()); |
| |
| wm::ActivateWindow(w1.get()); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| EXPECT_TRUE(w1->HasFocus()); |
| |
| w21->Focus(); |
| EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
| EXPECT_TRUE(w21->HasFocus()); |
| } |
| |
| // Verifies that we prevent all attempts to focus a child of a non-activatable |
| // window from claiming focus to that window. |
| TEST_F(ActivationControllerTest, PreventFocusToNonActivatableWindow) { |
| aura::test::TestWindowDelegate wd; |
| scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate( |
| &wd, -1, gfx::Rect(50, 50))); |
| // The RootWindow is a non-activatable parent. |
| scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate( |
| &wd, -2, gfx::Rect(50, 50), Shell::GetPrimaryRootWindow())); |
| scoped_ptr<aura::Window> w21(aura::test::CreateTestWindowWithDelegate( |
| &wd, -21, gfx::Rect(50, 50), w2.get())); |
| |
| wm::ActivateWindow(w1.get()); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| EXPECT_TRUE(w1->HasFocus()); |
| |
| // Try activating |w2|. It's not a child of an activatable container, so it |
| // should neither be activated nor get focus. |
| wm::ActivateWindow(w2.get()); |
| EXPECT_FALSE(wm::IsActiveWindow(w2.get())); |
| EXPECT_FALSE(w2->HasFocus()); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| EXPECT_TRUE(w1->HasFocus()); |
| |
| // Try focusing |w2|. Same rules apply. |
| w2->Focus(); |
| EXPECT_FALSE(wm::IsActiveWindow(w2.get())); |
| EXPECT_FALSE(w2->HasFocus()); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| EXPECT_TRUE(w1->HasFocus()); |
| |
| // Try focusing |w21|. Same rules apply. |
| EXPECT_FALSE(wm::IsActiveWindow(w2.get())); |
| EXPECT_FALSE(w21->HasFocus()); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| EXPECT_TRUE(w1->HasFocus()); |
| } |
| |
| TEST_F(ActivationControllerTest, CanActivateWindowIteselfTest) |
| { |
| aura::test::TestWindowDelegate wd; |
| |
| // Normal Window |
| scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate( |
| &wd, -1, gfx::Rect(50, 50))); |
| EXPECT_TRUE(wm::CanActivateWindow(w1.get())); |
| |
| // The RootWindow is a non-activatable parent. |
| scoped_ptr<aura::Window> w2(aura::test::CreateTestWindowWithDelegate( |
| &wd, -2, gfx::Rect(50, 50), Shell::GetPrimaryRootWindow())); |
| scoped_ptr<aura::Window> w21(aura::test::CreateTestWindowWithDelegate( |
| &wd, -21, gfx::Rect(50, 50), w2.get())); |
| EXPECT_FALSE(wm::CanActivateWindow(w2.get())); |
| EXPECT_FALSE(wm::CanActivateWindow(w21.get())); |
| |
| // The window has a transient child. |
| scoped_ptr<aura::Window> w3(CreateTestWindowInShellWithDelegate( |
| &wd, -3, gfx::Rect(50, 50))); |
| scoped_ptr<aura::Window> w31(CreateTestWindowInShellWithDelegate( |
| &wd, -31, gfx::Rect(50, 50))); |
| w3->AddTransientChild(w31.get()); |
| EXPECT_TRUE(wm::CanActivateWindow(w3.get())); |
| EXPECT_TRUE(wm::CanActivateWindow(w31.get())); |
| |
| // The window has a transient window-modal child. |
| scoped_ptr<aura::Window> w4(CreateTestWindowInShellWithDelegate( |
| &wd, -4, gfx::Rect(50, 50))); |
| scoped_ptr<aura::Window> w41(CreateTestWindowInShellWithDelegate( |
| &wd, -41, gfx::Rect(50, 50))); |
| w4->AddTransientChild(w41.get()); |
| w41->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_WINDOW); |
| EXPECT_FALSE(wm::CanActivateWindow(w4.get())); |
| EXPECT_TRUE(wm::CanActivateWindow(w41.get())); |
| |
| // The window has a transient system-modal child. |
| scoped_ptr<aura::Window> w5(CreateTestWindowInShellWithDelegate( |
| &wd, -5, gfx::Rect(50, 50))); |
| scoped_ptr<aura::Window> w51(CreateTestWindowInShellWithDelegate( |
| &wd, -51, gfx::Rect(50, 50))); |
| w5->AddTransientChild(w51.get()); |
| w51->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_SYSTEM); |
| EXPECT_FALSE(wm::CanActivateWindow(w5.get())); |
| EXPECT_TRUE(wm::CanActivateWindow(w51.get())); |
| } |
| |
| // Verifies code in ActivationController::OnWindowVisibilityChanged() that keeps |
| // hiding windows layers stacked above the newly active window while they |
| // animate away. |
| // TODO(beng): This test now duplicates a test in: |
| // ui/views/corewm/focus_controller_unittest.cc |
| // ...and can be removed once the new focus controller is enabled. |
| TEST_F(ActivationControllerTest, AnimateHideMaintainsStacking) { |
| aura::test::TestWindowDelegate wd; |
| scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate( |
| &wd, -1, gfx::Rect(50, 50, 50, 50))); |
| scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegate( |
| &wd, -2, gfx::Rect(75, 75, 50, 50))); |
| wm::ActivateWindow(w2.get()); |
| EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
| w2->Hide(); |
| typedef std::vector<ui::Layer*> Layers; |
| const Layers& children = w1->parent()->layer()->children(); |
| Layers::const_iterator w1_iter = |
| std::find(children.begin(), children.end(), w1->layer()); |
| Layers::const_iterator w2_iter = |
| std::find(children.begin(), children.end(), w2->layer()); |
| EXPECT_TRUE(w2_iter > w1_iter); |
| } |
| |
| // Verifies that activating a minimized window would restore it. |
| TEST_F(ActivationControllerTest, ActivateMinimizedWindow) { |
| aura::test::TestWindowDelegate wd; |
| scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate( |
| &wd, -1, gfx::Rect(50, 50))); |
| |
| wm::MinimizeWindow(w1.get()); |
| EXPECT_TRUE(wm::IsWindowMinimized(w1.get())); |
| |
| wm::ActivateWindow(w1.get()); |
| EXPECT_TRUE(wm::IsActiveWindow(w1.get())); |
| EXPECT_FALSE(wm::IsWindowMinimized(w1.get())); |
| } |
| |
| // Verifies that a minimized window would not be automatically activated as |
| // a replacement active window. |
| TEST_F(ActivationControllerTest, NoAutoActivateMinimizedWindow) { |
| aura::test::TestWindowDelegate wd; |
| scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate( |
| &wd, -1, gfx::Rect(50, 50, 50, 50))); |
| scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegate( |
| &wd, -2, gfx::Rect(75, 75, 50, 50))); |
| |
| wm::MinimizeWindow(w1.get()); |
| EXPECT_TRUE(wm::IsWindowMinimized(w1.get())); |
| |
| wm::ActivateWindow(w2.get()); |
| EXPECT_TRUE(wm::IsActiveWindow(w2.get())); |
| |
| w2->Hide(); |
| |
| EXPECT_FALSE(wm::IsActiveWindow(w1.get())); |
| EXPECT_TRUE(wm::IsWindowMinimized(w1.get())); |
| } |
| |
| // Verifies that a window with a hidden layer can be activated. |
| TEST_F(ActivationControllerTest, ActivateWithHiddenLayer) { |
| aura::test::TestWindowDelegate wd; |
| scoped_ptr<aura::Window> w1(CreateTestWindowInShellWithDelegate( |
| &wd, -1, gfx::Rect(50, 50, 50, 50))); |
| |
| EXPECT_TRUE(wm::CanActivateWindow(w1.get())); |
| w1->layer()->SetVisible(false); |
| EXPECT_TRUE(wm::CanActivateWindow(w1.get())); |
| } |
| |
| // Verifies that a unrelated window cannot be activated when in a system modal |
| // dialog. |
| TEST_F(ActivationControllerTest, DontActivateWindowWhenInSystemModalDialog) { |
| scoped_ptr<aura::Window> normal_window(CreateTestWindowInShellWithId(-1)); |
| EXPECT_FALSE(wm::IsActiveWindow(normal_window.get())); |
| wm::ActivateWindow(normal_window.get()); |
| EXPECT_TRUE(wm::IsActiveWindow(normal_window.get())); |
| |
| // Create and activate a system modal window. |
| aura::Window* modal_container = |
| ash::Shell::GetContainer( |
| Shell::GetPrimaryRootWindow(), |
| ash::internal::kShellWindowId_SystemModalContainer); |
| scoped_ptr<aura::Window> modal_window( |
| aura::test::CreateTestWindowWithId(-2, modal_container)); |
| modal_window->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_SYSTEM); |
| wm::ActivateWindow(modal_window.get()); |
| EXPECT_TRUE(ash::Shell::GetInstance()->IsSystemModalWindowOpen()); |
| EXPECT_FALSE(wm::IsActiveWindow(normal_window.get())); |
| EXPECT_TRUE(wm::IsActiveWindow(modal_window.get())); |
| |
| // We try to but cannot activate the normal window while we |
| // have the system modal window. |
| wm::ActivateWindow(normal_window.get()); |
| EXPECT_TRUE(ash::Shell::GetInstance()->IsSystemModalWindowOpen()); |
| EXPECT_FALSE(wm::IsActiveWindow(normal_window.get())); |
| EXPECT_TRUE(wm::IsActiveWindow(modal_window.get())); |
| |
| modal_window->Hide(); |
| modal_window.reset(); |
| EXPECT_FALSE(ash::Shell::GetInstance()->IsSystemModalWindowOpen()); |
| EXPECT_TRUE(wm::IsActiveWindow(normal_window.get())); |
| } |
| |
| // Verifies that a lock window can get focus even if lock |
| // container is not visible (e.g. before animating it). |
| TEST_F(ActivationControllerTest, ActivateLockScreen) { |
| aura::Window* lock_container = |
| Shell::GetContainer(Shell::GetPrimaryRootWindow(), c3); |
| aura::test::TestWindowDelegate wd; |
| scoped_ptr<aura::Window> w1(aura::test::CreateTestWindowWithDelegate( |
| &wd, -1, gfx::Rect(50, 50, 50, 50), lock_container)); |
| |
| lock_container->layer()->SetVisible(false); |
| w1->Focus(); |
| EXPECT_TRUE(w1->HasFocus()); |
| } |
| |
| // Verifies that a next active window is chosen from current |
| // active display. |
| TEST_F(ActivationControllerTest, NextActiveWindowOnMultipleDisplays) { |
| if (!SupportsMultipleDisplays()) |
| return; |
| |
| UpdateDisplay("300x300,300x300"); |
| Shell::RootWindowList root_windows = Shell::GetAllRootWindows(); |
| |
| scoped_ptr<aura::Window> w1_d1(CreateTestWindowInShellWithBounds( |
| gfx::Rect(10, 10, 100, 100))); |
| scoped_ptr<aura::Window> w2_d1(CreateTestWindowInShellWithBounds( |
| gfx::Rect(20, 20, 100, 100))); |
| |
| EXPECT_EQ(root_windows[0], w1_d1->GetRootWindow()); |
| EXPECT_EQ(root_windows[0], w2_d1->GetRootWindow()); |
| |
| scoped_ptr<aura::Window> w3_d2(CreateTestWindowInShellWithBounds( |
| gfx::Rect(310, 10, 100, 100))); |
| scoped_ptr<aura::Window> w4_d2(CreateTestWindowInShellWithBounds( |
| gfx::Rect(320, 20, 100, 100))); |
| EXPECT_EQ(root_windows[1], w3_d2->GetRootWindow()); |
| EXPECT_EQ(root_windows[1], w4_d2->GetRootWindow()); |
| |
| aura::client::ActivationClient* client = |
| aura::client::GetActivationClient(root_windows[0]); |
| client->ActivateWindow(w1_d1.get()); |
| EXPECT_EQ(w1_d1.get(), client->GetActiveWindow()); |
| |
| w1_d1.reset(); |
| EXPECT_EQ(w2_d1.get(), client->GetActiveWindow()); |
| |
| client->ActivateWindow(w3_d2.get()); |
| EXPECT_EQ(w3_d2.get(), client->GetActiveWindow()); |
| w3_d2.reset(); |
| EXPECT_EQ(w4_d2.get(), client->GetActiveWindow()); |
| } |
| |
| } // namespace test |
| } // namespace ash |