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/root_window_controller.h" 10 #include "ash/screen_util.h" 11 #include "ash/shelf/shelf_layout_manager.h" 12 #include "ash/shell.h" 13 #include "ash/switchable_windows.h" 14 #include "ash/test/ash_test_base.h" 15 #include "ash/test/shell_test_api.h" 16 #include "ash/wm/maximize_mode/maximize_mode_controller.h" 17 #include "ash/wm/mru_window_tracker.h" 18 #include "ash/wm/overview/window_selector_controller.h" 19 #include "ash/wm/window_properties.h" 20 #include "ash/wm/window_state.h" 21 #include "ash/wm/window_util.h" 22 #include "ash/wm/wm_event.h" 23 #include "base/strings/stringprintf.h" 24 #include "base/strings/utf_string_conversions.h" 25 #include "base/values.h" 26 #include "ui/aura/client/aura_constants.h" 27 #include "ui/aura/test/event_generator.h" 28 #include "ui/aura/test/test_window_delegate.h" 29 #include "ui/aura/test/test_windows.h" 30 #include "ui/aura/window.h" 31 #include "ui/base/hit_test.h" 32 33 namespace ash { 34 35 // TODO(skuhne): These tests are failing on Widows because maximized is there 36 // differently handled. Fix this! 37 #if !defined(OS_WIN) 38 39 class MaximizeModeWindowManagerTest : public test::AshTestBase { 40 public: 41 MaximizeModeWindowManagerTest() {} 42 virtual ~MaximizeModeWindowManagerTest() {} 43 44 // Creates a window which has a fixed size. 45 aura::Window* CreateFixedSizeNonMaximizableWindow(ui::wm::WindowType type, 46 const gfx::Rect& bounds) { 47 return CreateWindowInWatchedContainer( 48 type, bounds, gfx::Size(), false, false); 49 } 50 51 // Creates a window which can not be maximized, but resized. |max_size| 52 // denotes the maximal possible size, if the size is empty, the window has no 53 // upper limit. Note: This function will only work with a single root window. 54 aura::Window* CreateNonMaximizableWindow(ui::wm::WindowType type, 55 const gfx::Rect& bounds, 56 const gfx::Size& max_size) { 57 return CreateWindowInWatchedContainer(type, bounds, max_size, false, true); 58 } 59 60 // Creates a maximizable and resizable window. 61 aura::Window* CreateWindow(ui::wm::WindowType type, 62 const gfx::Rect bounds) { 63 return CreateWindowInWatchedContainer( 64 type, bounds, gfx::Size(), true, true); 65 } 66 67 // Creates a window which also has a widget. 68 aura::Window* CreateWindowWithWidget(const gfx::Rect& bounds) { 69 views::Widget* widget = new views::Widget(); 70 views::Widget::InitParams params; 71 params.context = CurrentContext(); 72 // Note: The widget will get deleted with the window. 73 widget->Init(params); 74 widget->Show(); 75 aura::Window* window = widget->GetNativeWindow(); 76 window->SetBounds(bounds); 77 window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL); 78 79 return window; 80 } 81 82 // Create the Maximized mode window manager. 83 ash::MaximizeModeWindowManager* CreateMaximizeModeWindowManager() { 84 EXPECT_FALSE(maximize_mode_window_manager()); 85 Shell::GetInstance()->maximize_mode_controller()-> 86 EnableMaximizeModeWindowManager(true); 87 return maximize_mode_window_manager(); 88 } 89 90 // Destroy the maximized mode window manager. 91 void DestroyMaximizeModeWindowManager() { 92 Shell::GetInstance()->maximize_mode_controller()-> 93 EnableMaximizeModeWindowManager(false); 94 EXPECT_FALSE(maximize_mode_window_manager()); 95 } 96 97 // Get the maximze window manager. 98 ash::MaximizeModeWindowManager* maximize_mode_window_manager() { 99 return Shell::GetInstance()->maximize_mode_controller()-> 100 maximize_mode_window_manager_.get(); 101 } 102 103 // Resize our desktop. 104 void ResizeDesktop(int width_delta) { 105 gfx::Size size = Shell::GetScreen()->GetDisplayNearestWindow( 106 Shell::GetPrimaryRootWindow()).size(); 107 size.Enlarge(0, width_delta); 108 UpdateDisplay(size.ToString()); 109 } 110 111 private: 112 // Create a window in one of the containers which are watched by the 113 // MaximizeModeWindowManager. Note that this only works with one root window. 114 // If |can_maximize| is not set, |max_size| is the upper limiting size for 115 // the window, whereas an empty size means that there is no limit. 116 aura::Window* CreateWindowInWatchedContainer(ui::wm::WindowType type, 117 const gfx::Rect& bounds, 118 const gfx::Size& max_size, 119 bool can_maximize, 120 bool can_resize) { 121 aura::test::TestWindowDelegate* delegate = NULL; 122 if (!can_maximize) { 123 delegate = aura::test::TestWindowDelegate::CreateSelfDestroyingDelegate(); 124 delegate->set_window_component(HTCAPTION); 125 if (!max_size.IsEmpty()) 126 delegate->set_maximum_size(max_size); 127 } 128 aura::Window* window = aura::test::CreateTestWindowWithDelegateAndType( 129 delegate, type, 0, bounds, NULL); 130 window->SetProperty(aura::client::kCanMaximizeKey, can_maximize); 131 if (!can_resize) 132 window->SetProperty(aura::client::kCanResizeKey, false); 133 aura::Window* container = Shell::GetContainer( 134 Shell::GetPrimaryRootWindow(), 135 kSwitchableWindowContainerIds[0]); 136 container->AddChild(window); 137 return window; 138 } 139 140 DISALLOW_COPY_AND_ASSIGN(MaximizeModeWindowManagerTest); 141 }; 142 143 // Test that creating the object and destroying it without any windows should 144 // not cause any problems. 145 TEST_F(MaximizeModeWindowManagerTest, SimpleStart) { 146 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 147 ASSERT_TRUE(manager); 148 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); 149 DestroyMaximizeModeWindowManager(); 150 } 151 152 // Test that existing windows will handled properly when going into maximized 153 // mode. 154 TEST_F(MaximizeModeWindowManagerTest, PreCreateWindows) { 155 // Bounds for windows we know can be controlled. 156 gfx::Rect rect1(10, 10, 200, 50); 157 gfx::Rect rect2(10, 60, 200, 50); 158 gfx::Rect rect3(20, 140, 100, 100); 159 // Bounds for anything else. 160 gfx::Rect rect(80, 90, 100, 110); 161 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1)); 162 scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2)); 163 scoped_ptr<aura::Window> w3( 164 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect3)); 165 scoped_ptr<aura::Window> w4(CreateWindow(ui::wm::WINDOW_TYPE_PANEL, rect)); 166 scoped_ptr<aura::Window> w5(CreateWindow(ui::wm::WINDOW_TYPE_POPUP, rect)); 167 scoped_ptr<aura::Window> w6(CreateWindow(ui::wm::WINDOW_TYPE_CONTROL, rect)); 168 scoped_ptr<aura::Window> w7(CreateWindow(ui::wm::WINDOW_TYPE_MENU, rect)); 169 scoped_ptr<aura::Window> w8(CreateWindow(ui::wm::WINDOW_TYPE_TOOLTIP, rect)); 170 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); 171 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); 172 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); 173 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); 174 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); 175 EXPECT_EQ(rect3.ToString(), w3->bounds().ToString()); 176 177 // Create the manager and make sure that all qualifying windows were detected 178 // and changed. 179 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 180 ASSERT_TRUE(manager); 181 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); 182 EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized()); 183 EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized()); 184 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); 185 EXPECT_NE(rect3.origin().ToString(), w3->bounds().origin().ToString()); 186 EXPECT_EQ(rect3.size().ToString(), w3->bounds().size().ToString()); 187 188 // All other windows should not have been touched. 189 EXPECT_FALSE(wm::GetWindowState(w4.get())->IsMaximized()); 190 EXPECT_FALSE(wm::GetWindowState(w5.get())->IsMaximized()); 191 EXPECT_FALSE(wm::GetWindowState(w6.get())->IsMaximized()); 192 EXPECT_FALSE(wm::GetWindowState(w7.get())->IsMaximized()); 193 EXPECT_FALSE(wm::GetWindowState(w8.get())->IsMaximized()); 194 EXPECT_EQ(rect.ToString(), w4->bounds().ToString()); 195 EXPECT_EQ(rect.ToString(), w5->bounds().ToString()); 196 EXPECT_EQ(rect.ToString(), w6->bounds().ToString()); 197 EXPECT_EQ(rect.ToString(), w7->bounds().ToString()); 198 EXPECT_EQ(rect.ToString(), w8->bounds().ToString()); 199 200 // Destroy the manager again and check that the windows return to their 201 // previous state. 202 DestroyMaximizeModeWindowManager(); 203 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); 204 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); 205 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); 206 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); 207 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); 208 EXPECT_EQ(rect3.ToString(), w3->bounds().ToString()); 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 216 // Test that non-maximizable windows get properly handled when going into 217 // maximized mode. 218 TEST_F(MaximizeModeWindowManagerTest, 219 PreCreateNonMaximizableButResizableWindows) { 220 // The window bounds. 221 gfx::Rect rect(10, 10, 200, 50); 222 gfx::Size max_size(300, 200); 223 gfx::Size empty_size; 224 scoped_ptr<aura::Window> unlimited_window( 225 CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, empty_size)); 226 scoped_ptr<aura::Window> limited_window( 227 CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, max_size)); 228 scoped_ptr<aura::Window> fixed_window( 229 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 230 EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized()); 231 EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString()); 232 EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized()); 233 EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString()); 234 EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized()); 235 EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString()); 236 237 gfx::Size workspace_size = ScreenUtil::GetMaximizedWindowBoundsInParent( 238 unlimited_window.get()).size(); 239 240 // Create the manager and make sure that all qualifying windows were detected 241 // and changed. 242 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 243 ASSERT_TRUE(manager); 244 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); 245 // The unlimited window should have the size of the workspace / parent window. 246 EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized()); 247 EXPECT_EQ("0,0", unlimited_window->bounds().origin().ToString()); 248 EXPECT_EQ(workspace_size.ToString(), 249 unlimited_window->bounds().size().ToString()); 250 // The limited window should have the size of the upper possible bounds. 251 EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized()); 252 EXPECT_NE(rect.origin().ToString(), 253 limited_window->bounds().origin().ToString()); 254 EXPECT_EQ(max_size.ToString(), 255 limited_window->bounds().size().ToString()); 256 // The fixed size window should have the size of the original window. 257 EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized()); 258 EXPECT_NE(rect.origin().ToString(), 259 fixed_window->bounds().origin().ToString()); 260 EXPECT_EQ(rect.size().ToString(), 261 fixed_window->bounds().size().ToString()); 262 263 // Destroy the manager again and check that the windows return to their 264 // previous state. 265 DestroyMaximizeModeWindowManager(); 266 EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized()); 267 EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString()); 268 EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized()); 269 EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString()); 270 EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized()); 271 EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString()); 272 } 273 274 // Test that creating windows while a maximizer exists picks them properly up. 275 TEST_F(MaximizeModeWindowManagerTest, CreateWindows) { 276 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 277 ASSERT_TRUE(manager); 278 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); 279 280 // Create the windows and see that the window manager picks them up. 281 // Rects for windows we know can be controlled. 282 gfx::Rect rect1(10, 10, 200, 50); 283 gfx::Rect rect2(10, 60, 200, 50); 284 gfx::Rect rect3(20, 140, 100, 100); 285 // One rect for anything else. 286 gfx::Rect rect(80, 90, 100, 110); 287 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1)); 288 scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2)); 289 scoped_ptr<aura::Window> w3( 290 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect3)); 291 scoped_ptr<aura::Window> w4(CreateWindow(ui::wm::WINDOW_TYPE_PANEL, rect)); 292 scoped_ptr<aura::Window> w5(CreateWindow(ui::wm::WINDOW_TYPE_POPUP, rect)); 293 scoped_ptr<aura::Window> w6(CreateWindow(ui::wm::WINDOW_TYPE_CONTROL, rect)); 294 scoped_ptr<aura::Window> w7(CreateWindow(ui::wm::WINDOW_TYPE_MENU, rect)); 295 scoped_ptr<aura::Window> w8(CreateWindow(ui::wm::WINDOW_TYPE_TOOLTIP, rect)); 296 EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized()); 297 EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized()); 298 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); 299 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); 300 301 // Make sure that the position of the unresizable window is in the middle of 302 // the screen. 303 gfx::Size work_area_size = 304 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w3.get()).size(); 305 gfx::Point center = 306 gfx::Point((work_area_size.width() - rect3.size().width()) / 2, 307 (work_area_size.height() - rect3.size().height()) / 2); 308 gfx::Rect centered_window_bounds = gfx::Rect(center, rect3.size()); 309 EXPECT_EQ(centered_window_bounds.ToString(), w3->bounds().ToString()); 310 311 // All other windows should not have been touched. 312 EXPECT_FALSE(wm::GetWindowState(w4.get())->IsMaximized()); 313 EXPECT_FALSE(wm::GetWindowState(w5.get())->IsMaximized()); 314 EXPECT_FALSE(wm::GetWindowState(w6.get())->IsMaximized()); 315 EXPECT_FALSE(wm::GetWindowState(w7.get())->IsMaximized()); 316 EXPECT_FALSE(wm::GetWindowState(w8.get())->IsMaximized()); 317 EXPECT_EQ(rect.ToString(), w4->bounds().ToString()); 318 EXPECT_EQ(rect.ToString(), w5->bounds().ToString()); 319 EXPECT_EQ(rect.ToString(), w6->bounds().ToString()); 320 EXPECT_EQ(rect.ToString(), w7->bounds().ToString()); 321 EXPECT_EQ(rect.ToString(), w8->bounds().ToString()); 322 323 // After the maximize mode was disabled all windows fall back into the mode 324 // they were created for. 325 DestroyMaximizeModeWindowManager(); 326 EXPECT_FALSE(wm::GetWindowState(w1.get())->IsMaximized()); 327 EXPECT_FALSE(wm::GetWindowState(w2.get())->IsMaximized()); 328 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); 329 EXPECT_EQ(rect1.ToString(), w1->bounds().ToString()); 330 EXPECT_EQ(rect2.ToString(), w2->bounds().ToString()); 331 EXPECT_EQ(rect3.ToString(), w3->bounds().ToString()); 332 EXPECT_EQ(rect.ToString(), w4->bounds().ToString()); 333 EXPECT_EQ(rect.ToString(), w5->bounds().ToString()); 334 EXPECT_EQ(rect.ToString(), w6->bounds().ToString()); 335 EXPECT_EQ(rect.ToString(), w7->bounds().ToString()); 336 EXPECT_EQ(rect.ToString(), w8->bounds().ToString()); 337 } 338 339 // Test that a window which got created while the maximize mode window manager 340 // is active gets restored to a usable (non tiny) size upon switching back. 341 TEST_F(MaximizeModeWindowManagerTest, 342 CreateWindowInMaximizedModeRestoresToUsefulSize) { 343 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 344 ASSERT_TRUE(manager); 345 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); 346 347 // We pass in an empty rectangle to simulate a window creation with no 348 // particular size. 349 gfx::Rect empty_rect(0, 0, 0, 0); 350 scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, 351 empty_rect)); 352 EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized()); 353 EXPECT_NE(empty_rect.ToString(), window->bounds().ToString()); 354 gfx::Rect maximized_size = window->bounds(); 355 356 // Destroy the maximize mode and check that the resulting size of the window 357 // is remaining as it is (but not maximized). 358 DestroyMaximizeModeWindowManager(); 359 360 EXPECT_FALSE(wm::GetWindowState(window.get())->IsMaximized()); 361 EXPECT_EQ(maximized_size.ToString(), window->bounds().ToString()); 362 } 363 364 // Test that non-maximizable windows get properly handled when created in 365 // maximized mode. 366 TEST_F(MaximizeModeWindowManagerTest, 367 CreateNonMaximizableButResizableWindows) { 368 // Create the manager and make sure that all qualifying windows were detected 369 // and changed. 370 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 371 ASSERT_TRUE(manager); 372 373 gfx::Rect rect(10, 10, 200, 50); 374 gfx::Size max_size(300, 200); 375 gfx::Size empty_size; 376 scoped_ptr<aura::Window> unlimited_window( 377 CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, empty_size)); 378 scoped_ptr<aura::Window> limited_window( 379 CreateNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect, max_size)); 380 scoped_ptr<aura::Window> fixed_window( 381 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 382 383 gfx::Size workspace_size = ScreenUtil::GetMaximizedWindowBoundsInParent( 384 unlimited_window.get()).size(); 385 386 // All windows should be sized now as big as possible and be centered. 387 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); 388 // The unlimited window should have the size of the workspace / parent window. 389 EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized()); 390 EXPECT_EQ("0,0", unlimited_window->bounds().origin().ToString()); 391 EXPECT_EQ(workspace_size.ToString(), 392 unlimited_window->bounds().size().ToString()); 393 // The limited window should have the size of the upper possible bounds. 394 EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized()); 395 EXPECT_NE(rect.origin().ToString(), 396 limited_window->bounds().origin().ToString()); 397 EXPECT_EQ(max_size.ToString(), 398 limited_window->bounds().size().ToString()); 399 // The fixed size window should have the size of the original window. 400 EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized()); 401 EXPECT_NE(rect.origin().ToString(), 402 fixed_window->bounds().origin().ToString()); 403 EXPECT_EQ(rect.size().ToString(), 404 fixed_window->bounds().size().ToString()); 405 406 // Destroy the manager again and check that the windows return to their 407 // creation state. 408 DestroyMaximizeModeWindowManager(); 409 410 EXPECT_FALSE(wm::GetWindowState(unlimited_window.get())->IsMaximized()); 411 EXPECT_EQ(rect.ToString(), unlimited_window->bounds().ToString()); 412 EXPECT_FALSE(wm::GetWindowState(limited_window.get())->IsMaximized()); 413 EXPECT_EQ(rect.ToString(), limited_window->bounds().ToString()); 414 EXPECT_FALSE(wm::GetWindowState(fixed_window.get())->IsMaximized()); 415 EXPECT_EQ(rect.ToString(), fixed_window->bounds().ToString()); 416 } 417 418 // Create a string which consists of the bounds and the state for comparison. 419 std::string GetPlacementString(const gfx::Rect& bounds, 420 ui::WindowShowState state) { 421 return bounds.ToString() + base::StringPrintf(" %d", state); 422 } 423 424 // Retrieves the window's restore state override - if any - and returns it as a 425 // string. 426 std::string GetPlacementOverride(aura::Window* window) { 427 gfx::Rect* bounds = window->GetProperty(ash::kRestoreBoundsOverrideKey); 428 if (bounds) { 429 gfx::Rect restore_bounds = *bounds; 430 ui::WindowShowState restore_state = 431 window->GetProperty(ash::kRestoreShowStateOverrideKey); 432 return GetPlacementString(restore_bounds, restore_state); 433 } 434 return std::string(); 435 } 436 437 // Test that the restore state will be kept at its original value for 438 // session restauration purposes. 439 TEST_F(MaximizeModeWindowManagerTest, TestRestoreIntegrety) { 440 gfx::Rect bounds(10, 10, 200, 50); 441 gfx::Size empty_size; 442 gfx::Rect empty_bounds; 443 scoped_ptr<aura::Window> normal_window( 444 CreateWindowWithWidget(bounds)); 445 scoped_ptr<aura::Window> maximized_window( 446 CreateWindowWithWidget(bounds)); 447 wm::GetWindowState(maximized_window.get())->Maximize(); 448 449 EXPECT_EQ(std::string(), GetPlacementOverride(normal_window.get())); 450 EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get())); 451 452 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 453 ASSERT_TRUE(manager); 454 455 // With the maximization the override states should be returned in its 456 // pre-maximized state. 457 EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_NORMAL), 458 GetPlacementOverride(normal_window.get())); 459 EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_MAXIMIZED), 460 GetPlacementOverride(maximized_window.get())); 461 462 // Changing a window's state now does not change the returned result. 463 wm::GetWindowState(maximized_window.get())->Minimize(); 464 EXPECT_EQ(GetPlacementString(bounds, ui::SHOW_STATE_MAXIMIZED), 465 GetPlacementOverride(maximized_window.get())); 466 467 // Destroy the manager again and check that the overrides get reset. 468 DestroyMaximizeModeWindowManager(); 469 EXPECT_EQ(std::string(), GetPlacementOverride(normal_window.get())); 470 EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get())); 471 472 // Changing a window's state now does not bring the overrides back. 473 wm::GetWindowState(maximized_window.get())->Restore(); 474 gfx::Rect new_bounds(10, 10, 200, 50); 475 maximized_window->SetBounds(new_bounds); 476 477 EXPECT_EQ(std::string(), GetPlacementOverride(maximized_window.get())); 478 } 479 480 // Test that windows which got created before the maximizer was created can be 481 // destroyed while the maximizer is still running. 482 TEST_F(MaximizeModeWindowManagerTest, PreCreateWindowsDeleteWhileActive) { 483 ash::MaximizeModeWindowManager* manager = NULL; 484 { 485 // Bounds for windows we know can be controlled. 486 gfx::Rect rect1(10, 10, 200, 50); 487 gfx::Rect rect2(10, 60, 200, 50); 488 gfx::Rect rect3(20, 140, 100, 100); 489 // Bounds for anything else. 490 gfx::Rect rect(80, 90, 100, 110); 491 scoped_ptr<aura::Window> w1( 492 CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1)); 493 scoped_ptr<aura::Window> w2( 494 CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2)); 495 scoped_ptr<aura::Window> w3( 496 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect3)); 497 498 // Create the manager and make sure that all qualifying windows were 499 // detected and changed. 500 manager = CreateMaximizeModeWindowManager(); 501 ASSERT_TRUE(manager); 502 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); 503 } 504 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); 505 DestroyMaximizeModeWindowManager(); 506 } 507 508 // Test that windows which got created while the maximizer was running can get 509 // destroyed before the maximizer gets destroyed. 510 TEST_F(MaximizeModeWindowManagerTest, CreateWindowsAndDeleteWhileActive) { 511 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 512 ASSERT_TRUE(manager); 513 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); 514 { 515 // Bounds for windows we know can be controlled. 516 gfx::Rect rect1(10, 10, 200, 50); 517 gfx::Rect rect2(10, 60, 200, 50); 518 gfx::Rect rect3(20, 140, 100, 100); 519 scoped_ptr<aura::Window> w1( 520 CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(10, 10, 200, 50))); 521 scoped_ptr<aura::Window> w2( 522 CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(10, 60, 200, 50))); 523 scoped_ptr<aura::Window> w3( 524 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, 525 gfx::Rect(20, 140, 100, 100))); 526 // Check that the windows got automatically maximized as well. 527 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); 528 EXPECT_TRUE(wm::GetWindowState(w1.get())->IsMaximized()); 529 EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized()); 530 EXPECT_FALSE(wm::GetWindowState(w3.get())->IsMaximized()); 531 } 532 EXPECT_EQ(0, manager->GetNumberOfManagedWindows()); 533 DestroyMaximizeModeWindowManager(); 534 } 535 536 // Test that windows which were maximized stay maximized. 537 TEST_F(MaximizeModeWindowManagerTest, MaximizedShouldRemainMaximized) { 538 // Bounds for windows we know can be controlled. 539 gfx::Rect rect(10, 10, 200, 50); 540 scoped_ptr<aura::Window> window( 541 CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 542 wm::GetWindowState(window.get())->Maximize(); 543 544 // Create the manager and make sure that the window gets detected. 545 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 546 ASSERT_TRUE(manager); 547 EXPECT_EQ(1, manager->GetNumberOfManagedWindows()); 548 EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized()); 549 550 // Destroy the manager again and check that the window will remain maximized. 551 DestroyMaximizeModeWindowManager(); 552 EXPECT_TRUE(wm::GetWindowState(window.get())->IsMaximized()); 553 wm::GetWindowState(window.get())->Restore(); 554 EXPECT_EQ(rect.ToString(), window->bounds().ToString()); 555 } 556 557 // Test that minimized windows do neither get maximized nor restored upon 558 // entering maximized mode and get restored to their previous state after 559 // leaving. 560 TEST_F(MaximizeModeWindowManagerTest, MinimizedWindowBehavior) { 561 // Bounds for windows we know can be controlled. 562 gfx::Rect rect(10, 10, 200, 50); 563 scoped_ptr<aura::Window> initially_minimized_window( 564 CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 565 scoped_ptr<aura::Window> initially_normal_window( 566 CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 567 scoped_ptr<aura::Window> initially_maximized_window( 568 CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 569 wm::GetWindowState(initially_minimized_window.get())->Minimize(); 570 wm::GetWindowState(initially_maximized_window.get())->Maximize(); 571 572 // Create the manager and make sure that the window gets detected. 573 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 574 ASSERT_TRUE(manager); 575 EXPECT_EQ(3, manager->GetNumberOfManagedWindows()); 576 EXPECT_TRUE(wm::GetWindowState( 577 initially_minimized_window.get())->IsMinimized()); 578 EXPECT_TRUE(wm::GetWindowState(initially_normal_window.get())->IsMaximized()); 579 EXPECT_TRUE(wm::GetWindowState( 580 initially_maximized_window.get())->IsMaximized()); 581 // Now minimize the second window to check that upon leaving the window 582 // will get restored to its minimized state. 583 wm::GetWindowState(initially_normal_window.get())->Minimize(); 584 wm::GetWindowState(initially_maximized_window.get())->Minimize(); 585 EXPECT_TRUE(wm::GetWindowState( 586 initially_minimized_window.get())->IsMinimized()); 587 EXPECT_TRUE(wm::GetWindowState( 588 initially_normal_window.get())->IsMinimized()); 589 EXPECT_TRUE(wm::GetWindowState( 590 initially_maximized_window.get())->IsMinimized()); 591 592 // Destroy the manager again and check that the window will get minimized. 593 DestroyMaximizeModeWindowManager(); 594 EXPECT_TRUE(wm::GetWindowState( 595 initially_minimized_window.get())->IsMinimized()); 596 EXPECT_FALSE(wm::GetWindowState( 597 initially_normal_window.get())->IsMinimized()); 598 EXPECT_TRUE(wm::GetWindowState( 599 initially_maximized_window.get())->IsMaximized()); 600 } 601 602 // Check that resizing the desktop does reposition unmaximizable, unresizable & 603 // managed windows. 604 TEST_F(MaximizeModeWindowManagerTest, DesktopSizeChangeMovesUnmaximizable) { 605 UpdateDisplay("400x400"); 606 // This window will move because it does not fit the new bounds. 607 gfx::Rect rect(20, 300, 100, 100); 608 scoped_ptr<aura::Window> window1( 609 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 610 EXPECT_EQ(rect.ToString(), window1->bounds().ToString()); 611 612 // This window will not move because it does fit the new bounds. 613 gfx::Rect rect2(20, 140, 100, 100); 614 scoped_ptr<aura::Window> window2( 615 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2)); 616 617 // Turning on the manager will reposition (but not resize) the window. 618 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 619 ASSERT_TRUE(manager); 620 EXPECT_EQ(2, manager->GetNumberOfManagedWindows()); 621 gfx::Rect moved_bounds(window1->bounds()); 622 EXPECT_NE(rect.origin().ToString(), moved_bounds.origin().ToString()); 623 EXPECT_EQ(rect.size().ToString(), moved_bounds.size().ToString()); 624 625 // Simulating a desktop resize should move the window again. 626 UpdateDisplay("300x300"); 627 gfx::Rect new_moved_bounds(window1->bounds()); 628 EXPECT_NE(rect.origin().ToString(), new_moved_bounds.origin().ToString()); 629 EXPECT_EQ(rect.size().ToString(), new_moved_bounds.size().ToString()); 630 EXPECT_NE(moved_bounds.origin().ToString(), new_moved_bounds.ToString()); 631 632 // Turning off the mode should not restore to the initial coordinates since 633 // the new resolution is smaller and the window was on the edge. 634 DestroyMaximizeModeWindowManager(); 635 EXPECT_NE(rect.ToString(), window1->bounds().ToString()); 636 EXPECT_EQ(rect2.ToString(), window2->bounds().ToString()); 637 } 638 639 // Check that windows return to original location if desktop size changes to 640 // something else and back while in maximize mode. 641 TEST_F(MaximizeModeWindowManagerTest, SizeChangeReturnWindowToOriginalPos) { 642 gfx::Rect rect(20, 140, 100, 100); 643 scoped_ptr<aura::Window> window( 644 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 645 646 // Turning on the manager will reposition (but not resize) the window. 647 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 648 ASSERT_TRUE(manager); 649 EXPECT_EQ(1, manager->GetNumberOfManagedWindows()); 650 gfx::Rect moved_bounds(window->bounds()); 651 EXPECT_NE(rect.origin().ToString(), moved_bounds.origin().ToString()); 652 EXPECT_EQ(rect.size().ToString(), moved_bounds.size().ToString()); 653 654 // Simulating a desktop resize should move the window again. 655 ResizeDesktop(-10); 656 gfx::Rect new_moved_bounds(window->bounds()); 657 EXPECT_NE(rect.origin().ToString(), new_moved_bounds.origin().ToString()); 658 EXPECT_EQ(rect.size().ToString(), new_moved_bounds.size().ToString()); 659 EXPECT_NE(moved_bounds.origin().ToString(), new_moved_bounds.ToString()); 660 661 // Then resize back to the original desktop size which should move windows 662 // to their original location after leaving the maximize mode. 663 ResizeDesktop(10); 664 DestroyMaximizeModeWindowManager(); 665 EXPECT_EQ(rect.ToString(), window->bounds().ToString()); 666 } 667 668 // Check that enabling of the maximize mode does not have an impact on the MRU 669 // order of windows. 670 TEST_F(MaximizeModeWindowManagerTest, ModeChangeKeepsMRUOrder) { 671 gfx::Rect rect(20, 140, 100, 100); 672 scoped_ptr<aura::Window> w1( 673 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 674 scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 675 scoped_ptr<aura::Window> w3(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 676 scoped_ptr<aura::Window> w4( 677 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 678 scoped_ptr<aura::Window> w5(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 679 680 // The windows should be in the reverse order of creation in the MRU list. 681 { 682 MruWindowTracker::WindowList windows = 683 MruWindowTracker::BuildWindowList(false); 684 EXPECT_EQ(w1.get(), windows[4]); 685 EXPECT_EQ(w2.get(), windows[3]); 686 EXPECT_EQ(w3.get(), windows[2]); 687 EXPECT_EQ(w4.get(), windows[1]); 688 EXPECT_EQ(w5.get(), windows[0]); 689 } 690 691 // Activating the window manager should keep the order. 692 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 693 ASSERT_TRUE(manager); 694 EXPECT_EQ(5, manager->GetNumberOfManagedWindows()); 695 { 696 MruWindowTracker::WindowList windows = 697 MruWindowTracker::BuildWindowList(false); 698 // We do not test maximization here again since that was done already. 699 EXPECT_EQ(w1.get(), windows[4]); 700 EXPECT_EQ(w2.get(), windows[3]); 701 EXPECT_EQ(w3.get(), windows[2]); 702 EXPECT_EQ(w4.get(), windows[1]); 703 EXPECT_EQ(w5.get(), windows[0]); 704 } 705 706 // Destroying should still keep the order. 707 DestroyMaximizeModeWindowManager(); 708 { 709 MruWindowTracker::WindowList windows = 710 MruWindowTracker::BuildWindowList(false); 711 // We do not test maximization here again since that was done already. 712 EXPECT_EQ(w1.get(), windows[4]); 713 EXPECT_EQ(w2.get(), windows[3]); 714 EXPECT_EQ(w3.get(), windows[2]); 715 EXPECT_EQ(w4.get(), windows[1]); 716 EXPECT_EQ(w5.get(), windows[0]); 717 } 718 } 719 720 // Check that a restore state change does always restore to maximized. 721 TEST_F(MaximizeModeWindowManagerTest, IgnoreRestoreStateChages) { 722 gfx::Rect rect(20, 140, 100, 100); 723 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 724 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 725 CreateMaximizeModeWindowManager(); 726 EXPECT_TRUE(window_state->IsMaximized()); 727 window_state->Minimize(); 728 EXPECT_TRUE(window_state->IsMinimized()); 729 window_state->Restore(); 730 EXPECT_TRUE(window_state->IsMaximized()); 731 window_state->Restore(); 732 EXPECT_TRUE(window_state->IsMaximized()); 733 DestroyMaximizeModeWindowManager(); 734 } 735 736 // Check that minimize and restore do the right thing. 737 TEST_F(MaximizeModeWindowManagerTest, TestMinimize) { 738 gfx::Rect rect(10, 10, 100, 100); 739 scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, 740 rect)); 741 wm::WindowState* window_state = wm::GetWindowState(window.get()); 742 EXPECT_EQ(rect.ToString(), window->bounds().ToString()); 743 ash::Shell::GetInstance()->maximize_mode_controller()-> 744 EnableMaximizeModeWindowManager(true); 745 EXPECT_TRUE(window_state->IsMaximized()); 746 EXPECT_FALSE(window_state->IsMinimized()); 747 EXPECT_TRUE(window->IsVisible()); 748 749 window_state->Minimize(); 750 EXPECT_FALSE(window_state->IsMaximized()); 751 EXPECT_TRUE(window_state->IsMinimized()); 752 EXPECT_FALSE(window->IsVisible()); 753 754 window_state->Maximize(); 755 EXPECT_TRUE(window_state->IsMaximized()); 756 EXPECT_FALSE(window_state->IsMinimized()); 757 EXPECT_TRUE(window->IsVisible()); 758 759 ash::Shell::GetInstance()->maximize_mode_controller()-> 760 EnableMaximizeModeWindowManager(false); 761 EXPECT_FALSE(window_state->IsMaximized()); 762 EXPECT_FALSE(window_state->IsMinimized()); 763 EXPECT_TRUE(window->IsVisible()); 764 } 765 766 // Check that a full screen window is staying full screen in maximize mode, 767 // and that it returns to full screen thereafter (if left). 768 TEST_F(MaximizeModeWindowManagerTest, KeepFullScreenModeOn) { 769 gfx::Rect rect(20, 140, 100, 100); 770 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 771 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 772 773 ShelfLayoutManager* shelf = 774 Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager(); 775 776 // Allow the shelf to hide. 777 shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS); 778 EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state()); 779 780 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 781 window_state->OnWMEvent(&event); 782 783 // With full screen, the shelf should get hidden. 784 EXPECT_TRUE(window_state->IsFullscreen()); 785 EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state()); 786 787 CreateMaximizeModeWindowManager(); 788 789 // The Full screen mode should continue to be on. 790 EXPECT_TRUE(window_state->IsFullscreen()); 791 EXPECT_FALSE(window_state->IsMaximized()); 792 EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state()); 793 794 // With leaving the fullscreen mode, the maximized mode should return and the 795 // shelf should become visible. 796 window_state->OnWMEvent(&event); 797 EXPECT_FALSE(window_state->IsFullscreen()); 798 EXPECT_TRUE(window_state->IsMaximized()); 799 EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state()); 800 801 // Ending the maximize mode should return to full screen and the shelf should 802 // be hidden again. 803 DestroyMaximizeModeWindowManager(); 804 EXPECT_TRUE(window_state->IsFullscreen()); 805 EXPECT_FALSE(window_state->IsMaximized()); 806 EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state()); 807 } 808 809 // Check that full screen mode can be turned on in maximized mode and remains 810 // upon coming back. 811 TEST_F(MaximizeModeWindowManagerTest, AllowFullScreenMode) { 812 gfx::Rect rect(20, 140, 100, 100); 813 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 814 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 815 816 ShelfLayoutManager* shelf = 817 Shell::GetPrimaryRootWindowController()->GetShelfLayoutManager(); 818 819 // Allow the shelf to hide. 820 shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS); 821 822 EXPECT_FALSE(window_state->IsFullscreen()); 823 EXPECT_FALSE(window_state->IsMaximized()); 824 EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state()); 825 826 CreateMaximizeModeWindowManager(); 827 828 // Fullscreen mode should still be off and the shelf should be visible. 829 EXPECT_FALSE(window_state->IsFullscreen()); 830 EXPECT_TRUE(window_state->IsMaximized()); 831 EXPECT_EQ(SHELF_VISIBLE, shelf->visibility_state()); 832 833 // After going into fullscreen mode, the shelf should be hidden. 834 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 835 window_state->OnWMEvent(&event); 836 EXPECT_TRUE(window_state->IsFullscreen()); 837 EXPECT_FALSE(window_state->IsMaximized()); 838 EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state()); 839 840 // With the destruction of the manager we should remain in full screen. 841 DestroyMaximizeModeWindowManager(); 842 EXPECT_TRUE(window_state->IsFullscreen()); 843 EXPECT_FALSE(window_state->IsMaximized()); 844 EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state()); 845 } 846 847 // Check that the full screen mode will stay active when the maximize mode is 848 // ended. 849 TEST_F(MaximizeModeWindowManagerTest, 850 FullScreenModeRemainsWhenCreatedInMaximizedMode) { 851 CreateMaximizeModeWindowManager(); 852 853 gfx::Rect rect(20, 140, 100, 100); 854 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 855 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 856 wm::WMEvent event_full_screen(wm::WM_EVENT_TOGGLE_FULLSCREEN); 857 window_state->OnWMEvent(&event_full_screen); 858 EXPECT_TRUE(window_state->IsFullscreen()); 859 860 // After the maximize mode manager is ended, full screen will remain. 861 DestroyMaximizeModeWindowManager(); 862 EXPECT_TRUE(window_state->IsFullscreen()); 863 } 864 865 // Check that the full screen mode will stay active throughout a maximzied mode 866 // session. 867 TEST_F(MaximizeModeWindowManagerTest, 868 FullScreenModeRemainsThroughMaximizeModeSwitch) { 869 gfx::Rect rect(20, 140, 100, 100); 870 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 871 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 872 wm::WMEvent event_full_screen(wm::WM_EVENT_TOGGLE_FULLSCREEN); 873 window_state->OnWMEvent(&event_full_screen); 874 EXPECT_TRUE(window_state->IsFullscreen()); 875 876 CreateMaximizeModeWindowManager(); 877 EXPECT_TRUE(window_state->IsFullscreen()); 878 DestroyMaximizeModeWindowManager(); 879 EXPECT_TRUE(window_state->IsFullscreen()); 880 } 881 882 // Check that an empty window does not get restored to a tiny size. 883 TEST_F(MaximizeModeWindowManagerTest, 884 CreateAndMaximizeInMaximizeModeShouldRetoreToGoodSizeGoingToDefault) { 885 CreateMaximizeModeWindowManager(); 886 gfx::Rect rect; 887 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 888 w1->Show(); 889 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 890 EXPECT_TRUE(window_state->IsMaximized()); 891 892 // There is a calling order in which the restore bounds can get set to an 893 // empty rectangle. We simulate this here. 894 window_state->SetRestoreBoundsInScreen(rect); 895 EXPECT_TRUE(window_state->GetRestoreBoundsInScreen().IsEmpty()); 896 897 // Setting the window to a new size will physically not change the window, 898 // but the restore size should get updated so that a restore later on will 899 // return to this size. 900 gfx::Rect requested_bounds(10, 20, 50, 70); 901 w1->SetBounds(requested_bounds); 902 EXPECT_TRUE(window_state->IsMaximized()); 903 EXPECT_EQ(requested_bounds.ToString(), 904 window_state->GetRestoreBoundsInScreen().ToString()); 905 906 DestroyMaximizeModeWindowManager(); 907 908 EXPECT_FALSE(window_state->IsMaximized()); 909 EXPECT_EQ(w1->bounds().ToString(), requested_bounds.ToString()); 910 } 911 912 // Check that snapping operations get ignored. 913 TEST_F(MaximizeModeWindowManagerTest, SnapModeTests) { 914 gfx::Rect rect(20, 140, 100, 100); 915 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 916 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 917 wm::WMEvent event_left(wm::WM_EVENT_SNAP_LEFT); 918 wm::WMEvent event_right(wm::WM_EVENT_SNAP_RIGHT); 919 window_state->OnWMEvent(&event_left); 920 EXPECT_TRUE(window_state->IsSnapped()); 921 922 CreateMaximizeModeWindowManager(); 923 924 // Fullscreen mode should now be off and it should not come back while in 925 // maximize mode. 926 EXPECT_FALSE(window_state->IsSnapped()); 927 EXPECT_TRUE(window_state->IsMaximized()); 928 window_state->OnWMEvent(&event_left); 929 EXPECT_FALSE(window_state->IsSnapped()); 930 EXPECT_TRUE(window_state->IsMaximized()); 931 window_state->OnWMEvent(&event_right); 932 EXPECT_FALSE(window_state->IsSnapped()); 933 EXPECT_TRUE(window_state->IsMaximized()); 934 935 DestroyMaximizeModeWindowManager(); 936 EXPECT_TRUE(window_state->IsSnapped()); 937 } 938 939 // Check that non maximizable windows cannot be dragged by the user. 940 TEST_F(MaximizeModeWindowManagerTest, TryToDesktopSizeDragUnmaximizable) { 941 gfx::Rect rect(10, 10, 100, 100); 942 scoped_ptr<aura::Window> window( 943 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 944 EXPECT_EQ(rect.ToString(), window->bounds().ToString()); 945 946 // 1. Move the mouse over the caption and check that dragging the window does 947 // change the location. 948 aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 949 generator.MoveMouseTo(gfx::Point(rect.x() + 2, rect.y() + 2)); 950 generator.PressLeftButton(); 951 generator.MoveMouseBy(10, 5); 952 RunAllPendingInMessageLoop(); 953 generator.ReleaseLeftButton(); 954 gfx::Point first_dragged_origin = window->bounds().origin(); 955 EXPECT_EQ(rect.x() + 10, first_dragged_origin.x()); 956 EXPECT_EQ(rect.y() + 5, first_dragged_origin.y()); 957 958 // 2. Check that turning on the manager will stop allowing the window from 959 // dragging. 960 ash::Shell::GetInstance()->maximize_mode_controller()-> 961 EnableMaximizeModeWindowManager(true); 962 gfx::Rect center_bounds(window->bounds()); 963 EXPECT_NE(rect.origin().ToString(), center_bounds.origin().ToString()); 964 generator.MoveMouseTo(gfx::Point(center_bounds.x() + 1, 965 center_bounds.y() + 1)); 966 generator.PressLeftButton(); 967 generator.MoveMouseBy(10, 5); 968 RunAllPendingInMessageLoop(); 969 generator.ReleaseLeftButton(); 970 EXPECT_EQ(center_bounds.x(), window->bounds().x()); 971 EXPECT_EQ(center_bounds.y(), window->bounds().y()); 972 ash::Shell::GetInstance()->maximize_mode_controller()-> 973 EnableMaximizeModeWindowManager(false); 974 975 // 3. Releasing the mazimize manager again will restore the window to its 976 // previous bounds and 977 generator.MoveMouseTo(gfx::Point(first_dragged_origin.x() + 1, 978 first_dragged_origin.y() + 1)); 979 generator.PressLeftButton(); 980 generator.MoveMouseBy(10, 5); 981 RunAllPendingInMessageLoop(); 982 generator.ReleaseLeftButton(); 983 EXPECT_EQ(first_dragged_origin.x() + 10, window->bounds().x()); 984 EXPECT_EQ(first_dragged_origin.y() + 5, window->bounds().y()); 985 } 986 987 // Test that overview is exited before entering / exiting maximize mode so that 988 // the window changes made by MaximizeModeWindowManager do not conflict with 989 // those made in WindowOverview. 990 TEST_F(MaximizeModeWindowManagerTest, ExitsOverview) { 991 // Bounds for windows we know can be controlled. 992 gfx::Rect rect1(10, 10, 200, 50); 993 gfx::Rect rect2(10, 60, 200, 50); 994 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1)); 995 scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2)); 996 997 WindowSelectorController* window_selector_controller = 998 Shell::GetInstance()->window_selector_controller(); 999 window_selector_controller->ToggleOverview(); 1000 ASSERT_TRUE(window_selector_controller->IsSelecting()); 1001 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 1002 ASSERT_TRUE(manager); 1003 EXPECT_FALSE(window_selector_controller->IsSelecting()); 1004 1005 window_selector_controller->ToggleOverview(); 1006 ASSERT_TRUE(window_selector_controller->IsSelecting()); 1007 // Destroy the manager again and check that the windows return to their 1008 // previous state. 1009 DestroyMaximizeModeWindowManager(); 1010 EXPECT_FALSE(window_selector_controller->IsSelecting()); 1011 } 1012 1013 // Test that an edge swipe from the top will end full screen mode. 1014 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromTop) { 1015 gfx::Rect rect(10, 10, 200, 50); 1016 scoped_ptr<aura::Window> 1017 background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1018 scoped_ptr<aura::Window> 1019 foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1020 wm::WindowState* background_window_state = 1021 wm::GetWindowState(background_window.get()); 1022 wm::WindowState* foreground_window_state = 1023 wm::GetWindowState(foreground_window.get()); 1024 wm::ActivateWindow(foreground_window.get()); 1025 CreateMaximizeModeWindowManager(); 1026 1027 // Fullscreen both windows. 1028 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1029 background_window_state->OnWMEvent(&event); 1030 foreground_window_state->OnWMEvent(&event); 1031 EXPECT_TRUE(background_window_state->IsFullscreen()); 1032 EXPECT_TRUE(foreground_window_state->IsFullscreen()); 1033 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); 1034 1035 // Do an edge swipe top into screen. 1036 aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1037 generator.GestureScrollSequence(gfx::Point(50, 0), 1038 gfx::Point(50, 100), 1039 base::TimeDelta::FromMilliseconds(20), 1040 10); 1041 1042 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1043 EXPECT_TRUE(background_window_state->IsFullscreen()); 1044 1045 // Do a second edge swipe top into screen. 1046 generator.GestureScrollSequence(gfx::Point(50, 0), 1047 gfx::Point(50, 100), 1048 base::TimeDelta::FromMilliseconds(20), 1049 10); 1050 1051 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1052 EXPECT_TRUE(background_window_state->IsFullscreen()); 1053 1054 DestroyMaximizeModeWindowManager(); 1055 } 1056 1057 // Test that an edge swipe from the bottom will end full screen mode. 1058 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromBottom) { 1059 gfx::Rect rect(10, 10, 200, 50); 1060 scoped_ptr<aura::Window> 1061 background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1062 scoped_ptr<aura::Window> 1063 foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1064 wm::WindowState* background_window_state = 1065 wm::GetWindowState(background_window.get()); 1066 wm::WindowState* foreground_window_state = 1067 wm::GetWindowState(foreground_window.get()); 1068 wm::ActivateWindow(foreground_window.get()); 1069 CreateMaximizeModeWindowManager(); 1070 1071 // Fullscreen both windows. 1072 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1073 background_window_state->OnWMEvent(&event); 1074 foreground_window_state->OnWMEvent(&event); 1075 EXPECT_TRUE(background_window_state->IsFullscreen()); 1076 EXPECT_TRUE(foreground_window_state->IsFullscreen()); 1077 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); 1078 1079 // Do an edge swipe bottom into screen. 1080 aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1081 int y = Shell::GetPrimaryRootWindow()->bounds().bottom(); 1082 generator.GestureScrollSequence(gfx::Point(50, y), 1083 gfx::Point(50, y - 100), 1084 base::TimeDelta::FromMilliseconds(20), 1085 10); 1086 1087 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1088 EXPECT_TRUE(background_window_state->IsFullscreen()); 1089 1090 DestroyMaximizeModeWindowManager(); 1091 } 1092 1093 // Test that an edge touch press at the top will end full screen mode. 1094 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtTop) { 1095 gfx::Rect rect(10, 10, 200, 50); 1096 scoped_ptr<aura::Window> 1097 background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1098 scoped_ptr<aura::Window> 1099 foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1100 wm::WindowState* background_window_state = 1101 wm::GetWindowState(background_window.get()); 1102 wm::WindowState* foreground_window_state = 1103 wm::GetWindowState(foreground_window.get()); 1104 wm::ActivateWindow(foreground_window.get()); 1105 CreateMaximizeModeWindowManager(); 1106 1107 // Fullscreen both windows. 1108 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1109 background_window_state->OnWMEvent(&event); 1110 foreground_window_state->OnWMEvent(&event); 1111 EXPECT_TRUE(background_window_state->IsFullscreen()); 1112 EXPECT_TRUE(foreground_window_state->IsFullscreen()); 1113 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); 1114 1115 // Touch tap on the top edge. 1116 aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1117 generator.GestureTapAt(gfx::Point(100, 0)); 1118 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1119 EXPECT_TRUE(background_window_state->IsFullscreen()); 1120 1121 // Try the same again and see that nothing changes. 1122 generator.GestureTapAt(gfx::Point(100, 0)); 1123 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1124 EXPECT_TRUE(background_window_state->IsFullscreen()); 1125 1126 DestroyMaximizeModeWindowManager(); 1127 } 1128 1129 // Test that an edge touch press at the bottom will end full screen mode. 1130 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtBottom) { 1131 gfx::Rect rect(10, 10, 200, 50); 1132 scoped_ptr<aura::Window> 1133 background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1134 scoped_ptr<aura::Window> 1135 foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1136 wm::WindowState* background_window_state = 1137 wm::GetWindowState(background_window.get()); 1138 wm::WindowState* foreground_window_state = 1139 wm::GetWindowState(foreground_window.get()); 1140 wm::ActivateWindow(foreground_window.get()); 1141 CreateMaximizeModeWindowManager(); 1142 1143 // Fullscreen both windows. 1144 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1145 background_window_state->OnWMEvent(&event); 1146 foreground_window_state->OnWMEvent(&event); 1147 EXPECT_TRUE(background_window_state->IsFullscreen()); 1148 EXPECT_TRUE(foreground_window_state->IsFullscreen()); 1149 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); 1150 1151 // Touch tap on the bottom edge. 1152 aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1153 generator.GestureTapAt( 1154 gfx::Point(100, Shell::GetPrimaryRootWindow()->bounds().bottom() - 1)); 1155 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1156 EXPECT_TRUE(background_window_state->IsFullscreen()); 1157 1158 // Try the same again and see that nothing changes. 1159 generator.GestureTapAt( 1160 gfx::Point(100, Shell::GetPrimaryRootWindow()->bounds().bottom() - 1)); 1161 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1162 EXPECT_TRUE(background_window_state->IsFullscreen()); 1163 1164 DestroyMaximizeModeWindowManager(); 1165 } 1166 1167 // Test that an edge swipe from the top on an immersive mode window will not end 1168 // full screen mode. 1169 TEST_F(MaximizeModeWindowManagerTest, NoExitImmersiveModeWithEdgeSwipeFromTop) { 1170 scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, 1171 gfx::Rect(10, 10, 200, 50))); 1172 wm::WindowState* window_state = wm::GetWindowState(window.get()); 1173 wm::ActivateWindow(window.get()); 1174 CreateMaximizeModeWindowManager(); 1175 1176 // Fullscreen the window. 1177 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1178 window_state->OnWMEvent(&event); 1179 EXPECT_TRUE(window_state->IsFullscreen()); 1180 EXPECT_FALSE(window_state->in_immersive_fullscreen()); 1181 EXPECT_EQ(window.get(), wm::GetActiveWindow()); 1182 1183 window_state->set_in_immersive_fullscreen(true); 1184 1185 // Do an edge swipe top into screen. 1186 aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1187 generator.GestureScrollSequence(gfx::Point(50, 0), 1188 gfx::Point(50, 100), 1189 base::TimeDelta::FromMilliseconds(20), 1190 10); 1191 1192 // It should have not exited full screen or immersive mode. 1193 EXPECT_TRUE(window_state->IsFullscreen()); 1194 EXPECT_TRUE(window_state->in_immersive_fullscreen()); 1195 1196 DestroyMaximizeModeWindowManager(); 1197 } 1198 1199 // Test that an edge swipe from the bottom will not end immersive mode. 1200 TEST_F(MaximizeModeWindowManagerTest, 1201 NoExitImmersiveModeWithEdgeSwipeFromBottom) { 1202 scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, 1203 gfx::Rect(10, 10, 200, 50))); 1204 wm::WindowState* window_state = wm::GetWindowState(window.get()); 1205 wm::ActivateWindow(window.get()); 1206 CreateMaximizeModeWindowManager(); 1207 1208 // Fullscreen the window. 1209 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1210 window_state->OnWMEvent(&event); 1211 EXPECT_TRUE(window_state->IsFullscreen()); 1212 EXPECT_FALSE(window_state->in_immersive_fullscreen()); 1213 EXPECT_EQ(window.get(), wm::GetActiveWindow()); 1214 window_state->set_in_immersive_fullscreen(true); 1215 EXPECT_TRUE(window_state->in_immersive_fullscreen()); 1216 1217 // Do an edge swipe bottom into screen. 1218 aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1219 int y = Shell::GetPrimaryRootWindow()->bounds().bottom(); 1220 generator.GestureScrollSequence(gfx::Point(50, y), 1221 gfx::Point(50, y - 100), 1222 base::TimeDelta::FromMilliseconds(20), 1223 10); 1224 1225 // The window should still be full screen and immersive. 1226 EXPECT_TRUE(window_state->IsFullscreen()); 1227 EXPECT_TRUE(window_state->in_immersive_fullscreen()); 1228 1229 DestroyMaximizeModeWindowManager(); 1230 } 1231 1232 #endif // OS_WIN 1233 1234 } // namespace ash 1235
