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 "ash/wm/maximize_mode/maximize_mode_window_manager.h" | |
6 | |
7 #include <string> | |
8 | |
9 #include "ash/ash_switches.h" | |
10 #include "ash/public/cpp/config.h" | |
11 #include "ash/root_window_controller.h" | |
12 #include "ash/screen_util.h" | |
13 #include "ash/shelf/shelf.h" | |
14 #include "ash/shell.h" | |
15 #include "ash/shell_port.h" | |
16 #include "ash/test/ash_test_base.h" | |
17 #include "ash/test/shell_test_api.h" | |
18 #include "ash/wm/maximize_mode/maximize_mode_controller.h" | |
19 #include "ash/wm/mru_window_tracker.h" | |
20 #include "ash/wm/overview/window_selector_controller.h" | |
21 #include "ash/wm/switchable_windows.h" | |
22 #include "ash/wm/window_properties.h" | |
23 #include "ash/wm/window_state.h" | |
24 #include "ash/wm/window_state_observer.h" | |
25 #include "ash/wm/window_util.h" | |
26 #include "ash/wm/wm_event.h" | |
27 #include "ash/wm_window.h" | |
28 #include "base/command_line.h" | |
29 #include "base/strings/stringprintf.h" | |
30 #include "base/strings/utf_string_conversions.h" | |
31 #include "base/values.h" | |
32 #include "services/ui/public/interfaces/window_manager_constants.mojom.h" | |
33 #include "ui/aura/client/aura_constants.h" | |
34 #include "ui/aura/test/test_window_delegate.h" | |
35 #include "ui/aura/test/test_windows.h" | |
36 #include "ui/aura/window.h" | |
37 #include "ui/base/hit_test.h" | |
38 #include "ui/events/test/event_generator.h" | |
39 #include "ui/views/widget/widget.h" | |
40 | |
41 namespace ash { | |
42 | |
43 class MaximizeModeWindowManagerTest : public test::AshTestBase { | |
44 public: | |
45 MaximizeModeWindowManagerTest() {} | |
46 ~MaximizeModeWindowManagerTest() override {} | |
47 | |
48 // Creates a window which has a fixed size. | |
49 aura::Window* CreateFixedSizeNonMaximizableWindow( | |
50 aura::client::WindowType type, | |
51 const gfx::Rect& bounds) { | |
52 return CreateWindowInWatchedContainer(type, bounds, gfx::Size(), false, | |
53 false); | |
54 } | |
55 | |
56 // Creates a window which can not be maximized, but resized. |max_size| | |
57 // denotes the maximal possible size, if the size is empty, the window has no | |
58 // upper limit. Note: This function will only work with a single root window. | |
59 aura::Window* CreateNonMaximizableWindow(aura::client::WindowType type, | |
60 const gfx::Rect& bounds, | |
61 const gfx::Size& max_size) { | |
62 return CreateWindowInWatchedContainer(type, bounds, max_size, false, true); | |
63 } | |
64 | |
65 // Creates a maximizable and resizable window. | |
66 aura::Window* CreateWindow(aura::client::WindowType type, | |
67 const gfx::Rect bounds) { | |
68 return CreateWindowInWatchedContainer(type, bounds, gfx::Size(), true, | |
69 true); | |
70 } | |
71 | |
72 // Creates a window which also has a widget. | |
73 aura::Window* CreateWindowWithWidget(const gfx::Rect& bounds) { | |
74 views::Widget* widget = new views::Widget(); | |
75 views::Widget::InitParams params; | |
76 params.context = CurrentContext(); | |
77 // Note: The widget will get deleted with the window. | |
78 widget->Init(params); | |
79 widget->Show(); | |
80 aura::Window* window = widget->GetNativeWindow(); | |
81 window->SetBounds(bounds); | |
82 window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL); | |
83 | |
84 return window; | |
85 } | |
86 | |
87 // Create the Maximized mode window manager. | |
88 MaximizeModeWindowManager* CreateMaximizeModeWindowManager() { | |
89 EXPECT_FALSE(maximize_mode_window_manager()); | |
90 Shell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager( | |
91 true); | |
92 return maximize_mode_window_manager(); | |
93 } | |
94 | |
95 // Destroy the maximized mode window manager. | |
96 void DestroyMaximizeModeWindowManager() { | |
97 Shell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager( | |
98 false); | |
99 EXPECT_FALSE(maximize_mode_window_manager()); | |
100 } | |
101 | |
102 // Get the maximze window manager. | |
103 MaximizeModeWindowManager* maximize_mode_window_manager() { | |
104 return Shell::Get() | |
105 ->maximize_mode_controller() | |
106 ->maximize_mode_window_manager_.get(); | |
107 } | |
108 | |
109 // Resize our desktop. | |
110 void ResizeDesktop(int width_delta) { | |
111 gfx::Size size = | |
112 display::Screen::GetScreen() | |
113 ->GetDisplayNearestWindow(Shell::GetPrimaryRootWindow()) | |
114 .size(); | |
115 size.Enlarge(0, width_delta); | |
116 UpdateDisplay(size.ToString()); | |
117 } | |
118 | |
119 private: | |
120 // Create a window in one of the containers which are watched by the | |
121 // MaximizeModeWindowManager. Note that this only works with one root window. | |
122 // If |can_maximize| is not set, |max_size| is the upper limiting size for | |
123 // the window, whereas an empty size means that there is no limit. | |
124 aura::Window* CreateWindowInWatchedContainer(aura::client::WindowType type, | |
125 const gfx::Rect& bounds, | |
126 const gfx::Size& max_size, | |
127 bool can_maximize, | |
128 bool can_resize) { | |
129 aura::test::TestWindowDelegate* delegate = NULL; | |
130 if (!can_maximize) { | |
131 delegate = aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(); | |
132 delegate->set_window_component(HTCAPTION); | |
133 if (!max_size.IsEmpty()) | |
134 delegate->set_maximum_size(max_size); | |
135 } | |
136 aura::Window* window = aura::test::CreateTestWindowWithDelegateAndType( | |
137 delegate, type, 0, bounds, NULL); | |
138 int32_t behavior = ui::mojom::kResizeBehaviorNone; | |
139 behavior |= can_resize ? ui::mojom::kResizeBehaviorCanResize : 0; | |
140 behavior |= can_maximize ? ui::mojom::kResizeBehaviorCanMaximize : 0; | |
141 window->SetProperty(aura::client::kResizeBehaviorKey, behavior); | |
142 aura::Window* container = Shell::GetContainer( | |
143 Shell::GetPrimaryRootWindow(), wm::kSwitchableWindowContainerIds[0]); | |
144 container->AddChild(window); | |
145 return window; | |
146 } | |
147 | |
148 DISALLOW_COPY_AND_ASSIGN(MaximizeModeWindowManagerTest); | |
149 }; | |
150 | |
151 // Test that creating the object and destroying it without any windows should | |
152 // not cause any problems. | |
153 TEST_F(MaximizeModeWindowManagerTest, SimpleStart) { | |
154 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
155 ASSERT_TRUE(manager); | |
156 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); | |
157 DestroyMaximizeModeWindowManager(); | |
158 } | |
159 | |
160 // Test that existing windows will handled properly when going into maximized | |
161 // mode. | |
162 TEST_F(MaximizeModeWindowManagerTest, PreCreateWindows) { | |
163 // Bounds for windows we know can be controlled. | |
164 gfx::Rect rect1(10, 10, 200, 50); | |
165 gfx::Rect rect2(10, 60, 200, 50); | |
166 gfx::Rect rect3(20, 140, 100, 100); | |
167 // Bounds for anything else. | |
168 gfx::Rect rect(80, 90, 100, 110); | |
169 std::unique_ptr<aura::Window> w1( | |
170 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect1)); | |
171 std::unique_ptr<aura::Window> w2( | |
172 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect2)); | |
173 std::unique_ptr<aura::Window> w3(CreateFixedSizeNonMaximizableWindow( | |
174 aura::client::WINDOW_TYPE_NORMAL, rect3)); | |
175 std::unique_ptr<aura::Window> w4( | |
176 CreateWindow(aura::client::WINDOW_TYPE_PANEL, rect)); | |
177 std::unique_ptr<aura::Window> w5( | |
178 CreateWindow(aura::client::WINDOW_TYPE_POPUP, rect)); | |
179 std::unique_ptr<aura::Window> w6( | |
180 CreateWindow(aura::client::WINDOW_TYPE_CONTROL, rect)); | |
181 std::unique_ptr<aura::Window> w7( | |
182 CreateWindow(aura::client::WINDOW_TYPE_MENU, rect)); | |
183 std::unique_ptr<aura::Window> w8( | |
184 CreateWindow(aura::client::WINDOW_TYPE_TOOLTIP, rect)); | |
185 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); | |
186 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); | |
187 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); | |
188 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); | |
189 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); | |
190 EXPECT_EQ(rect3.ToString(), w3->bounds().ToString()); | |
191 | |
192 // Create the manager and make sure that all qualifying windows were detected | |
193 // and changed. | |
194 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
195 ASSERT_TRUE(manager); | |
196 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); | |
197 EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized()); | |
198 EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized()); | |
199 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); | |
200 EXPECT_NE(rect3.origin().ToString(), w3->bounds().origin().ToString()); | |
201 EXPECT_EQ(rect3.size().ToString(), w3->bounds().size().ToString()); | |
202 | |
203 // All other windows should not have been touched. | |
204 EXPECT_FALSE(wm::GetWindowState(w4.get())->IsMaximized()); | |
205 EXPECT_FALSE(wm::GetWindowState(w5.get())->IsMaximized()); | |
206 EXPECT_FALSE(wm::GetWindowState(w6.get())->IsMaximized()); | |
207 EXPECT_FALSE(wm::GetWindowState(w7.get())->IsMaximized()); | |
208 EXPECT_FALSE(wm::GetWindowState(w8.get())->IsMaximized()); | |
209 EXPECT_EQ(rect.ToString(), w4->bounds().ToString()); | |
210 EXPECT_EQ(rect.ToString(), w5->bounds().ToString()); | |
211 EXPECT_EQ(rect.ToString(), w6->bounds().ToString()); | |
212 EXPECT_EQ(rect.ToString(), w7->bounds().ToString()); | |
213 EXPECT_EQ(rect.ToString(), w8->bounds().ToString()); | |
214 | |
215 // Destroy the manager again and check that the windows return to their | |
216 // previous state. | |
217 DestroyMaximizeModeWindowManager(); | |
218 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); | |
219 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); | |
220 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); | |
221 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); | |
222 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); | |
223 EXPECT_EQ(rect3.ToString(), w3->bounds().ToString()); | |
224 EXPECT_EQ(rect.ToString(), w4->bounds().ToString()); | |
225 EXPECT_EQ(rect.ToString(), w5->bounds().ToString()); | |
226 EXPECT_EQ(rect.ToString(), w6->bounds().ToString()); | |
227 EXPECT_EQ(rect.ToString(), w7->bounds().ToString()); | |
228 EXPECT_EQ(rect.ToString(), w8->bounds().ToString()); | |
229 } | |
230 | |
231 // The same test as the above but while a system modal dialog is shown. | |
232 TEST_F(MaximizeModeWindowManagerTest, GoingToMaximizedWithModalDialogPresent) { | |
233 // Bounds for windows we know can be controlled. | |
234 gfx::Rect rect1(10, 10, 200, 50); | |
235 gfx::Rect rect2(10, 60, 200, 50); | |
236 gfx::Rect rect3(20, 140, 100, 100); | |
237 // Bounds for anything else. | |
238 gfx::Rect rect(80, 90, 100, 110); | |
239 std::unique_ptr<aura::Window> w1( | |
240 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect1)); | |
241 std::unique_ptr<aura::Window> w2( | |
242 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect2)); | |
243 std::unique_ptr<aura::Window> w3(CreateFixedSizeNonMaximizableWindow( | |
244 aura::client::WINDOW_TYPE_NORMAL, rect3)); | |
245 std::unique_ptr<aura::Window> w4( | |
246 CreateWindow(aura::client::WINDOW_TYPE_PANEL, rect)); | |
247 std::unique_ptr<aura::Window> w5( | |
248 CreateWindow(aura::client::WINDOW_TYPE_POPUP, rect)); | |
249 std::unique_ptr<aura::Window> w6( | |
250 CreateWindow(aura::client::WINDOW_TYPE_CONTROL, rect)); | |
251 std::unique_ptr<aura::Window> w7( | |
252 CreateWindow(aura::client::WINDOW_TYPE_MENU, rect)); | |
253 std::unique_ptr<aura::Window> w8( | |
254 CreateWindow(aura::client::WINDOW_TYPE_TOOLTIP, rect)); | |
255 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); | |
256 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); | |
257 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); | |
258 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); | |
259 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); | |
260 EXPECT_EQ(rect3.ToString(), w3->bounds().ToString()); | |
261 | |
262 // Enable system modal dialog, and make sure both shelves are still hidden. | |
263 ShellPort::Get()->SimulateModalWindowOpenForTesting(true); | |
264 EXPECT_TRUE(ShellPort::Get()->IsSystemModalWindowOpen()); | |
265 | |
266 // Create the manager and make sure that all qualifying windows were detected | |
267 // and changed. | |
268 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
269 ASSERT_TRUE(manager); | |
270 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); | |
271 EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized()); | |
272 EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized()); | |
273 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); | |
274 EXPECT_NE(rect3.origin().ToString(), w3->bounds().origin().ToString()); | |
275 EXPECT_EQ(rect3.size().ToString(), w3->bounds().size().ToString()); | |
276 | |
277 // All other windows should not have been touched. | |
278 EXPECT_FALSE(wm::GetWindowState(w4.get())->IsMaximized()); | |
279 EXPECT_FALSE(wm::GetWindowState(w5.get())->IsMaximized()); | |
280 EXPECT_FALSE(wm::GetWindowState(w6.get())->IsMaximized()); | |
281 EXPECT_FALSE(wm::GetWindowState(w7.get())->IsMaximized()); | |
282 EXPECT_FALSE(wm::GetWindowState(w8.get())->IsMaximized()); | |
283 EXPECT_EQ(rect.ToString(), w4->bounds().ToString()); | |
284 EXPECT_EQ(rect.ToString(), w5->bounds().ToString()); | |
285 EXPECT_EQ(rect.ToString(), w6->bounds().ToString()); | |
286 EXPECT_EQ(rect.ToString(), w7->bounds().ToString()); | |
287 EXPECT_EQ(rect.ToString(), w8->bounds().ToString()); | |
288 | |
289 // Destroy the manager again and check that the windows return to their | |
290 // previous state. | |
291 DestroyMaximizeModeWindowManager(); | |
292 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); | |
293 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); | |
294 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); | |
295 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); | |
296 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); | |
297 EXPECT_EQ(rect3.ToString(), w3->bounds().ToString()); | |
298 EXPECT_EQ(rect.ToString(), w4->bounds().ToString()); | |
299 EXPECT_EQ(rect.ToString(), w5->bounds().ToString()); | |
300 EXPECT_EQ(rect.ToString(), w6->bounds().ToString()); | |
301 EXPECT_EQ(rect.ToString(), w7->bounds().ToString()); | |
302 EXPECT_EQ(rect.ToString(), w8->bounds().ToString()); | |
303 } | |
304 | |
305 // Test that non-maximizable windows get properly handled when going into | |
306 // maximized mode. | |
307 TEST_F(MaximizeModeWindowManagerTest, | |
308 PreCreateNonMaximizableButResizableWindows) { | |
309 // The window bounds. | |
310 gfx::Rect rect(10, 10, 200, 50); | |
311 gfx::Size max_size(300, 200); | |
312 gfx::Size empty_size; | |
313 std::unique_ptr<aura::Window> unlimited_window(CreateNonMaximizableWindow( | |
314 aura::client::WINDOW_TYPE_NORMAL, rect, empty_size)); | |
315 std::unique_ptr<aura::Window> limited_window(CreateNonMaximizableWindow( | |
316 aura::client::WINDOW_TYPE_NORMAL, rect, max_size)); | |
317 std::unique_ptr<aura::Window> fixed_window( | |
318 CreateFixedSizeNonMaximizableWindow(aura::client::WINDOW_TYPE_NORMAL, | |
319 rect)); | |
320 EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized()); | |
321 EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString()); | |
322 EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized()); | |
323 EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString()); | |
324 EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized()); | |
325 EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString()); | |
326 | |
327 gfx::Size workspace_size = | |
328 ScreenUtil::GetMaximizedWindowBoundsInParent(unlimited_window.get()) | |
329 .size(); | |
330 | |
331 // Create the manager and make sure that all qualifying windows were detected | |
332 // and changed. | |
333 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
334 ASSERT_TRUE(manager); | |
335 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); | |
336 // The unlimited window should have the size of the workspace / parent window. | |
337 EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized()); | |
338 EXPECT_EQ("0,0", unlimited_window->bounds().origin().ToString()); | |
339 EXPECT_EQ(workspace_size.ToString(), | |
340 unlimited_window->bounds().size().ToString()); | |
341 // The limited window should have the size of the upper possible bounds. | |
342 EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized()); | |
343 EXPECT_NE(rect.origin().ToString(), | |
344 limited_window->bounds().origin().ToString()); | |
345 EXPECT_EQ(max_size.ToString(), limited_window->bounds().size().ToString()); | |
346 // The fixed size window should have the size of the original window. | |
347 EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized()); | |
348 EXPECT_NE(rect.origin().ToString(), | |
349 fixed_window->bounds().origin().ToString()); | |
350 EXPECT_EQ(rect.size().ToString(), fixed_window->bounds().size().ToString()); | |
351 | |
352 // Destroy the manager again and check that the windows return to their | |
353 // previous state. | |
354 DestroyMaximizeModeWindowManager(); | |
355 EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized()); | |
356 EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString()); | |
357 EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized()); | |
358 EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString()); | |
359 EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized()); | |
360 EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString()); | |
361 } | |
362 | |
363 // Test that creating windows while a maximizer exists picks them properly up. | |
364 TEST_F(MaximizeModeWindowManagerTest, CreateWindows) { | |
365 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
366 ASSERT_TRUE(manager); | |
367 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); | |
368 | |
369 // Create the windows and see that the window manager picks them up. | |
370 // Rects for windows we know can be controlled. | |
371 gfx::Rect rect1(10, 10, 200, 50); | |
372 gfx::Rect rect2(10, 60, 200, 50); | |
373 gfx::Rect rect3(20, 140, 100, 100); | |
374 // One rect for anything else. | |
375 gfx::Rect rect(80, 90, 100, 110); | |
376 std::unique_ptr<aura::Window> w1( | |
377 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect1)); | |
378 std::unique_ptr<aura::Window> w2( | |
379 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect2)); | |
380 std::unique_ptr<aura::Window> w3(CreateFixedSizeNonMaximizableWindow( | |
381 aura::client::WINDOW_TYPE_NORMAL, rect3)); | |
382 std::unique_ptr<aura::Window> w4( | |
383 CreateWindow(aura::client::WINDOW_TYPE_PANEL, rect)); | |
384 std::unique_ptr<aura::Window> w5( | |
385 CreateWindow(aura::client::WINDOW_TYPE_POPUP, rect)); | |
386 std::unique_ptr<aura::Window> w6( | |
387 CreateWindow(aura::client::WINDOW_TYPE_CONTROL, rect)); | |
388 std::unique_ptr<aura::Window> w7( | |
389 CreateWindow(aura::client::WINDOW_TYPE_MENU, rect)); | |
390 std::unique_ptr<aura::Window> w8( | |
391 CreateWindow(aura::client::WINDOW_TYPE_TOOLTIP, rect)); | |
392 EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized()); | |
393 EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized()); | |
394 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); | |
395 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); | |
396 | |
397 // Make sure that the position of the unresizable window is in the middle of | |
398 // the screen. | |
399 gfx::Size work_area_size = | |
400 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w3.get()).size(); | |
401 gfx::Point center = | |
402 gfx::Point((work_area_size.width() - rect3.size().width()) / 2, | |
403 (work_area_size.height() - rect3.size().height()) / 2); | |
404 gfx::Rect centered_window_bounds = gfx::Rect(center, rect3.size()); | |
405 EXPECT_EQ(centered_window_bounds.ToString(), w3->bounds().ToString()); | |
406 | |
407 // All other windows should not have been touched. | |
408 EXPECT_FALSE(wm::GetWindowState(w4.get())->IsMaximized()); | |
409 EXPECT_FALSE(wm::GetWindowState(w5.get())->IsMaximized()); | |
410 EXPECT_FALSE(wm::GetWindowState(w6.get())->IsMaximized()); | |
411 EXPECT_FALSE(wm::GetWindowState(w7.get())->IsMaximized()); | |
412 EXPECT_FALSE(wm::GetWindowState(w8.get())->IsMaximized()); | |
413 EXPECT_EQ(rect.ToString(), w4->bounds().ToString()); | |
414 EXPECT_EQ(rect.ToString(), w5->bounds().ToString()); | |
415 EXPECT_EQ(rect.ToString(), w6->bounds().ToString()); | |
416 EXPECT_EQ(rect.ToString(), w7->bounds().ToString()); | |
417 EXPECT_EQ(rect.ToString(), w8->bounds().ToString()); | |
418 | |
419 // After the maximize mode was disabled all windows fall back into the mode | |
420 // they were created for. | |
421 DestroyMaximizeModeWindowManager(); | |
422 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); | |
423 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); | |
424 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); | |
425 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); | |
426 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); | |
427 EXPECT_EQ(rect3.ToString(), w3->bounds().ToString()); | |
428 EXPECT_EQ(rect.ToString(), w4->bounds().ToString()); | |
429 EXPECT_EQ(rect.ToString(), w5->bounds().ToString()); | |
430 EXPECT_EQ(rect.ToString(), w6->bounds().ToString()); | |
431 EXPECT_EQ(rect.ToString(), w7->bounds().ToString()); | |
432 EXPECT_EQ(rect.ToString(), w8->bounds().ToString()); | |
433 } | |
434 | |
435 // Test that a window which got created while the maximize mode window manager | |
436 // is active gets restored to a usable (non tiny) size upon switching back. | |
437 TEST_F(MaximizeModeWindowManagerTest, | |
438 CreateWindowInMaximizedModeRestoresToUsefulSize) { | |
439 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
440 ASSERT_TRUE(manager); | |
441 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); | |
442 | |
443 // We pass in an empty rectangle to simulate a window creation with no | |
444 // particular size. | |
445 gfx::Rect empty_rect(0, 0, 0, 0); | |
446 std::unique_ptr<aura::Window> window( | |
447 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, empty_rect)); | |
448 EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized()); | |
449 EXPECT_NE(empty_rect.ToString(), window->bounds().ToString()); | |
450 gfx::Rect maximized_size = window->bounds(); | |
451 | |
452 // Destroy the maximize mode and check that the resulting size of the window | |
453 // is remaining as it is (but not maximized). | |
454 DestroyMaximizeModeWindowManager(); | |
455 | |
456 EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized()); | |
457 EXPECT_EQ(maximized_size.ToString(), window->bounds().ToString()); | |
458 } | |
459 | |
460 // Test that non-maximizable windows get properly handled when created in | |
461 // maximized mode. | |
462 TEST_F(MaximizeModeWindowManagerTest, CreateNonMaximizableButResizableWindows) { | |
463 // Create the manager and make sure that all qualifying windows were detected | |
464 // and changed. | |
465 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
466 ASSERT_TRUE(manager); | |
467 | |
468 gfx::Rect rect(10, 10, 200, 50); | |
469 gfx::Size max_size(300, 200); | |
470 gfx::Size empty_size; | |
471 std::unique_ptr<aura::Window> unlimited_window(CreateNonMaximizableWindow( | |
472 aura::client::WINDOW_TYPE_NORMAL, rect, empty_size)); | |
473 std::unique_ptr<aura::Window> limited_window(CreateNonMaximizableWindow( | |
474 aura::client::WINDOW_TYPE_NORMAL, rect, max_size)); | |
475 std::unique_ptr<aura::Window> fixed_window( | |
476 CreateFixedSizeNonMaximizableWindow(aura::client::WINDOW_TYPE_NORMAL, | |
477 rect)); | |
478 | |
479 gfx::Size workspace_size = | |
480 ScreenUtil::GetMaximizedWindowBoundsInParent(unlimited_window.get()) | |
481 .size(); | |
482 | |
483 // All windows should be sized now as big as possible and be centered. | |
484 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); | |
485 // The unlimited window should have the size of the workspace / parent window. | |
486 EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized()); | |
487 EXPECT_EQ("0,0", unlimited_window->bounds().origin().ToString()); | |
488 EXPECT_EQ(workspace_size.ToString(), | |
489 unlimited_window->bounds().size().ToString()); | |
490 // The limited window should have the size of the upper possible bounds. | |
491 EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized()); | |
492 EXPECT_NE(rect.origin().ToString(), | |
493 limited_window->bounds().origin().ToString()); | |
494 EXPECT_EQ(max_size.ToString(), limited_window->bounds().size().ToString()); | |
495 // The fixed size window should have the size of the original window. | |
496 EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized()); | |
497 EXPECT_NE(rect.origin().ToString(), | |
498 fixed_window->bounds().origin().ToString()); | |
499 EXPECT_EQ(rect.size().ToString(), fixed_window->bounds().size().ToString()); | |
500 | |
501 // Destroy the manager again and check that the windows return to their | |
502 // creation state. | |
503 DestroyMaximizeModeWindowManager(); | |
504 | |
505 EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized()); | |
506 EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString()); | |
507 EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized()); | |
508 EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString()); | |
509 EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized()); | |
510 EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString()); | |
511 } | |
512 | |
513 // Create a string which consists of the bounds and the state for comparison. | |
514 std::string GetPlacementString(const gfx::Rect& bounds, | |
515 ui::WindowShowState state) { | |
516 return bounds.ToString() + base::StringPrintf(" %d", state); | |
517 } | |
518 | |
519 // Retrieves the window's restore state override - if any - and returns it as a | |
520 // string. | |
521 std::string GetPlacementOverride(aura::Window* window) { | |
522 gfx::Rect* bounds = window->GetProperty(kRestoreBoundsOverrideKey); | |
523 if (bounds) { | |
524 gfx::Rect restore_bounds = *bounds; | |
525 ui::WindowShowState restore_state = | |
526 window->GetProperty(kRestoreShowStateOverrideKey); | |
527 return GetPlacementString(restore_bounds, restore_state); | |
528 } | |
529 return std::string(); | |
530 } | |
531 | |
532 // Test that the restore state will be kept at its original value for | |
533 // session restauration purposes. | |
534 TEST_F(MaximizeModeWindowManagerTest, TestRestoreIntegrety) { | |
535 gfx::Rect bounds(10, 10, 200, 50); | |
536 gfx::Size empty_size; | |
537 gfx::Rect empty_bounds; | |
538 std::unique_ptr<aura::Window> normal_window(CreateWindowWithWidget(bounds)); | |
539 std::unique_ptr<aura::Window> maximized_window( | |
540 CreateWindowWithWidget(bounds)); | |
541 wm::GetWindowState(maximized_window.get())->Maximize(); | |
542 | |
543 EXPECT_EQ(std::string(), GetPlacementOverride(normal_window.get())); | |
544 EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get())); | |
545 | |
546 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
547 ASSERT_TRUE(manager); | |
548 | |
549 // With the maximization the override states should be returned in its | |
550 // pre-maximized state. | |
551 EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_NORMAL), | |
552 GetPlacementOverride(normal_window.get())); | |
553 EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_MAXIMIZED), | |
554 GetPlacementOverride(maximized_window.get())); | |
555 | |
556 // Changing a window's state now does not change the returned result. | |
557 wm::GetWindowState(maximized_window.get())->Minimize(); | |
558 EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_MAXIMIZED), | |
559 GetPlacementOverride(maximized_window.get())); | |
560 | |
561 // Destroy the manager again and check that the overrides get reset. | |
562 DestroyMaximizeModeWindowManager(); | |
563 EXPECT_EQ(std::string(), GetPlacementOverride(normal_window.get())); | |
564 EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get())); | |
565 | |
566 // Changing a window's state now does not bring the overrides back. | |
567 wm::GetWindowState(maximized_window.get())->Restore(); | |
568 gfx::Rect new_bounds(10, 10, 200, 50); | |
569 maximized_window->SetBounds(new_bounds); | |
570 | |
571 EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get())); | |
572 } | |
573 | |
574 // Test that windows which got created before the maximizer was created can be | |
575 // destroyed while the maximizer is still running. | |
576 TEST_F(MaximizeModeWindowManagerTest, PreCreateWindowsDeleteWhileActive) { | |
577 MaximizeModeWindowManager* manager = NULL; | |
578 { | |
579 // Bounds for windows we know can be controlled. | |
580 gfx::Rect rect1(10, 10, 200, 50); | |
581 gfx::Rect rect2(10, 60, 200, 50); | |
582 gfx::Rect rect3(20, 140, 100, 100); | |
583 // Bounds for anything else. | |
584 gfx::Rect rect(80, 90, 100, 110); | |
585 std::unique_ptr<aura::Window> w1( | |
586 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect1)); | |
587 std::unique_ptr<aura::Window> w2( | |
588 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect2)); | |
589 std::unique_ptr<aura::Window> w3(CreateFixedSizeNonMaximizableWindow( | |
590 aura::client::WINDOW_TYPE_NORMAL, rect3)); | |
591 | |
592 // Create the manager and make sure that all qualifying windows were | |
593 // detected and changed. | |
594 manager = CreateMaximizeModeWindowManager(); | |
595 ASSERT_TRUE(manager); | |
596 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); | |
597 } | |
598 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); | |
599 DestroyMaximizeModeWindowManager(); | |
600 } | |
601 | |
602 // Test that windows which got created while the maximizer was running can get | |
603 // destroyed before the maximizer gets destroyed. | |
604 TEST_F(MaximizeModeWindowManagerTest, CreateWindowsAndDeleteWhileActive) { | |
605 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
606 ASSERT_TRUE(manager); | |
607 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); | |
608 { | |
609 // Bounds for windows we know can be controlled. | |
610 gfx::Rect rect1(10, 10, 200, 50); | |
611 gfx::Rect rect2(10, 60, 200, 50); | |
612 gfx::Rect rect3(20, 140, 100, 100); | |
613 std::unique_ptr<aura::Window> w1(CreateWindow( | |
614 aura::client::WINDOW_TYPE_NORMAL, gfx::Rect(10, 10, 200, 50))); | |
615 std::unique_ptr<aura::Window> w2(CreateWindow( | |
616 aura::client::WINDOW_TYPE_NORMAL, gfx::Rect(10, 60, 200, 50))); | |
617 std::unique_ptr<aura::Window> w3(CreateFixedSizeNonMaximizableWindow( | |
618 aura::client::WINDOW_TYPE_NORMAL, gfx::Rect(20, 140, 100, 100))); | |
619 // Check that the windows got automatically maximized as well. | |
620 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); | |
621 EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized()); | |
622 EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized()); | |
623 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); | |
624 } | |
625 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); | |
626 DestroyMaximizeModeWindowManager(); | |
627 } | |
628 | |
629 // Test that windows which were maximized stay maximized. | |
630 TEST_F(MaximizeModeWindowManagerTest, MaximizedShouldRemainMaximized) { | |
631 // Bounds for windows we know can be controlled. | |
632 gfx::Rect rect(10, 10, 200, 50); | |
633 std::unique_ptr<aura::Window> window( | |
634 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
635 wm::GetWindowState(window.get())->Maximize(); | |
636 | |
637 // Create the manager and make sure that the window gets detected. | |
638 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
639 ASSERT_TRUE(manager); | |
640 EXPECT_EQ(1, manager->GetNumberOfManagedWindows()); | |
641 EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized()); | |
642 | |
643 // Destroy the manager again and check that the window will remain maximized. | |
644 DestroyMaximizeModeWindowManager(); | |
645 EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized()); | |
646 wm::GetWindowState(window.get())->Restore(); | |
647 EXPECT_EQ(rect.ToString(), window->bounds().ToString()); | |
648 } | |
649 | |
650 // Test that minimized windows do neither get maximized nor restored upon | |
651 // entering maximized mode and get restored to their previous state after | |
652 // leaving. | |
653 TEST_F(MaximizeModeWindowManagerTest, MinimizedWindowBehavior) { | |
654 // Bounds for windows we know can be controlled. | |
655 gfx::Rect rect(10, 10, 200, 50); | |
656 std::unique_ptr<aura::Window> initially_minimized_window( | |
657 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
658 std::unique_ptr<aura::Window> initially_normal_window( | |
659 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
660 std::unique_ptr<aura::Window> initially_maximized_window( | |
661 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
662 wm::GetWindowState(initially_minimized_window.get())->Minimize(); | |
663 wm::GetWindowState(initially_maximized_window.get())->Maximize(); | |
664 | |
665 // Create the manager and make sure that the window gets detected. | |
666 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
667 ASSERT_TRUE(manager); | |
668 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); | |
669 EXPECT_TRUE( | |
670 wm::GetWindowState(initially_minimized_window.get())->IsMinimized()); | |
671 EXPECT_TRUE(wm::GetWindowState(initially_normal_window.get())->IsMaximized()); | |
672 EXPECT_TRUE( | |
673 wm::GetWindowState(initially_maximized_window.get())->IsMaximized()); | |
674 // Now minimize the second window to check that upon leaving the window | |
675 // will get restored to its minimized state. | |
676 wm::GetWindowState(initially_normal_window.get())->Minimize(); | |
677 wm::GetWindowState(initially_maximized_window.get())->Minimize(); | |
678 EXPECT_TRUE( | |
679 wm::GetWindowState(initially_minimized_window.get())->IsMinimized()); | |
680 EXPECT_TRUE(wm::GetWindowState(initially_normal_window.get())->IsMinimized()); | |
681 EXPECT_TRUE( | |
682 wm::GetWindowState(initially_maximized_window.get())->IsMinimized()); | |
683 | |
684 // Destroy the manager again and check that the window will get minimized. | |
685 DestroyMaximizeModeWindowManager(); | |
686 EXPECT_TRUE( | |
687 wm::GetWindowState(initially_minimized_window.get())->IsMinimized()); | |
688 EXPECT_FALSE( | |
689 wm::GetWindowState(initially_normal_window.get())->IsMinimized()); | |
690 EXPECT_TRUE( | |
691 wm::GetWindowState(initially_maximized_window.get())->IsMaximized()); | |
692 } | |
693 | |
694 // Check that resizing the desktop does reposition unmaximizable, unresizable & | |
695 // managed windows. | |
696 TEST_F(MaximizeModeWindowManagerTest, DesktopSizeChangeMovesUnmaximizable) { | |
697 UpdateDisplay("400x400"); | |
698 // This window will move because it does not fit the new bounds. | |
699 gfx::Rect rect(20, 300, 100, 100); | |
700 std::unique_ptr<aura::Window> window1(CreateFixedSizeNonMaximizableWindow( | |
701 aura::client::WINDOW_TYPE_NORMAL, rect)); | |
702 EXPECT_EQ(rect.ToString(), window1->bounds().ToString()); | |
703 | |
704 // This window will not move because it does fit the new bounds. | |
705 gfx::Rect rect2(20, 140, 100, 100); | |
706 std::unique_ptr<aura::Window> window2(CreateFixedSizeNonMaximizableWindow( | |
707 aura::client::WINDOW_TYPE_NORMAL, rect2)); | |
708 | |
709 // Turning on the manager will reposition (but not resize) the window. | |
710 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
711 ASSERT_TRUE(manager); | |
712 EXPECT_EQ(2, manager->GetNumberOfManagedWindows()); | |
713 gfx::Rect moved_bounds(window1->bounds()); | |
714 EXPECT_NE(rect.origin().ToString(), moved_bounds.origin().ToString()); | |
715 EXPECT_EQ(rect.size().ToString(), moved_bounds.size().ToString()); | |
716 | |
717 // Simulating a desktop resize should move the window again. | |
718 UpdateDisplay("300x300"); | |
719 gfx::Rect new_moved_bounds(window1->bounds()); | |
720 EXPECT_NE(rect.origin().ToString(), new_moved_bounds.origin().ToString()); | |
721 EXPECT_EQ(rect.size().ToString(), new_moved_bounds.size().ToString()); | |
722 EXPECT_NE(moved_bounds.origin().ToString(), new_moved_bounds.ToString()); | |
723 | |
724 // Turning off the mode should not restore to the initial coordinates since | |
725 // the new resolution is smaller and the window was on the edge. | |
726 DestroyMaximizeModeWindowManager(); | |
727 EXPECT_NE(rect.ToString(), window1->bounds().ToString()); | |
728 EXPECT_EQ(rect2.ToString(), window2->bounds().ToString()); | |
729 } | |
730 | |
731 // Check that windows return to original location if desktop size changes to | |
732 // something else and back while in maximize mode. | |
733 TEST_F(MaximizeModeWindowManagerTest, SizeChangeReturnWindowToOriginalPos) { | |
734 gfx::Rect rect(20, 140, 100, 100); | |
735 std::unique_ptr<aura::Window> window(CreateFixedSizeNonMaximizableWindow( | |
736 aura::client::WINDOW_TYPE_NORMAL, rect)); | |
737 | |
738 // Turning on the manager will reposition (but not resize) the window. | |
739 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
740 ASSERT_TRUE(manager); | |
741 EXPECT_EQ(1, manager->GetNumberOfManagedWindows()); | |
742 gfx::Rect moved_bounds(window->bounds()); | |
743 EXPECT_NE(rect.origin().ToString(), moved_bounds.origin().ToString()); | |
744 EXPECT_EQ(rect.size().ToString(), moved_bounds.size().ToString()); | |
745 | |
746 // Simulating a desktop resize should move the window again. | |
747 ResizeDesktop(-10); | |
748 gfx::Rect new_moved_bounds(window->bounds()); | |
749 EXPECT_NE(rect.origin().ToString(), new_moved_bounds.origin().ToString()); | |
750 EXPECT_EQ(rect.size().ToString(), new_moved_bounds.size().ToString()); | |
751 EXPECT_NE(moved_bounds.origin().ToString(), new_moved_bounds.ToString()); | |
752 | |
753 // Then resize back to the original desktop size which should move windows | |
754 // to their original location after leaving the maximize mode. | |
755 ResizeDesktop(10); | |
756 DestroyMaximizeModeWindowManager(); | |
757 EXPECT_EQ(rect.ToString(), window->bounds().ToString()); | |
758 } | |
759 | |
760 // Check that enabling of the maximize mode does not have an impact on the MRU | |
761 // order of windows. | |
762 TEST_F(MaximizeModeWindowManagerTest, ModeChangeKeepsMRUOrder) { | |
763 gfx::Rect rect(20, 140, 100, 100); | |
764 std::unique_ptr<aura::Window> w1(CreateFixedSizeNonMaximizableWindow( | |
765 aura::client::WINDOW_TYPE_NORMAL, rect)); | |
766 std::unique_ptr<aura::Window> w2( | |
767 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
768 std::unique_ptr<aura::Window> w3( | |
769 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
770 std::unique_ptr<aura::Window> w4(CreateFixedSizeNonMaximizableWindow( | |
771 aura::client::WINDOW_TYPE_NORMAL, rect)); | |
772 std::unique_ptr<aura::Window> w5( | |
773 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
774 | |
775 // The windows should be in the reverse order of creation in the MRU list. | |
776 { | |
777 aura::Window::Windows windows = | |
778 Shell::Get()->mru_window_tracker()->BuildMruWindowList(); | |
779 | |
780 EXPECT_EQ(w1.get(), windows[4]); | |
781 EXPECT_EQ(w2.get(), windows[3]); | |
782 EXPECT_EQ(w3.get(), windows[2]); | |
783 EXPECT_EQ(w4.get(), windows[1]); | |
784 EXPECT_EQ(w5.get(), windows[0]); | |
785 } | |
786 | |
787 // Activating the window manager should keep the order. | |
788 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
789 ASSERT_TRUE(manager); | |
790 EXPECT_EQ(5, manager->GetNumberOfManagedWindows()); | |
791 { | |
792 aura::Window::Windows windows = | |
793 Shell::Get()->mru_window_tracker()->BuildMruWindowList(); | |
794 // We do not test maximization here again since that was done already. | |
795 EXPECT_EQ(w1.get(), windows[4]); | |
796 EXPECT_EQ(w2.get(), windows[3]); | |
797 EXPECT_EQ(w3.get(), windows[2]); | |
798 EXPECT_EQ(w4.get(), windows[1]); | |
799 EXPECT_EQ(w5.get(), windows[0]); | |
800 } | |
801 | |
802 // Destroying should still keep the order. | |
803 DestroyMaximizeModeWindowManager(); | |
804 { | |
805 aura::Window::Windows windows = | |
806 Shell::Get()->mru_window_tracker()->BuildMruWindowList(); | |
807 // We do not test maximization here again since that was done already. | |
808 EXPECT_EQ(w1.get(), windows[4]); | |
809 EXPECT_EQ(w2.get(), windows[3]); | |
810 EXPECT_EQ(w3.get(), windows[2]); | |
811 EXPECT_EQ(w4.get(), windows[1]); | |
812 EXPECT_EQ(w5.get(), windows[0]); | |
813 } | |
814 } | |
815 | |
816 // Check that a restore state change does always restore to maximized. | |
817 TEST_F(MaximizeModeWindowManagerTest, IgnoreRestoreStateChages) { | |
818 gfx::Rect rect(20, 140, 100, 100); | |
819 std::unique_ptr<aura::Window> w1( | |
820 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
821 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
822 CreateMaximizeModeWindowManager(); | |
823 EXPECT_TRUE(window_state->IsMaximized()); | |
824 window_state->Minimize(); | |
825 EXPECT_TRUE(window_state->IsMinimized()); | |
826 window_state->Restore(); | |
827 EXPECT_TRUE(window_state->IsMaximized()); | |
828 window_state->Restore(); | |
829 EXPECT_TRUE(window_state->IsMaximized()); | |
830 DestroyMaximizeModeWindowManager(); | |
831 } | |
832 | |
833 // Check that minimize and restore do the right thing. | |
834 TEST_F(MaximizeModeWindowManagerTest, TestMinimize) { | |
835 gfx::Rect rect(10, 10, 100, 100); | |
836 std::unique_ptr<aura::Window> window( | |
837 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
838 wm::WindowState* window_state = wm::GetWindowState(window.get()); | |
839 EXPECT_EQ(rect.ToString(), window->bounds().ToString()); | |
840 Shell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager( | |
841 true); | |
842 EXPECT_TRUE(window_state->IsMaximized()); | |
843 EXPECT_FALSE(window_state->IsMinimized()); | |
844 EXPECT_TRUE(window->IsVisible()); | |
845 | |
846 window_state->Minimize(); | |
847 EXPECT_FALSE(window_state->IsMaximized()); | |
848 EXPECT_TRUE(window_state->IsMinimized()); | |
849 EXPECT_FALSE(window->IsVisible()); | |
850 | |
851 window_state->Maximize(); | |
852 EXPECT_TRUE(window_state->IsMaximized()); | |
853 EXPECT_FALSE(window_state->IsMinimized()); | |
854 EXPECT_TRUE(window->IsVisible()); | |
855 | |
856 Shell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager( | |
857 false); | |
858 EXPECT_FALSE(window_state->IsMaximized()); | |
859 EXPECT_FALSE(window_state->IsMinimized()); | |
860 EXPECT_TRUE(window->IsVisible()); | |
861 } | |
862 | |
863 // Check that a full screen window remains full screen upon entering maximize | |
864 // mode. Furthermore, checks that this window is not full screen upon exiting | |
865 // maximize mode if it was un-full-screened while in maximize mode. | |
866 TEST_F(MaximizeModeWindowManagerTest, KeepFullScreenModeOn) { | |
867 gfx::Rect rect(20, 140, 100, 100); | |
868 std::unique_ptr<aura::Window> w1( | |
869 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
870 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
871 | |
872 Shelf* shelf = GetPrimaryShelf(); | |
873 | |
874 // Allow the shelf to hide. | |
875 shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS); | |
876 EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState()); | |
877 | |
878 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
879 window_state->OnWMEvent(&event); | |
880 | |
881 // With full screen, the shelf should get hidden. | |
882 EXPECT_TRUE(window_state->IsFullscreen()); | |
883 EXPECT_EQ(SHELF_HIDDEN, shelf->GetVisibilityState()); | |
884 | |
885 CreateMaximizeModeWindowManager(); | |
886 | |
887 // The Full screen mode should continue to be on. | |
888 EXPECT_TRUE(window_state->IsFullscreen()); | |
889 EXPECT_FALSE(window_state->IsMaximized()); | |
890 EXPECT_EQ(SHELF_HIDDEN, shelf->GetVisibilityState()); | |
891 | |
892 // With leaving the fullscreen mode, the maximized mode should return and the | |
893 // shelf should maintain its state from before maximize mode. | |
894 window_state->OnWMEvent(&event); | |
895 EXPECT_FALSE(window_state->IsFullscreen()); | |
896 EXPECT_TRUE(window_state->IsMaximized()); | |
897 EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState()); | |
898 | |
899 // We left fullscreen mode while in maximize mode, so the window should | |
900 // remain maximized and the shelf should not change state upon exiting | |
901 // maximize mode. | |
902 DestroyMaximizeModeWindowManager(); | |
903 EXPECT_FALSE(window_state->IsFullscreen()); | |
904 EXPECT_TRUE(window_state->IsMaximized()); | |
905 EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState()); | |
906 } | |
907 | |
908 // Similar to the fullscreen mode, the pinned mode should be kept as well. | |
909 TEST_F(MaximizeModeWindowManagerTest, KeepPinnedModeOn_Case1) { | |
910 // Scenario: in the default state, pin a window, enter to the maximized mode, | |
911 // then unpin. | |
912 gfx::Rect rect(20, 140, 100, 100); | |
913 std::unique_ptr<aura::Window> w1( | |
914 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
915 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
916 EXPECT_FALSE(window_state->IsPinned()); | |
917 | |
918 // Pin the window. | |
919 { | |
920 wm::WMEvent event(wm::WM_EVENT_PIN); | |
921 window_state->OnWMEvent(&event); | |
922 } | |
923 EXPECT_TRUE(window_state->IsPinned()); | |
924 | |
925 // Enter to Maximized mode. | |
926 // The pinned mode should continue to be on. | |
927 CreateMaximizeModeWindowManager(); | |
928 EXPECT_TRUE(window_state->IsPinned()); | |
929 | |
930 // Then unpin. | |
931 window_state->Restore(); | |
932 EXPECT_FALSE(window_state->IsPinned()); | |
933 | |
934 // Exit from Maximized mode. | |
935 // The window should not be back to the pinned mode. | |
936 DestroyMaximizeModeWindowManager(); | |
937 EXPECT_FALSE(window_state->IsPinned()); | |
938 } | |
939 | |
940 TEST_F(MaximizeModeWindowManagerTest, KeepPinnedModeOn_Case2) { | |
941 // Scenario: in the maximized mode, pin a window, exit from the maximized | |
942 // mode, then unpin. | |
943 gfx::Rect rect(20, 140, 100, 100); | |
944 std::unique_ptr<aura::Window> w1( | |
945 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
946 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
947 EXPECT_FALSE(window_state->IsPinned()); | |
948 | |
949 // Enter to Maximized mode. | |
950 CreateMaximizeModeWindowManager(); | |
951 EXPECT_FALSE(window_state->IsPinned()); | |
952 | |
953 // Pin the window. | |
954 { | |
955 wm::WMEvent event(wm::WM_EVENT_PIN); | |
956 window_state->OnWMEvent(&event); | |
957 } | |
958 EXPECT_TRUE(window_state->IsPinned()); | |
959 | |
960 // Exit from Maximized mode. | |
961 // The pinned mode should continue to be on. | |
962 DestroyMaximizeModeWindowManager(); | |
963 EXPECT_TRUE(window_state->IsPinned()); | |
964 | |
965 // Then unpin. | |
966 window_state->Restore(); | |
967 EXPECT_FALSE(window_state->IsPinned()); | |
968 | |
969 // Enter again to Maximized mode for verification. | |
970 // The window should not be back to the pinned mode. | |
971 CreateMaximizeModeWindowManager(); | |
972 EXPECT_FALSE(window_state->IsPinned()); | |
973 | |
974 // Exit from Maximized mode. | |
975 DestroyMaximizeModeWindowManager(); | |
976 EXPECT_FALSE(window_state->IsPinned()); | |
977 } | |
978 | |
979 TEST_F(MaximizeModeWindowManagerTest, KeepPinnedModeOn_Case3) { | |
980 // Scenario: in the default state, pin a window, enter to the maximized mode, | |
981 // exit from the maximized mode, then unpin. | |
982 gfx::Rect rect(20, 140, 100, 100); | |
983 std::unique_ptr<aura::Window> w1( | |
984 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
985 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
986 EXPECT_FALSE(window_state->IsPinned()); | |
987 | |
988 // Pin the window. | |
989 { | |
990 wm::WMEvent event(wm::WM_EVENT_PIN); | |
991 window_state->OnWMEvent(&event); | |
992 } | |
993 EXPECT_TRUE(window_state->IsPinned()); | |
994 | |
995 // Enter to Maximized mode. | |
996 // The pinned mode should continue to be on. | |
997 CreateMaximizeModeWindowManager(); | |
998 EXPECT_TRUE(window_state->IsPinned()); | |
999 | |
1000 // Exit from Maximized mode. | |
1001 // The pinned mode should continue to be on, too. | |
1002 DestroyMaximizeModeWindowManager(); | |
1003 EXPECT_TRUE(window_state->IsPinned()); | |
1004 | |
1005 // Then unpin. | |
1006 window_state->Restore(); | |
1007 EXPECT_FALSE(window_state->IsPinned()); | |
1008 | |
1009 // Enter again to Maximized mode for verification. | |
1010 // The window should not be back to the pinned mode. | |
1011 CreateMaximizeModeWindowManager(); | |
1012 EXPECT_FALSE(window_state->IsPinned()); | |
1013 | |
1014 // Exit from Maximized mode. | |
1015 DestroyMaximizeModeWindowManager(); | |
1016 } | |
1017 | |
1018 TEST_F(MaximizeModeWindowManagerTest, KeepPinnedModeOn_Case4) { | |
1019 // Scenario: in the maximized mode, pin a window, exit from the maximized | |
1020 // mode, enter back to the maximized mode, then unpin. | |
1021 gfx::Rect rect(20, 140, 100, 100); | |
1022 std::unique_ptr<aura::Window> w1( | |
1023 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1024 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
1025 EXPECT_FALSE(window_state->IsPinned()); | |
1026 | |
1027 // Enter to Maximized mode. | |
1028 CreateMaximizeModeWindowManager(); | |
1029 EXPECT_FALSE(window_state->IsPinned()); | |
1030 | |
1031 // Pin the window. | |
1032 { | |
1033 wm::WMEvent event(wm::WM_EVENT_PIN); | |
1034 window_state->OnWMEvent(&event); | |
1035 } | |
1036 EXPECT_TRUE(window_state->IsPinned()); | |
1037 | |
1038 // Exit from Maximized mode. | |
1039 // The pinned mode should continue to be on. | |
1040 DestroyMaximizeModeWindowManager(); | |
1041 EXPECT_TRUE(window_state->IsPinned()); | |
1042 | |
1043 // Enter again to Maximized mode. | |
1044 // The pinned mode should continue to be on, too. | |
1045 CreateMaximizeModeWindowManager(); | |
1046 EXPECT_TRUE(window_state->IsPinned()); | |
1047 | |
1048 // Then unpin. | |
1049 window_state->Restore(); | |
1050 EXPECT_FALSE(window_state->IsPinned()); | |
1051 | |
1052 // Exit from Maximized mode. | |
1053 // The window should not be back to the pinned mode. | |
1054 DestroyMaximizeModeWindowManager(); | |
1055 EXPECT_FALSE(window_state->IsPinned()); | |
1056 } | |
1057 | |
1058 // Verifies that if a window is un-full-screened while in maximize mode, | |
1059 // other changes to that window's state (such as minimizing it) are | |
1060 // preserved upon exiting maximize mode. | |
1061 TEST_F(MaximizeModeWindowManagerTest, MinimizePreservedAfterLeavingFullscreen) { | |
1062 gfx::Rect rect(20, 140, 100, 100); | |
1063 std::unique_ptr<aura::Window> w1( | |
1064 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1065 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
1066 | |
1067 Shelf* shelf = GetPrimaryShelf(); | |
1068 | |
1069 // Allow the shelf to hide and enter full screen. | |
1070 shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS); | |
1071 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
1072 window_state->OnWMEvent(&event); | |
1073 ASSERT_FALSE(window_state->IsMinimized()); | |
1074 | |
1075 // Enter maximize mode, exit full screen, and then minimize the window. | |
1076 CreateMaximizeModeWindowManager(); | |
1077 window_state->OnWMEvent(&event); | |
1078 window_state->Minimize(); | |
1079 ASSERT_TRUE(window_state->IsMinimized()); | |
1080 | |
1081 // The window should remain minimized when exiting maximize mode. | |
1082 DestroyMaximizeModeWindowManager(); | |
1083 EXPECT_TRUE(window_state->IsMinimized()); | |
1084 } | |
1085 | |
1086 // Check that full screen mode can be turned on in maximized mode and remains | |
1087 // upon coming back. | |
1088 TEST_F(MaximizeModeWindowManagerTest, AllowFullScreenMode) { | |
1089 gfx::Rect rect(20, 140, 100, 100); | |
1090 std::unique_ptr<aura::Window> w1( | |
1091 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1092 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
1093 | |
1094 Shelf* shelf = GetPrimaryShelf(); | |
1095 | |
1096 // Allow the shelf to hide. | |
1097 shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS); | |
1098 | |
1099 EXPECT_FALSE(window_state->IsFullscreen()); | |
1100 EXPECT_FALSE(window_state->IsMaximized()); | |
1101 EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState()); | |
1102 | |
1103 CreateMaximizeModeWindowManager(); | |
1104 | |
1105 // Fullscreen mode should still be off and the shelf should maintain its | |
1106 // state. | |
1107 EXPECT_FALSE(window_state->IsFullscreen()); | |
1108 EXPECT_TRUE(window_state->IsMaximized()); | |
1109 EXPECT_EQ(SHELF_AUTO_HIDE, shelf->GetVisibilityState()); | |
1110 | |
1111 // After going into fullscreen mode, the shelf should be hidden. | |
1112 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
1113 window_state->OnWMEvent(&event); | |
1114 EXPECT_TRUE(window_state->IsFullscreen()); | |
1115 EXPECT_FALSE(window_state->IsMaximized()); | |
1116 EXPECT_EQ(SHELF_HIDDEN, shelf->GetVisibilityState()); | |
1117 | |
1118 // With the destruction of the manager we should remain in full screen. | |
1119 DestroyMaximizeModeWindowManager(); | |
1120 EXPECT_TRUE(window_state->IsFullscreen()); | |
1121 EXPECT_FALSE(window_state->IsMaximized()); | |
1122 EXPECT_EQ(SHELF_HIDDEN, shelf->GetVisibilityState()); | |
1123 } | |
1124 | |
1125 // Check that the full screen mode will stay active when the maximize mode is | |
1126 // ended. | |
1127 TEST_F(MaximizeModeWindowManagerTest, | |
1128 FullScreenModeRemainsWhenCreatedInMaximizedMode) { | |
1129 CreateMaximizeModeWindowManager(); | |
1130 | |
1131 gfx::Rect rect(20, 140, 100, 100); | |
1132 std::unique_ptr<aura::Window> w1( | |
1133 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1134 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
1135 wm::WMEvent event_full_screen(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
1136 window_state->OnWMEvent(&event_full_screen); | |
1137 EXPECT_TRUE(window_state->IsFullscreen()); | |
1138 | |
1139 // After the maximize mode manager is ended, full screen will remain. | |
1140 DestroyMaximizeModeWindowManager(); | |
1141 EXPECT_TRUE(window_state->IsFullscreen()); | |
1142 } | |
1143 | |
1144 // Check that the full screen mode will stay active throughout a maximzied mode | |
1145 // session. | |
1146 TEST_F(MaximizeModeWindowManagerTest, | |
1147 FullScreenModeRemainsThroughMaximizeModeSwitch) { | |
1148 gfx::Rect rect(20, 140, 100, 100); | |
1149 std::unique_ptr<aura::Window> w1( | |
1150 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1151 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
1152 wm::WMEvent event_full_screen(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
1153 window_state->OnWMEvent(&event_full_screen); | |
1154 EXPECT_TRUE(window_state->IsFullscreen()); | |
1155 | |
1156 CreateMaximizeModeWindowManager(); | |
1157 EXPECT_TRUE(window_state->IsFullscreen()); | |
1158 DestroyMaximizeModeWindowManager(); | |
1159 EXPECT_TRUE(window_state->IsFullscreen()); | |
1160 } | |
1161 | |
1162 // Check that an empty window does not get restored to a tiny size. | |
1163 TEST_F(MaximizeModeWindowManagerTest, | |
1164 CreateAndMaximizeInMaximizeModeShouldRetoreToGoodSizeGoingToDefault) { | |
1165 CreateMaximizeModeWindowManager(); | |
1166 gfx::Rect rect; | |
1167 std::unique_ptr<aura::Window> w1( | |
1168 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1169 w1->Show(); | |
1170 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
1171 EXPECT_TRUE(window_state->IsMaximized()); | |
1172 | |
1173 // There is a calling order in which the restore bounds can get set to an | |
1174 // empty rectangle. We simulate this here. | |
1175 window_state->SetRestoreBoundsInScreen(rect); | |
1176 EXPECT_TRUE(window_state->GetRestoreBoundsInScreen().IsEmpty()); | |
1177 | |
1178 // Setting the window to a new size will physically not change the window, | |
1179 // but the restore size should get updated so that a restore later on will | |
1180 // return to this size. | |
1181 gfx::Rect requested_bounds(10, 20, 50, 70); | |
1182 w1->SetBounds(requested_bounds); | |
1183 EXPECT_TRUE(window_state->IsMaximized()); | |
1184 EXPECT_EQ(requested_bounds.ToString(), | |
1185 window_state->GetRestoreBoundsInScreen().ToString()); | |
1186 | |
1187 DestroyMaximizeModeWindowManager(); | |
1188 | |
1189 EXPECT_FALSE(window_state->IsMaximized()); | |
1190 EXPECT_EQ(w1->bounds().ToString(), requested_bounds.ToString()); | |
1191 } | |
1192 | |
1193 // Check that snapping operations get ignored. | |
1194 TEST_F(MaximizeModeWindowManagerTest, SnapModeTests) { | |
1195 gfx::Rect rect(20, 140, 100, 100); | |
1196 std::unique_ptr<aura::Window> w1( | |
1197 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1198 wm::WindowState* window_state = wm::GetWindowState(w1.get()); | |
1199 wm::WMEvent event_left(wm::WM_EVENT_SNAP_LEFT); | |
1200 wm::WMEvent event_right(wm::WM_EVENT_SNAP_RIGHT); | |
1201 window_state->OnWMEvent(&event_left); | |
1202 EXPECT_TRUE(window_state->IsSnapped()); | |
1203 | |
1204 CreateMaximizeModeWindowManager(); | |
1205 | |
1206 // Fullscreen mode should now be off and it should not come back while in | |
1207 // maximize mode. | |
1208 EXPECT_FALSE(window_state->IsSnapped()); | |
1209 EXPECT_TRUE(window_state->IsMaximized()); | |
1210 window_state->OnWMEvent(&event_left); | |
1211 EXPECT_FALSE(window_state->IsSnapped()); | |
1212 EXPECT_TRUE(window_state->IsMaximized()); | |
1213 window_state->OnWMEvent(&event_right); | |
1214 EXPECT_FALSE(window_state->IsSnapped()); | |
1215 EXPECT_TRUE(window_state->IsMaximized()); | |
1216 | |
1217 DestroyMaximizeModeWindowManager(); | |
1218 EXPECT_TRUE(window_state->IsSnapped()); | |
1219 } | |
1220 | |
1221 // Check that non maximizable windows cannot be dragged by the user. | |
1222 TEST_F(MaximizeModeWindowManagerTest, TryToDesktopSizeDragUnmaximizable) { | |
1223 gfx::Rect rect(10, 10, 100, 100); | |
1224 std::unique_ptr<aura::Window> window(CreateFixedSizeNonMaximizableWindow( | |
1225 aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1226 EXPECT_EQ(rect.ToString(), window->bounds().ToString()); | |
1227 | |
1228 // 1. Move the mouse over the caption and check that dragging the window does | |
1229 // change the location. | |
1230 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); | |
1231 generator.MoveMouseTo(gfx::Point(rect.x() + 2, rect.y() + 2)); | |
1232 generator.PressLeftButton(); | |
1233 generator.MoveMouseBy(10, 5); | |
1234 RunAllPendingInMessageLoop(); | |
1235 generator.ReleaseLeftButton(); | |
1236 gfx::Point first_dragged_origin = window->bounds().origin(); | |
1237 EXPECT_EQ(rect.x() + 10, first_dragged_origin.x()); | |
1238 EXPECT_EQ(rect.y() + 5, first_dragged_origin.y()); | |
1239 | |
1240 // 2. Check that turning on the manager will stop allowing the window from | |
1241 // dragging. | |
1242 Shell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager( | |
1243 true); | |
1244 gfx::Rect center_bounds(window->bounds()); | |
1245 EXPECT_NE(rect.origin().ToString(), center_bounds.origin().ToString()); | |
1246 generator.MoveMouseTo( | |
1247 gfx::Point(center_bounds.x() + 1, center_bounds.y() + 1)); | |
1248 generator.PressLeftButton(); | |
1249 generator.MoveMouseBy(10, 5); | |
1250 RunAllPendingInMessageLoop(); | |
1251 generator.ReleaseLeftButton(); | |
1252 EXPECT_EQ(center_bounds.x(), window->bounds().x()); | |
1253 EXPECT_EQ(center_bounds.y(), window->bounds().y()); | |
1254 Shell::Get()->maximize_mode_controller()->EnableMaximizeModeWindowManager( | |
1255 false); | |
1256 | |
1257 // 3. Releasing the mazimize manager again will restore the window to its | |
1258 // previous bounds and | |
1259 generator.MoveMouseTo( | |
1260 gfx::Point(first_dragged_origin.x() + 1, first_dragged_origin.y() + 1)); | |
1261 generator.PressLeftButton(); | |
1262 generator.MoveMouseBy(10, 5); | |
1263 RunAllPendingInMessageLoop(); | |
1264 generator.ReleaseLeftButton(); | |
1265 EXPECT_EQ(first_dragged_origin.x() + 10, window->bounds().x()); | |
1266 EXPECT_EQ(first_dragged_origin.y() + 5, window->bounds().y()); | |
1267 } | |
1268 | |
1269 // Test that overview is exited before entering / exiting maximize mode so that | |
1270 // the window changes made by MaximizeModeWindowManager do not conflict with | |
1271 // those made in WindowOverview. | |
1272 TEST_F(MaximizeModeWindowManagerTest, ExitsOverview) { | |
1273 // Bounds for windows we know can be controlled. | |
1274 gfx::Rect rect1(10, 10, 200, 50); | |
1275 gfx::Rect rect2(10, 60, 200, 50); | |
1276 std::unique_ptr<aura::Window> w1( | |
1277 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect1)); | |
1278 std::unique_ptr<aura::Window> w2( | |
1279 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect2)); | |
1280 | |
1281 WindowSelectorController* window_selector_controller = | |
1282 Shell::Get()->window_selector_controller(); | |
1283 ASSERT_TRUE(window_selector_controller->ToggleOverview()); | |
1284 ASSERT_TRUE(window_selector_controller->IsSelecting()); | |
1285 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
1286 ASSERT_TRUE(manager); | |
1287 EXPECT_FALSE(window_selector_controller->IsSelecting()); | |
1288 | |
1289 ASSERT_TRUE(window_selector_controller->ToggleOverview()); | |
1290 ASSERT_TRUE(window_selector_controller->IsSelecting()); | |
1291 // Destroy the manager again and check that the windows return to their | |
1292 // previous state. | |
1293 DestroyMaximizeModeWindowManager(); | |
1294 EXPECT_FALSE(window_selector_controller->IsSelecting()); | |
1295 } | |
1296 | |
1297 // Test that an edge swipe from the top will end full screen mode. | |
1298 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromTop) { | |
1299 // TODO: investigate failure. http://crbug.com/698093. | |
1300 if (Shell::GetAshConfig() == Config::MASH) | |
1301 return; | |
1302 | |
1303 gfx::Rect rect(10, 10, 200, 50); | |
1304 std::unique_ptr<aura::Window> background_window( | |
1305 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1306 std::unique_ptr<aura::Window> foreground_window( | |
1307 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1308 wm::WindowState* background_window_state = | |
1309 wm::GetWindowState(background_window.get()); | |
1310 wm::WindowState* foreground_window_state = | |
1311 wm::GetWindowState(foreground_window.get()); | |
1312 wm::ActivateWindow(foreground_window.get()); | |
1313 CreateMaximizeModeWindowManager(); | |
1314 | |
1315 // Fullscreen both windows. | |
1316 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
1317 background_window_state->OnWMEvent(&event); | |
1318 foreground_window_state->OnWMEvent(&event); | |
1319 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1320 EXPECT_TRUE(foreground_window_state->IsFullscreen()); | |
1321 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); | |
1322 | |
1323 // Do an edge swipe top into screen. | |
1324 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); | |
1325 generator.GestureScrollSequence(gfx::Point(50, 0), gfx::Point(50, 100), | |
1326 base::TimeDelta::FromMilliseconds(20), 10); | |
1327 | |
1328 EXPECT_FALSE(foreground_window_state->IsFullscreen()); | |
1329 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1330 | |
1331 // Do a second edge swipe top into screen. | |
1332 generator.GestureScrollSequence(gfx::Point(50, 0), gfx::Point(50, 100), | |
1333 base::TimeDelta::FromMilliseconds(20), 10); | |
1334 | |
1335 EXPECT_FALSE(foreground_window_state->IsFullscreen()); | |
1336 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1337 | |
1338 DestroyMaximizeModeWindowManager(); | |
1339 } | |
1340 | |
1341 // Test that an edge swipe from the bottom will end full screen mode. | |
1342 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromBottom) { | |
1343 // TODO: investigate failure. http://crbug.com/698093. | |
1344 if (Shell::GetAshConfig() == Config::MASH) | |
1345 return; | |
1346 | |
1347 gfx::Rect rect(10, 10, 200, 50); | |
1348 std::unique_ptr<aura::Window> background_window( | |
1349 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1350 std::unique_ptr<aura::Window> foreground_window( | |
1351 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1352 wm::WindowState* background_window_state = | |
1353 wm::GetWindowState(background_window.get()); | |
1354 wm::WindowState* foreground_window_state = | |
1355 wm::GetWindowState(foreground_window.get()); | |
1356 wm::ActivateWindow(foreground_window.get()); | |
1357 CreateMaximizeModeWindowManager(); | |
1358 | |
1359 // Fullscreen both windows. | |
1360 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
1361 background_window_state->OnWMEvent(&event); | |
1362 foreground_window_state->OnWMEvent(&event); | |
1363 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1364 EXPECT_TRUE(foreground_window_state->IsFullscreen()); | |
1365 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); | |
1366 | |
1367 // Do an edge swipe bottom into screen. | |
1368 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); | |
1369 int y = Shell::GetPrimaryRootWindow()->bounds().bottom(); | |
1370 generator.GestureScrollSequence(gfx::Point(50, y), gfx::Point(50, y - 100), | |
1371 base::TimeDelta::FromMilliseconds(20), 10); | |
1372 | |
1373 EXPECT_FALSE(foreground_window_state->IsFullscreen()); | |
1374 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1375 | |
1376 DestroyMaximizeModeWindowManager(); | |
1377 } | |
1378 | |
1379 // Test that an edge touch press at the top will end full screen mode. | |
1380 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtTop) { | |
1381 // TODO: investigate failure. http://crbug.com/698093. | |
1382 if (Shell::GetAshConfig() == Config::MASH) | |
1383 return; | |
1384 | |
1385 gfx::Rect rect(10, 10, 200, 50); | |
1386 std::unique_ptr<aura::Window> background_window( | |
1387 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1388 std::unique_ptr<aura::Window> foreground_window( | |
1389 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1390 wm::WindowState* background_window_state = | |
1391 wm::GetWindowState(background_window.get()); | |
1392 wm::WindowState* foreground_window_state = | |
1393 wm::GetWindowState(foreground_window.get()); | |
1394 wm::ActivateWindow(foreground_window.get()); | |
1395 CreateMaximizeModeWindowManager(); | |
1396 | |
1397 // Fullscreen both windows. | |
1398 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
1399 background_window_state->OnWMEvent(&event); | |
1400 foreground_window_state->OnWMEvent(&event); | |
1401 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1402 EXPECT_TRUE(foreground_window_state->IsFullscreen()); | |
1403 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); | |
1404 | |
1405 // Touch tap on the top edge. | |
1406 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); | |
1407 generator.GestureTapAt(gfx::Point(100, 0)); | |
1408 EXPECT_FALSE(foreground_window_state->IsFullscreen()); | |
1409 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1410 | |
1411 // Try the same again and see that nothing changes. | |
1412 generator.GestureTapAt(gfx::Point(100, 0)); | |
1413 EXPECT_FALSE(foreground_window_state->IsFullscreen()); | |
1414 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1415 | |
1416 DestroyMaximizeModeWindowManager(); | |
1417 } | |
1418 | |
1419 // Test that an edge touch press at the bottom will end full screen mode. | |
1420 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtBottom) { | |
1421 // TODO: investigate failure. http://crbug.com/698093. | |
1422 if (Shell::GetAshConfig() == Config::MASH) | |
1423 return; | |
1424 | |
1425 gfx::Rect rect(10, 10, 200, 50); | |
1426 std::unique_ptr<aura::Window> background_window( | |
1427 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1428 std::unique_ptr<aura::Window> foreground_window( | |
1429 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1430 wm::WindowState* background_window_state = | |
1431 wm::GetWindowState(background_window.get()); | |
1432 wm::WindowState* foreground_window_state = | |
1433 wm::GetWindowState(foreground_window.get()); | |
1434 wm::ActivateWindow(foreground_window.get()); | |
1435 CreateMaximizeModeWindowManager(); | |
1436 | |
1437 // Fullscreen both windows. | |
1438 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
1439 background_window_state->OnWMEvent(&event); | |
1440 foreground_window_state->OnWMEvent(&event); | |
1441 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1442 EXPECT_TRUE(foreground_window_state->IsFullscreen()); | |
1443 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); | |
1444 | |
1445 // Touch tap on the bottom edge. | |
1446 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); | |
1447 generator.GestureTapAt( | |
1448 gfx::Point(100, Shell::GetPrimaryRootWindow()->bounds().bottom() - 1)); | |
1449 EXPECT_FALSE(foreground_window_state->IsFullscreen()); | |
1450 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1451 | |
1452 // Try the same again and see that nothing changes. | |
1453 generator.GestureTapAt( | |
1454 gfx::Point(100, Shell::GetPrimaryRootWindow()->bounds().bottom() - 1)); | |
1455 EXPECT_FALSE(foreground_window_state->IsFullscreen()); | |
1456 EXPECT_TRUE(background_window_state->IsFullscreen()); | |
1457 | |
1458 DestroyMaximizeModeWindowManager(); | |
1459 } | |
1460 | |
1461 // Test that an edge swipe from the top on an immersive mode window will not end | |
1462 // full screen mode. | |
1463 TEST_F(MaximizeModeWindowManagerTest, NoExitImmersiveModeWithEdgeSwipeFromTop) { | |
1464 std::unique_ptr<aura::Window> window(CreateWindow( | |
1465 aura::client::WINDOW_TYPE_NORMAL, gfx::Rect(10, 10, 200, 50))); | |
1466 wm::WindowState* window_state = wm::GetWindowState(window.get()); | |
1467 wm::ActivateWindow(window.get()); | |
1468 CreateMaximizeModeWindowManager(); | |
1469 | |
1470 // Fullscreen the window. | |
1471 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
1472 window_state->OnWMEvent(&event); | |
1473 EXPECT_TRUE(window_state->IsFullscreen()); | |
1474 EXPECT_FALSE(window_state->in_immersive_fullscreen()); | |
1475 EXPECT_EQ(window.get(), wm::GetActiveWindow()); | |
1476 | |
1477 window_state->set_in_immersive_fullscreen(true); | |
1478 | |
1479 // Do an edge swipe top into screen. | |
1480 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); | |
1481 generator.GestureScrollSequence(gfx::Point(50, 0), gfx::Point(50, 100), | |
1482 base::TimeDelta::FromMilliseconds(20), 10); | |
1483 | |
1484 // It should have not exited full screen or immersive mode. | |
1485 EXPECT_TRUE(window_state->IsFullscreen()); | |
1486 EXPECT_TRUE(window_state->in_immersive_fullscreen()); | |
1487 | |
1488 DestroyMaximizeModeWindowManager(); | |
1489 } | |
1490 | |
1491 // Test that an edge swipe from the bottom will not end immersive mode. | |
1492 TEST_F(MaximizeModeWindowManagerTest, | |
1493 NoExitImmersiveModeWithEdgeSwipeFromBottom) { | |
1494 std::unique_ptr<aura::Window> window(CreateWindow( | |
1495 aura::client::WINDOW_TYPE_NORMAL, gfx::Rect(10, 10, 200, 50))); | |
1496 wm::WindowState* window_state = wm::GetWindowState(window.get()); | |
1497 wm::ActivateWindow(window.get()); | |
1498 CreateMaximizeModeWindowManager(); | |
1499 | |
1500 // Fullscreen the window. | |
1501 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); | |
1502 window_state->OnWMEvent(&event); | |
1503 EXPECT_TRUE(window_state->IsFullscreen()); | |
1504 EXPECT_FALSE(window_state->in_immersive_fullscreen()); | |
1505 EXPECT_EQ(window.get(), wm::GetActiveWindow()); | |
1506 window_state->set_in_immersive_fullscreen(true); | |
1507 EXPECT_TRUE(window_state->in_immersive_fullscreen()); | |
1508 | |
1509 // Do an edge swipe bottom into screen. | |
1510 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); | |
1511 int y = Shell::GetPrimaryRootWindow()->bounds().bottom(); | |
1512 generator.GestureScrollSequence(gfx::Point(50, y), gfx::Point(50, y - 100), | |
1513 base::TimeDelta::FromMilliseconds(20), 10); | |
1514 | |
1515 // The window should still be full screen and immersive. | |
1516 EXPECT_TRUE(window_state->IsFullscreen()); | |
1517 EXPECT_TRUE(window_state->in_immersive_fullscreen()); | |
1518 | |
1519 DestroyMaximizeModeWindowManager(); | |
1520 } | |
1521 | |
1522 // Tests that windows with the always-on-top property are not managed by | |
1523 // the MaximizeModeWindowManager while maximize mode is engaged (i.e., | |
1524 // they remain free-floating). | |
1525 TEST_F(MaximizeModeWindowManagerTest, AlwaysOnTopWindows) { | |
1526 gfx::Rect rect1(10, 10, 200, 50); | |
1527 gfx::Rect rect2(20, 140, 100, 100); | |
1528 | |
1529 // Create two windows with the always-on-top property. | |
1530 std::unique_ptr<aura::Window> w1( | |
1531 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect1)); | |
1532 std::unique_ptr<aura::Window> w2(CreateFixedSizeNonMaximizableWindow( | |
1533 aura::client::WINDOW_TYPE_NORMAL, rect2)); | |
1534 w1->SetProperty(aura::client::kAlwaysOnTopKey, true); | |
1535 w2->SetProperty(aura::client::kAlwaysOnTopKey, true); | |
1536 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); | |
1537 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); | |
1538 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); | |
1539 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); | |
1540 EXPECT_TRUE(wm::GetWindowState(w1.get())->can_be_dragged()); | |
1541 EXPECT_TRUE(wm::GetWindowState(w2.get())->can_be_dragged()); | |
1542 | |
1543 // Enter maximize mode. Neither window should be managed because they have | |
1544 // the always-on-top property set, which means that none of their properties | |
1545 // should change. | |
1546 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
1547 ASSERT_TRUE(manager); | |
1548 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); | |
1549 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); | |
1550 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); | |
1551 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); | |
1552 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); | |
1553 EXPECT_TRUE(wm::GetWindowState(w1.get())->can_be_dragged()); | |
1554 EXPECT_TRUE(wm::GetWindowState(w2.get())->can_be_dragged()); | |
1555 | |
1556 // Remove the always-on-top property from both windows while in maximize | |
1557 // mode. The windows should become managed, which means they should be | |
1558 // maximized/centered and no longer be draggable. | |
1559 w1->SetProperty(aura::client::kAlwaysOnTopKey, false); | |
1560 w2->SetProperty(aura::client::kAlwaysOnTopKey, false); | |
1561 EXPECT_EQ(2, manager->GetNumberOfManagedWindows()); | |
1562 EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized()); | |
1563 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); | |
1564 EXPECT_NE(rect1.origin().ToString(), w1->bounds().origin().ToString()); | |
1565 EXPECT_NE(rect1.size().ToString(), w1->bounds().size().ToString()); | |
1566 EXPECT_NE(rect2.origin().ToString(), w2->bounds().origin().ToString()); | |
1567 EXPECT_EQ(rect2.size().ToString(), w2->bounds().size().ToString()); | |
1568 EXPECT_FALSE(wm::GetWindowState(w1.get())->can_be_dragged()); | |
1569 EXPECT_FALSE(wm::GetWindowState(w2.get())->can_be_dragged()); | |
1570 | |
1571 // Applying the always-on-top property to both windows while in maximize | |
1572 // mode should cause both windows to return to their original size, | |
1573 // position, and state. | |
1574 w1->SetProperty(aura::client::kAlwaysOnTopKey, true); | |
1575 w2->SetProperty(aura::client::kAlwaysOnTopKey, true); | |
1576 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); | |
1577 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); | |
1578 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); | |
1579 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); | |
1580 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); | |
1581 EXPECT_TRUE(wm::GetWindowState(w1.get())->can_be_dragged()); | |
1582 EXPECT_TRUE(wm::GetWindowState(w2.get())->can_be_dragged()); | |
1583 | |
1584 // The always-on-top windows should not change when leaving maximize mode. | |
1585 DestroyMaximizeModeWindowManager(); | |
1586 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); | |
1587 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); | |
1588 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); | |
1589 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); | |
1590 EXPECT_TRUE(wm::GetWindowState(w1.get())->can_be_dragged()); | |
1591 EXPECT_TRUE(wm::GetWindowState(w2.get())->can_be_dragged()); | |
1592 } | |
1593 | |
1594 // Tests that windows that can control maximized bounds are not maximized | |
1595 // and not tracked. | |
1596 TEST_F(MaximizeModeWindowManagerTest, DontMaximizeClientManagedWindows) { | |
1597 gfx::Rect rect(10, 10, 200, 50); | |
1598 std::unique_ptr<aura::Window> window( | |
1599 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1600 | |
1601 wm::GetWindowState(window.get())->set_allow_set_bounds_direct(true); | |
1602 | |
1603 MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); | |
1604 EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized()); | |
1605 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); | |
1606 } | |
1607 | |
1608 namespace { | |
1609 | |
1610 class TestObserver : public wm::WindowStateObserver { | |
1611 public: | |
1612 TestObserver(){}; | |
1613 ~TestObserver() override{}; | |
1614 | |
1615 // wm::WindowStateObserver: | |
1616 void OnPreWindowStateTypeChange(wm::WindowState* window_state, | |
1617 wm::WindowStateType old_type) override { | |
1618 pre_count_++; | |
1619 last_old_state_ = old_type; | |
1620 } | |
1621 | |
1622 void OnPostWindowStateTypeChange(wm::WindowState* window_state, | |
1623 wm::WindowStateType old_type) override { | |
1624 post_count_++; | |
1625 EXPECT_EQ(last_old_state_, old_type); | |
1626 } | |
1627 | |
1628 int GetPreCountAndReset() { | |
1629 int r = pre_count_; | |
1630 pre_count_ = 0; | |
1631 return r; | |
1632 } | |
1633 | |
1634 int GetPostCountAndReset() { | |
1635 int r = post_count_; | |
1636 post_count_ = 0; | |
1637 return r; | |
1638 } | |
1639 | |
1640 wm::WindowStateType GetLastOldStateAndReset() { | |
1641 wm::WindowStateType r = last_old_state_; | |
1642 last_old_state_ = wm::WINDOW_STATE_TYPE_DEFAULT; | |
1643 return r; | |
1644 } | |
1645 | |
1646 private: | |
1647 int pre_count_ = 0; | |
1648 int post_count_ = 0; | |
1649 wm::WindowStateType last_old_state_ = wm::WINDOW_STATE_TYPE_DEFAULT; | |
1650 | |
1651 DISALLOW_COPY_AND_ASSIGN(TestObserver); | |
1652 }; | |
1653 | |
1654 } // namespace | |
1655 | |
1656 TEST_F(MaximizeModeWindowManagerTest, StateTyepChange) { | |
1657 TestObserver observer; | |
1658 gfx::Rect rect(10, 10, 200, 50); | |
1659 std::unique_ptr<aura::Window> window( | |
1660 CreateWindow(aura::client::WINDOW_TYPE_NORMAL, rect)); | |
1661 | |
1662 CreateMaximizeModeWindowManager(); | |
1663 | |
1664 wm::WindowState* window_state = wm::GetWindowState(window.get()); | |
1665 window_state->AddObserver(&observer); | |
1666 | |
1667 window->Show(); | |
1668 EXPECT_TRUE(window_state->IsMaximized()); | |
1669 EXPECT_EQ(0, observer.GetPreCountAndReset()); | |
1670 EXPECT_EQ(0, observer.GetPostCountAndReset()); | |
1671 | |
1672 // Window is already in maximized mode. | |
1673 wm::WMEvent maximize_event(wm::WM_EVENT_MAXIMIZE); | |
1674 window_state->OnWMEvent(&maximize_event); | |
1675 EXPECT_EQ(0, observer.GetPreCountAndReset()); | |
1676 EXPECT_EQ(0, observer.GetPostCountAndReset()); | |
1677 | |
1678 wm::WMEvent fullscreen_event(wm::WM_EVENT_FULLSCREEN); | |
1679 window_state->OnWMEvent(&fullscreen_event); | |
1680 EXPECT_EQ(1, observer.GetPreCountAndReset()); | |
1681 EXPECT_EQ(1, observer.GetPostCountAndReset()); | |
1682 EXPECT_EQ(wm::WINDOW_STATE_TYPE_MAXIMIZED, | |
1683 observer.GetLastOldStateAndReset()); | |
1684 | |
1685 window_state->OnWMEvent(&maximize_event); | |
1686 EXPECT_EQ(1, observer.GetPreCountAndReset()); | |
1687 EXPECT_EQ(1, observer.GetPostCountAndReset()); | |
1688 EXPECT_EQ(wm::WINDOW_STATE_TYPE_FULLSCREEN, | |
1689 observer.GetLastOldStateAndReset()); | |
1690 | |
1691 wm::WMEvent minimize_event(wm::WM_EVENT_MINIMIZE); | |
1692 window_state->OnWMEvent(&minimize_event); | |
1693 EXPECT_EQ(1, observer.GetPreCountAndReset()); | |
1694 EXPECT_EQ(1, observer.GetPostCountAndReset()); | |
1695 EXPECT_EQ(wm::WINDOW_STATE_TYPE_MAXIMIZED, | |
1696 observer.GetLastOldStateAndReset()); | |
1697 | |
1698 wm::WMEvent restore_event(wm::WM_EVENT_NORMAL); | |
1699 window_state->OnWMEvent(&restore_event); | |
1700 EXPECT_EQ(1, observer.GetPreCountAndReset()); | |
1701 EXPECT_EQ(1, observer.GetPostCountAndReset()); | |
1702 EXPECT_EQ(wm::WINDOW_STATE_TYPE_MINIMIZED, | |
1703 observer.GetLastOldStateAndReset()); | |
1704 | |
1705 window_state->RemoveObserver(&observer); | |
1706 | |
1707 DestroyMaximizeModeWindowManager(); | |
1708 } | |
1709 | |
1710 } // namespace ash | |
OLD | NEW |