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/test_window_delegate.h" 28 #include "ui/aura/test/test_windows.h" 29 #include "ui/aura/window.h" 30 #include "ui/base/hit_test.h" 31 #include "ui/events/test/event_generator.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 maintain its state from before maximize mode. 796 window_state->OnWMEvent(&event); 797 EXPECT_FALSE(window_state->IsFullscreen()); 798 EXPECT_TRUE(window_state->IsMaximized()); 799 EXPECT_EQ(SHELF_AUTO_HIDE, 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 maintain its 829 // state. 830 EXPECT_FALSE(window_state->IsFullscreen()); 831 EXPECT_TRUE(window_state->IsMaximized()); 832 EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state()); 833 834 // After going into fullscreen mode, the shelf should be hidden. 835 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 836 window_state->OnWMEvent(&event); 837 EXPECT_TRUE(window_state->IsFullscreen()); 838 EXPECT_FALSE(window_state->IsMaximized()); 839 EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state()); 840 841 // With the destruction of the manager we should remain in full screen. 842 DestroyMaximizeModeWindowManager(); 843 EXPECT_TRUE(window_state->IsFullscreen()); 844 EXPECT_FALSE(window_state->IsMaximized()); 845 EXPECT_EQ(SHELF_HIDDEN, shelf->visibility_state()); 846 } 847 848 // Check that the full screen mode will stay active when the maximize mode is 849 // ended. 850 TEST_F(MaximizeModeWindowManagerTest, 851 FullScreenModeRemainsWhenCreatedInMaximizedMode) { 852 CreateMaximizeModeWindowManager(); 853 854 gfx::Rect rect(20, 140, 100, 100); 855 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 856 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 857 wm::WMEvent event_full_screen(wm::WM_EVENT_TOGGLE_FULLSCREEN); 858 window_state->OnWMEvent(&event_full_screen); 859 EXPECT_TRUE(window_state->IsFullscreen()); 860 861 // After the maximize mode manager is ended, full screen will remain. 862 DestroyMaximizeModeWindowManager(); 863 EXPECT_TRUE(window_state->IsFullscreen()); 864 } 865 866 // Check that the full screen mode will stay active throughout a maximzied mode 867 // session. 868 TEST_F(MaximizeModeWindowManagerTest, 869 FullScreenModeRemainsThroughMaximizeModeSwitch) { 870 gfx::Rect rect(20, 140, 100, 100); 871 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 872 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 873 wm::WMEvent event_full_screen(wm::WM_EVENT_TOGGLE_FULLSCREEN); 874 window_state->OnWMEvent(&event_full_screen); 875 EXPECT_TRUE(window_state->IsFullscreen()); 876 877 CreateMaximizeModeWindowManager(); 878 EXPECT_TRUE(window_state->IsFullscreen()); 879 DestroyMaximizeModeWindowManager(); 880 EXPECT_TRUE(window_state->IsFullscreen()); 881 } 882 883 // Check that an empty window does not get restored to a tiny size. 884 TEST_F(MaximizeModeWindowManagerTest, 885 CreateAndMaximizeInMaximizeModeShouldRetoreToGoodSizeGoingToDefault) { 886 CreateMaximizeModeWindowManager(); 887 gfx::Rect rect; 888 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 889 w1->Show(); 890 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 891 EXPECT_TRUE(window_state->IsMaximized()); 892 893 // There is a calling order in which the restore bounds can get set to an 894 // empty rectangle. We simulate this here. 895 window_state->SetRestoreBoundsInScreen(rect); 896 EXPECT_TRUE(window_state->GetRestoreBoundsInScreen().IsEmpty()); 897 898 // Setting the window to a new size will physically not change the window, 899 // but the restore size should get updated so that a restore later on will 900 // return to this size. 901 gfx::Rect requested_bounds(10, 20, 50, 70); 902 w1->SetBounds(requested_bounds); 903 EXPECT_TRUE(window_state->IsMaximized()); 904 EXPECT_EQ(requested_bounds.ToString(), 905 window_state->GetRestoreBoundsInScreen().ToString()); 906 907 DestroyMaximizeModeWindowManager(); 908 909 EXPECT_FALSE(window_state->IsMaximized()); 910 EXPECT_EQ(w1->bounds().ToString(), requested_bounds.ToString()); 911 } 912 913 // Check that snapping operations get ignored. 914 TEST_F(MaximizeModeWindowManagerTest, SnapModeTests) { 915 gfx::Rect rect(20, 140, 100, 100); 916 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 917 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 918 wm::WMEvent event_left(wm::WM_EVENT_SNAP_LEFT); 919 wm::WMEvent event_right(wm::WM_EVENT_SNAP_RIGHT); 920 window_state->OnWMEvent(&event_left); 921 EXPECT_TRUE(window_state->IsSnapped()); 922 923 CreateMaximizeModeWindowManager(); 924 925 // Fullscreen mode should now be off and it should not come back while in 926 // maximize mode. 927 EXPECT_FALSE(window_state->IsSnapped()); 928 EXPECT_TRUE(window_state->IsMaximized()); 929 window_state->OnWMEvent(&event_left); 930 EXPECT_FALSE(window_state->IsSnapped()); 931 EXPECT_TRUE(window_state->IsMaximized()); 932 window_state->OnWMEvent(&event_right); 933 EXPECT_FALSE(window_state->IsSnapped()); 934 EXPECT_TRUE(window_state->IsMaximized()); 935 936 DestroyMaximizeModeWindowManager(); 937 EXPECT_TRUE(window_state->IsSnapped()); 938 } 939 940 // Check that non maximizable windows cannot be dragged by the user. 941 TEST_F(MaximizeModeWindowManagerTest, TryToDesktopSizeDragUnmaximizable) { 942 gfx::Rect rect(10, 10, 100, 100); 943 scoped_ptr<aura::Window> window( 944 CreateFixedSizeNonMaximizableWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 945 EXPECT_EQ(rect.ToString(), window->bounds().ToString()); 946 947 // 1. Move the mouse over the caption and check that dragging the window does 948 // change the location. 949 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 950 generator.MoveMouseTo(gfx::Point(rect.x() + 2, rect.y() + 2)); 951 generator.PressLeftButton(); 952 generator.MoveMouseBy(10, 5); 953 RunAllPendingInMessageLoop(); 954 generator.ReleaseLeftButton(); 955 gfx::Point first_dragged_origin = window->bounds().origin(); 956 EXPECT_EQ(rect.x() + 10, first_dragged_origin.x()); 957 EXPECT_EQ(rect.y() + 5, first_dragged_origin.y()); 958 959 // 2. Check that turning on the manager will stop allowing the window from 960 // dragging. 961 ash::Shell::GetInstance()->maximize_mode_controller()-> 962 EnableMaximizeModeWindowManager(true); 963 gfx::Rect center_bounds(window->bounds()); 964 EXPECT_NE(rect.origin().ToString(), center_bounds.origin().ToString()); 965 generator.MoveMouseTo(gfx::Point(center_bounds.x() + 1, 966 center_bounds.y() + 1)); 967 generator.PressLeftButton(); 968 generator.MoveMouseBy(10, 5); 969 RunAllPendingInMessageLoop(); 970 generator.ReleaseLeftButton(); 971 EXPECT_EQ(center_bounds.x(), window->bounds().x()); 972 EXPECT_EQ(center_bounds.y(), window->bounds().y()); 973 ash::Shell::GetInstance()->maximize_mode_controller()-> 974 EnableMaximizeModeWindowManager(false); 975 976 // 3. Releasing the mazimize manager again will restore the window to its 977 // previous bounds and 978 generator.MoveMouseTo(gfx::Point(first_dragged_origin.x() + 1, 979 first_dragged_origin.y() + 1)); 980 generator.PressLeftButton(); 981 generator.MoveMouseBy(10, 5); 982 RunAllPendingInMessageLoop(); 983 generator.ReleaseLeftButton(); 984 EXPECT_EQ(first_dragged_origin.x() + 10, window->bounds().x()); 985 EXPECT_EQ(first_dragged_origin.y() + 5, window->bounds().y()); 986 } 987 988 // Test that overview is exited before entering / exiting maximize mode so that 989 // the window changes made by MaximizeModeWindowManager do not conflict with 990 // those made in WindowOverview. 991 TEST_F(MaximizeModeWindowManagerTest, ExitsOverview) { 992 // Bounds for windows we know can be controlled. 993 gfx::Rect rect1(10, 10, 200, 50); 994 gfx::Rect rect2(10, 60, 200, 50); 995 scoped_ptr<aura::Window> w1(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect1)); 996 scoped_ptr<aura::Window> w2(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect2)); 997 998 WindowSelectorController* window_selector_controller = 999 Shell::GetInstance()->window_selector_controller(); 1000 window_selector_controller->ToggleOverview(); 1001 ASSERT_TRUE(window_selector_controller->IsSelecting()); 1002 ash::MaximizeModeWindowManager* manager = CreateMaximizeModeWindowManager(); 1003 ASSERT_TRUE(manager); 1004 EXPECT_FALSE(window_selector_controller->IsSelecting()); 1005 1006 window_selector_controller->ToggleOverview(); 1007 ASSERT_TRUE(window_selector_controller->IsSelecting()); 1008 // Destroy the manager again and check that the windows return to their 1009 // previous state. 1010 DestroyMaximizeModeWindowManager(); 1011 EXPECT_FALSE(window_selector_controller->IsSelecting()); 1012 } 1013 1014 // Test that an edge swipe from the top will end full screen mode. 1015 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromTop) { 1016 gfx::Rect rect(10, 10, 200, 50); 1017 scoped_ptr<aura::Window> 1018 background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1019 scoped_ptr<aura::Window> 1020 foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1021 wm::WindowState* background_window_state = 1022 wm::GetWindowState(background_window.get()); 1023 wm::WindowState* foreground_window_state = 1024 wm::GetWindowState(foreground_window.get()); 1025 wm::ActivateWindow(foreground_window.get()); 1026 CreateMaximizeModeWindowManager(); 1027 1028 // Fullscreen both windows. 1029 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1030 background_window_state->OnWMEvent(&event); 1031 foreground_window_state->OnWMEvent(&event); 1032 EXPECT_TRUE(background_window_state->IsFullscreen()); 1033 EXPECT_TRUE(foreground_window_state->IsFullscreen()); 1034 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); 1035 1036 // Do an edge swipe top into screen. 1037 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1038 generator.GestureScrollSequence(gfx::Point(50, 0), 1039 gfx::Point(50, 100), 1040 base::TimeDelta::FromMilliseconds(20), 1041 10); 1042 1043 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1044 EXPECT_TRUE(background_window_state->IsFullscreen()); 1045 1046 // Do a second edge swipe top into screen. 1047 generator.GestureScrollSequence(gfx::Point(50, 0), 1048 gfx::Point(50, 100), 1049 base::TimeDelta::FromMilliseconds(20), 1050 10); 1051 1052 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1053 EXPECT_TRUE(background_window_state->IsFullscreen()); 1054 1055 DestroyMaximizeModeWindowManager(); 1056 } 1057 1058 // Test that an edge swipe from the bottom will end full screen mode. 1059 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeSwipeFromBottom) { 1060 gfx::Rect rect(10, 10, 200, 50); 1061 scoped_ptr<aura::Window> 1062 background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1063 scoped_ptr<aura::Window> 1064 foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1065 wm::WindowState* background_window_state = 1066 wm::GetWindowState(background_window.get()); 1067 wm::WindowState* foreground_window_state = 1068 wm::GetWindowState(foreground_window.get()); 1069 wm::ActivateWindow(foreground_window.get()); 1070 CreateMaximizeModeWindowManager(); 1071 1072 // Fullscreen both windows. 1073 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1074 background_window_state->OnWMEvent(&event); 1075 foreground_window_state->OnWMEvent(&event); 1076 EXPECT_TRUE(background_window_state->IsFullscreen()); 1077 EXPECT_TRUE(foreground_window_state->IsFullscreen()); 1078 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); 1079 1080 // Do an edge swipe bottom into screen. 1081 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1082 int y = Shell::GetPrimaryRootWindow()->bounds().bottom(); 1083 generator.GestureScrollSequence(gfx::Point(50, y), 1084 gfx::Point(50, y - 100), 1085 base::TimeDelta::FromMilliseconds(20), 1086 10); 1087 1088 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1089 EXPECT_TRUE(background_window_state->IsFullscreen()); 1090 1091 DestroyMaximizeModeWindowManager(); 1092 } 1093 1094 // Test that an edge touch press at the top will end full screen mode. 1095 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtTop) { 1096 gfx::Rect rect(10, 10, 200, 50); 1097 scoped_ptr<aura::Window> 1098 background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1099 scoped_ptr<aura::Window> 1100 foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1101 wm::WindowState* background_window_state = 1102 wm::GetWindowState(background_window.get()); 1103 wm::WindowState* foreground_window_state = 1104 wm::GetWindowState(foreground_window.get()); 1105 wm::ActivateWindow(foreground_window.get()); 1106 CreateMaximizeModeWindowManager(); 1107 1108 // Fullscreen both windows. 1109 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1110 background_window_state->OnWMEvent(&event); 1111 foreground_window_state->OnWMEvent(&event); 1112 EXPECT_TRUE(background_window_state->IsFullscreen()); 1113 EXPECT_TRUE(foreground_window_state->IsFullscreen()); 1114 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); 1115 1116 // Touch tap on the top edge. 1117 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1118 generator.GestureTapAt(gfx::Point(100, 0)); 1119 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1120 EXPECT_TRUE(background_window_state->IsFullscreen()); 1121 1122 // Try the same again and see that nothing changes. 1123 generator.GestureTapAt(gfx::Point(100, 0)); 1124 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1125 EXPECT_TRUE(background_window_state->IsFullscreen()); 1126 1127 DestroyMaximizeModeWindowManager(); 1128 } 1129 1130 // Test that an edge touch press at the bottom will end full screen mode. 1131 TEST_F(MaximizeModeWindowManagerTest, ExitFullScreenWithEdgeTouchAtBottom) { 1132 gfx::Rect rect(10, 10, 200, 50); 1133 scoped_ptr<aura::Window> 1134 background_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1135 scoped_ptr<aura::Window> 1136 foreground_window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, rect)); 1137 wm::WindowState* background_window_state = 1138 wm::GetWindowState(background_window.get()); 1139 wm::WindowState* foreground_window_state = 1140 wm::GetWindowState(foreground_window.get()); 1141 wm::ActivateWindow(foreground_window.get()); 1142 CreateMaximizeModeWindowManager(); 1143 1144 // Fullscreen both windows. 1145 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1146 background_window_state->OnWMEvent(&event); 1147 foreground_window_state->OnWMEvent(&event); 1148 EXPECT_TRUE(background_window_state->IsFullscreen()); 1149 EXPECT_TRUE(foreground_window_state->IsFullscreen()); 1150 EXPECT_EQ(foreground_window.get(), wm::GetActiveWindow()); 1151 1152 // Touch tap on the bottom edge. 1153 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1154 generator.GestureTapAt( 1155 gfx::Point(100, Shell::GetPrimaryRootWindow()->bounds().bottom() - 1)); 1156 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1157 EXPECT_TRUE(background_window_state->IsFullscreen()); 1158 1159 // Try the same again and see that nothing changes. 1160 generator.GestureTapAt( 1161 gfx::Point(100, Shell::GetPrimaryRootWindow()->bounds().bottom() - 1)); 1162 EXPECT_FALSE(foreground_window_state->IsFullscreen()); 1163 EXPECT_TRUE(background_window_state->IsFullscreen()); 1164 1165 DestroyMaximizeModeWindowManager(); 1166 } 1167 1168 // Test that an edge swipe from the top on an immersive mode window will not end 1169 // full screen mode. 1170 TEST_F(MaximizeModeWindowManagerTest, NoExitImmersiveModeWithEdgeSwipeFromTop) { 1171 scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, 1172 gfx::Rect(10, 10, 200, 50))); 1173 wm::WindowState* window_state = wm::GetWindowState(window.get()); 1174 wm::ActivateWindow(window.get()); 1175 CreateMaximizeModeWindowManager(); 1176 1177 // Fullscreen the window. 1178 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1179 window_state->OnWMEvent(&event); 1180 EXPECT_TRUE(window_state->IsFullscreen()); 1181 EXPECT_FALSE(window_state->in_immersive_fullscreen()); 1182 EXPECT_EQ(window.get(), wm::GetActiveWindow()); 1183 1184 window_state->set_in_immersive_fullscreen(true); 1185 1186 // Do an edge swipe top into screen. 1187 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1188 generator.GestureScrollSequence(gfx::Point(50, 0), 1189 gfx::Point(50, 100), 1190 base::TimeDelta::FromMilliseconds(20), 1191 10); 1192 1193 // It should have not exited full screen or immersive mode. 1194 EXPECT_TRUE(window_state->IsFullscreen()); 1195 EXPECT_TRUE(window_state->in_immersive_fullscreen()); 1196 1197 DestroyMaximizeModeWindowManager(); 1198 } 1199 1200 // Test that an edge swipe from the bottom will not end immersive mode. 1201 TEST_F(MaximizeModeWindowManagerTest, 1202 NoExitImmersiveModeWithEdgeSwipeFromBottom) { 1203 scoped_ptr<aura::Window> window(CreateWindow(ui::wm::WINDOW_TYPE_NORMAL, 1204 gfx::Rect(10, 10, 200, 50))); 1205 wm::WindowState* window_state = wm::GetWindowState(window.get()); 1206 wm::ActivateWindow(window.get()); 1207 CreateMaximizeModeWindowManager(); 1208 1209 // Fullscreen the window. 1210 wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 1211 window_state->OnWMEvent(&event); 1212 EXPECT_TRUE(window_state->IsFullscreen()); 1213 EXPECT_FALSE(window_state->in_immersive_fullscreen()); 1214 EXPECT_EQ(window.get(), wm::GetActiveWindow()); 1215 window_state->set_in_immersive_fullscreen(true); 1216 EXPECT_TRUE(window_state->in_immersive_fullscreen()); 1217 1218 // Do an edge swipe bottom into screen. 1219 ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow()); 1220 int y = Shell::GetPrimaryRootWindow()->bounds().bottom(); 1221 generator.GestureScrollSequence(gfx::Point(50, y), 1222 gfx::Point(50, y - 100), 1223 base::TimeDelta::FromMilliseconds(20), 1224 10); 1225 1226 // The window should still be full screen and immersive. 1227 EXPECT_TRUE(window_state->IsFullscreen()); 1228 EXPECT_TRUE(window_state->in_immersive_fullscreen()); 1229 1230 DestroyMaximizeModeWindowManager(); 1231 } 1232 1233 #endif // OS_WIN 1234 1235 } // namespace ash 1236
