| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 "athena/wm/public/window_manager.h" | |
| 6 | |
| 7 #include "athena/screen/public/screen_manager.h" | |
| 8 #include "athena/test/base/athena_test_base.h" | |
| 9 #include "athena/test/base/test_windows.h" | |
| 10 #include "athena/wm/public/window_list_provider.h" | |
| 11 #include "athena/wm/split_view_controller.h" | |
| 12 #include "athena/wm/test/window_manager_impl_test_api.h" | |
| 13 #include "athena/wm/window_manager_impl.h" | |
| 14 #include "ui/aura/client/aura_constants.h" | |
| 15 #include "ui/aura/client/window_tree_client.h" | |
| 16 #include "ui/aura/test/test_window_delegate.h" | |
| 17 #include "ui/aura/window.h" | |
| 18 #include "ui/base/hit_test.h" | |
| 19 #include "ui/events/test/event_generator.h" | |
| 20 #include "ui/gfx/display.h" | |
| 21 #include "ui/gfx/screen.h" | |
| 22 #include "ui/wm/core/window_util.h" | |
| 23 | |
| 24 namespace athena { | |
| 25 | |
| 26 class WindowManagerTest : public test::AthenaTestBase { | |
| 27 public: | |
| 28 WindowManagerTest() {} | |
| 29 ~WindowManagerTest() override {} | |
| 30 | |
| 31 scoped_ptr<aura::Window> CreateAndActivateWindow( | |
| 32 aura::WindowDelegate* delegate) { | |
| 33 scoped_ptr<aura::Window> window( | |
| 34 test::CreateNormalWindow(delegate, nullptr)); | |
| 35 window->Show(); | |
| 36 wm::ActivateWindow(window.get()); | |
| 37 window->SetProperty(aura::client::kCanMaximizeKey, true); | |
| 38 return window.Pass(); | |
| 39 } | |
| 40 | |
| 41 private: | |
| 42 DISALLOW_COPY_AND_ASSIGN(WindowManagerTest); | |
| 43 }; | |
| 44 | |
| 45 TEST_F(WindowManagerTest, OverviewModeBasics) { | |
| 46 aura::test::TestWindowDelegate delegate; | |
| 47 scoped_ptr<aura::Window> first(CreateAndActivateWindow(&delegate)); | |
| 48 scoped_ptr<aura::Window> second(CreateAndActivateWindow(&delegate)); | |
| 49 | |
| 50 test::WindowManagerImplTestApi wm_api; | |
| 51 wm::ActivateWindow(second.get()); | |
| 52 | |
| 53 ASSERT_FALSE(WindowManager::Get()->IsOverviewModeActive()); | |
| 54 EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString()); | |
| 55 EXPECT_EQ(gfx::Screen::GetNativeScreen() | |
| 56 ->GetPrimaryDisplay() | |
| 57 .work_area() | |
| 58 .size() | |
| 59 .ToString(), | |
| 60 first->bounds().size().ToString()); | |
| 61 EXPECT_FALSE(WindowManager::Get()->IsOverviewModeActive()); | |
| 62 | |
| 63 // Tests that going into overview mode does not change the window bounds. | |
| 64 WindowManager::Get()->EnterOverview(); | |
| 65 ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 66 EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString()); | |
| 67 EXPECT_EQ(gfx::Screen::GetNativeScreen() | |
| 68 ->GetPrimaryDisplay() | |
| 69 .work_area() | |
| 70 .size() | |
| 71 .ToString(), | |
| 72 first->bounds().size().ToString()); | |
| 73 EXPECT_TRUE(first->IsVisible()); | |
| 74 EXPECT_TRUE(second->IsVisible()); | |
| 75 | |
| 76 // Terminate overview mode. |first| should be hidden, since it's not visible | |
| 77 // to the user anymore. | |
| 78 WindowManager::Get()->ExitOverview(); | |
| 79 ASSERT_FALSE(WindowManager::Get()->IsOverviewModeActive()); | |
| 80 EXPECT_FALSE(first->IsVisible()); | |
| 81 EXPECT_TRUE(second->IsVisible()); | |
| 82 } | |
| 83 | |
| 84 TEST_F(WindowManagerTest, OverviewToSplitViewMode) { | |
| 85 test::WindowManagerImplTestApi wm_api; | |
| 86 | |
| 87 aura::test::TestWindowDelegate delegate; | |
| 88 scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate)); | |
| 89 scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate)); | |
| 90 scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate)); | |
| 91 wm::ActivateWindow(w3.get()); | |
| 92 | |
| 93 WindowManager::Get()->EnterOverview(); | |
| 94 EXPECT_TRUE(w1->IsVisible()); | |
| 95 EXPECT_TRUE(w2->IsVisible()); | |
| 96 EXPECT_TRUE(w3->IsVisible()); | |
| 97 | |
| 98 // Go into split-view mode. | |
| 99 WindowOverviewModeDelegate* overview_delegate = wm_api.wm(); | |
| 100 overview_delegate->OnSelectSplitViewWindow(w3.get(), nullptr, w3.get()); | |
| 101 EXPECT_TRUE(w3->IsVisible()); | |
| 102 EXPECT_TRUE(w2->IsVisible()); | |
| 103 EXPECT_FALSE(w1->IsVisible()); | |
| 104 } | |
| 105 | |
| 106 TEST_F(WindowManagerTest, OnSelectWindow) { | |
| 107 test::WindowManagerImplTestApi wm_api; | |
| 108 aura::test::TestWindowDelegate delegate1; | |
| 109 aura::test::TestWindowDelegate delegate2; | |
| 110 aura::test::TestWindowDelegate delegate3; | |
| 111 | |
| 112 // (w1): A window that sets a maximum size | |
| 113 delegate1.set_maximum_size(gfx::Size(300, 200)); | |
| 114 scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate1)); | |
| 115 w1->SetBounds(gfx::Rect(0, 0, 300, 200)); | |
| 116 | |
| 117 // (w2): A window that doesn't set a max size and is maximizable | |
| 118 scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate2)); | |
| 119 w2->SetBounds(gfx::Rect(0, 0, 300, 200)); | |
| 120 w2->SetProperty(aura::client::kCanMaximizeKey, true); | |
| 121 | |
| 122 // (w3): A window that doesn't set a max size but is NOT maximizable | |
| 123 scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate3)); | |
| 124 w3->SetBounds(gfx::Rect(0, 0, 300, 200)); | |
| 125 w3->SetProperty(aura::client::kCanMaximizeKey, false); | |
| 126 | |
| 127 const gfx::Size old_bounds1 = w1->GetTargetBounds().size(); | |
| 128 const gfx::Size old_bounds2 = w2->GetTargetBounds().size(); | |
| 129 const gfx::Size old_bounds3 = w3->GetTargetBounds().size(); | |
| 130 const gfx::Size work_area = | |
| 131 gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size(); | |
| 132 | |
| 133 // Select w1, which has a max size, in the overview mode and make sure it's | |
| 134 // not maximized. | |
| 135 WindowManager::Get()->EnterOverview(); | |
| 136 WindowOverviewModeDelegate* overview_delegate = wm_api.wm(); | |
| 137 overview_delegate->OnSelectWindow(w1.get()); | |
| 138 const gfx::Size new_bounds1 = w1->GetTargetBounds().size(); | |
| 139 EXPECT_EQ(new_bounds1.ToString(), old_bounds1.ToString()); | |
| 140 EXPECT_NE(work_area.ToString(), new_bounds1.ToString()); | |
| 141 | |
| 142 // Select w2, which has no max size & can be maximized, in the overview | |
| 143 // mode and make sure it's actually maximized. | |
| 144 WindowManager::Get()->EnterOverview(); | |
| 145 overview_delegate->OnSelectWindow(w2.get()); | |
| 146 const gfx::Size new_bounds2 = w2->GetTargetBounds().size(); | |
| 147 EXPECT_NE(new_bounds2.ToString(), old_bounds2.ToString()); | |
| 148 EXPECT_EQ(work_area.ToString(), new_bounds2.ToString()); | |
| 149 | |
| 150 // Select w3, which has no max size & cannot be maximized, in the overview | |
| 151 // mode and make sure it's not maximized. | |
| 152 WindowManager::Get()->EnterOverview(); | |
| 153 overview_delegate->OnSelectWindow(w3.get()); | |
| 154 const gfx::Size new_bounds3 = w3->GetTargetBounds().size(); | |
| 155 EXPECT_EQ(new_bounds3.ToString(), old_bounds3.ToString()); | |
| 156 EXPECT_NE(work_area.ToString(), new_bounds3.ToString()); | |
| 157 } | |
| 158 | |
| 159 TEST_F(WindowManagerTest, NewWindowFromOverview) { | |
| 160 aura::test::TestWindowDelegate delegate; | |
| 161 scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate)); | |
| 162 scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate)); | |
| 163 | |
| 164 WindowManager::Get()->EnterOverview(); | |
| 165 EXPECT_TRUE(w1->IsVisible()); | |
| 166 EXPECT_TRUE(w2->IsVisible()); | |
| 167 | |
| 168 // Test that opening a new window exits overview mode. The new window could | |
| 169 // have been opened by JavaScript or by the home card. | |
| 170 scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate)); | |
| 171 | |
| 172 ASSERT_FALSE(WindowManager::Get()->IsOverviewModeActive()); | |
| 173 EXPECT_TRUE(w3->IsVisible()); | |
| 174 EXPECT_TRUE(wm::IsActiveWindow(w3.get())); | |
| 175 EXPECT_FALSE(w1->IsVisible()); | |
| 176 EXPECT_FALSE(w2->IsVisible()); | |
| 177 } | |
| 178 | |
| 179 TEST_F(WindowManagerTest, TitleDragSwitchBetweenWindows) { | |
| 180 aura::test::TestWindowDelegate delegate; | |
| 181 delegate.set_window_component(HTCAPTION); | |
| 182 scoped_ptr<aura::Window> first(CreateAndActivateWindow(&delegate)); | |
| 183 scoped_ptr<aura::Window> second(CreateAndActivateWindow(&delegate)); | |
| 184 scoped_ptr<aura::Window> third(CreateAndActivateWindow(&delegate)); | |
| 185 | |
| 186 test::WindowManagerImplTestApi wm_api; | |
| 187 | |
| 188 EXPECT_EQ(third.get(), | |
| 189 wm_api.GetWindowListProvider()->GetWindowList().back()); | |
| 190 | |
| 191 // Do a title-swipe from the top to switch to the previous window. | |
| 192 ui::test::EventGenerator generator(root_window()); | |
| 193 generator.GestureScrollSequence(gfx::Point(20, 10), | |
| 194 gfx::Point(20, 400), | |
| 195 base::TimeDelta::FromMilliseconds(20), | |
| 196 5); | |
| 197 EXPECT_TRUE(wm::IsActiveWindow(second.get())); | |
| 198 EXPECT_EQ(second.get(), | |
| 199 wm_api.GetWindowListProvider()->GetWindowList().back()); | |
| 200 EXPECT_TRUE(second->IsVisible()); | |
| 201 EXPECT_FALSE(third->IsVisible()); | |
| 202 | |
| 203 // Performing the same gesture again will switch back to |third|. | |
| 204 generator.GestureScrollSequence(gfx::Point(20, 10), | |
| 205 gfx::Point(20, 400), | |
| 206 base::TimeDelta::FromMilliseconds(20), | |
| 207 5); | |
| 208 EXPECT_TRUE(wm::IsActiveWindow(third.get())); | |
| 209 EXPECT_EQ(third.get(), | |
| 210 wm_api.GetWindowListProvider()->GetWindowList().back()); | |
| 211 EXPECT_FALSE(second->IsVisible()); | |
| 212 EXPECT_TRUE(third->IsVisible()); | |
| 213 | |
| 214 // Perform a swipe that doesn't go enough to perform the window switch. | |
| 215 generator.GestureScrollSequence(gfx::Point(20, 10), | |
| 216 gfx::Point(20, 90), | |
| 217 base::TimeDelta::FromMilliseconds(20), | |
| 218 5); | |
| 219 EXPECT_TRUE(wm::IsActiveWindow(third.get())); | |
| 220 EXPECT_EQ(third.get(), | |
| 221 wm_api.GetWindowListProvider()->GetWindowList().back()); | |
| 222 EXPECT_FALSE(second->IsVisible()); | |
| 223 EXPECT_TRUE(third->IsVisible()); | |
| 224 } | |
| 225 | |
| 226 // Verifies that the correct windows are replaced and the ordering of | |
| 227 // the window list changes correctly when the window titlebars are dragged | |
| 228 // in split view mode. | |
| 229 TEST_F(WindowManagerTest, ReplaceWindowsInSplitViewMode) { | |
| 230 aura::test::TestWindowDelegate delegate; | |
| 231 delegate.set_window_component(HTCAPTION); | |
| 232 scoped_ptr<aura::Window> first(CreateAndActivateWindow(&delegate)); | |
| 233 scoped_ptr<aura::Window> second(CreateAndActivateWindow(&delegate)); | |
| 234 scoped_ptr<aura::Window> third(CreateAndActivateWindow(&delegate)); | |
| 235 scoped_ptr<aura::Window> fourth(CreateAndActivateWindow(&delegate)); | |
| 236 | |
| 237 test::WindowManagerImplTestApi wm_api; | |
| 238 wm_api.wm()->ToggleSplitView(); | |
| 239 ASSERT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 240 | |
| 241 // Verify that the left and right windows have been set to the | |
| 242 // two windows at the top of the window list. | |
| 243 aura::Window::Windows windows = | |
| 244 wm_api.GetWindowListProvider()->GetWindowList(); | |
| 245 ASSERT_EQ(4u, windows.size()); | |
| 246 EXPECT_EQ(first.get(), windows[0]); | |
| 247 EXPECT_EQ(second.get(), windows[1]); | |
| 248 EXPECT_EQ(third.get(), windows[2]); | |
| 249 EXPECT_EQ(fourth.get(), windows[3]); | |
| 250 EXPECT_EQ(fourth.get(), wm_api.GetSplitViewController()->left_window()); | |
| 251 EXPECT_EQ(third.get(), wm_api.GetSplitViewController()->right_window()); | |
| 252 | |
| 253 // Swiping the title of the left window should change it from |fourth| | |
| 254 // to |second|. The right window should not change. | |
| 255 ui::test::EventGenerator generator(root_window()); | |
| 256 generator.GestureScrollSequence(gfx::Point(20, 10), | |
| 257 gfx::Point(20, 400), | |
| 258 base::TimeDelta::FromMilliseconds(20), | |
| 259 5); | |
| 260 EXPECT_EQ(second.get(), wm_api.GetSplitViewController()->left_window()); | |
| 261 EXPECT_EQ(third.get(), wm_api.GetSplitViewController()->right_window()); | |
| 262 | |
| 263 // |second| should be placed at the front of the list. The replaced | |
| 264 // window (|fourth|) should be stacked behind the non-replaced window | |
| 265 // (|third|). | |
| 266 windows = wm_api.GetWindowListProvider()->GetWindowList(); | |
| 267 ASSERT_EQ(4u, windows.size()); | |
| 268 EXPECT_EQ(first.get(), windows[0]); | |
| 269 EXPECT_EQ(fourth.get(), windows[1]); | |
| 270 EXPECT_EQ(third.get(), windows[2]); | |
| 271 EXPECT_EQ(second.get(), windows[3]); | |
| 272 | |
| 273 // Swiping the title of the right window should change it from |third| | |
| 274 // to |fourth|. The left window should not change. | |
| 275 int x_middle = root_window()->bounds().width() / 2; | |
| 276 generator.GestureScrollSequence(gfx::Point(x_middle + 20, 10), | |
| 277 gfx::Point(x_middle + 20, 400), | |
| 278 base::TimeDelta::FromMilliseconds(20), | |
| 279 5); | |
| 280 EXPECT_EQ(second.get(), wm_api.GetSplitViewController()->left_window()); | |
| 281 EXPECT_EQ(fourth.get(), wm_api.GetSplitViewController()->right_window()); | |
| 282 | |
| 283 // |fourth| should be placed at the front of the list. The replaced | |
| 284 // window (|third|) should be stacked behind the non-replaced window | |
| 285 // (|second|). | |
| 286 windows = wm_api.GetWindowListProvider()->GetWindowList(); | |
| 287 ASSERT_EQ(4u, windows.size()); | |
| 288 EXPECT_EQ(first.get(), windows[0]); | |
| 289 EXPECT_EQ(third.get(), windows[1]); | |
| 290 EXPECT_EQ(second.get(), windows[2]); | |
| 291 EXPECT_EQ(fourth.get(), windows[3]); | |
| 292 } | |
| 293 | |
| 294 TEST_F(WindowManagerTest, NewWindowBounds) { | |
| 295 aura::test::TestWindowDelegate delegate; | |
| 296 scoped_ptr<aura::Window> first(CreateAndActivateWindow(&delegate)); | |
| 297 | |
| 298 test::WindowManagerImplTestApi wm_api; | |
| 299 // The window should have the same size as the container. | |
| 300 const gfx::Size work_area = | |
| 301 gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().size(); | |
| 302 EXPECT_EQ(work_area.ToString(), | |
| 303 first->bounds().size().ToString()); | |
| 304 EXPECT_TRUE(first->bounds().origin().IsOrigin()); | |
| 305 | |
| 306 // A second window should have the same bounds as the first one. | |
| 307 scoped_ptr<aura::Window> second(CreateAndActivateWindow(&delegate)); | |
| 308 EXPECT_EQ(first->bounds().ToString(), second->bounds().ToString()); | |
| 309 | |
| 310 // Get into split view. | |
| 311 wm_api.GetSplitViewController()->ActivateSplitMode(nullptr, nullptr, nullptr); | |
| 312 const gfx::Rect left_bounds = | |
| 313 wm_api.GetSplitViewController()->left_window()->bounds(); | |
| 314 EXPECT_NE(work_area.ToString(), | |
| 315 left_bounds.size().ToString()); | |
| 316 | |
| 317 // A new window should replace the left window when in split view. | |
| 318 scoped_ptr<aura::Window> third(CreateAndActivateWindow(&delegate)); | |
| 319 EXPECT_EQ(wm_api.GetSplitViewController()->left_window(), third.get()); | |
| 320 EXPECT_EQ(left_bounds.ToString(), third->bounds().ToString()); | |
| 321 } | |
| 322 | |
| 323 TEST_F(WindowManagerTest, OverviewModeAccelerators) { | |
| 324 ui::test::EventGenerator generator(root_window()); | |
| 325 | |
| 326 // F6 toggles overview mode | |
| 327 ASSERT_FALSE(WindowManager::Get()->IsOverviewModeActive()); | |
| 328 generator.PressKey(ui::VKEY_F6, ui::EF_NONE); | |
| 329 EXPECT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 330 generator.PressKey(ui::VKEY_F6, ui::EF_NONE); | |
| 331 EXPECT_FALSE(WindowManager::Get()->IsOverviewModeActive()); | |
| 332 | |
| 333 // ESC exits overview mode | |
| 334 generator.PressKey(ui::VKEY_F6, ui::EF_NONE); | |
| 335 EXPECT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 336 generator.PressKey(ui::VKEY_ESCAPE, ui::EF_NONE); | |
| 337 EXPECT_FALSE(WindowManager::Get()->IsOverviewModeActive()); | |
| 338 } | |
| 339 | |
| 340 TEST_F(WindowManagerTest, SplitModeActivationByShortcut) { | |
| 341 test::WindowManagerImplTestApi wm_api; | |
| 342 | |
| 343 aura::test::TestWindowDelegate delegate; | |
| 344 scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate)); | |
| 345 | |
| 346 // Splitview mode needs at least two windows. | |
| 347 wm_api.wm()->ToggleSplitView(); | |
| 348 EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 349 | |
| 350 scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate)); | |
| 351 w2->Show(); | |
| 352 | |
| 353 wm_api.wm()->ToggleSplitView(); | |
| 354 EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 355 int width = | |
| 356 gfx::Screen::GetNativeScreen()->GetPrimaryDisplay().work_area().width(); | |
| 357 | |
| 358 EXPECT_EQ(w1->bounds().width(), w2->bounds().width()); | |
| 359 EXPECT_GE(width / 2, w1->bounds().width()); | |
| 360 | |
| 361 // Toggle back to normal mode. | |
| 362 wm_api.wm()->ToggleSplitView(); | |
| 363 EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 364 | |
| 365 // w2 is the top window, it should be resized to max width and must be visible | |
| 366 // w1 should be hidden. | |
| 367 EXPECT_EQ(width, w2->bounds().width()); | |
| 368 EXPECT_TRUE(w2->IsVisible()); | |
| 369 EXPECT_FALSE(w1->IsVisible()); | |
| 370 | |
| 371 // Expect w1 to be visible and maximized when activated. | |
| 372 // TODO(oshima): To change to wm::ActivateWindow once the correct window state | |
| 373 // is implemented. | |
| 374 w1->Show(); | |
| 375 EXPECT_EQ(width, w1->bounds().width()); | |
| 376 EXPECT_TRUE(w1->IsVisible()); | |
| 377 } | |
| 378 | |
| 379 TEST_F(WindowManagerTest, OverviewModeFromSplitMode) { | |
| 380 test::WindowManagerImplTestApi wm_api; | |
| 381 | |
| 382 aura::test::TestWindowDelegate delegate; | |
| 383 scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate)); | |
| 384 scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate)); | |
| 385 scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate)); | |
| 386 | |
| 387 // Get into split-view mode, and then turn on overview mode. | |
| 388 wm_api.GetSplitViewController()->ActivateSplitMode(nullptr, nullptr, nullptr); | |
| 389 WindowManager::Get()->EnterOverview(); | |
| 390 EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 391 EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window()); | |
| 392 EXPECT_EQ(w2.get(), wm_api.GetSplitViewController()->right_window()); | |
| 393 | |
| 394 WindowOverviewModeDelegate* overview_delegate = wm_api.wm(); | |
| 395 overview_delegate->OnSelectWindow(w1.get()); | |
| 396 EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 397 EXPECT_TRUE(w1->IsVisible()); | |
| 398 // Make sure the windows that were in split-view mode are hidden. | |
| 399 EXPECT_FALSE(w2->IsVisible()); | |
| 400 EXPECT_FALSE(w3->IsVisible()); | |
| 401 } | |
| 402 | |
| 403 // Clicking a background in overview should not crash. | |
| 404 TEST_F(WindowManagerTest, ClickBackgroundInOverview) { | |
| 405 test::WindowManagerImplTestApi wm_api; | |
| 406 | |
| 407 aura::test::TestWindowDelegate delegate; | |
| 408 scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate)); | |
| 409 WindowManager::Get()->EnterOverview(); | |
| 410 | |
| 411 ui::test::EventGenerator generator(root_window()); | |
| 412 generator.MoveMouseTo(1, 1); | |
| 413 generator.ClickLeftButton(); | |
| 414 } | |
| 415 | |
| 416 TEST_F(WindowManagerTest, CloseWindow) { | |
| 417 test::WindowManagerImplTestApi wm_api; | |
| 418 | |
| 419 aura::test::TestWindowDelegate delegate; | |
| 420 scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate)); | |
| 421 scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate)); | |
| 422 scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate)); | |
| 423 | |
| 424 EXPECT_EQ(w3.get(), | |
| 425 wm_api.GetWindowListProvider()->GetWindowList().back()); | |
| 426 EXPECT_TRUE(w3->IsVisible()); | |
| 427 EXPECT_TRUE(wm::IsActiveWindow(w3.get())); | |
| 428 | |
| 429 // Closes the front window (w3). | |
| 430 w3.reset(); | |
| 431 EXPECT_EQ(w2.get(), | |
| 432 wm_api.GetWindowListProvider()->GetWindowList().back()); | |
| 433 EXPECT_TRUE(w2->IsVisible()); | |
| 434 EXPECT_TRUE(wm::IsActiveWindow(w2.get())); | |
| 435 | |
| 436 // Closes a non-front window (w1). | |
| 437 w1.reset(); | |
| 438 EXPECT_EQ(w2.get(), | |
| 439 wm_api.GetWindowListProvider()->GetWindowList().back()); | |
| 440 EXPECT_TRUE(w2->IsVisible()); | |
| 441 EXPECT_TRUE(wm::IsActiveWindow(w2.get())); | |
| 442 | |
| 443 // Closes w2. | |
| 444 w2.reset(); | |
| 445 EXPECT_TRUE(wm_api.GetWindowListProvider()->GetWindowList().empty()); | |
| 446 } | |
| 447 | |
| 448 TEST_F(WindowManagerTest, CloseWindowInSplitMode) { | |
| 449 test::WindowManagerImplTestApi wm_api; | |
| 450 | |
| 451 aura::test::TestWindowDelegate delegate; | |
| 452 scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate)); | |
| 453 scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate)); | |
| 454 scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate)); | |
| 455 scoped_ptr<aura::Window> w4(CreateAndActivateWindow(&delegate)); | |
| 456 scoped_ptr<aura::Window> w5(CreateAndActivateWindow(&delegate)); | |
| 457 | |
| 458 // Get into split-view mode. | |
| 459 wm_api.GetSplitViewController()->ActivateSplitMode(NULL, NULL, NULL); | |
| 460 EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 461 EXPECT_EQ(w5.get(), wm_api.GetSplitViewController()->left_window()); | |
| 462 EXPECT_EQ(w4.get(), wm_api.GetSplitViewController()->right_window()); | |
| 463 EXPECT_TRUE(w5->IsVisible()); | |
| 464 EXPECT_TRUE(w4->IsVisible()); | |
| 465 EXPECT_TRUE(wm::IsActiveWindow(w5.get())); | |
| 466 | |
| 467 // Closes the left window (w5). | |
| 468 w5.reset(); | |
| 469 | |
| 470 EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 471 EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window()); | |
| 472 EXPECT_EQ(w4.get(), wm_api.GetSplitViewController()->right_window()); | |
| 473 EXPECT_TRUE(w4->IsVisible()); | |
| 474 EXPECT_TRUE(w3->IsVisible()); | |
| 475 EXPECT_TRUE(wm::IsActiveWindow(w4.get())); | |
| 476 | |
| 477 // Closes the right window (w4). | |
| 478 w4.reset(); | |
| 479 | |
| 480 EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 481 EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window()); | |
| 482 EXPECT_EQ(w2.get(), wm_api.GetSplitViewController()->right_window()); | |
| 483 EXPECT_TRUE(w3->IsVisible()); | |
| 484 EXPECT_TRUE(w2->IsVisible()); | |
| 485 EXPECT_TRUE(wm::IsActiveWindow(w3.get())); | |
| 486 | |
| 487 // Closes a non-visible window (w1). | |
| 488 w1.reset(); | |
| 489 | |
| 490 EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 491 EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window()); | |
| 492 EXPECT_EQ(w2.get(), wm_api.GetSplitViewController()->right_window()); | |
| 493 EXPECT_TRUE(w3->IsVisible()); | |
| 494 EXPECT_TRUE(w2->IsVisible()); | |
| 495 EXPECT_TRUE(wm::IsActiveWindow(w3.get())); | |
| 496 | |
| 497 // Closes a non-visible window (w1). | |
| 498 w3.reset(); | |
| 499 | |
| 500 EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 501 EXPECT_TRUE(w2->IsVisible()); | |
| 502 EXPECT_TRUE(wm::IsActiveWindow(w2.get())); | |
| 503 } | |
| 504 | |
| 505 TEST_F(WindowManagerTest, CloseWindowFromOverview) { | |
| 506 aura::test::TestWindowDelegate delegate; | |
| 507 scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate)); | |
| 508 scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate)); | |
| 509 scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate)); | |
| 510 EXPECT_FALSE(wm::IsActiveWindow(w1.get())); | |
| 511 EXPECT_FALSE(wm::IsActiveWindow(w2.get())); | |
| 512 EXPECT_TRUE(wm::IsActiveWindow(w3.get())); | |
| 513 | |
| 514 WindowManager::Get()->EnterOverview(); | |
| 515 | |
| 516 ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 517 EXPECT_TRUE(w1->IsVisible()); | |
| 518 EXPECT_TRUE(w2->IsVisible()); | |
| 519 EXPECT_TRUE(w3->IsVisible()); | |
| 520 EXPECT_FALSE(wm::IsActiveWindow(w1.get())); | |
| 521 EXPECT_FALSE(wm::IsActiveWindow(w2.get())); | |
| 522 EXPECT_FALSE(wm::IsActiveWindow(w3.get())); | |
| 523 | |
| 524 w3.reset(); | |
| 525 | |
| 526 ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 527 EXPECT_FALSE(wm::IsActiveWindow(w1.get())); | |
| 528 EXPECT_FALSE(wm::IsActiveWindow(w2.get())); | |
| 529 EXPECT_TRUE(w1->IsVisible()); | |
| 530 EXPECT_TRUE(w2->IsVisible()); | |
| 531 | |
| 532 w1.reset(); | |
| 533 | |
| 534 ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 535 EXPECT_FALSE(wm::IsActiveWindow(w2.get())); | |
| 536 EXPECT_TRUE(w2->IsVisible()); | |
| 537 } | |
| 538 | |
| 539 TEST_F(WindowManagerTest, CloseWindowInSplitModeFromOverview) { | |
| 540 test::WindowManagerImplTestApi wm_api; | |
| 541 | |
| 542 aura::test::TestWindowDelegate delegate; | |
| 543 scoped_ptr<aura::Window> w1(CreateAndActivateWindow(&delegate)); | |
| 544 scoped_ptr<aura::Window> w2(CreateAndActivateWindow(&delegate)); | |
| 545 scoped_ptr<aura::Window> w3(CreateAndActivateWindow(&delegate)); | |
| 546 scoped_ptr<aura::Window> w4(CreateAndActivateWindow(&delegate)); | |
| 547 scoped_ptr<aura::Window> w5(CreateAndActivateWindow(&delegate)); | |
| 548 | |
| 549 // Get into split-view mode. | |
| 550 wm_api.GetSplitViewController()->ActivateSplitMode(NULL, NULL, NULL); | |
| 551 WindowManager::Get()->EnterOverview(); | |
| 552 | |
| 553 ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 554 EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 555 EXPECT_EQ(w5.get(), wm_api.GetSplitViewController()->left_window()); | |
| 556 EXPECT_EQ(w4.get(), wm_api.GetSplitViewController()->right_window()); | |
| 557 EXPECT_TRUE(w5->IsVisible()); | |
| 558 EXPECT_TRUE(w4->IsVisible()); | |
| 559 | |
| 560 // Closes the left window (w5). | |
| 561 w5.reset(); | |
| 562 | |
| 563 ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 564 EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 565 EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window()); | |
| 566 EXPECT_EQ(w4.get(), wm_api.GetSplitViewController()->right_window()); | |
| 567 EXPECT_TRUE(w4->IsVisible()); | |
| 568 EXPECT_TRUE(w3->IsVisible()); | |
| 569 | |
| 570 // Closes the right window (w4). | |
| 571 w4.reset(); | |
| 572 | |
| 573 ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 574 EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 575 EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window()); | |
| 576 EXPECT_EQ(w2.get(), wm_api.GetSplitViewController()->right_window()); | |
| 577 EXPECT_TRUE(w3->IsVisible()); | |
| 578 EXPECT_TRUE(w2->IsVisible()); | |
| 579 | |
| 580 // Closes a non-visible window (w1). | |
| 581 w1.reset(); | |
| 582 | |
| 583 ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 584 EXPECT_TRUE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 585 EXPECT_EQ(w3.get(), wm_api.GetSplitViewController()->left_window()); | |
| 586 EXPECT_EQ(w2.get(), wm_api.GetSplitViewController()->right_window()); | |
| 587 EXPECT_TRUE(w3->IsVisible()); | |
| 588 EXPECT_TRUE(w2->IsVisible()); | |
| 589 | |
| 590 // Closes a non-visible window (w1). | |
| 591 w3.reset(); | |
| 592 | |
| 593 ASSERT_TRUE(WindowManager::Get()->IsOverviewModeActive()); | |
| 594 EXPECT_FALSE(wm_api.GetSplitViewController()->IsSplitViewModeActive()); | |
| 595 EXPECT_TRUE(w2->IsVisible()); | |
| 596 } | |
| 597 | |
| 598 } // namespace athena | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 863033002:
Delete athena/ (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master