OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "ash/wm/splitview/split_view_controller.h" |
| 6 #include "ash/shell.h" |
| 7 #include "ash/test/ash_test_base.h" |
| 8 #include "ash/wm/overview/window_selector_controller.h" |
| 9 #include "ash/wm/window_state.h" |
| 10 #include "ash/wm/window_util.h" |
| 11 #include "ash/wm/wm_event.h" |
| 12 #include "ui/aura/test/test_window_delegate.h" |
| 13 |
| 14 namespace ash { |
| 15 |
| 16 class SplitViewControllerTest : public test::AshTestBase { |
| 17 public: |
| 18 SplitViewControllerTest() {} |
| 19 ~SplitViewControllerTest() override {} |
| 20 |
| 21 void SetUp() override { test::AshTestBase::SetUp(); } |
| 22 |
| 23 aura::Window* CreateWindow(const gfx::Rect& bounds) { |
| 24 aura::Window* window = |
| 25 CreateTestWindowInShellWithDelegate(&delegate_, -1, bounds); |
| 26 return window; |
| 27 } |
| 28 |
| 29 void EndSplitView() { split_view_controller()->EndSplitView(); } |
| 30 |
| 31 void ToggleOverview() { |
| 32 Shell::Get()->window_selector_controller()->ToggleOverview(); |
| 33 } |
| 34 |
| 35 std::vector<aura::Window*> GetWindowsInOverviewGrids() { |
| 36 return Shell::Get() |
| 37 ->window_selector_controller() |
| 38 ->GetWindowsListInOverviewGridsForTesting(); |
| 39 } |
| 40 |
| 41 SplitViewController* split_view_controller() { |
| 42 return Shell::Get()->split_view_controller(); |
| 43 } |
| 44 |
| 45 private: |
| 46 aura::test::TestWindowDelegate delegate_; |
| 47 |
| 48 DISALLOW_COPY_AND_ASSIGN(SplitViewControllerTest); |
| 49 }; |
| 50 |
| 51 // Tests the basic functionalities. |
| 52 TEST_F(SplitViewControllerTest, Basic) { |
| 53 gfx::Rect bounds(0, 0, 400, 400); |
| 54 std::unique_ptr<aura::Window> window1(CreateWindow(bounds)); |
| 55 std::unique_ptr<aura::Window> window2(CreateWindow(bounds)); |
| 56 |
| 57 EXPECT_EQ(split_view_controller()->state(), SplitViewController::NOSNAP); |
| 58 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), false); |
| 59 |
| 60 split_view_controller()->SetLeftWindow(window1.get()); |
| 61 EXPECT_EQ(split_view_controller()->state(), |
| 62 SplitViewController::LEFT_SNAPPED); |
| 63 EXPECT_EQ(split_view_controller()->left_window(), window1.get()); |
| 64 EXPECT_NE(split_view_controller()->left_window(), window2.get()); |
| 65 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), true); |
| 66 EXPECT_EQ(window1->GetBoundsInScreen(), |
| 67 split_view_controller()->GetSnappedWindowBoundsInScreen( |
| 68 window1.get(), SplitViewController::LEFT_SNAPPED)); |
| 69 |
| 70 split_view_controller()->SetRightWindow(window2.get()); |
| 71 EXPECT_EQ(split_view_controller()->state(), |
| 72 SplitViewController::BOTH_SNAPPED); |
| 73 EXPECT_EQ(split_view_controller()->right_window(), window2.get()); |
| 74 EXPECT_NE(split_view_controller()->right_window(), window1.get()); |
| 75 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), true); |
| 76 EXPECT_EQ(window2->GetBoundsInScreen(), |
| 77 split_view_controller()->GetSnappedWindowBoundsInScreen( |
| 78 window2.get(), SplitViewController::RIGHT_SNAPPED)); |
| 79 |
| 80 EndSplitView(); |
| 81 EXPECT_EQ(split_view_controller()->state(), SplitViewController::NOSNAP); |
| 82 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), false); |
| 83 } |
| 84 |
| 85 // Tests that the default snapped window is the first window that gets snapped. |
| 86 TEST_F(SplitViewControllerTest, DefaultSnappedWindow) { |
| 87 gfx::Rect bounds(0, 0, 400, 400); |
| 88 std::unique_ptr<aura::Window> window1(CreateWindow(bounds)); |
| 89 std::unique_ptr<aura::Window> window2(CreateWindow(bounds)); |
| 90 |
| 91 split_view_controller()->SetLeftWindow(window1.get()); |
| 92 split_view_controller()->SetRightWindow(window2.get()); |
| 93 EXPECT_EQ(window1.get(), split_view_controller()->GetDefaultSnappedWindow()); |
| 94 |
| 95 EndSplitView(); |
| 96 split_view_controller()->SetLeftWindow(window2.get()); |
| 97 split_view_controller()->SetRightWindow(window1.get()); |
| 98 EXPECT_EQ(window2.get(), split_view_controller()->GetDefaultSnappedWindow()); |
| 99 } |
| 100 |
| 101 // Tests that closing one of the snapped windows exits the split view mode. |
| 102 TEST_F(SplitViewControllerTest, EndSplitViewUponWindowClose) { |
| 103 gfx::Rect bounds(0, 0, 400, 400); |
| 104 std::unique_ptr<aura::Window> window1(CreateWindow(bounds)); |
| 105 std::unique_ptr<aura::Window> window2(CreateWindow(bounds)); |
| 106 |
| 107 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), false); |
| 108 split_view_controller()->SetLeftWindow(window1.get()); |
| 109 split_view_controller()->SetRightWindow(window2.get()); |
| 110 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), true); |
| 111 |
| 112 window1.reset(); |
| 113 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), false); |
| 114 } |
| 115 |
| 116 // Tests that if one of the snapped window gets minimized / maximized / full- |
| 117 // screened, end the split view mode. |
| 118 TEST_F(SplitViewControllerTest, WindowStateChangeTest) { |
| 119 gfx::Rect bounds(0, 0, 400, 400); |
| 120 std::unique_ptr<aura::Window> window1(CreateWindow(bounds)); |
| 121 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), false); |
| 122 |
| 123 split_view_controller()->SetLeftWindow(window1.get()); |
| 124 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), true); |
| 125 |
| 126 wm::WMEvent minimize_event(wm::WM_EVENT_MINIMIZE); |
| 127 wm::GetWindowState(window1.get())->OnWMEvent(&minimize_event); |
| 128 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), false); |
| 129 |
| 130 split_view_controller()->SetLeftWindow(window1.get()); |
| 131 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), true); |
| 132 |
| 133 wm::WMEvent maximize_event(wm::WM_EVENT_MAXIMIZE); |
| 134 wm::GetWindowState(window1.get())->OnWMEvent(&maximize_event); |
| 135 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), false); |
| 136 |
| 137 split_view_controller()->SetLeftWindow(window1.get()); |
| 138 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), true); |
| 139 |
| 140 wm::WMEvent fullscreen_event(wm::WM_EVENT_FULLSCREEN); |
| 141 wm::GetWindowState(window1.get())->OnWMEvent(&fullscreen_event); |
| 142 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), false); |
| 143 } |
| 144 |
| 145 // Tests that if split view mode is active, activate another window will snap |
| 146 // the window to the non-default side of the screen. |
| 147 TEST_F(SplitViewControllerTest, WindowActivationTest) { |
| 148 gfx::Rect bounds(0, 0, 400, 400); |
| 149 std::unique_ptr<aura::Window> window1(CreateWindow(bounds)); |
| 150 std::unique_ptr<aura::Window> window2(CreateWindow(bounds)); |
| 151 std::unique_ptr<aura::Window> window3(CreateWindow(bounds)); |
| 152 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), false); |
| 153 |
| 154 split_view_controller()->SetLeftWindow(window1.get()); |
| 155 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), true); |
| 156 EXPECT_EQ(split_view_controller()->left_window(), window1.get()); |
| 157 EXPECT_EQ(split_view_controller()->state(), |
| 158 SplitViewController::LEFT_SNAPPED); |
| 159 |
| 160 wm::ActivateWindow(window2.get()); |
| 161 EXPECT_EQ(split_view_controller()->right_window(), window2.get()); |
| 162 EXPECT_EQ(split_view_controller()->state(), |
| 163 SplitViewController::BOTH_SNAPPED); |
| 164 |
| 165 wm::ActivateWindow(window3.get()); |
| 166 EXPECT_EQ(split_view_controller()->right_window(), window3.get()); |
| 167 EXPECT_EQ(split_view_controller()->state(), |
| 168 SplitViewController::BOTH_SNAPPED); |
| 169 } |
| 170 |
| 171 // Tests that if split view mode and overview mode are active at the same time, |
| 172 // i.e., half of the screen is occupied by a snapped window and half of the |
| 173 // screen is occupied by the overview windows grid, the next activatable window |
| 174 // will be picked to snap when exiting the overview mode. |
| 175 TEST_F(SplitViewControllerTest, ExitOverviewTest) { |
| 176 gfx::Rect bounds(0, 0, 400, 400); |
| 177 std::unique_ptr<aura::Window> window1(CreateWindow(bounds)); |
| 178 std::unique_ptr<aura::Window> window2(CreateWindow(bounds)); |
| 179 std::unique_ptr<aura::Window> window3(CreateWindow(bounds)); |
| 180 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), false); |
| 181 |
| 182 ToggleOverview(); |
| 183 split_view_controller()->SetLeftWindow(window1.get()); |
| 184 EXPECT_EQ(split_view_controller()->IsSplitViewModeActive(), true); |
| 185 EXPECT_EQ(split_view_controller()->left_window(), window1.get()); |
| 186 EXPECT_EQ(split_view_controller()->state(), |
| 187 SplitViewController::LEFT_SNAPPED); |
| 188 |
| 189 ToggleOverview(); |
| 190 EXPECT_EQ(split_view_controller()->state(), |
| 191 SplitViewController::BOTH_SNAPPED); |
| 192 EXPECT_EQ(split_view_controller()->right_window(), window3.get()); |
| 193 } |
| 194 |
| 195 // Tests that if split view mode is active when entering overview, the overview |
| 196 // windows grid should show in the non-default side of the screen, and the |
| 197 // default snapped window should not be shown in the overview window grid. |
| 198 TEST_F(SplitViewControllerTest, EnterOverviewTest) { |
| 199 gfx::Rect bounds(0, 0, 400, 400); |
| 200 std::unique_ptr<aura::Window> window1(CreateWindow(bounds)); |
| 201 std::unique_ptr<aura::Window> window2(CreateWindow(bounds)); |
| 202 std::unique_ptr<aura::Window> window3(CreateWindow(bounds)); |
| 203 |
| 204 split_view_controller()->SetLeftWindow(window1.get()); |
| 205 split_view_controller()->SetRightWindow(window2.get()); |
| 206 EXPECT_EQ(split_view_controller()->state(), |
| 207 SplitViewController::BOTH_SNAPPED); |
| 208 EXPECT_EQ(split_view_controller()->GetDefaultSnappedWindow(), window1.get()); |
| 209 |
| 210 ToggleOverview(); |
| 211 EXPECT_EQ(split_view_controller()->state(), |
| 212 SplitViewController::LEFT_SNAPPED); |
| 213 std::vector<aura::Window*> windows = GetWindowsInOverviewGrids(); |
| 214 auto iter = std::find(windows.begin(), windows.end(), |
| 215 split_view_controller()->GetDefaultSnappedWindow()); |
| 216 EXPECT_TRUE(iter == windows.end()); |
| 217 } |
| 218 |
| 219 } // namespace ash |
OLD | NEW |