Chromium Code Reviews Chromium Code Reviews
Issue 2391153002:
Converts most of WorkspaceLayoutManager tests to use common code (Closed)
| Index: ash/wm/workspace/workspace_layout_manager_unittest.cc |
| diff --git a/ash/wm/workspace/workspace_layout_manager_unittest.cc b/ash/wm/workspace/workspace_layout_manager_unittest.cc |
| index bc492d9ee7adf1ab0943348978e3e0ef9bb2c2c8..c659bfed04de3f7912a61d176577b7498382c78e 100644 |
| --- a/ash/wm/workspace/workspace_layout_manager_unittest.cc |
| +++ b/ash/wm/workspace/workspace_layout_manager_unittest.cc |
| @@ -14,10 +14,15 @@ |
| #include "ash/common/shelf/wm_shelf.h" |
| #include "ash/common/shell_observer.h" |
| #include "ash/common/shell_window_ids.h" |
| +#include "ash/common/test/ash_test.h" |
| +#include "ash/common/wm/fullscreen_window_finder.h" |
| #include "ash/common/wm/maximize_mode/workspace_backdrop_delegate.h" |
| #include "ash/common/wm/window_state.h" |
| #include "ash/common/wm/wm_event.h" |
| +#include "ash/common/wm/wm_screen_util.h" |
| #include "ash/common/wm/workspace/workspace_window_resizer.h" |
| +#include "ash/common/wm_lookup.h" |
| +#include "ash/common/wm_root_window_controller.h" |
| #include "ash/common/wm_shell.h" |
| #include "ash/display/display_manager.h" |
| #include "ash/root_window_controller.h" |
| @@ -30,10 +35,6 @@ |
| #include "base/command_line.h" |
| #include "base/compiler_specific.h" |
| #include "base/run_loop.h" |
| -#include "ui/aura/client/aura_constants.h" |
| -#include "ui/aura/test/test_windows.h" |
| -#include "ui/aura/window.h" |
| -#include "ui/aura/window_event_dispatcher.h" |
| #include "ui/base/ui_base_switches.h" |
| #include "ui/base/ui_base_types.h" |
| #include "ui/display/manager/display_layout.h" |
| @@ -96,33 +97,33 @@ class TestShellObserver : public ShellObserver { |
| } // namespace |
| -typedef test::AshTestBase WorkspaceLayoutManagerTest; |
| +using WorkspaceLayoutManagerTest = AshTest; |
| // Verifies that a window containing a restore coordinate will be restored to |
| // to the size prior to minimize, keeping the restore rectangle in tact (if |
| // there is one). |
| TEST_F(WorkspaceLayoutManagerTest, RestoreFromMinimizeKeepsRestore) { |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 3, 4))); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(gfx::Rect(1, 2, 3, 4))); |
| + WmWindow* window = window_owner->window(); |
| gfx::Rect bounds(10, 15, 25, 35); |
| window->SetBounds(bounds); |
| - wm::WindowState* window_state = wm::GetWindowState(window.get()); |
| + wm::WindowState* window_state = window->GetWindowState(); |
| // This will not be used for un-minimizing window. |
| window_state->SetRestoreBoundsInScreen(gfx::Rect(0, 0, 100, 100)); |
| window_state->Minimize(); |
| window_state->Restore(); |
| EXPECT_EQ("0,0 100x100", window_state->GetRestoreBoundsInScreen().ToString()); |
| - EXPECT_EQ("10,15 25x35", window.get()->bounds().ToString()); |
| + EXPECT_EQ("10,15 25x35", window->GetBounds().ToString()); |
| if (!SupportsMultipleDisplays()) |
| return; |
| UpdateDisplay("400x300,500x400"); |
| - window->SetBoundsInScreen(gfx::Rect(600, 0, 100, 100), |
| - ScreenUtil::GetSecondaryDisplay()); |
| - EXPECT_EQ(Shell::GetAllRootWindows()[1], window->GetRootWindow()); |
| + window->SetBoundsInScreen(gfx::Rect(600, 0, 100, 100), GetSecondaryDisplay()); |
| + EXPECT_EQ(WmShell::Get()->GetAllRootWindows()[1], window->GetRootWindow()); |
| window_state->Minimize(); |
| // This will not be used for un-minimizing window. |
| window_state->SetRestoreBoundsInScreen(gfx::Rect(0, 0, 100, 100)); |
| @@ -134,9 +135,9 @@ TEST_F(WorkspaceLayoutManagerTest, RestoreFromMinimizeKeepsRestore) { |
| window_state->Minimize(); |
| UpdateDisplay("400x300"); |
| window_state->Restore(); |
| - EXPECT_EQ(Shell::GetPrimaryRootWindow(), window->GetRootWindow()); |
| - EXPECT_TRUE( |
| - Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds())); |
| + EXPECT_EQ(WmShell::Get()->GetPrimaryRootWindow(), window->GetRootWindow()); |
| + EXPECT_TRUE(WmShell::Get()->GetPrimaryRootWindow()->GetBounds().Intersects( |
| + window->GetBounds())); |
| } |
| TEST_F(WorkspaceLayoutManagerTest, KeepMinimumVisibilityInDisplays) { |
| @@ -144,20 +145,23 @@ TEST_F(WorkspaceLayoutManagerTest, KeepMinimumVisibilityInDisplays) { |
| return; |
| UpdateDisplay("300x400,400x500"); |
| - aura::Window::Windows root_windows = Shell::GetAllRootWindows(); |
| + WmWindow::Windows root_windows = WmShell::Get()->GetAllRootWindows(); |
| + |
| + if (!SetSecondaryDisplayPlacement(display::DisplayPlacement::TOP, 0)) |
| + return; |
| - Shell::GetInstance()->display_manager()->SetLayoutForCurrentDisplays( |
| - test::CreateDisplayLayout(display::DisplayPlacement::TOP, 0)); |
| EXPECT_EQ("0,-500 400x500", root_windows[1]->GetBoundsInScreen().ToString()); |
| - std::unique_ptr<aura::Window> window1( |
| - CreateTestWindowInShellWithBounds(gfx::Rect(10, -400, 200, 200))); |
| - EXPECT_EQ("10,-400 200x200", window1->GetBoundsInScreen().ToString()); |
| + std::unique_ptr<WindowOwner> window1_owner( |
| + CreateTestWindow(gfx::Rect(10, -400, 200, 200))); |
| + EXPECT_EQ("10,-400 200x200", |
| + window1_owner->window()->GetBoundsInScreen().ToString()); |
| // Make sure the caption is visible. |
| - std::unique_ptr<aura::Window> window2( |
| - CreateTestWindowInShellWithBounds(gfx::Rect(10, -600, 200, 200))); |
| - EXPECT_EQ("10,-500 200x200", window2->GetBoundsInScreen().ToString()); |
| + std::unique_ptr<WindowOwner> window2_owner( |
| + CreateTestWindow(gfx::Rect(10, -600, 200, 200))); |
| + EXPECT_EQ("10,-500 200x200", |
| + window2_owner->window()->GetBoundsInScreen().ToString()); |
| } |
| TEST_F(WorkspaceLayoutManagerTest, NoMinimumVisibilityForPopupWindows) { |
| @@ -165,49 +169,50 @@ TEST_F(WorkspaceLayoutManagerTest, NoMinimumVisibilityForPopupWindows) { |
| // Create a popup window out of display boundaries and make sure it is not |
| // moved to have minimum visibility. |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithDelegateAndType( |
| - nullptr, ui::wm::WINDOW_TYPE_POPUP, 0, gfx::Rect(400, 100, 50, 50))); |
| - EXPECT_EQ("400,100 50x50", window->GetBoundsInScreen().ToString()); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(gfx::Rect(400, 100, 50, 50), ui::wm::WINDOW_TYPE_POPUP)); |
| + EXPECT_EQ("400,100 50x50", |
| + window_owner->window()->GetBoundsInScreen().ToString()); |
| } |
| TEST_F(WorkspaceLayoutManagerTest, KeepRestoredWindowInDisplay) { |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40))); |
| - wm::WindowState* window_state = wm::GetWindowState(window.get()); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(gfx::Rect(1, 2, 30, 40))); |
| + WmWindow* window = window_owner->window(); |
| + wm::WindowState* window_state = window->GetWindowState(); |
| // Maximized -> Normal transition. |
| window_state->Maximize(); |
| window_state->SetRestoreBoundsInScreen(gfx::Rect(-100, -100, 30, 40)); |
| window_state->Restore(); |
| - EXPECT_TRUE( |
| - Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds())); |
| + EXPECT_TRUE(WmShell::Get()->GetPrimaryRootWindow()->GetBounds().Intersects( |
| + window->GetBounds())); |
| // Y bounds should not be negative. |
| - EXPECT_EQ("-5,0 30x40", window->bounds().ToString()); |
| + EXPECT_EQ("-5,0 30x40", window->GetBounds().ToString()); |
| // Minimized -> Normal transition. |
| window->SetBounds(gfx::Rect(-100, -100, 30, 40)); |
| window_state->Minimize(); |
| - EXPECT_FALSE( |
| - Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds())); |
| - EXPECT_EQ("-100,-100 30x40", window->bounds().ToString()); |
| + EXPECT_FALSE(WmShell::Get()->GetPrimaryRootWindow()->GetBounds().Intersects( |
| + window->GetBounds())); |
| + EXPECT_EQ("-100,-100 30x40", window->GetBounds().ToString()); |
| window->Show(); |
| - EXPECT_TRUE( |
| - Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds())); |
| + EXPECT_TRUE(WmShell::Get()->GetPrimaryRootWindow()->GetBounds().Intersects( |
| + window->GetBounds())); |
| // Y bounds should not be negative. |
| - EXPECT_EQ("-5,0 30x40", window->bounds().ToString()); |
| + EXPECT_EQ("-5,0 30x40", window->GetBounds().ToString()); |
| // Fullscreen -> Normal transition. |
| window->SetBounds(gfx::Rect(0, 0, 30, 40)); // reset bounds. |
| - ASSERT_EQ("0,0 30x40", window->bounds().ToString()); |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN); |
| - EXPECT_EQ(window->bounds(), window->GetRootWindow()->bounds()); |
| + ASSERT_EQ("0,0 30x40", window->GetBounds().ToString()); |
| + window->SetShowState(ui::SHOW_STATE_FULLSCREEN); |
| + EXPECT_EQ(window->GetBounds(), window->GetRootWindow()->GetBounds()); |
| window_state->SetRestoreBoundsInScreen(gfx::Rect(-100, -100, 30, 40)); |
| window_state->Restore(); |
| - EXPECT_TRUE( |
| - Shell::GetPrimaryRootWindow()->bounds().Intersects(window->bounds())); |
| + EXPECT_TRUE(WmShell::Get()->GetPrimaryRootWindow()->GetBounds().Intersects( |
| + window->GetBounds())); |
| // Y bounds should not be negative. |
| - EXPECT_EQ("-5,0 30x40", window->bounds().ToString()); |
| + EXPECT_EQ("-5,0 30x40", window->GetBounds().ToString()); |
| } |
| TEST_F(WorkspaceLayoutManagerTest, MaximizeInDisplayToBeRestored) { |
| @@ -215,13 +220,14 @@ TEST_F(WorkspaceLayoutManagerTest, MaximizeInDisplayToBeRestored) { |
| return; |
| UpdateDisplay("300x400,400x500"); |
| - aura::Window::Windows root_windows = Shell::GetAllRootWindows(); |
| + WmWindow::Windows root_windows = WmShell::Get()->GetAllRootWindows(); |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40))); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(gfx::Rect(1, 2, 30, 40))); |
| + WmWindow* window = window_owner->window(); |
| EXPECT_EQ(root_windows[0], window->GetRootWindow()); |
| - wm::WindowState* window_state = wm::GetWindowState(window.get()); |
| + wm::WindowState* window_state = window->GetWindowState(); |
| window_state->SetRestoreBoundsInScreen(gfx::Rect(400, 0, 30, 40)); |
| // Maximize the window in 2nd display as the restore bounds |
| // is inside 2nd display. |
| @@ -253,16 +259,21 @@ TEST_F(WorkspaceLayoutManagerTest, MaximizeInDisplayToBeRestored) { |
| views::Widget::InitParams params; |
| params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; |
| params.delegate = new MaximizeDelegateView(gfx::Rect(400, 0, 30, 40)); |
| - params.context = root_windows[0]; |
| + ConfigureWidgetInitParamsForDisplay(root_windows[0], ¶ms); |
| w1->Init(params); |
| + WmLookup* wm_lookup = WmLookup::Get(); |
| + EXPECT_EQ(root_windows[0], |
| + wm_lookup->GetWindowForWidget(w1.get())->GetRootWindow()); |
| w1->Show(); |
| EXPECT_TRUE(w1->IsMaximized()); |
| - EXPECT_EQ(root_windows[1], w1->GetNativeView()->GetRootWindow()); |
| + EXPECT_EQ(root_windows[1], |
| + wm_lookup->GetWindowForWidget(w1.get())->GetRootWindow()); |
| EXPECT_EQ( |
| gfx::Rect(300, 0, 400, 500 - GetShelfConstant(SHELF_SIZE)).ToString(), |
| w1->GetWindowBoundsInScreen().ToString()); |
| w1->Restore(); |
| - EXPECT_EQ(root_windows[1], w1->GetNativeView()->GetRootWindow()); |
| + EXPECT_EQ(root_windows[1], |
| + wm_lookup->GetWindowForWidget(w1.get())->GetRootWindow()); |
| EXPECT_EQ("400,0 30x40", w1->GetWindowBoundsInScreen().ToString()); |
| } |
| @@ -271,17 +282,18 @@ TEST_F(WorkspaceLayoutManagerTest, FullscreenInDisplayToBeRestored) { |
| return; |
| UpdateDisplay("300x400,400x500"); |
| - aura::Window::Windows root_windows = Shell::GetAllRootWindows(); |
| + WmWindow::Windows root_windows = WmShell::Get()->GetAllRootWindows(); |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40))); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(gfx::Rect(1, 2, 30, 40))); |
| + WmWindow* window = window_owner->window(); |
| EXPECT_EQ(root_windows[0], window->GetRootWindow()); |
| - wm::WindowState* window_state = wm::GetWindowState(window.get()); |
| + wm::WindowState* window_state = window->GetWindowState(); |
| window_state->SetRestoreBoundsInScreen(gfx::Rect(400, 0, 30, 40)); |
| // Maximize the window in 2nd display as the restore bounds |
| // is inside 2nd display. |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN); |
| + window->SetShowState(ui::SHOW_STATE_FULLSCREEN); |
| EXPECT_EQ(root_windows[1], window->GetRootWindow()); |
| EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString()); |
| @@ -292,7 +304,7 @@ TEST_F(WorkspaceLayoutManagerTest, FullscreenInDisplayToBeRestored) { |
| // If the restore bounds intersects with the current display, |
| // don't move. |
| window_state->SetRestoreBoundsInScreen(gfx::Rect(295, 0, 30, 40)); |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN); |
| + window->SetShowState(ui::SHOW_STATE_FULLSCREEN); |
| EXPECT_EQ(root_windows[1], window->GetRootWindow()); |
| EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString()); |
| @@ -301,37 +313,38 @@ TEST_F(WorkspaceLayoutManagerTest, FullscreenInDisplayToBeRestored) { |
| EXPECT_EQ("295,0 30x40", window->GetBoundsInScreen().ToString()); |
| } |
| -// WindowObserver implementation used by DontClobberRestoreBoundsWindowObserver. |
| -// This code mirrors what BrowserFrameAsh does. In particular when this code |
| -// sees the window was maximized it changes the bounds of a secondary |
| -// window. The secondary window mirrors the status window. |
| -class DontClobberRestoreBoundsWindowObserver : public aura::WindowObserver { |
| +// WmWindowObserver implementation used by |
| +// DontClobberRestoreBoundsWindowObserver. This code mirrors what |
| +// BrowserFrameAsh does. In particular when this code sees the window was |
| +// maximized it changes the bounds of a secondary window. The secondary window |
| +// mirrors the status window. |
| +class DontClobberRestoreBoundsWindowObserver : public WmWindowObserver { |
| public: |
| - DontClobberRestoreBoundsWindowObserver() : window_(nullptr) {} |
| + explicit DontClobberRestoreBoundsWindowObserver(AshTest* ash_test) |
| + : ash_test_(ash_test), window_(nullptr) {} |
| - void set_window(aura::Window* window) { window_ = window; } |
| + void set_window(WmWindow* window) { window_ = window; } |
| // aura::WindowObserver: |
|
James Cook
2016/10/04 23:16:05
WmWindowObserver
sky
2016/10/06 17:57:07
Done.
|
| - void OnWindowPropertyChanged(aura::Window* window, |
| - const void* key, |
| - intptr_t old) override { |
| + void OnWindowPropertyChanged(WmWindow* window, |
| + WmWindowProperty property) override { |
| if (!window_) |
| return; |
| - if (wm::GetWindowState(window)->IsMaximized()) { |
| - aura::Window* w = window_; |
| + if (window->GetWindowState()->IsMaximized()) { |
| + WmWindow* w = window_; |
| window_ = nullptr; |
| - gfx::Rect shelf_bounds( |
| - test::AshTestBase::GetPrimaryShelf()->GetIdealBounds()); |
| - const gfx::Rect& window_bounds(w->bounds()); |
| + gfx::Rect shelf_bounds(ash_test_->GetPrimaryShelf()->GetIdealBounds()); |
|
James Cook
2016/10/04 23:16:05
GetPrimaryShelf() being static would help here
sky
2016/10/06 17:57:07
Done.
|
| + const gfx::Rect& window_bounds(w->GetBounds()); |
| w->SetBounds(gfx::Rect(window_bounds.x(), shelf_bounds.y() - 1, |
| window_bounds.width(), window_bounds.height())); |
| } |
| } |
| private: |
| - aura::Window* window_; |
| + AshTest* ash_test_; |
| + WmWindow* window_; |
| DISALLOW_COPY_AND_ASSIGN(DontClobberRestoreBoundsWindowObserver); |
| }; |
| @@ -340,26 +353,27 @@ class DontClobberRestoreBoundsWindowObserver : public aura::WindowObserver { |
| // notification sets the bounds of a window to overlap the shelf. Verifies this |
| // doesn't effect the restore bounds. |
| TEST_F(WorkspaceLayoutManagerTest, DontClobberRestoreBounds) { |
| - DontClobberRestoreBoundsWindowObserver window_observer; |
| - std::unique_ptr<aura::Window> window(new aura::Window(nullptr)); |
| - window->SetType(ui::wm::WINDOW_TYPE_NORMAL); |
| - window->Init(ui::LAYER_TEXTURED); |
| + DontClobberRestoreBoundsWindowObserver window_observer(this); |
| + WindowOwner window_owner(WmShell::Get()->NewWindow(ui::wm::WINDOW_TYPE_NORMAL, |
| + ui::LAYER_TEXTURED)); |
| + WmWindow* window = window_owner.window(); |
| window->SetBounds(gfx::Rect(10, 20, 30, 40)); |
| // NOTE: for this test to exercise the failure the observer needs to be added |
| // before the parent set. This mimics what BrowserFrameAsh does. |
| window->AddObserver(&window_observer); |
| - ParentWindowInPrimaryRootWindow(window.get()); |
| + ParentWindowInPrimaryRootWindow(window); |
| window->Show(); |
| - wm::WindowState* window_state = wm::GetWindowState(window.get()); |
| + wm::WindowState* window_state = window->GetWindowState(); |
| window_state->Activate(); |
| - std::unique_ptr<aura::Window> window2( |
| - CreateTestWindowInShellWithBounds(gfx::Rect(12, 20, 30, 40))); |
| - ::wm::AddTransientChild(window.get(), window2.get()); |
| + std::unique_ptr<WindowOwner> window_owner2( |
| + CreateTestWindow(gfx::Rect(12, 20, 30, 40))); |
| + WmWindow* window2 = window_owner2->window(); |
| + AddTransientChild(window, window2); |
| window2->Show(); |
| - window_observer.set_window(window2.get()); |
| + window_observer.set_window(window2); |
| window_state->Maximize(); |
| EXPECT_EQ("10,20 30x40", window_state->GetRestoreBoundsInScreen().ToString()); |
| window->RemoveObserver(&window_observer); |
| @@ -367,28 +381,30 @@ TEST_F(WorkspaceLayoutManagerTest, DontClobberRestoreBounds) { |
| // Verifies when a window is maximized all descendant windows have a size. |
| TEST_F(WorkspaceLayoutManagerTest, ChildBoundsResetOnMaximize) { |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithBounds(gfx::Rect(10, 20, 30, 40))); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(gfx::Rect(10, 20, 30, 40))); |
| + WmWindow* window = window_owner->window(); |
| window->Show(); |
| - wm::WindowState* window_state = wm::GetWindowState(window.get()); |
| + wm::WindowState* window_state = window->GetWindowState(); |
| window_state->Activate(); |
| - std::unique_ptr<aura::Window> child_window( |
| - aura::test::CreateTestWindowWithBounds(gfx::Rect(5, 6, 7, 8), |
| - window.get())); |
| - child_window->Show(); |
| + std::unique_ptr<WindowOwner> child_window_owner( |
| + CreateChildWindow(window, gfx::Rect(5, 6, 7, 8))); |
| + WmWindow* child_window = child_window_owner->window(); |
| window_state->Maximize(); |
| - EXPECT_EQ("5,6 7x8", child_window->bounds().ToString()); |
| + EXPECT_EQ("5,6 7x8", child_window->GetBounds().ToString()); |
| } |
| // Verifies a window created with maximized state has the maximized |
| // bounds. |
| TEST_F(WorkspaceLayoutManagerTest, MaximizeWithEmptySize) { |
| - std::unique_ptr<aura::Window> window( |
| - aura::test::CreateTestWindowWithBounds(gfx::Rect(0, 0, 0, 0), nullptr)); |
| - wm::GetWindowState(window.get())->Maximize(); |
| - aura::Window* default_container = Shell::GetContainer( |
| - Shell::GetPrimaryRootWindow(), kShellWindowId_DefaultContainer); |
| - default_container->AddChild(window.get()); |
| + WindowOwner window_owner(WmShell::Get()->NewWindow(ui::wm::WINDOW_TYPE_NORMAL, |
| + ui::LAYER_TEXTURED)); |
| + WmWindow* window = window_owner.window(); |
| + window->GetWindowState()->Maximize(); |
| + WmWindow* default_container = |
| + WmShell::Get()->GetPrimaryRootWindowController()->GetContainer( |
| + kShellWindowId_DefaultContainer); |
| + default_container->AddChild(window); |
| window->Show(); |
| gfx::Rect work_area( |
| display::Screen::GetScreen()->GetPrimaryDisplay().work_area()); |
| @@ -398,33 +414,34 @@ TEST_F(WorkspaceLayoutManagerTest, MaximizeWithEmptySize) { |
| TEST_F(WorkspaceLayoutManagerTest, WindowShouldBeOnScreenWhenAdded) { |
| // Normal window bounds shouldn't be changed. |
| gfx::Rect window_bounds(100, 100, 200, 200); |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithBounds(window_bounds)); |
| - EXPECT_EQ(window_bounds, window->bounds()); |
| + std::unique_ptr<WindowOwner> window_owner(CreateTestWindow(window_bounds)); |
| + WmWindow* window = window_owner->window(); |
| + EXPECT_EQ(window_bounds, window->GetBounds()); |
| // If the window is out of the workspace, it would be moved on screen. |
| gfx::Rect root_window_bounds = |
| - Shell::GetInstance()->GetPrimaryRootWindow()->bounds(); |
| + WmShell::Get()->GetPrimaryRootWindow()->GetBounds(); |
| window_bounds.Offset(root_window_bounds.width(), root_window_bounds.height()); |
| ASSERT_FALSE(window_bounds.Intersects(root_window_bounds)); |
| - std::unique_ptr<aura::Window> out_window( |
| - CreateTestWindowInShellWithBounds(window_bounds)); |
| - EXPECT_EQ(window_bounds.size(), out_window->bounds().size()); |
| - gfx::Rect bounds = out_window->bounds(); |
| + std::unique_ptr<WindowOwner> out_window_owner( |
| + CreateTestWindow(window_bounds)); |
| + WmWindow* out_window = out_window_owner->window(); |
| + EXPECT_EQ(window_bounds.size(), out_window->GetBounds().size()); |
| + gfx::Rect bounds = out_window->GetBounds(); |
| bounds.Intersect(root_window_bounds); |
| // 30% of the window edge must be visible. |
| - EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29); |
| - EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29); |
| + EXPECT_GT(bounds.width(), out_window->GetBounds().width() * 0.29); |
| + EXPECT_GT(bounds.height(), out_window->GetBounds().height() * 0.29); |
| - aura::Window* parent = out_window->parent(); |
| - parent->RemoveChild(out_window.get()); |
| + WmWindow* parent = out_window->GetParent(); |
| + parent->RemoveChild(out_window); |
| out_window->SetBounds(gfx::Rect(-200, -200, 200, 200)); |
| // UserHasChangedWindowPositionOrSize flag shouldn't turn off this behavior. |
| - wm::GetWindowState(window.get())->set_bounds_changed_by_user(true); |
| - parent->AddChild(out_window.get()); |
| - EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29); |
| - EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29); |
| + window->GetWindowState()->set_bounds_changed_by_user(true); |
| + parent->AddChild(out_window); |
| + EXPECT_GT(bounds.width(), out_window->GetBounds().width() * 0.29); |
| + EXPECT_GT(bounds.height(), out_window->GetBounds().height() * 0.29); |
| // Make sure we always make more than 1/3 of the window edge visible even |
| // if the initial bounds intersects with display. |
| @@ -434,32 +451,35 @@ TEST_F(WorkspaceLayoutManagerTest, WindowShouldBeOnScreenWhenAdded) { |
| // Make sure that the initial bounds' visible area is less than 26% |
| // so that the auto adjustment logic kicks in. |
| - ASSERT_LT(bounds.width(), out_window->bounds().width() * 0.26); |
| - ASSERT_LT(bounds.height(), out_window->bounds().height() * 0.26); |
| + ASSERT_LT(bounds.width(), out_window->GetBounds().width() * 0.26); |
| + ASSERT_LT(bounds.height(), out_window->GetBounds().height() * 0.26); |
| ASSERT_TRUE(window_bounds.Intersects(root_window_bounds)); |
| - std::unique_ptr<aura::Window> partially_out_window( |
| - CreateTestWindowInShellWithBounds(window_bounds)); |
| - EXPECT_EQ(window_bounds.size(), partially_out_window->bounds().size()); |
| - bounds = partially_out_window->bounds(); |
| + std::unique_ptr<WindowOwner> partially_out_window_owner( |
| + CreateTestWindow(window_bounds)); |
| + WmWindow* partially_out_window = partially_out_window_owner->window(); |
| + EXPECT_EQ(window_bounds.size(), partially_out_window->GetBounds().size()); |
| + bounds = partially_out_window->GetBounds(); |
| bounds.Intersect(root_window_bounds); |
| - EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29); |
| - EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29); |
| + EXPECT_GT(bounds.width(), out_window->GetBounds().width() * 0.29); |
| + EXPECT_GT(bounds.height(), out_window->GetBounds().height() * 0.29); |
| // Make sure the window whose 30% width/height is bigger than display |
| // will be placed correctly. |
| window_bounds.SetRect(-1900, -1900, 3000, 3000); |
| - std::unique_ptr<aura::Window> window_bigger_than_display( |
| - CreateTestWindowInShellWithBounds(window_bounds)); |
| + std::unique_ptr<WindowOwner> window_bigger_than_display_owner( |
| + CreateTestWindow(window_bounds)); |
| + WmWindow* window_bigger_than_display = |
| + window_bigger_than_display_owner->window(); |
| EXPECT_GE(root_window_bounds.width(), |
| - window_bigger_than_display->bounds().width()); |
| + window_bigger_than_display->GetBounds().width()); |
| EXPECT_GE(root_window_bounds.height(), |
| - window_bigger_than_display->bounds().height()); |
| + window_bigger_than_display->GetBounds().height()); |
| - bounds = window_bigger_than_display->bounds(); |
| + bounds = window_bigger_than_display->GetBounds(); |
| bounds.Intersect(root_window_bounds); |
| - EXPECT_GT(bounds.width(), out_window->bounds().width() * 0.29); |
| - EXPECT_GT(bounds.height(), out_window->bounds().height() * 0.29); |
| + EXPECT_GT(bounds.width(), out_window->GetBounds().width() * 0.29); |
| + EXPECT_GT(bounds.height(), out_window->GetBounds().height() * 0.29); |
| } |
| // Verifies the size of a window is enforced to be smaller than the work area. |
| @@ -469,26 +489,28 @@ TEST_F(WorkspaceLayoutManagerTest, SizeToWorkArea) { |
| display::Screen::GetScreen()->GetPrimaryDisplay().work_area().size()); |
| const gfx::Rect window_bounds(100, 101, work_area.width() + 1, |
| work_area.height() + 2); |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithBounds(window_bounds)); |
| + std::unique_ptr<WindowOwner> window_owner(CreateTestWindow(window_bounds)); |
| + WmWindow* window = window_owner->window(); |
| EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(), |
| - window->bounds().ToString()); |
| + window->GetBounds().ToString()); |
| // Directly setting the bounds triggers a slightly different code path. Verify |
| // that too. |
| window->SetBounds(window_bounds); |
| EXPECT_EQ(gfx::Rect(gfx::Point(100, 101), work_area).ToString(), |
| - window->bounds().ToString()); |
| + window->GetBounds().ToString()); |
| } |
| TEST_F(WorkspaceLayoutManagerTest, NotifyFullscreenChanges) { |
| TestShellObserver observer; |
| - std::unique_ptr<aura::Window> window1( |
| - CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40))); |
| - std::unique_ptr<aura::Window> window2( |
| - CreateTestWindowInShellWithBounds(gfx::Rect(1, 2, 30, 40))); |
| - wm::WindowState* window_state1 = wm::GetWindowState(window1.get()); |
| - wm::WindowState* window_state2 = wm::GetWindowState(window2.get()); |
| + std::unique_ptr<WindowOwner> window1_owner( |
| + CreateTestWindow(gfx::Rect(1, 2, 30, 40))); |
| + WmWindow* window1 = window1_owner->window(); |
| + std::unique_ptr<WindowOwner> window2_owner( |
|
James Cook
2016/10/04 23:16:05
How about consistently using either |window2_owner
sky
2016/10/06 17:57:07
Done.
|
| + CreateTestWindow(gfx::Rect(1, 2, 30, 40))); |
| + WmWindow* window2 = window2_owner->window(); |
| + wm::WindowState* window_state1 = window1->GetWindowState(); |
| + wm::WindowState* window_state2 = window2->GetWindowState(); |
| window_state2->Activate(); |
| const wm::WMEvent toggle_fullscreen_event(wm::WM_EVENT_TOGGLE_FULLSCREEN); |
| @@ -515,69 +537,61 @@ TEST_F(WorkspaceLayoutManagerTest, NotifyFullscreenChanges) { |
| EXPECT_TRUE(observer.is_fullscreen()); |
| // Closing the window should change the fullscreen state. |
| - window2.reset(); |
| + window2_owner.reset(); |
| EXPECT_EQ(6, observer.call_count()); |
| EXPECT_FALSE(observer.is_fullscreen()); |
| } |
| // Following "Solo" tests were originally written for BaseLayoutManager. |
| -namespace { |
| - |
| -class WorkspaceLayoutManagerSoloTest : public test::AshTestBase { |
| - public: |
| - WorkspaceLayoutManagerSoloTest() {} |
| - ~WorkspaceLayoutManagerSoloTest() override {} |
| - |
| - aura::Window* CreateTestWindow(const gfx::Rect& bounds) { |
| - return CreateTestWindowInShellWithBounds(bounds); |
| - } |
| - |
| - private: |
| - DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerSoloTest); |
| -}; |
| - |
| -} // namespace |
| +using WorkspaceLayoutManagerSoloTest = AshTest; |
| // Tests normal->maximize->normal. |
| TEST_F(WorkspaceLayoutManagerSoloTest, Maximize) { |
| gfx::Rect bounds(100, 100, 200, 200); |
| - std::unique_ptr<aura::Window> window(CreateTestWindow(bounds)); |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED); |
| + std::unique_ptr<WindowOwner> window_owner(CreateTestWindow(bounds)); |
| + WmWindow* window = window_owner->window(); |
| + window->SetShowState(ui::SHOW_STATE_MAXIMIZED); |
| // Maximized window fills the work area, not the whole display. |
| - EXPECT_EQ( |
| - ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString(), |
| - window->bounds().ToString()); |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL); |
| - EXPECT_EQ(bounds.ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(wm::GetMaximizedWindowBoundsInParent(window).ToString(), |
| + window->GetBounds().ToString()); |
| + window->SetShowState(ui::SHOW_STATE_NORMAL); |
| + EXPECT_EQ(bounds.ToString(), window->GetBounds().ToString()); |
| } |
| // Tests normal->minimize->normal. |
| TEST_F(WorkspaceLayoutManagerSoloTest, Minimize) { |
| gfx::Rect bounds(100, 100, 200, 200); |
| - std::unique_ptr<aura::Window> window(CreateTestWindow(bounds)); |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED); |
| + std::unique_ptr<WindowOwner> window_owner(CreateTestWindow(bounds)); |
| + WmWindow* window = window_owner->window(); |
| + window->SetShowState(ui::SHOW_STATE_MINIMIZED); |
| // Note: Currently minimize doesn't do anything except set the state. |
| // See crbug.com/104571. |
| - EXPECT_EQ(bounds.ToString(), window->bounds().ToString()); |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL); |
| - EXPECT_EQ(bounds.ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(bounds.ToString(), window->GetBounds().ToString()); |
| + window->SetShowState(ui::SHOW_STATE_NORMAL); |
| + EXPECT_EQ(bounds.ToString(), window->GetBounds().ToString()); |
| } |
| -// A WindowDelegate which sets the focus when the window |
| +// A WmWindowObserver which sets the focus when the window |
| // becomes visible. |
| -class FocusDelegate : public aura::test::TestWindowDelegate { |
| +class FocusDelegate : public WmWindowObserver { |
|
James Cook
2016/10/04 23:16:05
Rename to FocusObserver (or something other than D
sky
2016/10/06 17:57:07
FocusOwner seemed like a confusing name to me, so
|
| public: |
| FocusDelegate() : window_(nullptr), show_state_(ui::SHOW_STATE_END) {} |
| - ~FocusDelegate() override {} |
| - |
| - void set_window(aura::Window* window) { window_ = window; } |
| + ~FocusDelegate() override { SetWindow(nullptr); } |
| + |
| + void SetWindow(WmWindow* window) { |
| + if (window_) |
| + window_->RemoveObserver(this); |
| + window_ = window; |
| + if (window_) |
| + window_->AddObserver(this); |
| + } |
| - // aura::test::TestWindowDelegate overrides: |
| - void OnWindowTargetVisibilityChanged(bool visible) override { |
| + // WmWindowObserver: |
| + void OnWindowVisibilityChanged(WmWindow* window, bool visible) override { |
| if (window_) { |
| if (visible) |
| - window_->Focus(); |
| - show_state_ = window_->GetProperty(aura::client::kShowStateKey); |
| + window_->SetFocused(); |
| + show_state_ = window_->GetShowState(); |
| } |
| } |
| @@ -588,7 +602,7 @@ class FocusDelegate : public aura::test::TestWindowDelegate { |
| } |
| private: |
| - aura::Window* window_; |
| + WmWindow* window_; |
| ui::WindowShowState show_state_; |
| DISALLOW_COPY_AND_ASSIGN(FocusDelegate); |
| @@ -600,15 +614,17 @@ class FocusDelegate : public aura::test::TestWindowDelegate { |
| // crbug.com/168383. |
| TEST_F(WorkspaceLayoutManagerSoloTest, FocusDuringUnminimize) { |
| FocusDelegate delegate; |
| - std::unique_ptr<aura::Window> window(CreateTestWindowInShellWithDelegate( |
| - &delegate, 0, gfx::Rect(100, 100, 100, 100))); |
| - delegate.set_window(window.get()); |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(gfx::Rect(100, 100, 100, 100))); |
| + WmWindow* window = window_owner->window(); |
| + delegate.SetWindow(window); |
| + window->SetShowState(ui::SHOW_STATE_MINIMIZED); |
| EXPECT_FALSE(window->IsVisible()); |
| EXPECT_EQ(ui::SHOW_STATE_MINIMIZED, delegate.GetShowStateAndReset()); |
| window->Show(); |
| EXPECT_TRUE(window->IsVisible()); |
| EXPECT_EQ(ui::SHOW_STATE_NORMAL, delegate.GetShowStateAndReset()); |
| + delegate.SetWindow(nullptr); |
| } |
| // Tests maximized window size during root window resize. |
| @@ -620,186 +636,180 @@ TEST_F(WorkspaceLayoutManagerSoloTest, FocusDuringUnminimize) { |
| #endif |
| TEST_F(WorkspaceLayoutManagerSoloTest, MAYBE_MaximizeRootWindowResize) { |
| gfx::Rect bounds(100, 100, 200, 200); |
| - std::unique_ptr<aura::Window> window(CreateTestWindow(bounds)); |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED); |
| + std::unique_ptr<WindowOwner> window_owner(CreateTestWindow(bounds)); |
| + WmWindow* window = window_owner->window(); |
| + window->SetShowState(ui::SHOW_STATE_MAXIMIZED); |
| gfx::Rect initial_work_area_bounds = |
| - ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()); |
| - EXPECT_EQ(initial_work_area_bounds.ToString(), window->bounds().ToString()); |
| + wm::GetMaximizedWindowBoundsInParent(window); |
| + EXPECT_EQ(initial_work_area_bounds.ToString(), |
| + window->GetBounds().ToString()); |
| // Enlarge the root window. We should still match the work area size. |
| UpdateDisplay("900x700"); |
| - EXPECT_EQ( |
| - ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString(), |
| - window->bounds().ToString()); |
| - EXPECT_NE( |
| - initial_work_area_bounds.ToString(), |
| - ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString()); |
| + EXPECT_EQ(wm::GetMaximizedWindowBoundsInParent(window).ToString(), |
| + window->GetBounds().ToString()); |
| + EXPECT_NE(initial_work_area_bounds.ToString(), |
| + wm::GetMaximizedWindowBoundsInParent(window).ToString()); |
| } |
| // Tests normal->fullscreen->normal. |
| TEST_F(WorkspaceLayoutManagerSoloTest, Fullscreen) { |
| gfx::Rect bounds(100, 100, 200, 200); |
| - std::unique_ptr<aura::Window> window(CreateTestWindow(bounds)); |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN); |
| + std::unique_ptr<WindowOwner> window_owner(CreateTestWindow(bounds)); |
| + WmWindow* window = window_owner->window(); |
| + window->SetShowState(ui::SHOW_STATE_FULLSCREEN); |
| // Fullscreen window fills the whole display. |
| - EXPECT_EQ(display::Screen::GetScreen() |
| - ->GetDisplayNearestWindow(window.get()) |
| - .bounds() |
| - .ToString(), |
| - window->bounds().ToString()); |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL); |
| - EXPECT_EQ(bounds.ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(window->GetDisplayNearestWindow().bounds().ToString(), |
| + window->GetBounds().ToString()); |
| + window->SetShowState(ui::SHOW_STATE_NORMAL); |
| + EXPECT_EQ(bounds.ToString(), window->GetBounds().ToString()); |
| } |
| // Tests that fullscreen window causes always_on_top windows to stack below. |
| TEST_F(WorkspaceLayoutManagerSoloTest, FullscreenSuspendsAlwaysOnTop) { |
| gfx::Rect bounds(100, 100, 200, 200); |
| - std::unique_ptr<aura::Window> fullscreen_window(CreateTestWindow(bounds)); |
| - std::unique_ptr<aura::Window> always_on_top_window1(CreateTestWindow(bounds)); |
| - std::unique_ptr<aura::Window> always_on_top_window2(CreateTestWindow(bounds)); |
| - always_on_top_window1->SetProperty(aura::client::kAlwaysOnTopKey, true); |
| - always_on_top_window2->SetProperty(aura::client::kAlwaysOnTopKey, true); |
| + std::unique_ptr<WindowOwner> fullscreen_window_owner( |
| + CreateTestWindow(bounds)); |
| + WmWindow* fullscreen_window = fullscreen_window_owner->window(); |
| + std::unique_ptr<WindowOwner> always_on_top_window1_owner( |
| + CreateTestWindow(bounds)); |
| + WmWindow* always_on_top_window1 = always_on_top_window1_owner->window(); |
| + std::unique_ptr<WindowOwner> always_on_top_window2_owner( |
| + CreateTestWindow(bounds)); |
| + WmWindow* always_on_top_window2 = always_on_top_window2_owner->window(); |
| + always_on_top_window1->SetAlwaysOnTop(true); |
| + always_on_top_window2->SetAlwaysOnTop(true); |
| // Making a window fullscreen temporarily suspends always on top state. |
| - fullscreen_window->SetProperty(aura::client::kShowStateKey, |
| - ui::SHOW_STATE_FULLSCREEN); |
| - EXPECT_FALSE( |
| - always_on_top_window1->GetProperty(aura::client::kAlwaysOnTopKey)); |
| - EXPECT_FALSE( |
| - always_on_top_window2->GetProperty(aura::client::kAlwaysOnTopKey)); |
| - EXPECT_NE(nullptr, GetRootWindowController(fullscreen_window->GetRootWindow()) |
| - ->GetWindowForFullscreenMode()); |
| + fullscreen_window->SetShowState(ui::SHOW_STATE_FULLSCREEN); |
| + EXPECT_FALSE(always_on_top_window1->IsAlwaysOnTop()); |
| + EXPECT_FALSE(always_on_top_window2->IsAlwaysOnTop()); |
| + EXPECT_NE(nullptr, wm::GetWindowForFullscreenMode(fullscreen_window)); |
| // Adding a new always-on-top window is not affected by fullscreen. |
| - std::unique_ptr<aura::Window> always_on_top_window3(CreateTestWindow(bounds)); |
| - always_on_top_window3->SetProperty(aura::client::kAlwaysOnTopKey, true); |
| - EXPECT_TRUE( |
| - always_on_top_window3->GetProperty(aura::client::kAlwaysOnTopKey)); |
| + std::unique_ptr<WindowOwner> always_on_top_window3_owner( |
| + CreateTestWindow(bounds)); |
| + WmWindow* always_on_top_window3 = always_on_top_window3_owner->window(); |
| + always_on_top_window3->SetAlwaysOnTop(true); |
| + EXPECT_TRUE(always_on_top_window3->IsAlwaysOnTop()); |
| // Making fullscreen window normal restores always on top windows. |
| - fullscreen_window->SetProperty(aura::client::kShowStateKey, |
| - ui::SHOW_STATE_NORMAL); |
| - EXPECT_TRUE( |
| - always_on_top_window1->GetProperty(aura::client::kAlwaysOnTopKey)); |
| - EXPECT_TRUE( |
| - always_on_top_window2->GetProperty(aura::client::kAlwaysOnTopKey)); |
| - EXPECT_TRUE( |
| - always_on_top_window3->GetProperty(aura::client::kAlwaysOnTopKey)); |
| - EXPECT_EQ(nullptr, GetRootWindowController(fullscreen_window->GetRootWindow()) |
| - ->GetWindowForFullscreenMode()); |
| + fullscreen_window->SetShowState(ui::SHOW_STATE_NORMAL); |
| + EXPECT_TRUE(always_on_top_window1->IsAlwaysOnTop()); |
| + EXPECT_TRUE(always_on_top_window2->IsAlwaysOnTop()); |
| + EXPECT_TRUE(always_on_top_window3->IsAlwaysOnTop()); |
| + EXPECT_EQ(nullptr, wm::GetWindowForFullscreenMode(fullscreen_window)); |
| } |
| // Similary, pinned window causes always_on_top_ windows to stack below. |
| TEST_F(WorkspaceLayoutManagerSoloTest, PinnedSuspendsAlwaysOnTop) { |
| + // TODO: mash doesn't support pinning yet http://crbug.com/622486. |
| + if (IsMash()) |
| + return; |
| + |
| gfx::Rect bounds(100, 100, 200, 200); |
| - std::unique_ptr<aura::Window> pinned_window(CreateTestWindow(bounds)); |
| - std::unique_ptr<aura::Window> always_on_top_window1(CreateTestWindow(bounds)); |
| - std::unique_ptr<aura::Window> always_on_top_window2(CreateTestWindow(bounds)); |
| - always_on_top_window1->SetProperty(aura::client::kAlwaysOnTopKey, true); |
| - always_on_top_window2->SetProperty(aura::client::kAlwaysOnTopKey, true); |
| + std::unique_ptr<WindowOwner> pinned_window_owner(CreateTestWindow(bounds)); |
| + WmWindow* pinned_window = pinned_window_owner->window(); |
| + std::unique_ptr<WindowOwner> always_on_top_window1_owner( |
| + CreateTestWindow(bounds)); |
| + WmWindow* always_on_top_window1 = always_on_top_window1_owner->window(); |
| + std::unique_ptr<WindowOwner> always_on_top_window2_owner( |
| + CreateTestWindow(bounds)); |
| + WmWindow* always_on_top_window2 = always_on_top_window2_owner->window(); |
| + always_on_top_window1->SetAlwaysOnTop(true); |
| + always_on_top_window2->SetAlwaysOnTop(true); |
| // Making a window pinned temporarily suspends always on top state. |
| - wm::PinWindow(pinned_window.get(), /* trusted */ false); |
| - EXPECT_FALSE( |
| - always_on_top_window1->GetProperty(aura::client::kAlwaysOnTopKey)); |
| - EXPECT_FALSE( |
| - always_on_top_window2->GetProperty(aura::client::kAlwaysOnTopKey)); |
| + const bool trusted = false; |
| + pinned_window->SetPinned(trusted); |
| + EXPECT_FALSE(always_on_top_window1->IsAlwaysOnTop()); |
| + EXPECT_FALSE(always_on_top_window2->IsAlwaysOnTop()); |
| // Adding a new always-on-top window also is affected by pinned mode. |
| - std::unique_ptr<aura::Window> always_on_top_window3(CreateTestWindow(bounds)); |
| - always_on_top_window3->SetProperty(aura::client::kAlwaysOnTopKey, true); |
| - EXPECT_FALSE( |
| - always_on_top_window3->GetProperty(aura::client::kAlwaysOnTopKey)); |
| + std::unique_ptr<WindowOwner> always_on_top_window3_owner( |
| + CreateTestWindow(bounds)); |
| + WmWindow* always_on_top_window3 = always_on_top_window3_owner->window(); |
| + always_on_top_window3->SetAlwaysOnTop(true); |
| + EXPECT_FALSE(always_on_top_window3->IsAlwaysOnTop()); |
| // Making pinned window normal restores always on top windows. |
| - WmWindowAura::Get(pinned_window.get())->GetWindowState()->Restore(); |
| - EXPECT_TRUE( |
| - always_on_top_window1->GetProperty(aura::client::kAlwaysOnTopKey)); |
| - EXPECT_TRUE( |
| - always_on_top_window2->GetProperty(aura::client::kAlwaysOnTopKey)); |
| - EXPECT_TRUE( |
| - always_on_top_window3->GetProperty(aura::client::kAlwaysOnTopKey)); |
| + pinned_window->GetWindowState()->Restore(); |
| + EXPECT_TRUE(always_on_top_window1->IsAlwaysOnTop()); |
| + EXPECT_TRUE(always_on_top_window2->IsAlwaysOnTop()); |
| + EXPECT_TRUE(always_on_top_window3->IsAlwaysOnTop()); |
| } |
| // Tests fullscreen window size during root window resize. |
| TEST_F(WorkspaceLayoutManagerSoloTest, FullscreenRootWindowResize) { |
| gfx::Rect bounds(100, 100, 200, 200); |
| - std::unique_ptr<aura::Window> window(CreateTestWindow(bounds)); |
| + std::unique_ptr<WindowOwner> window_owner(CreateTestWindow(bounds)); |
| + WmWindow* window = window_owner->window(); |
| // Fullscreen window fills the whole display. |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN); |
| - EXPECT_EQ(display::Screen::GetScreen() |
| - ->GetDisplayNearestWindow(window.get()) |
| - .bounds() |
| - .ToString(), |
| - window->bounds().ToString()); |
| + window->SetShowState(ui::SHOW_STATE_FULLSCREEN); |
| + EXPECT_EQ(window->GetDisplayNearestWindow().bounds().ToString(), |
| + window->GetBounds().ToString()); |
| // Enlarge the root window. We should still match the display size. |
| UpdateDisplay("800x600"); |
| - EXPECT_EQ(display::Screen::GetScreen() |
| - ->GetDisplayNearestWindow(window.get()) |
| - .bounds() |
| - .ToString(), |
| - window->bounds().ToString()); |
| + EXPECT_EQ(window->GetDisplayNearestWindow().bounds().ToString(), |
| + window->GetBounds().ToString()); |
| } |
| // Tests that when the screen gets smaller the windows aren't bigger than |
| // the screen. |
| TEST_F(WorkspaceLayoutManagerSoloTest, RootWindowResizeShrinksWindows) { |
| - std::unique_ptr<aura::Window> window( |
| + std::unique_ptr<WindowOwner> window_owner( |
| CreateTestWindow(gfx::Rect(10, 20, 500, 400))); |
| - gfx::Rect work_area = display::Screen::GetScreen() |
| - ->GetDisplayNearestWindow(window.get()) |
| - .work_area(); |
| + WmWindow* window = window_owner->window(); |
| + gfx::Rect work_area = window->GetDisplayNearestWindow().work_area(); |
| // Invariant: Window is smaller than work area. |
| - EXPECT_LE(window->bounds().width(), work_area.width()); |
| - EXPECT_LE(window->bounds().height(), work_area.height()); |
| + EXPECT_LE(window->GetBounds().width(), work_area.width()); |
| + EXPECT_LE(window->GetBounds().height(), work_area.height()); |
| // Make the root window narrower than our window. |
| UpdateDisplay("300x400"); |
| - work_area = display::Screen::GetScreen() |
| - ->GetDisplayNearestWindow(window.get()) |
| - .work_area(); |
| - EXPECT_LE(window->bounds().width(), work_area.width()); |
| - EXPECT_LE(window->bounds().height(), work_area.height()); |
| + work_area = window->GetDisplayNearestWindow().work_area(); |
| + EXPECT_LE(window->GetBounds().width(), work_area.width()); |
| + EXPECT_LE(window->GetBounds().height(), work_area.height()); |
| // Make the root window shorter than our window. |
| UpdateDisplay("300x200"); |
| - work_area = display::Screen::GetScreen() |
| - ->GetDisplayNearestWindow(window.get()) |
| - .work_area(); |
| - EXPECT_LE(window->bounds().width(), work_area.width()); |
| - EXPECT_LE(window->bounds().height(), work_area.height()); |
| + work_area = window->GetDisplayNearestWindow().work_area(); |
| + EXPECT_LE(window->GetBounds().width(), work_area.width()); |
| + EXPECT_LE(window->GetBounds().height(), work_area.height()); |
| // Enlarging the root window does not change the window bounds. |
| - gfx::Rect old_bounds = window->bounds(); |
| + gfx::Rect old_bounds = window->GetBounds(); |
| UpdateDisplay("800x600"); |
| - EXPECT_EQ(old_bounds.width(), window->bounds().width()); |
| - EXPECT_EQ(old_bounds.height(), window->bounds().height()); |
| + EXPECT_EQ(old_bounds.width(), window->GetBounds().width()); |
| + EXPECT_EQ(old_bounds.height(), window->GetBounds().height()); |
| } |
| // Verifies maximizing sets the restore bounds, and restoring |
| // restores the bounds. |
| TEST_F(WorkspaceLayoutManagerSoloTest, MaximizeSetsRestoreBounds) { |
| - std::unique_ptr<aura::Window> window( |
| + std::unique_ptr<WindowOwner> window_owner( |
| CreateTestWindow(gfx::Rect(10, 20, 30, 40))); |
| - wm::WindowState* window_state = wm::GetWindowState(window.get()); |
| + WmWindow* window = window_owner->window(); |
| + wm::WindowState* window_state = window->GetWindowState(); |
| // Maximize it, which will keep the previous restore bounds. |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED); |
| + window->SetShowState(ui::SHOW_STATE_MAXIMIZED); |
| EXPECT_EQ("10,20 30x40", window_state->GetRestoreBoundsInParent().ToString()); |
| // Restore it, which should restore bounds and reset restore bounds. |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL); |
| - EXPECT_EQ("10,20 30x40", window->bounds().ToString()); |
| + window->SetShowState(ui::SHOW_STATE_NORMAL); |
| + EXPECT_EQ("10,20 30x40", window->GetBounds().ToString()); |
| EXPECT_FALSE(window_state->HasRestoreBounds()); |
| } |
| // Verifies maximizing keeps the restore bounds if set. |
| TEST_F(WorkspaceLayoutManagerSoloTest, MaximizeResetsRestoreBounds) { |
| - std::unique_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(1, 2, 3, 4))); |
| - |
| - wm::WindowState* window_state = wm::GetWindowState(window.get()); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(gfx::Rect(1, 2, 3, 4))); |
| + WmWindow* window = window_owner->window(); |
| + wm::WindowState* window_state = window->GetWindowState(); |
| window_state->SetRestoreBoundsInParent(gfx::Rect(10, 11, 12, 13)); |
| // Maximize it, which will keep the previous restore bounds. |
| - window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED); |
| + window->SetShowState(ui::SHOW_STATE_MAXIMIZED); |
| EXPECT_EQ("10,11 12x13", window_state->GetRestoreBoundsInParent().ToString()); |
| } |
| @@ -807,11 +817,13 @@ TEST_F(WorkspaceLayoutManagerSoloTest, MaximizeResetsRestoreBounds) { |
| // maximzied state from a minimized state. |
| TEST_F(WorkspaceLayoutManagerSoloTest, |
| BoundsAfterRestoringToMaximizeFromMinimize) { |
| - std::unique_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(1, 2, 3, 4))); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(gfx::Rect(1, 2, 3, 4))); |
| + WmWindow* window = window_owner->window(); |
| gfx::Rect bounds(10, 15, 25, 35); |
| window->SetBounds(bounds); |
| - wm::WindowState* window_state = wm::GetWindowState(window.get()); |
| + wm::WindowState* window_state = window->GetWindowState(); |
| // Maximize it, which should reset restore bounds. |
| window_state->Maximize(); |
| EXPECT_EQ(bounds.ToString(), |
| @@ -829,73 +841,67 @@ TEST_F(WorkspaceLayoutManagerSoloTest, |
| EXPECT_TRUE(window_state->IsMaximized()); |
| window_state->Restore(); |
| - EXPECT_EQ(bounds.ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(bounds.ToString(), window->GetBounds().ToString()); |
| } |
| // Verify if the window is not resized during screen lock. See: crbug.com/173127 |
| TEST_F(WorkspaceLayoutManagerSoloTest, NotResizeWhenScreenIsLocked) { |
| SetCanLockScreen(true); |
| - std::unique_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(1, 2, 3, 4))); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(gfx::Rect(1, 2, 3, 4))); |
| + WmWindow* window = window_owner->window(); |
| // window with AlwaysOnTop will be managed by BaseLayoutManager. |
| - window->SetProperty(aura::client::kAlwaysOnTopKey, true); |
| + window->SetAlwaysOnTop(true); |
| window->Show(); |
| WmShelf* shelf = GetPrimaryShelf(); |
| shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS); |
| - window->SetBounds(ScreenUtil::GetMaximizedWindowBoundsInParent(window.get())); |
| - gfx::Rect window_bounds = window->bounds(); |
| - EXPECT_EQ( |
| - ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString(), |
| - window_bounds.ToString()); |
| + window->SetBounds(wm::GetMaximizedWindowBoundsInParent(window)); |
| + gfx::Rect window_bounds = window->GetBounds(); |
| + EXPECT_EQ(wm::GetMaximizedWindowBoundsInParent(window).ToString(), |
| + window_bounds.ToString()); |
| // The window size should not get touched while we are in lock screen. |
| WmShell::Get()->GetSessionStateDelegate()->LockScreen(); |
| ShelfLayoutManager* shelf_layout_manager = shelf->shelf_layout_manager(); |
| shelf_layout_manager->UpdateVisibilityState(); |
| - EXPECT_EQ(window_bounds.ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(window_bounds.ToString(), window->GetBounds().ToString()); |
| // Coming out of the lock screen the window size should still remain. |
| WmShell::Get()->GetSessionStateDelegate()->UnlockScreen(); |
| shelf_layout_manager->UpdateVisibilityState(); |
| - EXPECT_EQ( |
| - ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString(), |
| - window_bounds.ToString()); |
| - EXPECT_EQ(window_bounds.ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(wm::GetMaximizedWindowBoundsInParent(window).ToString(), |
| + window_bounds.ToString()); |
| + EXPECT_EQ(window_bounds.ToString(), window->GetBounds().ToString()); |
| } |
| // Following tests are written to test the backdrop functionality. |
| namespace { |
| -WorkspaceLayoutManager* GetWorkspaceLayoutManager(aura::Window* container) { |
| - return static_cast<WorkspaceLayoutManager*>( |
| - WmWindowAura::Get(container)->GetLayoutManager()); |
| +WorkspaceLayoutManager* GetWorkspaceLayoutManager(WmWindow* container) { |
| + return static_cast<WorkspaceLayoutManager*>(container->GetLayoutManager()); |
| } |
| -class WorkspaceLayoutManagerBackdropTest : public test::AshTestBase { |
| +class WorkspaceLayoutManagerBackdropTest : public AshTest { |
| public: |
| WorkspaceLayoutManagerBackdropTest() : default_container_(nullptr) {} |
| ~WorkspaceLayoutManagerBackdropTest() override {} |
| void SetUp() override { |
| - test::AshTestBase::SetUp(); |
| + AshTest::SetUp(); |
| UpdateDisplay("800x600"); |
| - default_container_ = Shell::GetContainer(Shell::GetPrimaryRootWindow(), |
| - kShellWindowId_DefaultContainer); |
| - } |
| - |
| - aura::Window* CreateTestWindow(const gfx::Rect& bounds) { |
| - aura::Window* window = CreateTestWindowInShellWithBounds(bounds); |
| - return window; |
| + default_container_ = |
| + WmShell::Get()->GetPrimaryRootWindowController()->GetContainer( |
| + kShellWindowId_DefaultContainer); |
| } |
| // Turn the top window back drop on / off. |
| void ShowTopWindowBackdrop(bool show) { |
| std::unique_ptr<WorkspaceLayoutManagerBackdropDelegate> backdrop; |
| if (show) { |
| - backdrop.reset(new WorkspaceBackdropDelegate( |
| - WmWindowAura::Get(default_container_))); |
| + backdrop.reset(new WorkspaceBackdropDelegate(default_container_)); |
| } |
| GetWorkspaceLayoutManager(default_container_) |
| ->SetMaximizeBackdropDelegate(std::move(backdrop)); |
| @@ -904,29 +910,29 @@ class WorkspaceLayoutManagerBackdropTest : public test::AshTestBase { |
| } |
| // Return the default container. |
| - aura::Window* default_container() { return default_container_; } |
| + WmWindow* default_container() { return default_container_; } |
| // Return the order of windows (top most first) as they are in the default |
| // container. If the window is visible it will be a big letter, otherwise a |
| // small one. The backdrop will be an X and unknown windows will be shown as |
| // '!'. |
| - std::string GetWindowOrderAsString(aura::Window* backdrop, |
| - aura::Window* wa, |
| - aura::Window* wb, |
| - aura::Window* wc) { |
| + std::string GetWindowOrderAsString(WmWindow* backdrop, |
| + WmWindow* wa, |
| + WmWindow* wb, |
| + WmWindow* wc) { |
| std::string result; |
| - for (int i = static_cast<int>(default_container()->children().size()) - 1; |
| - i >= 0; --i) { |
| + WmWindow::Windows children = default_container()->GetChildren(); |
| + for (int i = static_cast<int>(children.size()) - 1; i >= 0; --i) { |
|
James Cook
2016/10/04 23:16:05
nice. easier to read both the loop and the code be
sky
2016/10/06 17:57:07
Acknowledged.
|
| if (!result.empty()) |
| result += ","; |
| - if (default_container()->children()[i] == wa) |
| - result += default_container()->children()[i]->IsVisible() ? "A" : "a"; |
| - else if (default_container()->children()[i] == wb) |
| - result += default_container()->children()[i]->IsVisible() ? "B" : "b"; |
| - else if (default_container()->children()[i] == wc) |
| - result += default_container()->children()[i]->IsVisible() ? "C" : "c"; |
| - else if (default_container()->children()[i] == backdrop) |
| - result += default_container()->children()[i]->IsVisible() ? "X" : "x"; |
| + if (children[i] == wa) |
| + result += children[i]->IsVisible() ? "A" : "a"; |
| + else if (children[i] == wb) |
| + result += children[i]->IsVisible() ? "B" : "b"; |
| + else if (children[i] == wc) |
| + result += children[i]->IsVisible() ? "C" : "c"; |
| + else if (children[i] == backdrop) |
| + result += children[i]->IsVisible() ? "X" : "x"; |
| else |
| result += "!"; |
| } |
| @@ -935,7 +941,7 @@ class WorkspaceLayoutManagerBackdropTest : public test::AshTestBase { |
| private: |
| // The default container. |
| - aura::Window* default_container_; |
| + WmWindow* default_container_; |
| DISALLOW_COPY_AND_ASSIGN(WorkspaceLayoutManagerBackdropTest); |
| }; |
| @@ -945,103 +951,120 @@ class WorkspaceLayoutManagerBackdropTest : public test::AshTestBase { |
| // Check that creating the BackDrop without destroying it does not lead into |
| // a crash. |
| TEST_F(WorkspaceLayoutManagerBackdropTest, BackdropCrashTest) { |
| + // TODO: Triggers crash in mash: http://crbug.com/652871. |
| + if (IsMash()) |
| + return; |
| + |
| ShowTopWindowBackdrop(true); |
| } |
| // Verify basic assumptions about the backdrop. |
| TEST_F(WorkspaceLayoutManagerBackdropTest, BasicBackdropTests) { |
| + // TODO: Triggers crash in mash: http://crbug.com/652871. |
| + if (IsMash()) |
| + return; |
| + |
| // Create a backdrop and see that there is one window (the backdrop) and |
| // that the size is the same as the default container as well as that it is |
| // not visible. |
| ShowTopWindowBackdrop(true); |
| - ASSERT_EQ(1U, default_container()->children().size()); |
| - EXPECT_FALSE(default_container()->children()[0]->IsVisible()); |
| + ASSERT_EQ(1U, default_container()->GetChildren().size()); |
| + EXPECT_FALSE(default_container()->GetChildren()[0]->IsVisible()); |
| { |
| // Add a window and make sure that the backdrop is the second child. |
| - std::unique_ptr<aura::Window> window( |
| + std::unique_ptr<WindowOwner> window_owner( |
| CreateTestWindow(gfx::Rect(1, 2, 3, 4))); |
| + WmWindow* window = window_owner->window(); |
| window->Show(); |
| - ASSERT_EQ(2U, default_container()->children().size()); |
| - EXPECT_TRUE(default_container()->children()[0]->IsVisible()); |
| - EXPECT_TRUE(default_container()->children()[1]->IsVisible()); |
| - EXPECT_EQ(window.get(), default_container()->children()[1]); |
| - EXPECT_EQ(default_container()->bounds().ToString(), |
| - default_container()->children()[0]->bounds().ToString()); |
| + ASSERT_EQ(2U, default_container()->GetChildren().size()); |
| + EXPECT_TRUE(default_container()->GetChildren()[0]->IsVisible()); |
| + EXPECT_TRUE(default_container()->GetChildren()[1]->IsVisible()); |
| + EXPECT_EQ(window, default_container()->GetChildren()[1]); |
| + EXPECT_EQ(default_container()->GetBounds().ToString(), |
| + default_container()->GetChildren()[0]->GetBounds().ToString()); |
| } |
| // With the window gone the backdrop should be invisible again. |
| - ASSERT_EQ(1U, default_container()->children().size()); |
| - EXPECT_FALSE(default_container()->children()[0]->IsVisible()); |
| + ASSERT_EQ(1U, default_container()->GetChildren().size()); |
| + EXPECT_FALSE(default_container()->GetChildren()[0]->IsVisible()); |
| // Destroying the Backdrop should empty the container. |
| ShowTopWindowBackdrop(false); |
| - ASSERT_EQ(0U, default_container()->children().size()); |
| + ASSERT_EQ(0U, default_container()->GetChildren().size()); |
| } |
| // Verify that the backdrop gets properly created and placed. |
| TEST_F(WorkspaceLayoutManagerBackdropTest, VerifyBackdropAndItsStacking) { |
| - std::unique_ptr<aura::Window> window1( |
| + // TODO: Triggers crash in mash: http://crbug.com/652871. |
| + if (IsMash()) |
| + return; |
| + |
| + std::unique_ptr<WindowOwner> window1_owner( |
| CreateTestWindow(gfx::Rect(1, 2, 3, 4))); |
| + WmWindow* window1 = window1_owner->window(); |
| window1->Show(); |
| // Get the default container and check that only a single window is in there. |
| - ASSERT_EQ(1U, default_container()->children().size()); |
| - EXPECT_EQ(window1.get(), default_container()->children()[0]); |
| - EXPECT_EQ("A", |
| - GetWindowOrderAsString(nullptr, window1.get(), nullptr, nullptr)); |
| + ASSERT_EQ(1U, default_container()->GetChildren().size()); |
| + EXPECT_EQ(window1, default_container()->GetChildren()[0]); |
| + EXPECT_EQ("A", GetWindowOrderAsString(nullptr, window1, nullptr, nullptr)); |
| // Create 2 more windows and check that they are also in the container. |
| - std::unique_ptr<aura::Window> window2( |
| + std::unique_ptr<WindowOwner> window2_owner( |
| CreateTestWindow(gfx::Rect(10, 2, 3, 4))); |
| - std::unique_ptr<aura::Window> window3( |
| + WmWindow* window2 = window2_owner->window(); |
| + std::unique_ptr<WindowOwner> window3_owner( |
| CreateTestWindow(gfx::Rect(20, 2, 3, 4))); |
| + WmWindow* window3 = window3_owner->window(); |
| window2->Show(); |
| window3->Show(); |
| - aura::Window* backdrop = nullptr; |
| - EXPECT_EQ("C,B,A", GetWindowOrderAsString(backdrop, window1.get(), |
| - window2.get(), window3.get())); |
| + WmWindow* backdrop = nullptr; |
| + EXPECT_EQ("C,B,A", |
| + GetWindowOrderAsString(backdrop, window1, window2, window3)); |
| // Turn on the backdrop mode and check that the window shows up where it |
| // should be (second highest number). |
| ShowTopWindowBackdrop(true); |
| - backdrop = default_container()->children()[2]; |
| - EXPECT_EQ("C,X,B,A", GetWindowOrderAsString(backdrop, window1.get(), |
| - window2.get(), window3.get())); |
| + backdrop = default_container()->GetChildren()[2]; |
| + EXPECT_EQ("C,X,B,A", |
| + GetWindowOrderAsString(backdrop, window1, window2, window3)); |
| // Switch the order of windows and check that it still remains in that |
| // location. |
| - default_container()->StackChildAtTop(window2.get()); |
| - EXPECT_EQ("B,X,C,A", GetWindowOrderAsString(backdrop, window1.get(), |
| - window2.get(), window3.get())); |
| + default_container()->StackChildAtTop(window2); |
| + EXPECT_EQ("B,X,C,A", |
| + GetWindowOrderAsString(backdrop, window1, window2, window3)); |
| // Make the top window invisible and check. |
| - window2.get()->Hide(); |
| - EXPECT_EQ("b,C,X,A", GetWindowOrderAsString(backdrop, window1.get(), |
| - window2.get(), window3.get())); |
| + window2->Hide(); |
| + EXPECT_EQ("b,C,X,A", |
| + GetWindowOrderAsString(backdrop, window1, window2, window3)); |
| // Then delete window after window and see that everything is in order. |
| - window1.reset(); |
| - EXPECT_EQ("b,C,X", GetWindowOrderAsString(backdrop, window1.get(), |
| - window2.get(), window3.get())); |
| - window3.reset(); |
| - EXPECT_EQ("b,x", GetWindowOrderAsString(backdrop, window1.get(), |
| - window2.get(), window3.get())); |
| + window1_owner.reset(); |
| + EXPECT_EQ("b,C,X", |
| + GetWindowOrderAsString(backdrop, window1, window2, window3)); |
| + window3_owner.reset(); |
| + EXPECT_EQ("b,x", GetWindowOrderAsString(backdrop, window1, window2, window3)); |
| ShowTopWindowBackdrop(false); |
| - EXPECT_EQ("b", GetWindowOrderAsString(nullptr, window1.get(), window2.get(), |
| - window3.get())); |
| + EXPECT_EQ("b", GetWindowOrderAsString(nullptr, window1, window2, window3)); |
| } |
| // Tests that when hidding the shelf, that the backdrop resizes to fill the |
| // entire workspace area. |
| TEST_F(WorkspaceLayoutManagerBackdropTest, ShelfVisibilityChangesBounds) { |
| + // TODO: Triggers crash in mash: http://crbug.com/652871. |
| + if (IsMash()) |
| + return; |
| + |
| WmShelf* shelf = GetPrimaryShelf(); |
| ShelfLayoutManager* shelf_layout_manager = shelf->shelf_layout_manager(); |
| ShowTopWindowBackdrop(true); |
| RunAllPendingInMessageLoop(); |
| ASSERT_EQ(SHELF_VISIBLE, shelf_layout_manager->visibility_state()); |
| - gfx::Rect initial_bounds = default_container()->children()[0]->bounds(); |
| + gfx::Rect initial_bounds = default_container()->GetChildren()[0]->GetBounds(); |
| shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN); |
| shelf_layout_manager->UpdateVisibilityState(); |
| @@ -1049,45 +1072,42 @@ TEST_F(WorkspaceLayoutManagerBackdropTest, ShelfVisibilityChangesBounds) { |
| // including the backdrop. |
| shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER); |
| shelf_layout_manager->UpdateVisibilityState(); |
| - gfx::Rect reduced_bounds = default_container()->children()[0]->bounds(); |
| + gfx::Rect reduced_bounds = default_container()->GetChildren()[0]->GetBounds(); |
| EXPECT_LT(reduced_bounds.height(), initial_bounds.height()); |
| shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_ALWAYS_HIDDEN); |
| shelf_layout_manager->UpdateVisibilityState(); |
| - EXPECT_GT(default_container()->children()[0]->bounds().height(), |
| + EXPECT_GT(default_container()->GetChildren()[0]->GetBounds().height(), |
| reduced_bounds.height()); |
| } |
| -class WorkspaceLayoutManagerKeyboardTest : public test::AshTestBase { |
| +class WorkspaceLayoutManagerKeyboardTest : public AshTest { |
| public: |
| WorkspaceLayoutManagerKeyboardTest() : layout_manager_(nullptr) {} |
| ~WorkspaceLayoutManagerKeyboardTest() override {} |
| void SetUp() override { |
| - test::AshTestBase::SetUp(); |
| + AshTest::SetUp(); |
| UpdateDisplay("800x600"); |
| - aura::Window* default_container = Shell::GetContainer( |
| - Shell::GetPrimaryRootWindow(), kShellWindowId_DefaultContainer); |
| + WmWindow* default_container = |
| + WmShell::Get()->GetPrimaryRootWindowController()->GetContainer( |
| + kShellWindowId_DefaultContainer); |
| layout_manager_ = GetWorkspaceLayoutManager(default_container); |
| } |
| - aura::Window* CreateTestWindow(const gfx::Rect& bounds) { |
| - return CreateTestWindowInShellWithBounds(bounds); |
| - } |
| - |
| void ShowKeyboard() { |
| layout_manager_->OnKeyboardBoundsChanging(keyboard_bounds_); |
| restore_work_area_insets_ = |
| display::Screen::GetScreen()->GetPrimaryDisplay().GetWorkAreaInsets(); |
| - Shell::GetInstance()->SetDisplayWorkAreaInsets( |
| - Shell::GetPrimaryRootWindow(), |
| + WmShell::Get()->SetDisplayWorkAreaInsets( |
| + WmShell::Get()->GetPrimaryRootWindow(), |
| gfx::Insets(0, 0, keyboard_bounds_.height(), 0)); |
| } |
| void HideKeyboard() { |
| - Shell::GetInstance()->SetDisplayWorkAreaInsets( |
| - Shell::GetPrimaryRootWindow(), restore_work_area_insets_); |
| + WmShell::Get()->SetDisplayWorkAreaInsets( |
| + WmShell::Get()->GetPrimaryRootWindow(), restore_work_area_insets_); |
| layout_manager_->OnKeyboardBoundsChanging(gfx::Rect()); |
| } |
| @@ -1124,15 +1144,14 @@ TEST_F(WorkspaceLayoutManagerKeyboardTest, ChildWindowFocused) { |
| gfx::Rect work_area( |
| display::Screen::GetScreen()->GetPrimaryDisplay().work_area()); |
| - aura::test::TestWindowDelegate delegate1; |
| - std::unique_ptr<aura::Window> parent_window( |
| - CreateTestWindowInShellWithDelegate(&delegate1, -1, work_area)); |
| - aura::test::TestWindowDelegate delegate2; |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithDelegate(&delegate2, -1, work_area)); |
| - parent_window->AddChild(window.get()); |
| + std::unique_ptr<WindowOwner> parent_window_owner( |
| + CreateToplevelTestWindow(work_area)); |
| + WmWindow* parent_window = parent_window_owner->window(); |
| + std::unique_ptr<WindowOwner> window_owner(CreateTestWindow(work_area)); |
| + WmWindow* window = window_owner->window(); |
| + parent_window->AddChild(window); |
| - wm::ActivateWindow(window.get()); |
| + window->Activate(); |
| int available_height = |
| display::Screen::GetScreen()->GetPrimaryDisplay().bounds().height() - |
| @@ -1141,13 +1160,13 @@ TEST_F(WorkspaceLayoutManagerKeyboardTest, ChildWindowFocused) { |
| gfx::Rect initial_window_bounds(50, 50, 100, 500); |
| parent_window->SetBounds(initial_window_bounds); |
| EXPECT_EQ(initial_window_bounds.ToString(), |
| - parent_window->bounds().ToString()); |
| + parent_window->GetBounds().ToString()); |
| ShowKeyboard(); |
| EXPECT_EQ(gfx::Rect(50, 0, 100, available_height).ToString(), |
| - parent_window->bounds().ToString()); |
| + parent_window->GetBounds().ToString()); |
| HideKeyboard(); |
| EXPECT_EQ(initial_window_bounds.ToString(), |
| - parent_window->bounds().ToString()); |
| + parent_window->GetBounds().ToString()); |
| } |
| TEST_F(WorkspaceLayoutManagerKeyboardTest, AdjustWindowForA11yKeyboard) { |
| @@ -1155,33 +1174,33 @@ TEST_F(WorkspaceLayoutManagerKeyboardTest, AdjustWindowForA11yKeyboard) { |
| gfx::Rect work_area( |
| display::Screen::GetScreen()->GetPrimaryDisplay().work_area()); |
| - aura::test::TestWindowDelegate delegate; |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithDelegate(&delegate, -1, work_area)); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateToplevelTestWindow(work_area)); |
| + WmWindow* window = window_owner->window(); |
| int available_height = |
| display::Screen::GetScreen()->GetPrimaryDisplay().bounds().height() - |
| keyboard_bounds().height(); |
| - wm::ActivateWindow(window.get()); |
| + window->Activate(); |
| - EXPECT_EQ(gfx::Rect(work_area).ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(gfx::Rect(work_area).ToString(), window->GetBounds().ToString()); |
| ShowKeyboard(); |
| EXPECT_EQ(gfx::Rect(work_area.origin(), |
| gfx::Size(work_area.width(), available_height)) |
| .ToString(), |
| - window->bounds().ToString()); |
| + window->GetBounds().ToString()); |
| HideKeyboard(); |
| - EXPECT_EQ(gfx::Rect(work_area).ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(gfx::Rect(work_area).ToString(), window->GetBounds().ToString()); |
| gfx::Rect small_window_bound(50, 50, 100, 500); |
| window->SetBounds(small_window_bound); |
| - EXPECT_EQ(small_window_bound.ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(small_window_bound.ToString(), window->GetBounds().ToString()); |
| ShowKeyboard(); |
| EXPECT_EQ(gfx::Rect(50, 0, 100, available_height).ToString(), |
| - window->bounds().ToString()); |
| + window->GetBounds().ToString()); |
| HideKeyboard(); |
| - EXPECT_EQ(small_window_bound.ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(small_window_bound.ToString(), window->GetBounds().ToString()); |
| gfx::Rect occluded_window_bounds( |
| 50, keyboard_bounds().y() + keyboard_bounds().height() / 2, 50, |
| @@ -1194,23 +1213,23 @@ TEST_F(WorkspaceLayoutManagerKeyboardTest, AdjustWindowForA11yKeyboard) { |
| gfx::Rect(50, keyboard_bounds().y() - keyboard_bounds().height() / 2, |
| occluded_window_bounds.width(), occluded_window_bounds.height()) |
| .ToString(), |
| - window->bounds().ToString()); |
| + window->GetBounds().ToString()); |
| HideKeyboard(); |
| - EXPECT_EQ(occluded_window_bounds.ToString(), window->bounds().ToString()); |
| + EXPECT_EQ(occluded_window_bounds.ToString(), window->GetBounds().ToString()); |
| } |
| -TEST_F(WorkspaceLayoutManagerKeyboardTest, IgnoreKeyboardBoundsChagne) { |
| +TEST_F(WorkspaceLayoutManagerKeyboardTest, IgnoreKeyboardBoundsChange) { |
| InitKeyboardBounds(); |
| - aura::test::TestWindowDelegate delegate2; |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithDelegate(&delegate2, -1, keyboard_bounds())); |
| - wm::GetWindowState(window.get())->set_ignore_keyboard_bounds_change(true); |
| - wm::ActivateWindow(window.get()); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateTestWindow(keyboard_bounds())); |
| + WmWindow* window = window_owner->window(); |
| + window->GetWindowState()->set_ignore_keyboard_bounds_change(true); |
| + window->Activate(); |
| - EXPECT_EQ(keyboard_bounds(), window->bounds()); |
| + EXPECT_EQ(keyboard_bounds(), window->GetBounds()); |
| ShowKeyboard(); |
| - EXPECT_EQ(keyboard_bounds(), window->bounds()); |
| + EXPECT_EQ(keyboard_bounds(), window->GetBounds()); |
| } |
| TEST_F(WorkspaceLayoutManagerKeyboardTest, ChangeWorkAreaInNonStickyMode) { |
| @@ -1223,41 +1242,41 @@ TEST_F(WorkspaceLayoutManagerKeyboardTest, ChangeWorkAreaInNonStickyMode) { |
| gfx::Rect work_area( |
| display::Screen::GetScreen()->GetPrimaryDisplay().work_area()); |
| - aura::test::TestWindowDelegate delegate; |
| gfx::Rect orig_window_bounds(0, 100, work_area.width(), |
| work_area.height() - 100); |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithDelegate(&delegate, -1, orig_window_bounds)); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateToplevelTestWindow(orig_window_bounds)); |
| + WmWindow* window = window_owner->window(); |
| - wm::ActivateWindow(window.get()); |
| - EXPECT_EQ(orig_window_bounds, window->bounds()); |
| + window->Activate(); |
| + EXPECT_EQ(orig_window_bounds, window->GetBounds()); |
| // Open keyboard in non-sticky mode. |
| kb_controller->ShowKeyboard(false); |
| kb_controller->ui()->GetKeyboardWindow()->SetBounds( |
| keyboard::FullWidthKeyboardBoundsFromRootBounds( |
| - Shell::GetPrimaryRootWindow()->bounds(), 100)); |
| + WmShell::Get()->GetPrimaryRootWindow()->GetBounds(), 100)); |
| int shift = |
| work_area.height() - kb_controller->GetContainerWindow()->bounds().y(); |
| gfx::Rect changed_window_bounds(orig_window_bounds); |
| changed_window_bounds.Offset(0, -shift); |
| // Window should be shifted up. |
| - EXPECT_EQ(changed_window_bounds, window->bounds()); |
| + EXPECT_EQ(changed_window_bounds, window->GetBounds()); |
| kb_controller->HideKeyboard( |
| keyboard::KeyboardController::HIDE_REASON_AUTOMATIC); |
| - EXPECT_EQ(orig_window_bounds, window->bounds()); |
| + EXPECT_EQ(orig_window_bounds, window->GetBounds()); |
| // Open keyboard in sticky mode. |
| kb_controller->ShowKeyboard(true); |
| // Window should be shifted up. |
| - EXPECT_EQ(changed_window_bounds, window->bounds()); |
| + EXPECT_EQ(changed_window_bounds, window->GetBounds()); |
| kb_controller->HideKeyboard( |
| keyboard::KeyboardController::HIDE_REASON_AUTOMATIC); |
| - EXPECT_EQ(orig_window_bounds, window->bounds()); |
| + EXPECT_EQ(orig_window_bounds, window->GetBounds()); |
| } |
| // When kAshUseNewVKWindowBehavior flag enabled, do not change accessibility |
| @@ -1276,27 +1295,27 @@ TEST_F(WorkspaceLayoutManagerKeyboardTest, |
| gfx::Rect work_area( |
| display::Screen::GetScreen()->GetPrimaryDisplay().work_area()); |
| - aura::test::TestWindowDelegate delegate; |
| gfx::Rect orig_window_bounds(0, 100, work_area.width(), |
| work_area.height() - 100); |
| - std::unique_ptr<aura::Window> window( |
| - CreateTestWindowInShellWithDelegate(&delegate, -1, orig_window_bounds)); |
| + std::unique_ptr<WindowOwner> window_owner( |
| + CreateToplevelTestWindow(orig_window_bounds)); |
| + WmWindow* window = window_owner->window(); |
| - wm::ActivateWindow(window.get()); |
| - EXPECT_EQ(orig_window_bounds, window->bounds()); |
| + window->Activate(); |
| + EXPECT_EQ(orig_window_bounds, window->GetBounds()); |
| // Open keyboard in non-sticky mode. |
| kb_controller->ShowKeyboard(false); |
| kb_controller->ui()->GetKeyboardWindow()->SetBounds( |
| keyboard::FullWidthKeyboardBoundsFromRootBounds( |
| - Shell::GetPrimaryRootWindow()->bounds(), 100)); |
| + WmShell::Get()->GetPrimaryRootWindow()->GetBounds(), 100)); |
| // Window should not be shifted up. |
| - EXPECT_EQ(orig_window_bounds, window->bounds()); |
| + EXPECT_EQ(orig_window_bounds, window->GetBounds()); |
| kb_controller->HideKeyboard( |
| keyboard::KeyboardController::HIDE_REASON_AUTOMATIC); |
| - EXPECT_EQ(orig_window_bounds, window->bounds()); |
| + EXPECT_EQ(orig_window_bounds, window->GetBounds()); |
| // Open keyboard in sticky mode. |
| kb_controller->ShowKeyboard(true); |
| @@ -1306,11 +1325,11 @@ TEST_F(WorkspaceLayoutManagerKeyboardTest, |
| gfx::Rect changed_window_bounds(orig_window_bounds); |
| changed_window_bounds.Offset(0, -shift); |
| // Window should be shifted up. |
| - EXPECT_EQ(changed_window_bounds, window->bounds()); |
| + EXPECT_EQ(changed_window_bounds, window->GetBounds()); |
| kb_controller->HideKeyboard( |
| keyboard::KeyboardController::HIDE_REASON_AUTOMATIC); |
| - EXPECT_EQ(orig_window_bounds, window->bounds()); |
| + EXPECT_EQ(orig_window_bounds, window->GetBounds()); |
| } |
|
James Cook
2016/10/04 23:16:05
Wow, this file looks like it was a lot of work to
sky
2016/10/06 17:57:07
Tedious, but mostly mechanical changes. Hopefully
|
| } // namespace ash |
