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 |