| Index: athena/wm/window_manager_unittest.cc
|
| diff --git a/athena/wm/window_manager_unittest.cc b/athena/wm/window_manager_unittest.cc
|
| deleted file mode 100644
|
| index b11d306d1b904ae8d3bdd240ca73cfce4c9a9d4a..0000000000000000000000000000000000000000
|
| --- a/athena/wm/window_manager_unittest.cc
|
| +++ /dev/null
|
| @@ -1,598 +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 "athena/wm/public/window_manager.h"
|
| -
|
| -#include "athena/screen/public/screen_manager.h"
|
| -#include "athena/test/base/athena_test_base.h"
|
| -#include "athena/test/base/test_windows.h"
|
| -#include "athena/wm/public/window_list_provider.h"
|
| -#include "athena/wm/split_view_controller.h"
|
| -#include "athena/wm/test/window_manager_impl_test_api.h"
|
| -#include "athena/wm/window_manager_impl.h"
|
| -#include "ui/aura/client/aura_constants.h"
|
| -#include "ui/aura/client/window_tree_client.h"
|
| -#include "ui/aura/test/test_window_delegate.h"
|
| -#include "ui/aura/window.h"
|
| -#include "ui/base/hit_test.h"
|
| -#include "ui/events/test/event_generator.h"
|
| -#include "ui/gfx/display.h"
|
| -#include "ui/gfx/screen.h"
|
| -#include "ui/wm/core/window_util.h"
|
| -
|
| -namespace athena {
|
| -
|
| -class WindowManagerTest : public test::AthenaTestBase {
|
| - public:
|
| - WindowManagerTest() {}
|
| - ~WindowManagerTest() override {}
|
| -
|
| - scoped_ptr<aura::Window> CreateAndActivateWindow(
|
| - aura::WindowDelegate* delegate) {
|
| - scoped_ptr<aura::Window> window(
|
| - test::CreateNormalWindow(delegate, nullptr));
|
| - window->Show();
|
| - wm::ActivateWindow(window.get());
|
| - window->SetProperty(aura::client::kCanMaximizeKey, true);
|
| - return window.Pass();
|
| - }
|
| -
|
| - private:
|
| - DISALLOW_COPY_AND_ASSIGN(WindowManagerTest);
|
| -};
|
| -
|
| -TEST_F(WindowManagerTest, OverviewModeBasics) {
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> first(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> second(CreateAndActivateWindow(&delegate));
|
| -
|
| - test::WindowManagerImplTestApi wm_api;
|
| - wm::ActivateWindow(second.get());
|
| -
|
| - ASSERT_FALSE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString());
|
| - EXPECT_EQ(gfx::Screen::GetNativeScreen()
|
| - ->GetPrimaryDisplay()
|
| - .work_area()
|
| - .size()
|
| - .ToString(),
|
| - first->bounds().size().ToString());
|
| - EXPECT_FALSE(WindowManager::Get()->IsOverviewModeActive());
|
| -
|
| - // Tests that going into overview mode does not change the window bounds.
|
| - WindowManager::Get()->EnterOverview();
|
| - ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString());
|
| - EXPECT_EQ(gfx::Screen::GetNativeScreen()
|
| - ->GetPrimaryDisplay()
|
| - .work_area()
|
| - .size()
|
| - .ToString(),
|
| - first->bounds().size().ToString());
|
| - EXPECT_TRUE(first->IsVisible());
|
| - EXPECT_TRUE(second->IsVisible());
|
| -
|
| - // Terminate overview mode. |first| should be hidden, since it's not visible
|
| - // to the user anymore.
|
| - WindowManager::Get()->ExitOverview();
|
| - ASSERT_FALSE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_FALSE(first->IsVisible());
|
| - EXPECT_TRUE(second->IsVisible());
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, OverviewToSplitViewMode) {
|
| - test::WindowManagerImplTestApi wm_api;
|
| -
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate));
|
| - wm::ActivateWindow(w3.get());
|
| -
|
| - WindowManager::Get()->EnterOverview();
|
| - EXPECT_TRUE(w1->IsVisible());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| -
|
| - // Go into split-view mode.
|
| - WindowOverviewModeDelegate* overview_delegate = wm_api.wm();
|
| - overview_delegate->OnSelectSplitViewWindow(w3.get(), nullptr, w3.get());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| - EXPECT_FALSE(w1->IsVisible());
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, OnSelectWindow) {
|
| - test::WindowManagerImplTestApi wm_api;
|
| - aura::test::TestWindowDelegate delegate1;
|
| - aura::test::TestWindowDelegate delegate2;
|
| - aura::test::TestWindowDelegate delegate3;
|
| -
|
| - // (w1): A window that sets a maximum size
|
| - delegate1.set_maximum_size(gfx::Size(300, 200));
|
| - scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate1));
|
| - w1->SetBounds(gfx::Rect(0, 0, 300, 200));
|
| -
|
| - // (w2): A window that doesn't set a max size and is maximizable
|
| - scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate2));
|
| - w2->SetBounds(gfx::Rect(0, 0, 300, 200));
|
| - w2->SetProperty(aura::client::kCanMaximizeKey, true);
|
| -
|
| - // (w3): A window that doesn't set a max size but is NOT maximizable
|
| - scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate3));
|
| - w3->SetBounds(gfx::Rect(0, 0, 300, 200));
|
| - w3->SetProperty(aura::client::kCanMaximizeKey, false);
|
| -
|
| - const gfx::Size old_bounds1 = w1->GetTargetBounds().size();
|
| - const gfx::Size old_bounds2 = w2->GetTargetBounds().size();
|
| - const gfx::Size old_bounds3 = w3->GetTargetBounds().size();
|
| - const gfx::Size work_area =
|
| - gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
|
| -
|
| - // Select w1, which has a max size, in the overview mode and make sure it's
|
| - // not maximized.
|
| - WindowManager::Get()->EnterOverview();
|
| - WindowOverviewModeDelegate* overview_delegate = wm_api.wm();
|
| - overview_delegate->OnSelectWindow(w1.get());
|
| - const gfx::Size new_bounds1 = w1->GetTargetBounds().size();
|
| - EXPECT_EQ(new_bounds1.ToString(), old_bounds1.ToString());
|
| - EXPECT_NE(work_area.ToString(), new_bounds1.ToString());
|
| -
|
| - // Select w2, which has no max size & can be maximized, in the overview
|
| - // mode and make sure it's actually maximized.
|
| - WindowManager::Get()->EnterOverview();
|
| - overview_delegate->OnSelectWindow(w2.get());
|
| - const gfx::Size new_bounds2 = w2->GetTargetBounds().size();
|
| - EXPECT_NE(new_bounds2.ToString(), old_bounds2.ToString());
|
| - EXPECT_EQ(work_area.ToString(), new_bounds2.ToString());
|
| -
|
| - // Select w3, which has no max size & cannot be maximized, in the overview
|
| - // mode and make sure it's not maximized.
|
| - WindowManager::Get()->EnterOverview();
|
| - overview_delegate->OnSelectWindow(w3.get());
|
| - const gfx::Size new_bounds3 = w3->GetTargetBounds().size();
|
| - EXPECT_EQ(new_bounds3.ToString(), old_bounds3.ToString());
|
| - EXPECT_NE(work_area.ToString(), new_bounds3.ToString());
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, NewWindowFromOverview) {
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate));
|
| -
|
| - WindowManager::Get()->EnterOverview();
|
| - EXPECT_TRUE(w1->IsVisible());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| -
|
| - // Test that opening a new window exits overview mode. The new window could
|
| - // have been opened by JavaScript or by the home card.
|
| - scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate));
|
| -
|
| - ASSERT_FALSE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| - EXPECT_TRUE(wm::IsActiveWindow(w3.get()));
|
| - EXPECT_FALSE(w1->IsVisible());
|
| - EXPECT_FALSE(w2->IsVisible());
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindows) {
|
| - aura::test::TestWindowDelegate delegate;
|
| - delegate.set_window_component(HTCAPTION);
|
| - scoped_ptr<aura::Window> first(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> second(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> third(CreateAndActivateWindow(&delegate));
|
| -
|
| - test::WindowManagerImplTestApi wm_api;
|
| -
|
| - EXPECT_EQ(third.get(),
|
| - wm_api.GetWindowListProvider()->GetWindowList().back());
|
| -
|
| - // Do a title-swipe from the top to switch to the previous window.
|
| - ui::test::EventGenerator generator(root_window());
|
| - generator.GestureScrollSequence(gfx::Point(20, 10),
|
| - gfx::Point(20, 400),
|
| - base::TimeDelta::FromMilliseconds(20),
|
| - 5);
|
| - EXPECT_TRUE(wm::IsActiveWindow(second.get()));
|
| - EXPECT_EQ(second.get(),
|
| - wm_api.GetWindowListProvider()->GetWindowList().back());
|
| - EXPECT_TRUE(second->IsVisible());
|
| - EXPECT_FALSE(third->IsVisible());
|
| -
|
| - // Performing the same gesture again will switch back to |third|.
|
| - generator.GestureScrollSequence(gfx::Point(20, 10),
|
| - gfx::Point(20, 400),
|
| - base::TimeDelta::FromMilliseconds(20),
|
| - 5);
|
| - EXPECT_TRUE(wm::IsActiveWindow(third.get()));
|
| - EXPECT_EQ(third.get(),
|
| - wm_api.GetWindowListProvider()->GetWindowList().back());
|
| - EXPECT_FALSE(second->IsVisible());
|
| - EXPECT_TRUE(third->IsVisible());
|
| -
|
| - // Perform a swipe that doesn't go enough to perform the window switch.
|
| - generator.GestureScrollSequence(gfx::Point(20, 10),
|
| - gfx::Point(20, 90),
|
| - base::TimeDelta::FromMilliseconds(20),
|
| - 5);
|
| - EXPECT_TRUE(wm::IsActiveWindow(third.get()));
|
| - EXPECT_EQ(third.get(),
|
| - wm_api.GetWindowListProvider()->GetWindowList().back());
|
| - EXPECT_FALSE(second->IsVisible());
|
| - EXPECT_TRUE(third->IsVisible());
|
| -}
|
| -
|
| -// Verifies that the correct windows are replaced and the ordering of
|
| -// the window list changes correctly when the window titlebars are dragged
|
| -// in split view mode.
|
| -TEST_F(WindowManagerTest, ReplaceWindowsInSplitViewMode) {
|
| - aura::test::TestWindowDelegate delegate;
|
| - delegate.set_window_component(HTCAPTION);
|
| - scoped_ptr<aura::Window> first(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> second(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> third(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> fourth(CreateAndActivateWindow(&delegate));
|
| -
|
| - test::WindowManagerImplTestApi wm_api;
|
| - wm_api.wm()->ToggleSplitView();
|
| - ASSERT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| -
|
| - // Verify that the left and right windows have been set to the
|
| - // two windows at the top of the window list.
|
| - aura::Window::Windows windows =
|
| - wm_api.GetWindowListProvider()->GetWindowList();
|
| - ASSERT_EQ(4u, windows.size());
|
| - EXPECT_EQ(first.get(), windows[0]);
|
| - EXPECT_EQ(second.get(), windows[1]);
|
| - EXPECT_EQ(third.get(), windows[2]);
|
| - EXPECT_EQ(fourth.get(), windows[3]);
|
| - EXPECT_EQ(fourth.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(third.get(), wm_api.GetSplitViewController()->right_window());
|
| -
|
| - // Swiping the title of the left window should change it from |fourth|
|
| - // to |second|. The right window should not change.
|
| - ui::test::EventGenerator generator(root_window());
|
| - generator.GestureScrollSequence(gfx::Point(20, 10),
|
| - gfx::Point(20, 400),
|
| - base::TimeDelta::FromMilliseconds(20),
|
| - 5);
|
| - EXPECT_EQ(second.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(third.get(), wm_api.GetSplitViewController()->right_window());
|
| -
|
| - // |second| should be placed at the front of the list. The replaced
|
| - // window (|fourth|) should be stacked behind the non-replaced window
|
| - // (|third|).
|
| - windows = wm_api.GetWindowListProvider()->GetWindowList();
|
| - ASSERT_EQ(4u, windows.size());
|
| - EXPECT_EQ(first.get(), windows[0]);
|
| - EXPECT_EQ(fourth.get(), windows[1]);
|
| - EXPECT_EQ(third.get(), windows[2]);
|
| - EXPECT_EQ(second.get(), windows[3]);
|
| -
|
| - // Swiping the title of the right window should change it from |third|
|
| - // to |fourth|. The left window should not change.
|
| - int x_middle = root_window()->bounds().width() / 2;
|
| - generator.GestureScrollSequence(gfx::Point(x_middle + 20, 10),
|
| - gfx::Point(x_middle + 20, 400),
|
| - base::TimeDelta::FromMilliseconds(20),
|
| - 5);
|
| - EXPECT_EQ(second.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(fourth.get(), wm_api.GetSplitViewController()->right_window());
|
| -
|
| - // |fourth| should be placed at the front of the list. The replaced
|
| - // window (|third|) should be stacked behind the non-replaced window
|
| - // (|second|).
|
| - windows = wm_api.GetWindowListProvider()->GetWindowList();
|
| - ASSERT_EQ(4u, windows.size());
|
| - EXPECT_EQ(first.get(), windows[0]);
|
| - EXPECT_EQ(third.get(), windows[1]);
|
| - EXPECT_EQ(second.get(), windows[2]);
|
| - EXPECT_EQ(fourth.get(), windows[3]);
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, NewWindowBounds) {
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> first(CreateAndActivateWindow(&delegate));
|
| -
|
| - test::WindowManagerImplTestApi wm_api;
|
| - // The window should have the same size as the container.
|
| - const gfx::Size work_area =
|
| - gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size();
|
| - EXPECT_EQ(work_area.ToString(),
|
| - first->bounds().size().ToString());
|
| - EXPECT_TRUE(first->bounds().origin().IsOrigin());
|
| -
|
| - // A second window should have the same bounds as the first one.
|
| - scoped_ptr<aura::Window> second(CreateAndActivateWindow(&delegate));
|
| - EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString());
|
| -
|
| - // Get into split view.
|
| - wm_api.GetSplitViewController()->ActivateSplitMode(nullptr, nullptr, nullptr);
|
| - const gfx::Rect left_bounds =
|
| - wm_api.GetSplitViewController()->left_window()->bounds();
|
| - EXPECT_NE(work_area.ToString(),
|
| - left_bounds.size().ToString());
|
| -
|
| - // A new window should replace the left window when in split view.
|
| - scoped_ptr<aura::Window> third(CreateAndActivateWindow(&delegate));
|
| - EXPECT_EQ(wm_api.GetSplitViewController()->left_window(), third.get());
|
| - EXPECT_EQ(left_bounds.ToString(), third->bounds().ToString());
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, OverviewModeAccelerators) {
|
| - ui::test::EventGenerator generator(root_window());
|
| -
|
| - // F6 toggles overview mode
|
| - ASSERT_FALSE(WindowManager::Get()->IsOverviewModeActive());
|
| - generator.PressKey(ui::VKEY_F6, ui::EF_NONE);
|
| - EXPECT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - generator.PressKey(ui::VKEY_F6, ui::EF_NONE);
|
| - EXPECT_FALSE(WindowManager::Get()->IsOverviewModeActive());
|
| -
|
| - // ESC exits overview mode
|
| - generator.PressKey(ui::VKEY_F6, ui::EF_NONE);
|
| - EXPECT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - generator.PressKey(ui::VKEY_ESCAPE, ui::EF_NONE);
|
| - EXPECT_FALSE(WindowManager::Get()->IsOverviewModeActive());
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, SplitModeActivationByShortcut) {
|
| - test::WindowManagerImplTestApi wm_api;
|
| -
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate));
|
| -
|
| - // Splitview mode needs at least two windows.
|
| - wm_api.wm()->ToggleSplitView();
|
| - EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| -
|
| - scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate));
|
| - w2->Show();
|
| -
|
| - wm_api.wm()->ToggleSplitView();
|
| - EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - int width =
|
| - gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().width();
|
| -
|
| - EXPECT_EQ(w1->bounds().width(), w2->bounds().width());
|
| - EXPECT_GE(width / 2, w1->bounds().width());
|
| -
|
| - // Toggle back to normal mode.
|
| - wm_api.wm()->ToggleSplitView();
|
| - EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| -
|
| - // w2 is the top window, it should be resized to max width and must be visible
|
| - // w1 should be hidden.
|
| - EXPECT_EQ(width, w2->bounds().width());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| - EXPECT_FALSE(w1->IsVisible());
|
| -
|
| - // Expect w1 to be visible and maximized when activated.
|
| - // TODO(oshima): To change to wm::ActivateWindow once the correct window state
|
| - // is implemented.
|
| - w1->Show();
|
| - EXPECT_EQ(width, w1->bounds().width());
|
| - EXPECT_TRUE(w1->IsVisible());
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, OverviewModeFromSplitMode) {
|
| - test::WindowManagerImplTestApi wm_api;
|
| -
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate));
|
| -
|
| - // Get into split-view mode, and then turn on overview mode.
|
| - wm_api.GetSplitViewController()->ActivateSplitMode(nullptr, nullptr, nullptr);
|
| - WindowManager::Get()->EnterOverview();
|
| - EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(w2.get(), wm_api.GetSplitViewController()->right_window());
|
| -
|
| - WindowOverviewModeDelegate* overview_delegate = wm_api.wm();
|
| - overview_delegate->OnSelectWindow(w1.get());
|
| - EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_TRUE(w1->IsVisible());
|
| - // Make sure the windows that were in split-view mode are hidden.
|
| - EXPECT_FALSE(w2->IsVisible());
|
| - EXPECT_FALSE(w3->IsVisible());
|
| -}
|
| -
|
| -// Clicking a background in overview should not crash.
|
| -TEST_F(WindowManagerTest, ClickBackgroundInOverview) {
|
| - test::WindowManagerImplTestApi wm_api;
|
| -
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate));
|
| - WindowManager::Get()->EnterOverview();
|
| -
|
| - ui::test::EventGenerator generator(root_window());
|
| - generator.MoveMouseTo(1, 1);
|
| - generator.ClickLeftButton();
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, CloseWindow) {
|
| - test::WindowManagerImplTestApi wm_api;
|
| -
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate));
|
| -
|
| - EXPECT_EQ(w3.get(),
|
| - wm_api.GetWindowListProvider()->GetWindowList().back());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| - EXPECT_TRUE(wm::IsActiveWindow(w3.get()));
|
| -
|
| - // Closes the front window (w3).
|
| - w3.reset();
|
| - EXPECT_EQ(w2.get(),
|
| - wm_api.GetWindowListProvider()->GetWindowList().back());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| - EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
|
| -
|
| - // Closes a non-front window (w1).
|
| - w1.reset();
|
| - EXPECT_EQ(w2.get(),
|
| - wm_api.GetWindowListProvider()->GetWindowList().back());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| - EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
|
| -
|
| - // Closes w2.
|
| - w2.reset();
|
| - EXPECT_TRUE(wm_api.GetWindowListProvider()->GetWindowList().empty());
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, CloseWindowInSplitMode) {
|
| - test::WindowManagerImplTestApi wm_api;
|
| -
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w4(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w5(CreateAndActivateWindow(&delegate));
|
| -
|
| - // Get into split-view mode.
|
| - wm_api.GetSplitViewController()->ActivateSplitMode(NULL, NULL, NULL);
|
| - EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_EQ(w5.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(w4.get(), wm_api.GetSplitViewController()->right_window());
|
| - EXPECT_TRUE(w5->IsVisible());
|
| - EXPECT_TRUE(w4->IsVisible());
|
| - EXPECT_TRUE(wm::IsActiveWindow(w5.get()));
|
| -
|
| - // Closes the left window (w5).
|
| - w5.reset();
|
| -
|
| - EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(w4.get(), wm_api.GetSplitViewController()->right_window());
|
| - EXPECT_TRUE(w4->IsVisible());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| - EXPECT_TRUE(wm::IsActiveWindow(w4.get()));
|
| -
|
| - // Closes the right window (w4).
|
| - w4.reset();
|
| -
|
| - EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(w2.get(), wm_api.GetSplitViewController()->right_window());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| - EXPECT_TRUE(wm::IsActiveWindow(w3.get()));
|
| -
|
| - // Closes a non-visible window (w1).
|
| - w1.reset();
|
| -
|
| - EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(w2.get(), wm_api.GetSplitViewController()->right_window());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| - EXPECT_TRUE(wm::IsActiveWindow(w3.get()));
|
| -
|
| - // Closes a non-visible window (w1).
|
| - w3.reset();
|
| -
|
| - EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| - EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, CloseWindowFromOverview) {
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate));
|
| - EXPECT_FALSE(wm::IsActiveWindow(w1.get()));
|
| - EXPECT_FALSE(wm::IsActiveWindow(w2.get()));
|
| - EXPECT_TRUE(wm::IsActiveWindow(w3.get()));
|
| -
|
| - WindowManager::Get()->EnterOverview();
|
| -
|
| - ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_TRUE(w1->IsVisible());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| - EXPECT_FALSE(wm::IsActiveWindow(w1.get()));
|
| - EXPECT_FALSE(wm::IsActiveWindow(w2.get()));
|
| - EXPECT_FALSE(wm::IsActiveWindow(w3.get()));
|
| -
|
| - w3.reset();
|
| -
|
| - ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_FALSE(wm::IsActiveWindow(w1.get()));
|
| - EXPECT_FALSE(wm::IsActiveWindow(w2.get()));
|
| - EXPECT_TRUE(w1->IsVisible());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| -
|
| - w1.reset();
|
| -
|
| - ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_FALSE(wm::IsActiveWindow(w2.get()));
|
| - EXPECT_TRUE(w2->IsVisible());
|
| -}
|
| -
|
| -TEST_F(WindowManagerTest, CloseWindowInSplitModeFromOverview) {
|
| - test::WindowManagerImplTestApi wm_api;
|
| -
|
| - aura::test::TestWindowDelegate delegate;
|
| - scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w4(CreateAndActivateWindow(&delegate));
|
| - scoped_ptr<aura::Window> w5(CreateAndActivateWindow(&delegate));
|
| -
|
| - // Get into split-view mode.
|
| - wm_api.GetSplitViewController()->ActivateSplitMode(NULL, NULL, NULL);
|
| - WindowManager::Get()->EnterOverview();
|
| -
|
| - ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_EQ(w5.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(w4.get(), wm_api.GetSplitViewController()->right_window());
|
| - EXPECT_TRUE(w5->IsVisible());
|
| - EXPECT_TRUE(w4->IsVisible());
|
| -
|
| - // Closes the left window (w5).
|
| - w5.reset();
|
| -
|
| - ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(w4.get(), wm_api.GetSplitViewController()->right_window());
|
| - EXPECT_TRUE(w4->IsVisible());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| -
|
| - // Closes the right window (w4).
|
| - w4.reset();
|
| -
|
| - ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(w2.get(), wm_api.GetSplitViewController()->right_window());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| -
|
| - // Closes a non-visible window (w1).
|
| - w1.reset();
|
| -
|
| - ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window());
|
| - EXPECT_EQ(w2.get(), wm_api.GetSplitViewController()->right_window());
|
| - EXPECT_TRUE(w3->IsVisible());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| -
|
| - // Closes a non-visible window (w1).
|
| - w3.reset();
|
| -
|
| - ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive());
|
| - EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive());
|
| - EXPECT_TRUE(w2->IsVisible());
|
| -}
|
| -
|
| -} // namespace athena
|
|
|