1 // Copyright (c) 2013 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/dock/docked_window_resizer.h" 6 7 #include "ash/ash_switches.h" 8 #include "ash/root_window_controller.h" 9 #include "ash/screen_util.h" 10 #include "ash/shelf/shelf.h" 11 #include "ash/shelf/shelf_layout_manager.h" 12 #include "ash/shelf/shelf_model.h" 13 #include "ash/shelf/shelf_types.h" 14 #include "ash/shelf/shelf_widget.h" 15 #include "ash/shell.h" 16 #include "ash/shell_window_ids.h" 17 #include "ash/test/ash_test_base.h" 18 #include "ash/test/cursor_manager_test_api.h" 19 #include "ash/test/shell_test_api.h" 20 #include "ash/test/test_shelf_delegate.h" 21 #include "ash/wm/coordinate_conversion.h" 22 #include "ash/wm/dock/docked_window_layout_manager.h" 23 #include "ash/wm/drag_window_resizer.h" 24 #include "ash/wm/panels/panel_layout_manager.h" 25 #include "ash/wm/window_state.h" 26 #include "ash/wm/window_util.h" 27 #include "ash/wm/wm_event.h" 28 #include "base/command_line.h" 29 #include "ui/aura/client/aura_constants.h" 30 #include "ui/aura/client/window_tree_client.h" 31 #include "ui/aura/test/event_generator.h" 32 #include "ui/aura/test/test_window_delegate.h" 33 #include "ui/aura/window_event_dispatcher.h" 34 #include "ui/base/hit_test.h" 35 #include "ui/base/ui_base_types.h" 36 #include "ui/views/widget/widget.h" 37 #include "ui/wm/core/window_util.h" 38 39 namespace ash { 40 41 class DockedWindowResizerTest 42 : public test::AshTestBase, 43 public testing::WithParamInterface<ui::wm::WindowType> { 44 public: 45 DockedWindowResizerTest() : model_(NULL), window_type_(GetParam()) {} 46 virtual ~DockedWindowResizerTest() {} 47 48 virtual void SetUp() OVERRIDE { 49 AshTestBase::SetUp(); 50 UpdateDisplay("600x400"); 51 test::ShellTestApi test_api(Shell::GetInstance()); 52 model_ = test_api.shelf_model(); 53 } 54 55 virtual void TearDown() OVERRIDE { 56 AshTestBase::TearDown(); 57 } 58 59 protected: 60 enum DockedEdge { 61 DOCKED_EDGE_NONE, 62 DOCKED_EDGE_LEFT, 63 DOCKED_EDGE_RIGHT, 64 }; 65 66 int ideal_width() const { return DockedWindowLayoutManager::kIdealWidth; } 67 int min_dock_gap() const { return DockedWindowLayoutManager::kMinDockGap; } 68 int max_width() const { return DockedWindowLayoutManager::kMaxDockWidth; } 69 int docked_width(const DockedWindowLayoutManager* layout_manager) const { 70 return layout_manager->docked_width_; 71 } 72 int docked_alignment(const DockedWindowLayoutManager* layout_manager) const { 73 return layout_manager->alignment_; 74 } 75 aura::Window* CreateTestWindow(const gfx::Rect& bounds) { 76 aura::Window* window = CreateTestWindowInShellWithDelegateAndType( 77 &delegate_, 78 window_type_, 79 0, 80 bounds); 81 if (window_type_ == ui::wm::WINDOW_TYPE_PANEL) { 82 test::TestShelfDelegate* shelf_delegate = 83 test::TestShelfDelegate::instance(); 84 shelf_delegate->AddShelfItem(window); 85 PanelLayoutManager* manager = static_cast<PanelLayoutManager*>( 86 Shell::GetContainer(window->GetRootWindow(), 87 kShellWindowId_PanelContainer)->layout_manager()); 88 manager->Relayout(); 89 } 90 return window; 91 } 92 93 aura::Window* CreateModalWindow(const gfx::Rect& bounds) { 94 aura::Window* window = new aura::Window(&delegate_); 95 window->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_SYSTEM); 96 window->SetType(ui::wm::WINDOW_TYPE_NORMAL); 97 window->Init(aura::WINDOW_LAYER_TEXTURED); 98 window->Show(); 99 100 if (bounds.IsEmpty()) { 101 ParentWindowInPrimaryRootWindow(window); 102 } else { 103 gfx::Display display = 104 Shell::GetScreen()->GetDisplayMatching(bounds); 105 aura::Window* root = ash::Shell::GetInstance()->display_controller()-> 106 GetRootWindowForDisplayId(display.id()); 107 gfx::Point origin = bounds.origin(); 108 wm::ConvertPointFromScreen(root, &origin); 109 window->SetBounds(gfx::Rect(origin, bounds.size())); 110 aura::client::ParentWindowWithContext(window, root, bounds); 111 } 112 return window; 113 } 114 115 static WindowResizer* CreateSomeWindowResizer( 116 aura::Window* window, 117 const gfx::Point& point_in_parent, 118 int window_component) { 119 return CreateWindowResizer( 120 window, 121 point_in_parent, 122 window_component, 123 aura::client::WINDOW_MOVE_SOURCE_MOUSE).release(); 124 } 125 126 void DragStart(aura::Window* window) { 127 DragStartAtOffsetFromWindowOrigin(window, 0, 0); 128 } 129 130 void DragStartAtOffsetFromWindowOrigin(aura::Window* window, 131 int dx, int dy) { 132 initial_location_in_parent_ = 133 window->bounds().origin() + gfx::Vector2d(dx, dy); 134 resizer_.reset(CreateSomeWindowResizer(window, 135 initial_location_in_parent_, 136 HTCAPTION)); 137 ASSERT_TRUE(resizer_.get()); 138 } 139 140 void ResizeStartAtOffsetFromWindowOrigin(aura::Window* window, 141 int dx, int dy, 142 int window_component) { 143 initial_location_in_parent_ = 144 window->bounds().origin() + gfx::Vector2d(dx, dy); 145 resizer_.reset(CreateSomeWindowResizer(window, 146 initial_location_in_parent_, 147 window_component)); 148 ASSERT_TRUE(resizer_.get()); 149 } 150 151 void DragMove(int dx, int dy) { 152 resizer_->Drag(initial_location_in_parent_ + gfx::Vector2d(dx, dy), 0); 153 } 154 155 void DragEnd() { 156 resizer_->CompleteDrag(); 157 resizer_.reset(); 158 } 159 160 void DragRevert() { 161 resizer_->RevertDrag(); 162 resizer_.reset(); 163 } 164 165 // Panels are parented by panel container during drags. 166 // All other windows that are tested here are parented by dock container 167 // during drags. 168 int CorrectContainerIdDuringDrag() { 169 if (window_type_ == ui::wm::WINDOW_TYPE_PANEL) 170 return kShellWindowId_PanelContainer; 171 return kShellWindowId_DockedContainer; 172 } 173 174 // Test dragging the window vertically (to detach if it is a panel) and then 175 // horizontally to the edge with an added offset from the edge of |dx|. 176 void DragRelativeToEdge(DockedEdge edge, 177 aura::Window* window, 178 int dx) { 179 DragVerticallyAndRelativeToEdge( 180 edge, 181 window, 182 dx, 183 window_type_ == ui::wm::WINDOW_TYPE_PANEL ? -100 : 20, 184 25, 185 5); 186 } 187 188 void DragToVerticalPositionAndToEdge(DockedEdge edge, 189 aura::Window* window, 190 int y) { 191 DragToVerticalPositionRelativeToEdge(edge, window, 0, y); 192 } 193 194 void DragToVerticalPositionRelativeToEdge(DockedEdge edge, 195 aura::Window* window, 196 int dx, 197 int y) { 198 gfx::Rect initial_bounds = window->GetBoundsInScreen(); 199 DragVerticallyAndRelativeToEdge(edge, 200 window, 201 dx, y - initial_bounds.y(), 202 25, 5); 203 } 204 205 // Detach if our window is a panel, then drag it vertically by |dy| and 206 // horizontally to the edge with an added offset from the edge of |dx|. 207 void DragVerticallyAndRelativeToEdge(DockedEdge edge, 208 aura::Window* window, 209 int dx, int dy, 210 int grab_x, int grab_y) { 211 gfx::Rect initial_bounds = window->GetBoundsInScreen(); 212 // avoid snap by clicking away from the border 213 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(window, 214 grab_x, grab_y)); 215 216 gfx::Rect work_area = 217 Shell::GetScreen()->GetDisplayNearestWindow(window).work_area(); 218 gfx::Point initial_location_in_screen = initial_location_in_parent_; 219 wm::ConvertPointToScreen(window->parent(), &initial_location_in_screen); 220 // Drag the window left or right to the edge (or almost to it). 221 if (edge == DOCKED_EDGE_LEFT) 222 dx += work_area.x() - initial_location_in_screen.x(); 223 else if (edge == DOCKED_EDGE_RIGHT) 224 dx += work_area.right() - 1 - initial_location_in_screen.x(); 225 DragMove(dx, dy); 226 EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id()); 227 // Release the mouse and the panel should be attached to the dock. 228 DragEnd(); 229 230 // x-coordinate can get adjusted by snapping or sticking. 231 // y-coordinate could be changed by possible automatic layout if docked. 232 if (window->parent()->id() != kShellWindowId_DockedContainer && 233 !wm::GetWindowState(window)->HasRestoreBounds()) { 234 EXPECT_EQ(initial_bounds.y() + dy, window->GetBoundsInScreen().y()); 235 } 236 } 237 238 bool test_panels() const { return window_type_ == ui::wm::WINDOW_TYPE_PANEL; } 239 240 aura::test::TestWindowDelegate* delegate() { 241 return &delegate_; 242 } 243 244 const gfx::Point& initial_location_in_parent() const { 245 return initial_location_in_parent_; 246 } 247 248 private: 249 scoped_ptr<WindowResizer> resizer_; 250 ShelfModel* model_; 251 ui::wm::WindowType window_type_; 252 aura::test::TestWindowDelegate delegate_; 253 254 // Location at start of the drag in |window->parent()|'s coordinates. 255 gfx::Point initial_location_in_parent_; 256 257 DISALLOW_COPY_AND_ASSIGN(DockedWindowResizerTest); 258 }; 259 260 // Verifies a window can be dragged and attached to the dock. 261 TEST_P(DockedWindowResizerTest, AttachRightPrecise) { 262 if (!SupportsHostWindowResize()) 263 return; 264 265 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 266 DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0); 267 268 // The window should be docked at the right edge. 269 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 270 window->GetBoundsInScreen().right()); 271 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 272 } 273 274 // Verifies a window can be dragged and attached to the dock 275 // even if pointer overshoots the screen edge by a few pixels (sticky edge) 276 TEST_P(DockedWindowResizerTest, AttachRightOvershoot) { 277 if (!SupportsHostWindowResize()) 278 return; 279 280 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 281 DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), +4); 282 283 // The window should be docked at the right edge. 284 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 285 window->GetBoundsInScreen().right()); 286 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 287 } 288 289 // Verifies a window can be dragged and then if a pointer is not quite reaching 290 // the screen edge the window does not get docked and stays in the desktop. 291 TEST_P(DockedWindowResizerTest, AttachRightUndershoot) { 292 if (!SupportsHostWindowResize()) 293 return; 294 295 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 296 // Grabbing at 70px ensures that at least 30% of the window is in screen, 297 // otherwise the window would be adjusted in 298 // WorkspaceLayoutManager::AdjustWindowBoundsWhenAdded. 299 const int kGrabOffsetX = 70; 300 const int kUndershootBy = 1; 301 DragVerticallyAndRelativeToEdge(DOCKED_EDGE_RIGHT, 302 window.get(), 303 -kUndershootBy, test_panels() ? -100 : 20, 304 kGrabOffsetX, 5); 305 306 // The window right should be past the screen edge but not docked. 307 // Initial touch point is 70px to the right which helps to find where the edge 308 // should be. 309 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right() + 310 window->bounds().width() - kGrabOffsetX - kUndershootBy - 1, 311 window->GetBoundsInScreen().right()); 312 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 313 } 314 315 // Verifies a window can be dragged and attached to the dock. 316 TEST_P(DockedWindowResizerTest, AttachLeftPrecise) { 317 if (!SupportsHostWindowResize()) 318 return; 319 320 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 321 DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), 0); 322 323 // The window should be docked at the left edge. 324 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().x(), 325 window->GetBoundsInScreen().x()); 326 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 327 } 328 329 // Verifies a window can be dragged and attached to the dock 330 // even if pointer overshoots the screen edge by a few pixels (sticky edge) 331 TEST_P(DockedWindowResizerTest, AttachLeftOvershoot) { 332 if (!SupportsHostWindowResize()) 333 return; 334 335 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 336 DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), -4); 337 338 // The window should be docked at the left edge. 339 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().x(), 340 window->GetBoundsInScreen().x()); 341 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 342 } 343 344 // Verifies a window can be dragged and then if a pointer is not quite reaching 345 // the screen edge the window does not get docked and stays in the desktop. 346 TEST_P(DockedWindowResizerTest, AttachLeftUndershoot) { 347 if (!SupportsHostWindowResize()) 348 return; 349 350 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 351 gfx::Rect initial_bounds(window->bounds()); 352 DragRelativeToEdge(DOCKED_EDGE_LEFT, window.get(), 1); 353 354 // The window should be crossing the screen edge but not docked. 355 int expected_x = initial_bounds.x() - initial_location_in_parent().x() + 1; 356 EXPECT_EQ(expected_x, window->GetBoundsInScreen().x()); 357 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 358 } 359 360 // Dock on the right side, change shelf alignment, check that windows move to 361 // the opposite side. 362 TEST_P(DockedWindowResizerTest, AttachRightChangeShelf) { 363 if (!SupportsHostWindowResize()) 364 return; 365 366 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 367 DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0); 368 369 // The window should be docked at the right edge. 370 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 371 window->GetBoundsInScreen().right()); 372 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 373 374 // set launcher shelf to be aligned on the right 375 ash::Shell* shell = ash::Shell::GetInstance(); 376 shell->SetShelfAlignment(SHELF_ALIGNMENT_RIGHT, 377 shell->GetPrimaryRootWindow()); 378 // The window should have moved and get attached to the left dock. 379 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().x(), 380 window->GetBoundsInScreen().x()); 381 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 382 383 // set launcher shelf to be aligned on the left 384 shell->SetShelfAlignment(SHELF_ALIGNMENT_LEFT, 385 shell->GetPrimaryRootWindow()); 386 // The window should have moved and get attached to the right edge. 387 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 388 window->GetBoundsInScreen().right()); 389 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 390 391 // set launcher shelf to be aligned at the bottom 392 shell->SetShelfAlignment(SHELF_ALIGNMENT_BOTTOM, 393 shell->GetPrimaryRootWindow()); 394 // The window should stay in the right edge. 395 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 396 window->GetBoundsInScreen().right()); 397 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 398 } 399 400 // Dock on the right side, try to undock, then drag more to really undock 401 TEST_P(DockedWindowResizerTest, AttachTryDetach) { 402 if (!SupportsHostWindowResize()) 403 return; 404 405 scoped_ptr<aura::Window> window(CreateTestWindow( 406 gfx::Rect(0, 0, ideal_width() + 10, 201))); 407 DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0); 408 409 // The window should be docked at the right edge. 410 // Its width should shrink to ideal width. 411 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 412 window->GetBoundsInScreen().right()); 413 EXPECT_EQ(ideal_width(), window->GetBoundsInScreen().width()); 414 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 415 416 // Try to detach by dragging left less than kSnapToDockDistance. 417 // The window should stay docked. 418 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin( 419 window.get(), 10, 0)); 420 DragMove(-4, -10); 421 // Release the mouse and the window should be still attached to the dock. 422 DragEnd(); 423 424 // The window should be still attached to the right edge. 425 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 426 window->GetBoundsInScreen().right()); 427 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 428 429 // Try to detach by dragging left by kSnapToDockDistance or more. 430 // The window should get undocked. 431 const int left_edge = window->bounds().x(); 432 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin( 433 window.get(), 10, 0)); 434 DragMove(-32, -10); 435 // Release the mouse and the window should be no longer attached to the dock. 436 DragEnd(); 437 438 // The window should be floating on the desktop again and moved to the left. 439 EXPECT_EQ(left_edge - 32, window->GetBoundsInScreen().x()); 440 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 441 } 442 443 // Dock on the right side, and undock by dragging the right edge of the window 444 // header. This test is useful because both the position of the dragged window 445 // and the position of the mouse are used in determining whether a window should 446 // be undocked. 447 TEST_P(DockedWindowResizerTest, AttachTryDetachDragRightEdgeOfHeader) { 448 if (!SupportsHostWindowResize()) 449 return; 450 451 scoped_ptr<aura::Window> window(CreateTestWindow( 452 gfx::Rect(0, 0, ideal_width() + 10, 201))); 453 DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0); 454 455 // The window should be docked at the right edge. 456 // Its width should shrink to ideal width. 457 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 458 window->GetBoundsInScreen().right()); 459 EXPECT_EQ(ideal_width(), window->GetBoundsInScreen().width()); 460 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 461 462 // Try to detach by dragging left less than kSnapToDockDistance. 463 // The window should stay docked. 464 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin( 465 window.get(), ideal_width() - 10, 0)); 466 DragMove(-4, -10); 467 // Release the mouse and the window should be still attached to the dock. 468 DragEnd(); 469 470 // The window should be still attached to the right edge. 471 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 472 window->GetBoundsInScreen().right()); 473 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 474 475 // Try to detach by dragging left by kSnapToDockDistance or more. 476 // The window should get undocked. 477 const int left_edge = window->bounds().x(); 478 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin( 479 window.get(), ideal_width() - 10, 0)); 480 DragMove(-32, -10); 481 // Release the mouse and the window should be no longer attached to the dock. 482 DragEnd(); 483 484 // The window should be floating on the desktop again and moved to the left. 485 EXPECT_EQ(left_edge - 32, window->GetBoundsInScreen().x()); 486 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 487 } 488 489 // Minimize a docked window, then restore it and check that it is still docked. 490 TEST_P(DockedWindowResizerTest, AttachMinimizeRestore) { 491 if (!SupportsHostWindowResize()) 492 return; 493 494 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 495 DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0); 496 497 // The window should be docked at the right edge. 498 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 499 window->GetBoundsInScreen().right()); 500 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 501 502 wm::WindowState* window_state = wm::GetWindowState(window.get()); 503 // Minimize the window, it should be hidden. 504 window_state->Minimize(); 505 RunAllPendingInMessageLoop(); 506 EXPECT_FALSE(window->IsVisible()); 507 EXPECT_TRUE(window_state->IsMinimized()); 508 // Restore the window; window should be visible. 509 window_state->Restore(); 510 RunAllPendingInMessageLoop(); 511 EXPECT_TRUE(window->IsVisible()); 512 EXPECT_TRUE(window_state->IsNormalStateType()); 513 } 514 515 // Maximize a docked window and check that it is maximized and no longer docked. 516 TEST_P(DockedWindowResizerTest, AttachMaximize) { 517 if (!SupportsHostWindowResize()) 518 return; 519 520 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 521 DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0); 522 523 // The window should be docked at the right edge. 524 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 525 window->GetBoundsInScreen().right()); 526 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 527 528 wm::WindowState* window_state = wm::GetWindowState(window.get()); 529 // Maximize the window, it should get undocked and maximized in a desktop. 530 window_state->Maximize(); 531 RunAllPendingInMessageLoop(); 532 EXPECT_TRUE(window->IsVisible()); 533 EXPECT_TRUE(window_state->IsMaximized()); 534 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 535 } 536 537 // Dock two windows, undock one, check that the other one is still docked. 538 TEST_P(DockedWindowResizerTest, AttachTwoWindows) { 539 if (!SupportsHostWindowResize()) 540 return; 541 UpdateDisplay("600x600"); 542 543 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 544 scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 545 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 546 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 50); 547 548 // Docking second window should not minimize the first. 549 wm::WindowState* window_state1 = wm::GetWindowState(w1.get()); 550 EXPECT_FALSE(window_state1->IsMinimized()); 551 552 // Both windows should be docked at the right edge. 553 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 554 w1->GetBoundsInScreen().right()); 555 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 556 557 EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().right(), 558 w2->GetBoundsInScreen().right()); 559 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 560 561 // Detach by dragging left (should get undocked). 562 const int left_edge = w2->bounds().x(); 563 ASSERT_NO_FATAL_FAILURE(DragStart(w2.get())); 564 // Drag up as well to avoid attaching panels to launcher shelf. 565 DragMove(-32, -100); 566 // Release the mouse and the window should be no longer attached to the edge. 567 DragEnd(); 568 569 // The first window should be still docked. 570 EXPECT_FALSE(window_state1->IsMinimized()); 571 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 572 w1->GetBoundsInScreen().right()); 573 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 574 575 // The window should be floating on the desktop again and moved to the left. 576 EXPECT_EQ(left_edge - 32, w2->GetBoundsInScreen().x()); 577 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 578 } 579 580 // Create two windows, dock one and change shelf to auto-hide. 581 TEST_P(DockedWindowResizerTest, AttachOneAutoHideShelf) { 582 if (!SupportsHostWindowResize()) 583 return; 584 585 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 586 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 587 588 // w1 should be docked at the right edge. 589 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 590 w1->GetBoundsInScreen().right()); 591 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 592 593 scoped_ptr<aura::Window> w2(CreateTestWindowInShellWithDelegateAndType( 594 NULL, ui::wm::WINDOW_TYPE_NORMAL, 0, gfx::Rect(20, 20, 150, 20))); 595 wm::GetWindowState(w2.get())->Maximize(); 596 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 597 EXPECT_TRUE(wm::GetWindowState(w2.get())->IsMaximized()); 598 599 gfx::Rect work_area = 600 Shell::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area(); 601 DockedWindowLayoutManager* manager = 602 static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager()); 603 604 // Docked window should be centered vertically in the work area. 605 EXPECT_EQ(work_area.CenterPoint().y(), w1->bounds().CenterPoint().y()); 606 // Docked background should extend to the bottom of work area. 607 EXPECT_EQ(work_area.bottom(), manager->docked_bounds().bottom()); 608 609 // set launcher shelf to be aligned on the right 610 ash::Shell* shell = ash::Shell::GetInstance(); 611 shell->SetShelfAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS, 612 shell->GetPrimaryRootWindow()); 613 work_area = 614 Shell::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area(); 615 // Docked window should be centered vertically in the work area. 616 EXPECT_EQ(work_area.CenterPoint().y(), w1->bounds().CenterPoint().y()); 617 // Docked background should extend to the bottom of work area. 618 EXPECT_EQ(work_area.bottom(), manager->docked_bounds().bottom()); 619 } 620 621 // Dock one window, try to dock another window on the opposite side (should not 622 // dock). 623 TEST_P(DockedWindowResizerTest, AttachOnTwoSides) { 624 if (!SupportsHostWindowResize()) 625 return; 626 627 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 628 scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 629 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 630 gfx::Rect initial_bounds(w2->bounds()); 631 DragToVerticalPositionAndToEdge(DOCKED_EDGE_LEFT, w2.get(), 50); 632 633 // The first window should be docked at the right edge. 634 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 635 w1->GetBoundsInScreen().right()); 636 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 637 638 // The second window should be near the left edge but not snapped. 639 // Normal window will get side-maximized while panels will not. 640 int expected_x = test_panels() ? 641 (initial_bounds.x() - initial_location_in_parent().x()) : 0; 642 EXPECT_EQ(expected_x, w2->GetBoundsInScreen().x()); 643 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 644 } 645 646 // Tests that reverting a drag restores docked state if a window was docked. 647 TEST_P(DockedWindowResizerTest, RevertDragRestoresAttachment) { 648 if (!SupportsHostWindowResize()) 649 return; 650 651 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 652 DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0); 653 654 // The window should be docked at the right edge. 655 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 656 window->GetBoundsInScreen().right()); 657 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 658 659 // Drag the window out but revert the drag 660 ASSERT_NO_FATAL_FAILURE(DragStart(window.get())); 661 DragMove(-50, 0); 662 DragRevert(); 663 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 664 665 // Detach window. 666 ASSERT_NO_FATAL_FAILURE(DragStart(window.get())); 667 DragMove(-50, 0); 668 DragEnd(); 669 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 670 } 671 672 // Tests that reverting drag restores undocked state if a window was not docked. 673 TEST_P(DockedWindowResizerTest, RevertDockedDragRevertsAttachment) { 674 if (!SupportsHostWindowResize()) 675 return; 676 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 677 aura::Window* dock_container = Shell::GetContainer( 678 window->GetRootWindow(), 679 kShellWindowId_DockedContainer); 680 DockedWindowLayoutManager* manager = 681 static_cast<DockedWindowLayoutManager*>(dock_container->layout_manager()); 682 int previous_container_id = window->parent()->id(); 683 // Drag the window out but revert the drag 684 ASSERT_NO_FATAL_FAILURE(DragStart(window.get())); 685 DragMove(-50 - window->bounds().x(), 50 - window->bounds().y()); 686 EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id()); 687 DragRevert(); 688 EXPECT_EQ(previous_container_id, window->parent()->id()); 689 EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager)); 690 691 // Drag a window to the left so that it overlaps the screen edge. 692 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin( 693 window.get(), 694 window->bounds().width()/2 + 10, 695 0)); 696 DragMove(-50 - window->bounds().x(), 50 - window->bounds().y()); 697 DragEnd(); 698 // The window now overlaps the left screen edge but is not docked. 699 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 700 EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager)); 701 EXPECT_LT(window->bounds().x(), 0); 702 EXPECT_GT(window->bounds().right(), 0); 703 704 // Drag the window further left and revert the drag. 705 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin( 706 window.get(), 707 window->bounds().width()/2 + 10, 708 0)); 709 DragMove(-10, 10); 710 DragRevert(); 711 // The window should be in default container and not docked. 712 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 713 // Docked area alignment should be cleared. 714 EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager)); 715 } 716 717 // Move a docked window to the second display 718 TEST_P(DockedWindowResizerTest, DragAcrossDisplays) { 719 if (!SupportsMultipleDisplays()) 720 return; 721 722 UpdateDisplay("800x800,800x800"); 723 aura::Window::Windows root_windows = Shell::GetAllRootWindows(); 724 EXPECT_EQ(2, static_cast<int>(root_windows.size())); 725 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 726 gfx::Rect initial_bounds = window->GetBoundsInScreen(); 727 EXPECT_EQ(root_windows[0], window->GetRootWindow()); 728 729 DragRelativeToEdge(DOCKED_EDGE_RIGHT, window.get(), 0); 730 // The window should be docked at the right edge. 731 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 732 window->GetBoundsInScreen().right()); 733 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 734 735 // Try dragging to the right - enough to get it peeking at the other screen 736 // but not enough to land in the other screen. 737 // The window should stay on the left screen. 738 ASSERT_NO_FATAL_FAILURE(DragStart(window.get())); 739 DragMove(100, 0); 740 EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id()); 741 DragEnd(); 742 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 743 window->GetBoundsInScreen().right()); 744 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 745 EXPECT_EQ(root_windows[0], window->GetRootWindow()); 746 747 // Undock and move to the right - enough to get the mouse pointer past the 748 // edge of the screen and into the second screen. The window should now be 749 // in the second screen and not docked. 750 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin( 751 window.get(), 752 window->bounds().width()/2 + 10, 753 0)); 754 DragMove(window->bounds().width()/2 - 5, 0); 755 EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id()); 756 DragEnd(); 757 EXPECT_NE(window->GetRootWindow()->GetBoundsInScreen().right(), 758 window->GetBoundsInScreen().right()); 759 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 760 EXPECT_EQ(root_windows[1], window->GetRootWindow()); 761 762 // Keep dragging it to the right until its left edge touches the screen edge. 763 // The window should now be in the second screen and not docked. 764 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin( 765 window.get(), 766 window->bounds().width()/2 + 10, 767 0)); 768 DragMove(window->GetRootWindow()->GetBoundsInScreen().x() - 769 window->GetBoundsInScreen().x(), 770 0); 771 EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id()); 772 DragEnd(); 773 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().x(), 774 window->GetBoundsInScreen().x()); 775 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 776 EXPECT_EQ(root_windows[1], window->GetRootWindow()); 777 } 778 779 // Dock two windows, undock one. 780 // Test the docked windows area size and default container resizing. 781 TEST_P(DockedWindowResizerTest, AttachTwoWindowsDetachOne) { 782 if (!SupportsHostWindowResize()) 783 return; 784 UpdateDisplay("600x600"); 785 786 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 787 scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 201))); 788 // Work area should cover the whole screen. 789 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(), 790 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width()); 791 792 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 793 // A window should be docked at the right edge. 794 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 795 w1->GetBoundsInScreen().right()); 796 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 797 DockedWindowLayoutManager* manager = 798 static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager()); 799 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 800 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 801 802 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 100); 803 // Both windows should now be docked at the right edge. 804 EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().right(), 805 w2->GetBoundsInScreen().right()); 806 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 807 // Dock width should be set to a wider window. 808 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 809 EXPECT_EQ(std::max(w1->bounds().width(), w2->bounds().width()), 810 docked_width(manager)); 811 812 // Try to detach by dragging left a bit (should not get undocked). 813 // This would normally detach a single docked window but since we have another 814 // window and the mouse pointer does not leave the dock area the window 815 // should stay docked. 816 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(w2.get(), 60, 0)); 817 // Drag up as well as left to avoid attaching panels to launcher shelf. 818 DragMove(-40, -40); 819 // Release the mouse and the window should be still attached to the edge. 820 DragEnd(); 821 822 // The first window should be still docked. 823 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 824 w1->GetBoundsInScreen().right()); 825 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 826 827 // The second window should be still docked. 828 EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().right(), 829 w2->GetBoundsInScreen().right()); 830 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 831 832 // Detach by dragging left more (should get undocked). 833 const int left_edge = w2->bounds().x(); 834 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin( 835 w2.get(), 836 w2->bounds().width()/2 + 10, 837 0)); 838 // Drag up as well to avoid attaching panels to launcher shelf. 839 const int drag_x = -(w2->bounds().width()/2 + 20); 840 DragMove(drag_x, -100); 841 // Release the mouse and the window should be no longer attached to the edge. 842 DragEnd(); 843 844 // The second window should be floating on the desktop again. 845 EXPECT_EQ(left_edge + drag_x, w2->bounds().x()); 846 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 847 // Dock width should be set to remaining single docked window. 848 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 849 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 850 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 851 } 852 853 // Dock one of the windows. Maximize other testing desktop resizing. 854 TEST_P(DockedWindowResizerTest, AttachWindowMaximizeOther) { 855 if (!SupportsHostWindowResize()) 856 return; 857 858 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 859 scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 201))); 860 // Work area should cover the whole screen. 861 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(), 862 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width()); 863 864 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 865 // A window should be docked at the right edge. 866 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 867 w1->GetBoundsInScreen().right()); 868 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 869 DockedWindowLayoutManager* manager = 870 static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager()); 871 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 872 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 873 874 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(w2.get(), 25, 5)); 875 DragMove(w2->GetRootWindow()->bounds().width() 876 -w2->bounds().width() 877 -(w2->bounds().width()/2 + 20) 878 -w2->bounds().x(), 879 50 - w2->bounds().y()); 880 DragEnd(); 881 // The first window should be still docked. 882 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 883 w1->GetBoundsInScreen().right()); 884 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 885 886 // The second window should be floating on the desktop. 887 EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().right() - 888 (w2->bounds().width()/2 + 20), 889 w2->GetBoundsInScreen().right()); 890 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 891 // Dock width should be set to remaining single docked window. 892 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 893 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 894 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 895 // Desktop work area should now shrink. 896 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() - 897 docked_width(manager) - min_dock_gap(), 898 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width()); 899 900 // Maximize the second window - Maximized area should be shrunk. 901 const gfx::Rect restored_bounds = w2->bounds(); 902 wm::WindowState* w2_state = wm::GetWindowState(w2.get()); 903 w2_state->Maximize(); 904 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() - 905 docked_width(manager) - min_dock_gap(), 906 w2->bounds().width()); 907 908 // Detach the first window (this should require very little drag). 909 ASSERT_NO_FATAL_FAILURE(DragStart(w1.get())); 910 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 911 DragMove(-35, 10); 912 // Alignment is set to "NONE" when drag starts. 913 EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager)); 914 // Release the mouse and the window should be no longer attached to the edge. 915 DragEnd(); 916 EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager)); 917 // Dock should get shrunk and desktop should get expanded. 918 EXPECT_EQ(kShellWindowId_DefaultContainer, w1->parent()->id()); 919 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 920 EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager)); 921 EXPECT_EQ(0, docked_width(manager)); 922 // The second window should now get resized and take up the whole screen. 923 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(), 924 w2->bounds().width()); 925 926 // Dock the first window to the left edge. 927 // Click at an offset from origin to prevent snapping. 928 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(w1.get(), 10, 0)); 929 // Drag left to get pointer touching the screen edge. 930 DragMove(-w1->bounds().x() - 10, 0); 931 // Alignment set to "NONE" during the drag of the window when none are docked. 932 EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager)); 933 // Release the mouse and the window should be now attached to the edge. 934 DragEnd(); 935 // Dock should get expanded and desktop should get shrunk. 936 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 937 EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager)); 938 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 939 // Second window should still be in the desktop. 940 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 941 // Maximized window should be shrunk. 942 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() - 943 docked_width(manager) - min_dock_gap(), 944 w2->bounds().width()); 945 946 // Unmaximize the second window. 947 w2_state->Restore(); 948 // Its bounds should get restored. 949 EXPECT_EQ(restored_bounds, w2->bounds()); 950 } 951 952 // Dock one window. Test the sticky behavior near screen or desktop edge. 953 TEST_P(DockedWindowResizerTest, AttachOneTestSticky) { 954 if (!SupportsHostWindowResize()) 955 return; 956 957 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 958 scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 201))); 959 // Work area should cover the whole screen. 960 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(), 961 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width()); 962 963 DragToVerticalPositionAndToEdge(DOCKED_EDGE_LEFT, w1.get(), 20); 964 // A window should be docked at the left edge. 965 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().x(), 966 w1->GetBoundsInScreen().x()); 967 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 968 DockedWindowLayoutManager* manager = 969 static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager()); 970 // The first window should be docked. 971 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().x(), 972 w1->GetBoundsInScreen().x()); 973 // Dock width should be set to that of a single docked window. 974 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 975 EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager)); 976 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 977 978 // Position second window in the desktop 20px to the right of the docked w1. 979 DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_LEFT, 980 w2.get(), 981 20 + 25 - 982 min_dock_gap(), 983 50); 984 // The second window should be floating on the desktop. 985 EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().x() + 986 (w1->bounds().right() + 20), 987 w2->GetBoundsInScreen().x()); 988 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 989 // Dock width should be set to that of a single docked window. 990 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 991 EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager)); 992 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 993 994 // Drag w2 almost to the dock, the mouse pointer not quite reaching the dock. 995 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(w2.get(), 10, 0)); 996 DragMove(1 + docked_width(manager) - w2->bounds().x(), 0); 997 // Alignment set to "LEFT" during the drag because dock has a window in it. 998 EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager)); 999 // Release the mouse and the window should not be attached to the edge. 1000 DragEnd(); 1001 // Dock should still have only one window in it. 1002 EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager)); 1003 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1004 // The second window should still be in the desktop. 1005 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1006 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 1007 1008 // Drag w2 by a bit more - it should resist the drag (stuck edges) 1009 int start_x = w2->bounds().x(); 1010 ASSERT_NO_FATAL_FAILURE(DragStartAtOffsetFromWindowOrigin(w2.get(), 100, 5)); 1011 DragMove(-2, 0); 1012 // Window should not actually move. 1013 EXPECT_EQ(start_x, w2->bounds().x()); 1014 // Alignment set to "LEFT" during the drag because dock has a window in it. 1015 EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager)); 1016 // Release the mouse and the window should not be attached to the edge. 1017 DragEnd(); 1018 // Window should be still where it was before the last drag started. 1019 EXPECT_EQ(start_x, w2->bounds().x()); 1020 // Dock should still have only one window in it 1021 EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager)); 1022 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1023 // The second window should still be in the desktop 1024 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1025 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 1026 1027 // Drag w2 by more than the stuck threshold and drop it into the dock. 1028 ASSERT_NO_FATAL_FAILURE(DragStart(w2.get())); 1029 DragMove(-100, 0); 1030 // Window should actually move. 1031 EXPECT_NE(start_x, w2->bounds().x()); 1032 // Alignment set to "LEFT" during the drag because dock has a window in it. 1033 EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager)); 1034 // Release the mouse and the window should be attached to the edge. 1035 DragEnd(); 1036 // Both windows are docked now. 1037 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1038 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 1039 // Dock should get expanded and desktop should get shrunk. 1040 EXPECT_EQ(DOCKED_ALIGNMENT_LEFT, docked_alignment(manager)); 1041 EXPECT_EQ(std::max(w1->bounds().width(), w2->bounds().width()), 1042 docked_width(manager)); 1043 // Desktop work area should now shrink by dock width. 1044 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() - 1045 docked_width(manager) - min_dock_gap(), 1046 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width()); 1047 } 1048 1049 // Dock two windows, resize one. 1050 // Test the docked windows area size and remaining desktop resizing. 1051 TEST_P(DockedWindowResizerTest, ResizeOneOfTwoWindows) { 1052 if (!SupportsHostWindowResize()) 1053 return; 1054 1055 // Wider display to start since panels are limited to half the display width. 1056 UpdateDisplay("1000x600"); 1057 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 1058 scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 201))); 1059 // Work area should cover the whole screen. 1060 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width(), 1061 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width()); 1062 1063 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 1064 // A window should be docked at the right edge. 1065 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 1066 w1->GetBoundsInScreen().right()); 1067 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1068 DockedWindowLayoutManager* manager = 1069 static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager()); 1070 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1071 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1072 1073 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 100); 1074 // Both windows should now be docked at the right edge. 1075 EXPECT_EQ(w2->GetRootWindow()->GetBoundsInScreen().right(), 1076 w2->GetBoundsInScreen().right()); 1077 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 1078 // Dock width should be set to a wider window. 1079 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1080 EXPECT_EQ(std::max(w1->bounds().width(), w2->bounds().width()), 1081 docked_width(manager)); 1082 1083 // Resize the first window left by a bit and test that the dock expands. 1084 int previous_width = w1->bounds().width(); 1085 const int kResizeSpan1 = 30; 1086 ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(), 1087 0, 20, 1088 HTLEFT)); 1089 DragMove(-kResizeSpan1, 0); 1090 // Alignment set to "RIGHT" during the drag because dock has a window in it. 1091 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1092 // Release the mouse and the window should be attached to the edge. 1093 DragEnd(); 1094 // Dock should still have both windows in it. 1095 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1096 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 1097 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1098 // w1 is now wider than before. The dock should expand and be as wide as w1. 1099 EXPECT_EQ(previous_width + kResizeSpan1, w1->bounds().width()); 1100 // Both windows should get resized since they both don't have min/max size. 1101 EXPECT_EQ(w1->bounds().width(), w2->bounds().width()); 1102 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1103 // Desktop work area should shrink. 1104 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() - 1105 docked_width(manager) - min_dock_gap(), 1106 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width()); 1107 1108 // Resize the first window left by more than the dock maximum width. 1109 // This should cause the window width to be restricted by maximum dock width. 1110 previous_width = w1->bounds().width(); 1111 const int kResizeSpan2 = 250; 1112 ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(), 1113 0, 20, 1114 HTLEFT)); 1115 DragMove(-kResizeSpan2, 0); 1116 // Alignment set to "RIGHT" during the drag because dock has a window in it. 1117 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1118 // Release the mouse and the window should be attached to the edge. 1119 DragEnd(); 1120 // Dock should still have both windows in it. 1121 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1122 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 1123 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1124 // w1 is now as wide as the maximum dock width and the dock should get 1125 // resized to the maximum width. 1126 EXPECT_EQ(max_width(), w1->bounds().width()); 1127 // Both windows should get resized since they both don't have min/max size. 1128 EXPECT_EQ(w1->bounds().width(), w2->bounds().width()); 1129 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1130 // Desktop work area should shrink. 1131 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() - 1132 docked_width(manager) - min_dock_gap(), 1133 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width()); 1134 1135 // Resize the first window right to get it completely inside the docked area. 1136 previous_width = w1->bounds().width(); 1137 const int kResizeSpan3 = 100; 1138 ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(), 1139 0, 20, 1140 HTLEFT)); 1141 DragMove(kResizeSpan3, 0); 1142 // Alignment set to "RIGHT" during the drag because dock has a window in it. 1143 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1144 // Release the mouse and the window should be docked. 1145 DragEnd(); 1146 // Dock should still have both windows in it. 1147 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1148 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 1149 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1150 // w1 should be narrower than before by the length of the drag. 1151 EXPECT_EQ(previous_width - kResizeSpan3, w1->bounds().width()); 1152 // Both windows should get resized since they both don't have min/max size. 1153 EXPECT_EQ(w1->bounds().width(), w2->bounds().width()); 1154 // The dock should be as wide as w1 or w2. 1155 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1156 // Desktop work area should shrink. 1157 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w2.get()).width() - 1158 docked_width(manager) - min_dock_gap(), 1159 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w2.get()).width()); 1160 1161 // Resize the first window left to be overhang again. 1162 previous_width = w1->bounds().width(); 1163 ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(), 1164 0, 20, 1165 HTLEFT)); 1166 DragMove(-kResizeSpan3, 0); 1167 DragEnd(); 1168 EXPECT_EQ(previous_width + kResizeSpan3, w1->bounds().width()); 1169 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1170 // Docked area should be as wide as possible (maximum) and same as w1. 1171 EXPECT_EQ(max_width(), docked_width(manager)); 1172 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1173 1174 // Undock the first window. Docked area should shrink to its ideal size. 1175 ASSERT_NO_FATAL_FAILURE(DragStart(w1.get())); 1176 // Drag up as well to avoid attaching panels to launcher shelf. 1177 DragMove(-(400 - 210), -100); 1178 // Alignment set to "RIGHT" since we have another window docked. 1179 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1180 // Release the mouse and the window should be no longer attached to the edge. 1181 DragEnd(); 1182 EXPECT_EQ(kShellWindowId_DefaultContainer, w1->parent()->id()); 1183 // Dock should be as wide as w2 (and same as ideal width). 1184 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1185 EXPECT_EQ(ideal_width(), docked_width(manager)); 1186 EXPECT_EQ(w2->bounds().width(), docked_width(manager)); 1187 // The second window should be still docked. 1188 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 1189 // Desktop work area should be inset. 1190 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w1.get()).width() - 1191 docked_width(manager) - min_dock_gap(), 1192 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()).width()); 1193 } 1194 1195 // Dock a window, resize it and test that undocking it preserves the width. 1196 TEST_P(DockedWindowResizerTest, ResizingKeepsWidth) { 1197 if (!SupportsHostWindowResize()) 1198 return; 1199 1200 // Wider display to start since panels are limited to half the display width. 1201 UpdateDisplay("1000x600"); 1202 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 1203 1204 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 1205 // Window should be docked at the right edge. 1206 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 1207 w1->GetBoundsInScreen().right()); 1208 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1209 DockedWindowLayoutManager* manager = 1210 static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager()); 1211 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1212 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1213 1214 // Resize the window left by a bit and test that the dock expands. 1215 int previous_width = w1->bounds().width(); 1216 const int kResizeSpan1 = 30; 1217 ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(), 1218 0, 20, 1219 HTLEFT)); 1220 DragMove(-kResizeSpan1, 0); 1221 // Alignment stays "RIGHT" during the drag because the only docked window 1222 // is being resized. 1223 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1224 // Release the mouse and the window should be attached to the edge. 1225 DragEnd(); 1226 // The window should get docked. 1227 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1228 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1229 // w1 is now wider and the dock should expand to be as wide as w1. 1230 EXPECT_EQ(previous_width + kResizeSpan1, w1->bounds().width()); 1231 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1232 1233 // Undock by dragging almost to the left edge. 1234 DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_LEFT, w1.get(), 100, 20); 1235 // Width should be preserved. 1236 EXPECT_EQ(previous_width + kResizeSpan1, w1->bounds().width()); 1237 // Height should be restored to what it was originally. 1238 EXPECT_EQ(201, w1->bounds().height()); 1239 1240 // Dock again. 1241 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 1242 // Width should be reset to initial ideal width (25px). 1243 EXPECT_EQ(ideal_width(), w1->bounds().width()); 1244 1245 // Undock again by dragging left. 1246 DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_LEFT, w1.get(), 100, 20); 1247 // Width should be reset to what it was last time the window was not docked. 1248 EXPECT_EQ(previous_width + kResizeSpan1, w1->bounds().width()); 1249 // Height should be restored to what it was originally. 1250 EXPECT_EQ(201, w1->bounds().height()); 1251 } 1252 1253 // Dock a window, resize it and test that it stays docked. 1254 TEST_P(DockedWindowResizerTest, ResizingKeepsDockedState) { 1255 if (!SupportsHostWindowResize()) 1256 return; 1257 1258 // Wider display to start since panels are limited to half the display width. 1259 UpdateDisplay("1000x600"); 1260 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 1261 1262 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 1263 // Window should be docked at the right edge. 1264 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 1265 w1->GetBoundsInScreen().right()); 1266 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1267 DockedWindowLayoutManager* manager = 1268 static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager()); 1269 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1270 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1271 1272 // Resize the window left by a bit and test that the dock expands. 1273 int previous_width = w1->bounds().width(); 1274 const int kResizeSpan1 = 30; 1275 ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin( 1276 w1.get(), 0, 20, HTLEFT)); 1277 DragMove(-kResizeSpan1, 0); 1278 // Normally alignment would be reset to "NONE" during the drag when there is 1279 // only a single window docked and it is being dragged. However because that 1280 // window is being resized rather than moved the alignment is not changed. 1281 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1282 // Release the mouse and the window should be attached to the edge. 1283 DragEnd(); 1284 // The window should stay docked. 1285 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1286 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1287 // w1 is now wider and the dock should expand to be as wide as w1. 1288 EXPECT_EQ(previous_width + kResizeSpan1, w1->bounds().width()); 1289 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1290 1291 // Resize the window by dragging its right edge left a bit and test that the 1292 // window stays docked. 1293 previous_width = w1->bounds().width(); 1294 const int kResizeSpan2 = 15; 1295 ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin( 1296 w1.get(), w1->bounds().width(), 20, HTRIGHT)); 1297 DragMove(-kResizeSpan2, 0); 1298 // Alignment stays "RIGHT" during the drag because the window is being 1299 // resized rather than dragged. 1300 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1301 // Release the mouse and the window should be attached to the edge. 1302 DragEnd(); 1303 // The window should stay docked. 1304 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1305 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1306 // The dock should stay as wide as w1 is now (a bit less than before). 1307 EXPECT_EQ(previous_width - kResizeSpan2, w1->bounds().width()); 1308 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1309 } 1310 1311 // Dock two windows, resize one. Test the docked windows area size. 1312 TEST_P(DockedWindowResizerTest, ResizeTwoWindows) { 1313 if (!SupportsHostWindowResize()) 1314 return; 1315 1316 // Wider display to start since panels are limited to half the display width. 1317 UpdateDisplay("1000x600"); 1318 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 1319 scoped_ptr<aura::Window> w2(CreateTestWindow(gfx::Rect(0, 0, 210, 201))); 1320 1321 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 1322 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 100); 1323 // Both windows should now be docked at the right edge. 1324 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1325 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 1326 // Dock width should be set to ideal width. 1327 DockedWindowLayoutManager* manager = 1328 static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager()); 1329 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1330 EXPECT_EQ(ideal_width(), docked_width(manager)); 1331 1332 // Resize the first window left by a bit and test that the dock expands. 1333 int previous_width = w1->bounds().width(); 1334 const int kResizeSpan1 = 30; 1335 ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(), 1336 0, 20, 1337 HTLEFT)); 1338 DragMove(-kResizeSpan1, 0); 1339 DragEnd(); 1340 // w1 is now wider than before. 1341 EXPECT_EQ(previous_width + kResizeSpan1, w1->bounds().width()); 1342 // Both windows should get resized since they both don't have min/max size. 1343 EXPECT_EQ(w1->bounds().width(), w2->bounds().width()); 1344 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1345 1346 // Resize the second window left by a bit more and test that the dock expands. 1347 previous_width = w2->bounds().width(); 1348 ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w2.get(), 1349 0, 20, 1350 HTLEFT)); 1351 DragMove(-kResizeSpan1, 0); 1352 DragEnd(); 1353 // w2 should get wider since it was resized by a user. 1354 EXPECT_EQ(previous_width + kResizeSpan1, w2->bounds().width()); 1355 // w1 should stay as wide as w2 since both were flush with the dock edge. 1356 EXPECT_EQ(w2->bounds().width(), w1->bounds().width()); 1357 EXPECT_EQ(w2->bounds().width(), docked_width(manager)); 1358 1359 // Undock w2 and then dock it back. 1360 DragToVerticalPositionRelativeToEdge(DOCKED_EDGE_RIGHT, w2.get(), -400, 100); 1361 EXPECT_EQ(kShellWindowId_DefaultContainer, w2->parent()->id()); 1362 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w2.get(), 100); 1363 EXPECT_EQ(kShellWindowId_DockedContainer, w2->parent()->id()); 1364 // w2 should become same width as w1. 1365 EXPECT_EQ(w1->bounds().width(), w2->bounds().width()); 1366 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1367 1368 // Make w1 even wider. 1369 ASSERT_NO_FATAL_FAILURE(ResizeStartAtOffsetFromWindowOrigin(w1.get(), 1370 0, 20, 1371 HTLEFT)); 1372 DragMove(-kResizeSpan1, 0); 1373 DragEnd(); 1374 // Making w1 wider should make both windows wider since w2 no longer remembers 1375 // user width. 1376 EXPECT_EQ(w1->bounds().width(), w2->bounds().width()); 1377 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1378 } 1379 1380 // Tests that dragging a window down to shelf attaches a panel but does not 1381 // attach a regular window. 1382 TEST_P(DockedWindowResizerTest, DragToShelf) { 1383 if (!SupportsHostWindowResize()) 1384 return; 1385 1386 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 1387 // Work area should cover the whole screen. 1388 EXPECT_EQ(ScreenUtil::GetDisplayBoundsInParent(w1.get()).width(), 1389 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()).width()); 1390 1391 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 1392 // A window should be docked at the right edge. 1393 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 1394 w1->GetBoundsInScreen().right()); 1395 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1396 DockedWindowLayoutManager* manager = 1397 static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager()); 1398 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1399 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1400 1401 // Detach and drag down to shelf. 1402 ASSERT_NO_FATAL_FAILURE(DragStart(w1.get())); 1403 DragMove(-40, 0); 1404 // Alignment is set to "NONE" when drag starts. 1405 EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager)); 1406 // Release the mouse and the window should be no longer attached to the edge. 1407 DragEnd(); 1408 EXPECT_EQ(DOCKED_ALIGNMENT_NONE, docked_alignment(manager)); 1409 1410 // Drag down almost to shelf. A panel will snap, a regular window won't. 1411 ShelfWidget* shelf = Shelf::ForPrimaryDisplay()->shelf_widget(); 1412 const int shelf_y = shelf->GetWindowBoundsInScreen().y(); 1413 const int kDistanceFromShelf = 10; 1414 ASSERT_NO_FATAL_FAILURE(DragStart(w1.get())); 1415 DragMove(0, -kDistanceFromShelf + shelf_y - w1->bounds().bottom()); 1416 DragEnd(); 1417 if (test_panels()) { 1418 // The panel should be touching the shelf and attached. 1419 EXPECT_EQ(shelf_y, w1->bounds().bottom()); 1420 EXPECT_TRUE(wm::GetWindowState(w1.get())->panel_attached()); 1421 } else { 1422 // The window should not be touching the shelf. 1423 EXPECT_EQ(shelf_y - kDistanceFromShelf, w1->bounds().bottom()); 1424 } 1425 } 1426 1427 // Tests that docking and undocking a |window| with a transient child properly 1428 // maintains the parent of that transient child to be the same as the |window|. 1429 TEST_P(DockedWindowResizerTest, DragWindowWithTransientChild) { 1430 if (!SupportsHostWindowResize()) 1431 return; 1432 1433 // Create a window with a transient child. 1434 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 1435 scoped_ptr<aura::Window> child(CreateTestWindowInShellWithDelegateAndType( 1436 NULL, ui::wm::WINDOW_TYPE_NORMAL, 0, gfx::Rect(20, 20, 150, 20))); 1437 ::wm::AddTransientChild(window.get(), child.get()); 1438 if (window->parent() != child->parent()) 1439 window->parent()->AddChild(child.get()); 1440 EXPECT_EQ(window.get(), ::wm::GetTransientParent(child.get())); 1441 1442 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, window.get(), 20); 1443 1444 // A window should be docked at the right edge. 1445 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 1446 EXPECT_EQ(kShellWindowId_DockedContainer, child->parent()->id()); 1447 1448 // Drag the child - it should move freely and stay where it is dragged. 1449 ASSERT_NO_FATAL_FAILURE(DragStart(child.get())); 1450 DragMove(500, 20); 1451 DragEnd(); 1452 EXPECT_EQ(gfx::Point(20 + 500, 20 + 20).ToString(), 1453 child->GetBoundsInScreen().origin().ToString()); 1454 1455 // Undock the window by dragging left. 1456 ASSERT_NO_FATAL_FAILURE(DragStart(window.get())); 1457 DragMove(-32, -10); 1458 DragEnd(); 1459 1460 // The window should be undocked and the transient child should be reparented. 1461 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 1462 EXPECT_EQ(kShellWindowId_DefaultContainer, child->parent()->id()); 1463 // The child should not have moved. 1464 EXPECT_EQ(gfx::Point(20 + 500, 20 + 20).ToString(), 1465 child->GetBoundsInScreen().origin().ToString()); 1466 } 1467 1468 // Tests that reparenting windows during the drag does not affect system modal 1469 // windows that are transient children of the dragged windows. 1470 TEST_P(DockedWindowResizerTest, DragWindowWithModalTransientChild) { 1471 if (!SupportsHostWindowResize()) 1472 return; 1473 1474 // Create a window. 1475 scoped_ptr<aura::Window> window(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 1476 gfx::Rect bounds(window->bounds()); 1477 1478 // Start dragging the window. 1479 ASSERT_NO_FATAL_FAILURE(DragStart(window.get())); 1480 gfx::Vector2d move_vector(40, test_panels() ? -60 : 60); 1481 DragMove(move_vector.x(), move_vector.y()); 1482 EXPECT_EQ(CorrectContainerIdDuringDrag(), window->parent()->id()); 1483 1484 // While still dragging create a modal window and make it a transient child of 1485 // the |window|. 1486 scoped_ptr<aura::Window> child(CreateModalWindow(gfx::Rect(20, 20, 150, 20))); 1487 ::wm::AddTransientChild(window.get(), child.get()); 1488 EXPECT_EQ(window.get(), ::wm::GetTransientParent(child.get())); 1489 EXPECT_EQ(kShellWindowId_SystemModalContainer, child->parent()->id()); 1490 1491 // End the drag, the |window| should have moved (if it is a panel it will 1492 // no longer be attached to the shelf since we dragged it above). 1493 DragEnd(); 1494 bounds.Offset(move_vector); 1495 EXPECT_EQ(bounds.ToString(), window->GetBoundsInScreen().ToString()); 1496 1497 // The original |window| should be in the default container (not docked or 1498 // attached). 1499 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 1500 // The transient |child| should still be in system modal container. 1501 EXPECT_EQ(kShellWindowId_SystemModalContainer, child->parent()->id()); 1502 // The |child| should not have moved. 1503 EXPECT_EQ(gfx::Point(20, 20).ToString(), 1504 child->GetBoundsInScreen().origin().ToString()); 1505 // The |child| should still be a transient child of |window|. 1506 EXPECT_EQ(window.get(), ::wm::GetTransientParent(child.get())); 1507 } 1508 1509 // Tests that side snapping a window undocks it, closes the dock and then snaps. 1510 TEST_P(DockedWindowResizerTest, SideSnapDocked) { 1511 if (!SupportsHostWindowResize() || test_panels()) 1512 return; 1513 1514 scoped_ptr<aura::Window> w1(CreateTestWindow(gfx::Rect(0, 0, 201, 201))); 1515 wm::WindowState* window_state = wm::GetWindowState(w1.get()); 1516 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 1517 // A window should be docked at the right edge. 1518 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 1519 w1->GetBoundsInScreen().right()); 1520 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1521 DockedWindowLayoutManager* manager = 1522 static_cast<DockedWindowLayoutManager*>(w1->parent()->layout_manager()); 1523 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1524 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1525 EXPECT_TRUE(window_state->IsDocked()); 1526 EXPECT_FALSE(window_state->IsSnapped()); 1527 1528 // Side snap at right edge. 1529 const wm::WMEvent snap_right(wm::WM_EVENT_SNAP_RIGHT); 1530 window_state->OnWMEvent(&snap_right); 1531 // The window should be snapped at the right edge and the dock should close. 1532 gfx::Rect work_area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get())); 1533 EXPECT_EQ(0, docked_width(manager)); 1534 EXPECT_EQ(work_area.height(), w1->bounds().height()); 1535 EXPECT_EQ(work_area.right(), w1->bounds().right()); 1536 EXPECT_EQ(kShellWindowId_DefaultContainer, w1->parent()->id()); 1537 EXPECT_FALSE(window_state->IsDocked()); 1538 EXPECT_TRUE(window_state->IsSnapped()); 1539 1540 // Dock again. 1541 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, w1.get(), 20); 1542 // A window should be docked at the right edge. 1543 EXPECT_EQ(w1->GetRootWindow()->GetBoundsInScreen().right(), 1544 w1->GetBoundsInScreen().right()); 1545 EXPECT_EQ(kShellWindowId_DockedContainer, w1->parent()->id()); 1546 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1547 EXPECT_EQ(w1->bounds().width(), docked_width(manager)); 1548 EXPECT_TRUE(window_state->IsDocked()); 1549 EXPECT_FALSE(window_state->IsSnapped()); 1550 1551 // Side snap at left edge. 1552 const wm::WMEvent snap_left(wm::WM_EVENT_SNAP_LEFT); 1553 window_state->OnWMEvent(&snap_left); 1554 // The window should be snapped at the right edge and the dock should close. 1555 EXPECT_EQ(work_area.ToString(), 1556 ScreenUtil::GetDisplayWorkAreaBoundsInParent(w1.get()).ToString()); 1557 EXPECT_EQ(0, docked_width(manager)); 1558 EXPECT_EQ(work_area.height(), w1->bounds().height()); 1559 EXPECT_EQ(work_area.x(), w1->bounds().x()); 1560 EXPECT_EQ(kShellWindowId_DefaultContainer, w1->parent()->id()); 1561 EXPECT_FALSE(window_state->IsDocked()); 1562 EXPECT_TRUE(window_state->IsSnapped()); 1563 } 1564 1565 // Tests that a window is undocked if the window is maximized via a keyboard 1566 // accelerator during a drag. 1567 TEST_P(DockedWindowResizerTest, MaximizedDuringDrag) { 1568 if (!SupportsHostWindowResize() || test_panels()) 1569 return; 1570 1571 scoped_ptr<aura::Window> window(CreateTestWindow( 1572 gfx::Rect(0, 0, ideal_width(), 201))); 1573 wm::WindowState* window_state = wm::GetWindowState(window.get()); 1574 1575 // Dock the window to the right edge. 1576 DragToVerticalPositionAndToEdge(DOCKED_EDGE_RIGHT, window.get(), 20); 1577 EXPECT_EQ(window->GetRootWindow()->GetBoundsInScreen().right(), 1578 window->GetBoundsInScreen().right()); 1579 EXPECT_EQ(kShellWindowId_DockedContainer, window->parent()->id()); 1580 DockedWindowLayoutManager* manager = 1581 static_cast<DockedWindowLayoutManager*>( 1582 window->parent()->layout_manager()); 1583 EXPECT_EQ(DOCKED_ALIGNMENT_RIGHT, docked_alignment(manager)); 1584 EXPECT_EQ(window->bounds().width(), docked_width(manager)); 1585 EXPECT_TRUE(window_state->IsDocked()); 1586 1587 // Maximize the window while in a real drag. In particular, 1588 // ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowStateTypeChanged() 1589 // must be called in order for the maximized window's size to be correct. 1590 delegate()->set_window_component(HTCAPTION); 1591 aura::test::EventGenerator& generator = GetEventGenerator(); 1592 generator.MoveMouseTo(window->GetBoundsInScreen().origin()); 1593 generator.PressLeftButton(); 1594 generator.MoveMouseBy(10, 10); 1595 window_state->Maximize(); 1596 generator.ReleaseLeftButton(); 1597 1598 // |window| should get undocked. 1599 EXPECT_EQ(kShellWindowId_DefaultContainer, window->parent()->id()); 1600 EXPECT_EQ(0, docked_width(manager)); 1601 EXPECT_EQ( 1602 ScreenUtil::GetMaximizedWindowBoundsInParent(window.get()).ToString(), 1603 window->bounds().ToString()); 1604 EXPECT_TRUE(window_state->IsMaximized()); 1605 } 1606 1607 // Tests run twice - on both panels and normal windows 1608 INSTANTIATE_TEST_CASE_P(NormalOrPanel, 1609 DockedWindowResizerTest, 1610 testing::Values(ui::wm::WINDOW_TYPE_NORMAL, 1611 ui::wm::WINDOW_TYPE_PANEL)); 1612 1613 } // namespace ash 1614
