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 "chrome/browser/ui/browser.h" 6 #include "chrome/browser/ui/panels/base_panel_browser_test.h" 7 #include "chrome/browser/ui/panels/detached_panel_collection.h" 8 #include "chrome/browser/ui/panels/docked_panel_collection.h" 9 #include "chrome/browser/ui/panels/native_panel.h" 10 #include "chrome/browser/ui/panels/panel.h" 11 #include "chrome/browser/ui/panels/panel_manager.h" 12 #include "chrome/browser/ui/panels/stacked_panel_collection.h" 13 #include "chrome/browser/web_applications/web_app.h" 14 #include "chrome/test/base/testing_profile.h" 15 #include "content/public/test/test_utils.h" 16 17 class StackedPanelBrowserTest : public BasePanelBrowserTest { 18 }; 19 20 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, CheckStackedPanelProperties) { 21 PanelManager* panel_manager = PanelManager::GetInstance(); 22 23 // Create 2 stacked panels. 24 StackedPanelCollection* stack = panel_manager->CreateStack(); 25 gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); 26 Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); 27 gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); 28 Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); 29 gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 120, 110); 30 Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack); 31 32 scoped_ptr<NativePanelTesting> panel1_testing( 33 CreateNativePanelTesting(panel1)); 34 scoped_ptr<NativePanelTesting> panel2_testing( 35 CreateNativePanelTesting(panel2)); 36 scoped_ptr<NativePanelTesting> panel3_testing( 37 CreateNativePanelTesting(panel3)); 38 39 // Check that all 3 panels are in a stack. 40 ASSERT_EQ(0, panel_manager->docked_collection()->num_panels()); 41 ASSERT_EQ(0, panel_manager->detached_collection()->num_panels()); 42 ASSERT_EQ(1, panel_manager->num_stacks()); 43 ASSERT_EQ(3, stack->num_panels()); 44 EXPECT_EQ(stack, panel1->stack()); 45 EXPECT_EQ(stack, panel2->stack()); 46 EXPECT_EQ(stack, panel3->stack()); 47 48 // Check buttons. 49 EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::CLOSE_BUTTON)); 50 EXPECT_TRUE(panel2_testing->IsButtonVisible(panel::CLOSE_BUTTON)); 51 EXPECT_TRUE(panel3_testing->IsButtonVisible(panel::CLOSE_BUTTON)); 52 53 if (PanelManager::CanUseSystemMinimize()) 54 EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 55 else 56 EXPECT_FALSE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 57 EXPECT_FALSE(panel2_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 58 EXPECT_FALSE(panel3_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 59 60 EXPECT_FALSE(panel1_testing->IsButtonVisible(panel::RESTORE_BUTTON)); 61 EXPECT_FALSE(panel2_testing->IsButtonVisible(panel::RESTORE_BUTTON)); 62 EXPECT_FALSE(panel3_testing->IsButtonVisible(panel::RESTORE_BUTTON)); 63 64 // Check bounds. 65 gfx::Rect panel1_expected_bounds(panel1_initial_bounds); 66 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 67 gfx::Rect panel2_expected_bounds(panel1_expected_bounds.x(), 68 panel1_expected_bounds.bottom(), 69 panel1_expected_bounds.width(), 70 panel2_initial_bounds.height()); 71 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 72 gfx::Rect panel3_expected_bounds(panel2_expected_bounds.x(), 73 panel2_expected_bounds.bottom(), 74 panel2_expected_bounds.width(), 75 panel3_initial_bounds.height()); 76 EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); 77 78 // Check other properties. 79 EXPECT_FALSE(panel1->IsAlwaysOnTop()); 80 EXPECT_FALSE(panel2->IsAlwaysOnTop()); 81 EXPECT_FALSE(panel3->IsAlwaysOnTop()); 82 83 EXPECT_FALSE(panel1->IsMinimized()); 84 EXPECT_FALSE(panel2->IsMinimized()); 85 EXPECT_FALSE(panel3->IsMinimized()); 86 87 EXPECT_EQ(panel::RESIZABLE_LEFT | panel::RESIZABLE_RIGHT | 88 panel::RESIZABLE_TOP | panel::RESIZABLE_TOP_LEFT | 89 panel::RESIZABLE_TOP_RIGHT | panel::RESIZABLE_BOTTOM, 90 panel1->CanResizeByMouse()); 91 EXPECT_EQ(panel::RESIZABLE_LEFT | panel::RESIZABLE_RIGHT | 92 panel::RESIZABLE_BOTTOM, 93 panel2->CanResizeByMouse()); 94 EXPECT_EQ(panel::RESIZABLE_LEFT | panel::RESIZABLE_RIGHT | 95 panel::RESIZABLE_BOTTOM | panel::RESIZABLE_BOTTOM_LEFT | 96 panel::RESIZABLE_BOTTOM_RIGHT, 97 panel3->CanResizeByMouse()); 98 99 EXPECT_EQ(panel::TOP_ROUNDED, panel1_testing->GetWindowCornerStyle()); 100 EXPECT_EQ(panel::NOT_ROUNDED, panel2_testing->GetWindowCornerStyle()); 101 EXPECT_EQ(panel::BOTTOM_ROUNDED, panel3_testing->GetWindowCornerStyle()); 102 103 Panel::AttentionMode expected_attention_mode = 104 static_cast<Panel::AttentionMode>(Panel::USE_PANEL_ATTENTION | 105 Panel::USE_SYSTEM_ATTENTION); 106 EXPECT_EQ(expected_attention_mode, panel1->attention_mode()); 107 EXPECT_EQ(expected_attention_mode, panel2->attention_mode()); 108 EXPECT_EQ(expected_attention_mode, panel3->attention_mode()); 109 110 panel_manager->CloseAll(); 111 } 112 113 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 114 CheckMinimizedStackedPanelProperties) { 115 PanelManager* panel_manager = PanelManager::GetInstance(); 116 117 // Create 2 stacked panels. 118 StackedPanelCollection* stack = panel_manager->CreateStack(); 119 gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); 120 Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); 121 gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); 122 Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); 123 gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 120, 110); 124 Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack); 125 126 scoped_ptr<NativePanelTesting> panel1_testing( 127 CreateNativePanelTesting(panel1)); 128 scoped_ptr<NativePanelTesting> panel2_testing( 129 CreateNativePanelTesting(panel2)); 130 scoped_ptr<NativePanelTesting> panel3_testing( 131 CreateNativePanelTesting(panel3)); 132 133 // Minimize these 2 panels. 134 panel1->Minimize(); 135 WaitForBoundsAnimationFinished(panel1); 136 panel2->Minimize(); 137 WaitForBoundsAnimationFinished(panel2); 138 panel3->Minimize(); 139 WaitForBoundsAnimationFinished(panel3); 140 141 // Check that all 2 panels are in a stack. 142 ASSERT_EQ(0, panel_manager->docked_collection()->num_panels()); 143 ASSERT_EQ(0, panel_manager->detached_collection()->num_panels()); 144 ASSERT_EQ(1, panel_manager->num_stacks()); 145 ASSERT_EQ(3, stack->num_panels()); 146 EXPECT_EQ(stack, panel1->stack()); 147 EXPECT_EQ(stack, panel2->stack()); 148 EXPECT_EQ(stack, panel3->stack()); 149 150 // Check buttons. 151 EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::CLOSE_BUTTON)); 152 EXPECT_TRUE(panel2_testing->IsButtonVisible(panel::CLOSE_BUTTON)); 153 EXPECT_TRUE(panel3_testing->IsButtonVisible(panel::CLOSE_BUTTON)); 154 155 if (PanelManager::CanUseSystemMinimize()) 156 EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 157 else 158 EXPECT_FALSE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 159 EXPECT_FALSE(panel2_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 160 EXPECT_FALSE(panel3_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 161 162 EXPECT_FALSE(panel1_testing->IsButtonVisible(panel::RESTORE_BUTTON)); 163 EXPECT_FALSE(panel2_testing->IsButtonVisible(panel::RESTORE_BUTTON)); 164 EXPECT_FALSE(panel3_testing->IsButtonVisible(panel::RESTORE_BUTTON)); 165 166 // Check bounds. 167 gfx::Rect panel1_expected_bounds(panel1_initial_bounds); 168 panel1_expected_bounds.set_height(panel1->TitleOnlyHeight()); 169 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 170 gfx::Rect panel2_expected_bounds(panel1_expected_bounds.x(), 171 panel1_expected_bounds.bottom(), 172 panel1_expected_bounds.width(), 173 panel2->TitleOnlyHeight()); 174 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 175 gfx::Rect panel3_expected_bounds(panel2_expected_bounds.x(), 176 panel2_expected_bounds.bottom(), 177 panel2_expected_bounds.width(), 178 panel3->TitleOnlyHeight()); 179 EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); 180 181 // Check other properties. 182 EXPECT_FALSE(panel1->IsAlwaysOnTop()); 183 EXPECT_FALSE(panel2->IsAlwaysOnTop()); 184 EXPECT_FALSE(panel3->IsAlwaysOnTop()); 185 186 EXPECT_TRUE(panel1->IsMinimized()); 187 EXPECT_TRUE(panel2->IsMinimized()); 188 EXPECT_TRUE(panel3->IsMinimized()); 189 190 EXPECT_EQ(panel::RESIZABLE_LEFT | panel::RESIZABLE_RIGHT, 191 panel1->CanResizeByMouse()); 192 EXPECT_EQ(panel::RESIZABLE_LEFT | panel::RESIZABLE_RIGHT, 193 panel2->CanResizeByMouse()); 194 EXPECT_EQ(panel::RESIZABLE_LEFT | panel::RESIZABLE_RIGHT, 195 panel3->CanResizeByMouse()); 196 197 EXPECT_EQ(panel::TOP_ROUNDED, panel1_testing->GetWindowCornerStyle()); 198 EXPECT_EQ(panel::NOT_ROUNDED, panel2_testing->GetWindowCornerStyle()); 199 EXPECT_EQ(panel::BOTTOM_ROUNDED, panel3_testing->GetWindowCornerStyle()); 200 201 Panel::AttentionMode expected_attention_mode = 202 static_cast<Panel::AttentionMode>(Panel::USE_PANEL_ATTENTION | 203 Panel::USE_SYSTEM_ATTENTION); 204 EXPECT_EQ(expected_attention_mode, panel1->attention_mode()); 205 EXPECT_EQ(expected_attention_mode, panel2->attention_mode()); 206 EXPECT_EQ(expected_attention_mode, panel3->attention_mode()); 207 208 panel_manager->CloseAll(); 209 } 210 211 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, ClickTitlebar) { 212 PanelManager* panel_manager = PanelManager::GetInstance(); 213 214 // Create 2 stacked panels. 215 StackedPanelCollection* stack = panel_manager->CreateStack(); 216 gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); 217 Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); 218 gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); 219 Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); 220 ASSERT_EQ(1, panel_manager->num_stacks()); 221 222 scoped_ptr<NativePanelTesting> panel1_testing( 223 CreateNativePanelTesting(panel1)); 224 scoped_ptr<NativePanelTesting> panel2_testing( 225 CreateNativePanelTesting(panel2)); 226 227 gfx::Point panel1_origin = panel2->GetBounds().origin(); 228 gfx::Point panel2_origin = panel2->GetBounds().origin(); 229 230 EXPECT_FALSE(panel1->IsMinimized()); 231 EXPECT_FALSE(panel2->IsMinimized()); 232 233 gfx::Rect panel1_expected_bounds(panel1_initial_bounds); 234 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 235 gfx::Rect panel2_expected_bounds(panel1_expected_bounds.x(), 236 panel1_expected_bounds.bottom(), 237 panel1_expected_bounds.width(), 238 panel2_initial_bounds.height()); 239 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 240 241 // Clicking on P2's titlebar to collapse it. 242 panel2_testing->PressLeftMouseButtonTitlebar(panel2_origin); 243 panel2_testing->ReleaseMouseButtonTitlebar(); 244 WaitForBoundsAnimationFinished(panel2); 245 EXPECT_FALSE(panel1->IsMinimized()); 246 EXPECT_TRUE(panel2->IsMinimized()); 247 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 248 panel2_expected_bounds.set_height(panel2->TitleOnlyHeight()); 249 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 250 251 // Clicking on P2's titlebar to expand it. 252 panel2_testing->PressLeftMouseButtonTitlebar(panel2_origin); 253 panel2_testing->ReleaseMouseButtonTitlebar(); 254 WaitForBoundsAnimationFinished(panel2); 255 EXPECT_FALSE(panel1->IsMinimized()); 256 EXPECT_FALSE(panel2->IsMinimized()); 257 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 258 panel2_expected_bounds.set_height(panel2_initial_bounds.height()); 259 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 260 261 // Clicking on P2's titlebar with APPLY_TO_ALL modifier to collapse all 262 // panels. 263 panel2_testing->PressLeftMouseButtonTitlebar(panel2_origin, 264 panel::APPLY_TO_ALL); 265 panel2_testing->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 266 WaitForBoundsAnimationFinished(panel1); 267 WaitForBoundsAnimationFinished(panel2); 268 EXPECT_TRUE(panel1->IsMinimized()); 269 EXPECT_TRUE(panel2->IsMinimized()); 270 panel1_expected_bounds.set_height(panel1->TitleOnlyHeight()); 271 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 272 panel2_expected_bounds.set_y(panel1_expected_bounds.bottom()); 273 panel2_expected_bounds.set_height(panel2->TitleOnlyHeight()); 274 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 275 276 // Clicking on P1's titlebar with APPLY_TO_ALL modifier to expand all 277 // panels. 278 panel1_testing->PressLeftMouseButtonTitlebar(panel1_origin, 279 panel::APPLY_TO_ALL); 280 panel1_testing->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 281 WaitForBoundsAnimationFinished(panel1); 282 WaitForBoundsAnimationFinished(panel2); 283 EXPECT_FALSE(panel1->IsMinimized()); 284 EXPECT_FALSE(panel2->IsMinimized()); 285 panel1_expected_bounds.set_height(panel1_initial_bounds.height()); 286 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 287 panel2_expected_bounds.set_y(panel1_expected_bounds.bottom()); 288 panel2_expected_bounds.set_height(panel2_initial_bounds.height()); 289 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 290 291 panel_manager->CloseAll(); 292 } 293 294 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, CallMinimizeAndRestoreApi) { 295 PanelManager* panel_manager = PanelManager::GetInstance(); 296 297 // Create 2 stacked panels. 298 StackedPanelCollection* stack = panel_manager->CreateStack(); 299 gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); 300 Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); 301 gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); 302 Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); 303 ASSERT_EQ(1, panel_manager->num_stacks()); 304 305 EXPECT_FALSE(panel1->IsMinimized()); 306 EXPECT_FALSE(panel2->IsMinimized()); 307 308 gfx::Rect panel1_expected_bounds(panel1_initial_bounds); 309 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 310 gfx::Rect panel2_expected_bounds(panel1_expected_bounds.x(), 311 panel1_expected_bounds.bottom(), 312 panel1_expected_bounds.width(), 313 panel2_initial_bounds.height()); 314 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 315 316 // Collapsing P1 by calling its Minimize API. 317 panel1->Minimize(); 318 WaitForBoundsAnimationFinished(panel1); 319 EXPECT_TRUE(panel1->IsMinimized()); 320 EXPECT_FALSE(panel2->IsMinimized()); 321 panel1_expected_bounds.set_height(panel1->TitleOnlyHeight()); 322 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 323 panel2_expected_bounds.set_y(panel1_expected_bounds.bottom()); 324 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 325 326 // Expanding P1 by calling its Restore API. 327 panel1->Restore(); 328 WaitForBoundsAnimationFinished(panel1); 329 EXPECT_FALSE(panel1->IsMinimized()); 330 EXPECT_FALSE(panel2->IsMinimized()); 331 panel1_expected_bounds.set_height(panel1_initial_bounds.height()); 332 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 333 panel2_expected_bounds.set_y(panel1_expected_bounds.bottom()); 334 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 335 336 panel_manager->CloseAll(); 337 } 338 339 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, ExpandToFitWithinScreen) { 340 PanelManager* panel_manager = PanelManager::GetInstance(); 341 gfx::Rect work_area = 342 panel_manager->display_settings_provider()->GetPrimaryWorkArea(); 343 344 // Create 4 stacked panels. P4 is the active panel. 345 StackedPanelCollection* stack = panel_manager->CreateStack(); 346 Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 90, 200, 150), stack); 347 Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack); 348 Panel* panel3 = CreateStackedPanel("3", gfx::Rect(0, 0, 150, 120), stack); 349 Panel* panel4 = CreateStackedPanel("4", gfx::Rect(0, 0, 150, 100), stack); 350 ASSERT_EQ(4, stack->num_panels()); 351 ASSERT_FALSE(panel1->IsMinimized()); 352 ASSERT_FALSE(panel2->IsMinimized()); 353 ASSERT_FALSE(panel3->IsMinimized()); 354 ASSERT_FALSE(panel4->IsMinimized()); 355 EXPECT_LE(panel4->GetBounds().bottom(), work_area.bottom()); 356 int old_stack_top_position = panel1->GetBounds().y(); 357 358 // Collapse P2. 359 panel2->Minimize(); 360 WaitForBoundsAnimationFinished(panel2); 361 ASSERT_FALSE(panel1->IsMinimized()); 362 ASSERT_TRUE(panel2->IsMinimized()); 363 ASSERT_FALSE(panel3->IsMinimized()); 364 ASSERT_FALSE(panel4->IsMinimized()); 365 366 // Grow P2's restored height. 367 gfx::Size panel2_full_size = panel2->full_size(); 368 panel2_full_size.set_height(panel2_full_size.height() + 30); 369 panel2->set_full_size(panel2_full_size); 370 371 // Expand P2. Expect that the least recently active panel P1 is minimized in 372 // order to make space for P2. 373 panel2->Restore(); 374 WaitForBoundsAnimationFinished(panel2); 375 WaitForBoundsAnimationFinished(panel3); 376 WaitForBoundsAnimationFinished(panel4); 377 ASSERT_TRUE(panel1->IsMinimized()); 378 ASSERT_FALSE(panel2->IsMinimized()); 379 ASSERT_FALSE(panel3->IsMinimized()); 380 ASSERT_FALSE(panel4->IsMinimized()); 381 EXPECT_EQ(old_stack_top_position, panel1->GetBounds().y()); 382 EXPECT_LE(panel4->GetBounds().bottom(), work_area.bottom()); 383 EXPECT_EQ(panel2->GetBounds().height(), panel2_full_size.height()); 384 385 // Grow P1's restored height. 386 gfx::Size panel1_full_size = panel1->full_size(); 387 panel1_full_size.set_height(panel1_full_size.height() + 180); 388 panel1->set_full_size(panel1_full_size); 389 390 // Expand P1. Expect that both P2 and P3 are collapsed and the stack moves 391 // up in order to make space for P1. 392 panel1->Restore(); 393 WaitForBoundsAnimationFinished(panel1); 394 WaitForBoundsAnimationFinished(panel2); 395 WaitForBoundsAnimationFinished(panel3); 396 WaitForBoundsAnimationFinished(panel4); 397 ASSERT_FALSE(panel1->IsMinimized()); 398 ASSERT_TRUE(panel2->IsMinimized()); 399 ASSERT_TRUE(panel3->IsMinimized()); 400 ASSERT_FALSE(panel4->IsMinimized()); 401 EXPECT_LT(panel1->GetBounds().y(), old_stack_top_position); 402 EXPECT_GE(panel1->GetBounds().y(), work_area.y()); 403 EXPECT_LE(panel4->GetBounds().bottom(), work_area.bottom()); 404 EXPECT_EQ(panel1->GetBounds().height(), panel1_full_size.height()); 405 old_stack_top_position = panel1->GetBounds().y(); 406 407 // Expand P3. Expect that P1 get collapsed in order to make space for P3. 408 panel3->Restore(); 409 WaitForBoundsAnimationFinished(panel1); 410 WaitForBoundsAnimationFinished(panel2); 411 WaitForBoundsAnimationFinished(panel3); 412 WaitForBoundsAnimationFinished(panel4); 413 ASSERT_TRUE(panel1->IsMinimized()); 414 ASSERT_TRUE(panel2->IsMinimized()); 415 ASSERT_FALSE(panel3->IsMinimized()); 416 ASSERT_FALSE(panel4->IsMinimized()); 417 EXPECT_EQ(old_stack_top_position, panel1->GetBounds().y()); 418 EXPECT_LE(panel4->GetBounds().bottom(), work_area.bottom()); 419 420 // Grow P2's restored height by a very large value such that the stack with 421 // P2 in full height will not fit within the screen. 422 panel2_full_size = panel2->full_size(); 423 panel2_full_size.set_height(panel2_full_size.height() + 500); 424 panel2->set_full_size(panel2_full_size); 425 426 // Expand P2. Expect: 427 // 1) Both P1 and P3 are collapsed 428 // 2) The stack moves up to the top of the screen 429 // 3) P2's restored height is reduced 430 panel2->Restore(); 431 WaitForBoundsAnimationFinished(panel1); 432 WaitForBoundsAnimationFinished(panel2); 433 WaitForBoundsAnimationFinished(panel3); 434 WaitForBoundsAnimationFinished(panel4); 435 EXPECT_TRUE(panel1->IsMinimized()); 436 EXPECT_FALSE(panel2->IsMinimized()); 437 EXPECT_TRUE(panel3->IsMinimized()); 438 EXPECT_FALSE(panel4->IsMinimized()); 439 EXPECT_EQ(panel1->GetBounds().y(), work_area.y()); 440 EXPECT_EQ(panel4->GetBounds().bottom(), work_area.bottom()); 441 EXPECT_LT(panel2->GetBounds().height(), panel2_full_size.height()); 442 443 panel_manager->CloseAll(); 444 } 445 446 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, ExpandAllToFitWithinScreen) { 447 PanelManager* panel_manager = PanelManager::GetInstance(); 448 gfx::Rect work_area = 449 panel_manager->display_settings_provider()->GetPrimaryWorkArea(); 450 451 // Create 3 stacked panels. 452 StackedPanelCollection* stack = panel_manager->CreateStack(); 453 Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 150, 200, 200), stack); 454 Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack); 455 Panel* panel3 = CreateStackedPanel("3", gfx::Rect(0, 0, 150, 120), stack); 456 ASSERT_EQ(3, stack->num_panels()); 457 458 scoped_ptr<NativePanelTesting> panel2_testing( 459 CreateNativePanelTesting(panel2)); 460 461 // Collapse all panels by clicking on P2's titlebar with APPLY_TO_ALL 462 // modifier. 463 panel2_testing->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(), 464 panel::APPLY_TO_ALL); 465 panel2_testing->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 466 WaitForBoundsAnimationFinished(panel1); 467 WaitForBoundsAnimationFinished(panel2); 468 WaitForBoundsAnimationFinished(panel3); 469 ASSERT_TRUE(panel1->IsMinimized()); 470 ASSERT_TRUE(panel2->IsMinimized()); 471 ASSERT_TRUE(panel3->IsMinimized()); 472 473 // Grow P2's restored height by a very large value. 474 gfx::Size panel2_full_size = panel2->full_size(); 475 panel2_full_size.set_height(panel2_full_size.height() + 500); 476 panel2->set_full_size(panel2_full_size); 477 478 // Expand all panels by clicking on P2's titlebar with APPLY_TO_ALL 479 // modifier again. Expect only P2 is expanded due to no available space for 480 // P1 and P3. 481 panel2_testing->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(), 482 panel::APPLY_TO_ALL); 483 panel2_testing->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL); 484 WaitForBoundsAnimationFinished(panel1); 485 WaitForBoundsAnimationFinished(panel2); 486 WaitForBoundsAnimationFinished(panel3); 487 EXPECT_TRUE(panel1->IsMinimized()); 488 EXPECT_FALSE(panel2->IsMinimized()); 489 EXPECT_TRUE(panel3->IsMinimized()); 490 EXPECT_EQ(panel1->GetBounds().y(), work_area.y()); 491 EXPECT_EQ(panel3->GetBounds().bottom(), work_area.bottom()); 492 493 panel_manager->CloseAll(); 494 } 495 496 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, MinimizeButtonVisibility) { 497 PanelManager* panel_manager = PanelManager::GetInstance(); 498 499 // Create 3 stacked panels. 500 StackedPanelCollection* stack = panel_manager->CreateStack(); 501 gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); 502 Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); 503 gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); 504 Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); 505 gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 250, 120); 506 Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack); 507 ASSERT_EQ(1, panel_manager->num_stacks()); 508 ASSERT_EQ(3, stack->num_panels()); 509 510 scoped_ptr<NativePanelTesting> panel1_testing( 511 CreateNativePanelTesting(panel1)); 512 scoped_ptr<NativePanelTesting> panel2_testing( 513 CreateNativePanelTesting(panel2)); 514 scoped_ptr<NativePanelTesting> panel3_testing( 515 CreateNativePanelTesting(panel3)); 516 517 // Only P1 shows minimize button. 518 if (PanelManager::CanUseSystemMinimize()) 519 EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 520 else 521 EXPECT_FALSE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 522 EXPECT_FALSE(panel2_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 523 EXPECT_FALSE(panel3_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 524 525 // Drag P2 away to unstack from P1. 526 // Expect only P2, top panel of the stack consisting P2 and P3, shows minimize 527 // button. 528 gfx::Point mouse_location(panel2->GetBounds().origin()); 529 panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); 530 gfx::Vector2d drag_delta_to_unstack(120, 50); 531 panel2_testing->DragTitlebar(mouse_location + drag_delta_to_unstack); 532 panel2_testing->FinishDragTitlebar(); 533 ASSERT_EQ(1, panel_manager->detached_collection()->num_panels()); 534 ASSERT_EQ(1, panel_manager->num_stacks()); 535 ASSERT_EQ(2, stack->num_panels()); 536 537 if (PanelManager::CanUseSystemMinimize()) { 538 EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 539 EXPECT_TRUE(panel2_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 540 } else { 541 EXPECT_FALSE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 542 EXPECT_FALSE(panel2_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 543 } 544 EXPECT_FALSE(panel3_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 545 546 // Drag P1 to stack to the top edge of P2. 547 // Expect only P1, top panel of the stack consisting P1, P2 and P3, shows 548 // minimize button. 549 gfx::Rect bounds1 = panel1->GetBounds(); 550 gfx::Rect bounds2 = panel2->GetBounds(); 551 mouse_location = bounds1.origin(); 552 panel1_testing->PressLeftMouseButtonTitlebar(mouse_location); 553 gfx::Vector2d drag_delta_to_stack(bounds2.x() - bounds1.x(), 554 bounds2.y() - bounds1.bottom()); 555 panel1_testing->DragTitlebar(mouse_location + drag_delta_to_stack); 556 panel1_testing->FinishDragTitlebar(); 557 ASSERT_EQ(0, panel_manager->detached_collection()->num_panels()); 558 ASSERT_EQ(1, panel_manager->num_stacks()); 559 ASSERT_EQ(3, stack->num_panels()); 560 561 if (PanelManager::CanUseSystemMinimize()) 562 EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 563 else 564 EXPECT_FALSE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 565 EXPECT_FALSE(panel2_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 566 EXPECT_FALSE(panel3_testing->IsButtonVisible(panel::MINIMIZE_BUTTON)); 567 568 panel_manager->CloseAll(); 569 } 570 571 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, DISABLED_ClickMinimizeButton) { 572 PanelManager* panel_manager = PanelManager::GetInstance(); 573 574 // Create 2 stacked panels. 575 StackedPanelCollection* stack = panel_manager->CreateStack(); 576 gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); 577 Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); 578 gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); 579 Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); 580 ASSERT_EQ(1, panel_manager->num_stacks()); 581 582 scoped_ptr<NativePanelTesting> panel1_testing( 583 CreateNativePanelTesting(panel1)); 584 585 EXPECT_FALSE(panel1->IsMinimized()); 586 EXPECT_FALSE(panel2->IsMinimized()); 587 588 // Collapsing P1 by calling its Minimize API. 589 panel1->OnMinimizeButtonClicked(panel::NO_MODIFIER); 590 EXPECT_FALSE(panel1->IsMinimized()); 591 EXPECT_FALSE(panel2->IsMinimized()); 592 EXPECT_TRUE(panel1_testing->VerifySystemMinimizeState()); 593 594 panel_manager->CloseAll(); 595 } 596 597 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, UngroupMinimizedPanels) { 598 PanelManager* panel_manager = PanelManager::GetInstance(); 599 600 // Create 3 stacked panels. 601 StackedPanelCollection* stack = panel_manager->CreateStack(); 602 gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); 603 Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); 604 gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); 605 Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); 606 gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 250, 120); 607 Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack); 608 ASSERT_EQ(1, panel_manager->num_stacks()); 609 ASSERT_EQ(3, stack->num_panels()); 610 611 scoped_ptr<NativePanelTesting> panel2_testing( 612 CreateNativePanelTesting(panel2)); 613 scoped_ptr<NativePanelTesting> panel3_testing( 614 CreateNativePanelTesting(panel3)); 615 616 // Minimize these 3 panels. 617 panel1->Minimize(); 618 WaitForBoundsAnimationFinished(panel1); 619 panel2->Minimize(); 620 WaitForBoundsAnimationFinished(panel3); 621 panel3->Minimize(); 622 WaitForBoundsAnimationFinished(panel3); 623 624 EXPECT_TRUE(panel1->IsMinimized()); 625 EXPECT_TRUE(panel2->IsMinimized()); 626 EXPECT_TRUE(panel3->IsMinimized()); 627 628 gfx::Rect panel1_expected_bounds(panel1_initial_bounds); 629 panel1_expected_bounds.set_height(panel1->TitleOnlyHeight()); 630 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 631 gfx::Rect panel2_expected_bounds(panel1_expected_bounds.x(), 632 panel1_expected_bounds.bottom(), 633 panel1_expected_bounds.width(), 634 panel2->TitleOnlyHeight()); 635 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 636 gfx::Rect panel3_expected_bounds(panel2_expected_bounds.x(), 637 panel2_expected_bounds.bottom(), 638 panel2_expected_bounds.width(), 639 panel3->TitleOnlyHeight()); 640 EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); 641 642 // Drag P2 away to unstack from P1. 643 // Expect P2 and P3 are still stacked and minimized while P1 becomes detached 644 // and expanded. The minimize button of P2 should become visible now. 645 gfx::Point mouse_location(panel2->GetBounds().origin()); 646 panel2_testing->PressLeftMouseButtonTitlebar(mouse_location); 647 gfx::Vector2d drag_delta(120, 50); 648 panel2_testing->DragTitlebar(mouse_location + drag_delta); 649 panel2_testing->FinishDragTitlebar(); 650 WaitForBoundsAnimationFinished(panel1); 651 ASSERT_EQ(1, panel_manager->detached_collection()->num_panels()); 652 ASSERT_EQ(1, panel_manager->num_stacks()); 653 ASSERT_EQ(2, stack->num_panels()); 654 655 EXPECT_FALSE(panel1->IsMinimized()); 656 EXPECT_TRUE(panel2->IsMinimized()); 657 EXPECT_TRUE(panel3->IsMinimized()); 658 659 panel1_expected_bounds.set_height(panel1_initial_bounds.height()); 660 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 661 panel2_expected_bounds.Offset(drag_delta); 662 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 663 panel3_expected_bounds.Offset(drag_delta); 664 EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); 665 666 // Drag P3 away to unstack from P2. 667 // Expect both panels become detached and expanded. 668 mouse_location = panel3->GetBounds().origin(); 669 panel3_testing->PressLeftMouseButtonTitlebar(mouse_location); 670 panel3_testing->DragTitlebar(mouse_location + drag_delta); 671 panel3_testing->FinishDragTitlebar(); 672 WaitForBoundsAnimationFinished(panel2); 673 WaitForBoundsAnimationFinished(panel3); 674 ASSERT_EQ(3, panel_manager->detached_collection()->num_panels()); 675 ASSERT_EQ(0, panel_manager->num_stacks()); 676 677 EXPECT_FALSE(panel1->IsMinimized()); 678 EXPECT_FALSE(panel2->IsMinimized()); 679 EXPECT_FALSE(panel3->IsMinimized()); 680 681 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 682 panel2_expected_bounds.set_height(panel2_initial_bounds.height()); 683 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 684 panel3_expected_bounds.Offset(drag_delta); 685 panel3_expected_bounds.set_height(panel3_initial_bounds.height()); 686 EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); 687 688 panel_manager->CloseAll(); 689 } 690 691 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 692 AddNewPanelToStackWithMostPanels) { 693 PanelManager* panel_manager = PanelManager::GetInstance(); 694 695 // Create one stack with 2 panels. 696 StackedPanelCollection* stack1 = panel_manager->CreateStack(); 697 CreateStackedPanel("1", gfx::Rect(200, 50, 200, 150), stack1); 698 CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack1); 699 ASSERT_EQ(2, panel_manager->num_panels()); 700 ASSERT_EQ(1, panel_manager->num_stacks()); 701 ASSERT_EQ(2, stack1->num_panels()); 702 703 // Create another stack with 3 panels. 704 StackedPanelCollection* stack2 = panel_manager->CreateStack(); 705 CreateStackedPanel("3", gfx::Rect(100, 50, 200, 150), stack2); 706 CreateStackedPanel("4", gfx::Rect(0, 0, 150, 100), stack2); 707 CreateStackedPanel("5", gfx::Rect(0, 0, 250, 120), stack2); 708 ASSERT_EQ(5, panel_manager->num_panels()); 709 ASSERT_EQ(2, panel_manager->num_stacks()); 710 ASSERT_EQ(3, stack2->num_panels()); 711 712 // Create new panel. Expect that it will append to stack2 since it has most 713 // panels. 714 CreatePanelParams params("N", gfx::Rect(50, 50, 150, 100), SHOW_AS_ACTIVE); 715 params.create_mode = PanelManager::CREATE_AS_DETACHED; 716 Panel* new_panel = CreatePanelWithParams(params); 717 EXPECT_EQ(6, panel_manager->num_panels()); 718 EXPECT_EQ(2, panel_manager->num_stacks()); 719 EXPECT_EQ(2, stack1->num_panels()); 720 EXPECT_EQ(4, stack2->num_panels()); 721 EXPECT_TRUE(stack2->HasPanel(new_panel)); 722 EXPECT_TRUE(new_panel == stack2->bottom_panel()); 723 724 panel_manager->CloseAll(); 725 } 726 727 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 728 AddNewPanelToRightMostStack) { 729 PanelManager* panel_manager = PanelManager::GetInstance(); 730 731 // Create one stack with 2 panels. 732 StackedPanelCollection* stack1 = panel_manager->CreateStack(); 733 CreateStackedPanel("1", gfx::Rect(100, 50, 200, 150), stack1); 734 CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack1); 735 ASSERT_EQ(2, panel_manager->num_panels()); 736 ASSERT_EQ(1, panel_manager->num_stacks()); 737 ASSERT_EQ(2, stack1->num_panels()); 738 739 // Create another stack with 2 panels. 740 StackedPanelCollection* stack2 = panel_manager->CreateStack(); 741 CreateStackedPanel("3", gfx::Rect(200, 50, 200, 150), stack2); 742 CreateStackedPanel("4", gfx::Rect(0, 0, 150, 100), stack2); 743 ASSERT_EQ(4, panel_manager->num_panels()); 744 ASSERT_EQ(2, panel_manager->num_stacks()); 745 ASSERT_EQ(2, stack2->num_panels()); 746 747 // Create new panel. Both stack1 and stack2 have same number of panels. Since 748 // stack2 is right-most, new panel will be added to it. 749 CreatePanelParams params("N", gfx::Rect(50, 50, 150, 100), SHOW_AS_ACTIVE); 750 params.create_mode = PanelManager::CREATE_AS_DETACHED; 751 Panel* new_panel = CreatePanelWithParams(params); 752 EXPECT_EQ(5, panel_manager->num_panels()); 753 EXPECT_EQ(2, panel_manager->num_stacks()); 754 EXPECT_EQ(2, stack1->num_panels()); 755 EXPECT_EQ(3, stack2->num_panels()); 756 EXPECT_TRUE(stack2->HasPanel(new_panel)); 757 EXPECT_TRUE(new_panel == stack2->bottom_panel()); 758 759 panel_manager->CloseAll(); 760 } 761 762 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 763 AddNewPanelToTopMostStack) { 764 PanelManager* panel_manager = PanelManager::GetInstance(); 765 766 // Create one stack with 2 panels. 767 StackedPanelCollection* stack1 = panel_manager->CreateStack(); 768 CreateStackedPanel("1", gfx::Rect(100, 90, 200, 150), stack1); 769 CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack1); 770 ASSERT_EQ(2, panel_manager->num_panels()); 771 ASSERT_EQ(1, panel_manager->num_stacks()); 772 ASSERT_EQ(2, stack1->num_panels()); 773 774 // Create another stack with 2 panels. 775 StackedPanelCollection* stack2 = panel_manager->CreateStack(); 776 CreateStackedPanel("3", gfx::Rect(100, 50, 200, 150), stack2); 777 CreateStackedPanel("4", gfx::Rect(0, 0, 150, 100), stack2); 778 ASSERT_EQ(4, panel_manager->num_panels()); 779 ASSERT_EQ(2, panel_manager->num_stacks()); 780 ASSERT_EQ(2, stack2->num_panels()); 781 782 // Create new panel. Both stack1 and stack2 have same number of panels and 783 // same right position. Since stack2 is top-most, new panel will be added to 784 // it. 785 CreatePanelParams params("N", gfx::Rect(50, 50, 150, 100), SHOW_AS_ACTIVE); 786 params.create_mode = PanelManager::CREATE_AS_DETACHED; 787 Panel* new_panel = CreatePanelWithParams(params); 788 EXPECT_EQ(5, panel_manager->num_panels()); 789 EXPECT_EQ(2, panel_manager->num_stacks()); 790 EXPECT_EQ(2, stack1->num_panels()); 791 EXPECT_EQ(3, stack2->num_panels()); 792 EXPECT_TRUE(stack2->HasPanel(new_panel)); 793 EXPECT_TRUE(new_panel == stack2->bottom_panel()); 794 795 panel_manager->CloseAll(); 796 } 797 798 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 799 AddNewPanelToGroupWithRightMostDetachedPanel) { 800 PanelManager* panel_manager = PanelManager::GetInstance(); 801 802 // Create 2 detached panels. 803 CreateDetachedPanel("1", gfx::Rect(200, 50, 250, 150)); 804 Panel* panel2 = CreateDetachedPanel("2", gfx::Rect(250, 100, 150, 100)); 805 ASSERT_EQ(2, panel_manager->num_panels()); 806 ASSERT_EQ(0, panel_manager->num_stacks()); 807 ASSERT_EQ(2, panel_manager->detached_collection()->num_panels()); 808 809 // Create new panel. Expect that new panel will stack to the bottom of panel2 810 // since it is right-most. 811 CreatePanelParams params("N", gfx::Rect(50, 50, 150, 100), SHOW_AS_ACTIVE); 812 params.create_mode = PanelManager::CREATE_AS_DETACHED; 813 Panel* new_panel = CreatePanelWithParams(params); 814 EXPECT_EQ(3, panel_manager->num_panels()); 815 EXPECT_EQ(1, panel_manager->detached_collection()->num_panels()); 816 ASSERT_EQ(1, panel_manager->num_stacks()); 817 StackedPanelCollection* stack = panel_manager->stacks().front(); 818 EXPECT_EQ(2, stack->num_panels()); 819 EXPECT_TRUE(panel2 == stack->top_panel()); 820 EXPECT_TRUE(new_panel == stack->bottom_panel()); 821 822 panel_manager->CloseAll(); 823 } 824 825 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 826 AddNewPanelToGroupWitTopMostDetachedPanel) { 827 PanelManager* panel_manager = PanelManager::GetInstance(); 828 829 // Create 2 detached panels. 830 CreateDetachedPanel("1", gfx::Rect(200, 100, 100, 150)); 831 Panel* panel2 = CreateDetachedPanel("2", gfx::Rect(200, 50, 100, 100)); 832 ASSERT_EQ(2, panel_manager->num_panels()); 833 ASSERT_EQ(0, panel_manager->num_stacks()); 834 ASSERT_EQ(2, panel_manager->detached_collection()->num_panels()); 835 836 // Create new panel. Expect that new panel will stack to the bottom of panel2 837 // since it is top-most. 838 CreatePanelParams params("N", gfx::Rect(50, 50, 150, 100), SHOW_AS_ACTIVE); 839 params.create_mode = PanelManager::CREATE_AS_DETACHED; 840 Panel* new_panel = CreatePanelWithParams(params); 841 EXPECT_EQ(3, panel_manager->num_panels()); 842 EXPECT_EQ(1, panel_manager->detached_collection()->num_panels()); 843 ASSERT_EQ(1, panel_manager->num_stacks()); 844 StackedPanelCollection* stack = panel_manager->stacks().front(); 845 EXPECT_EQ(2, stack->num_panels()); 846 EXPECT_TRUE(panel2 == stack->top_panel()); 847 EXPECT_TRUE(new_panel == stack->bottom_panel()); 848 849 panel_manager->CloseAll(); 850 } 851 852 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 853 AddNewPanelToStackWithCollapseToFit) { 854 PanelManager* panel_manager = PanelManager::GetInstance(); 855 856 // Create one stack with 4 panels. 857 // The panels from most recent active to least recent active are: 858 // P4 P3 P2 P1 859 StackedPanelCollection* stack = panel_manager->CreateStack(); 860 Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 50, 200, 140), stack); 861 Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 150), stack); 862 Panel* panel3 = CreateStackedPanel("3", gfx::Rect(0, 0, 180, 120), stack); 863 Panel* panel4 = CreateStackedPanel("4", gfx::Rect(0, 0, 170, 110), stack); 864 ASSERT_EQ(4, panel_manager->num_panels()); 865 ASSERT_EQ(1, panel_manager->num_stacks()); 866 ASSERT_EQ(4, stack->num_panels()); 867 EXPECT_FALSE(panel1->IsMinimized()); 868 EXPECT_FALSE(panel2->IsMinimized()); 869 EXPECT_FALSE(panel3->IsMinimized()); 870 EXPECT_FALSE(panel4->IsMinimized()); 871 872 // Create a panel. Expect the least recent active panel P1 gets minimized such 873 // that there is enough space for new panel to append to the stack. 874 // The panels from most recent active to least recent active are: 875 // PM P4 P3 P2 P1* 876 CreatePanelParams params1("M", gfx::Rect(50, 50, 300, 110), SHOW_AS_ACTIVE); 877 params1.create_mode = PanelManager::CREATE_AS_DETACHED; 878 Panel* new_panel1 = CreatePanelWithParams(params1); 879 EXPECT_EQ(5, panel_manager->num_panels()); 880 EXPECT_EQ(1, panel_manager->num_stacks()); 881 EXPECT_EQ(5, stack->num_panels()); 882 EXPECT_TRUE(new_panel1 == stack->bottom_panel()); 883 EXPECT_TRUE(panel1->IsMinimized()); 884 EXPECT_FALSE(panel2->IsMinimized()); 885 EXPECT_FALSE(panel3->IsMinimized()); 886 EXPECT_FALSE(panel4->IsMinimized()); 887 EXPECT_FALSE(new_panel1->IsMinimized()); 888 889 // Create another panel. Expect P2 and P3 are minimized such that there is 890 // enough space for new panel to append to the stack. 891 CreatePanelParams params2("N", gfx::Rect(50, 50, 300, 180), SHOW_AS_ACTIVE); 892 params2.create_mode = PanelManager::CREATE_AS_DETACHED; 893 Panel* new_panel2 = CreatePanelWithParams(params2); 894 EXPECT_EQ(6, panel_manager->num_panels()); 895 EXPECT_EQ(1, panel_manager->num_stacks()); 896 EXPECT_EQ(6, stack->num_panels()); 897 EXPECT_TRUE(new_panel2 == stack->bottom_panel()); 898 EXPECT_TRUE(panel1->IsMinimized()); 899 EXPECT_TRUE(panel2->IsMinimized()); 900 EXPECT_TRUE(panel3->IsMinimized()); 901 EXPECT_FALSE(panel4->IsMinimized()); 902 EXPECT_FALSE(new_panel1->IsMinimized()); 903 EXPECT_FALSE(new_panel2->IsMinimized()); 904 905 panel_manager->CloseAll(); 906 } 907 908 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 909 AddNewPanelToGroupWithDetachedPanelWithCollapseToFit) { 910 PanelManager* panel_manager = PanelManager::GetInstance(); 911 912 // Create 2 detached panels. 913 // Since P2 is active, it will not get collapsed when the new panel to stack 914 // with needs the space. 915 Panel* panel1 = 916 CreateInactiveDetachedPanel("1", gfx::Rect(100, 310, 200, 200)); 917 Panel* panel2 = CreateDetachedPanel("2", gfx::Rect(300, 300, 150, 200)); 918 ASSERT_EQ(2, panel_manager->num_panels()); 919 ASSERT_EQ(0, panel_manager->num_stacks()); 920 ASSERT_EQ(2, panel_manager->detached_collection()->num_panels()); 921 922 // Create new panel. Expect panel1 is minimized such that there is enough 923 // space for new panel to append to panel1. 924 CreatePanelParams params("N", gfx::Rect(50, 50, 300, 220), SHOW_AS_ACTIVE); 925 params.create_mode = PanelManager::CREATE_AS_DETACHED; 926 Panel* new_panel = CreatePanelWithParams(params); 927 EXPECT_EQ(3, panel_manager->num_panels()); 928 EXPECT_EQ(1, panel_manager->detached_collection()->num_panels()); 929 ASSERT_EQ(1, panel_manager->num_stacks()); 930 StackedPanelCollection* stack = panel_manager->stacks().front(); 931 EXPECT_EQ(2, stack->num_panels()); 932 EXPECT_TRUE(panel1 == stack->top_panel()); 933 EXPECT_TRUE(new_panel == stack->bottom_panel()); 934 EXPECT_TRUE(panel1->IsMinimized()); 935 EXPECT_FALSE(panel2->IsMinimized()); 936 EXPECT_FALSE(new_panel->IsMinimized()); 937 938 panel_manager->CloseAll(); 939 } 940 941 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 942 AddNewPanelAsDetachedDueToNoPanelToGroupWith) { 943 PanelManager* panel_manager = PanelManager::GetInstance(); 944 945 // Create one stack with 2 panels. 946 StackedPanelCollection* stack = panel_manager->CreateStack(); 947 CreateStackedPanel("1", gfx::Rect(100, 350, 200, 100), stack); 948 CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack); 949 ASSERT_EQ(2, panel_manager->num_panels()); 950 ASSERT_EQ(1, panel_manager->num_stacks()); 951 ASSERT_EQ(2, stack->num_panels()); 952 953 // Create 2 detached panels. 954 CreateDetachedPanel("3", gfx::Rect(300, 450, 200, 100)); 955 CreateDetachedPanel("4", gfx::Rect(250, 150, 150, 200)); 956 ASSERT_EQ(4, panel_manager->num_panels()); 957 ASSERT_EQ(2, panel_manager->detached_collection()->num_panels()); 958 ASSERT_EQ(1, panel_manager->num_stacks()); 959 960 // Create new panel. Expect that new panel has to be created as detached due 961 // to that there is not enough space from any stack or detached panel. 962 CreatePanelParams params("N", gfx::Rect(50, 50, 300, 300), SHOW_AS_ACTIVE); 963 params.create_mode = PanelManager::CREATE_AS_DETACHED; 964 Panel* new_panel = CreatePanelWithParams(params); 965 EXPECT_EQ(5, panel_manager->num_panels()); 966 EXPECT_EQ(3, panel_manager->detached_collection()->num_panels()); 967 EXPECT_EQ(1, panel_manager->num_stacks()); 968 EXPECT_EQ(2, stack->num_panels()); 969 EXPECT_TRUE(panel_manager->detached_collection()->HasPanel(new_panel)); 970 971 panel_manager->CloseAll(); 972 } 973 974 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 975 AddNewPanelFromDifferentExtension) { 976 PanelManager* panel_manager = PanelManager::GetInstance(); 977 978 // Create 2 test extensions. 979 base::DictionaryValue empty_value; 980 scoped_refptr<extensions::Extension> extension1 = 981 CreateExtension(FILE_PATH_LITERAL("TestExtension1"), 982 extensions::Manifest::INTERNAL, empty_value); 983 std::string extension1_app_name = 984 web_app::GenerateApplicationNameFromExtensionId(extension1->id()); 985 scoped_refptr<extensions::Extension> extension2 = 986 CreateExtension(FILE_PATH_LITERAL("TestExtension2"), 987 extensions::Manifest::INTERNAL, empty_value); 988 std::string extension2_app_name = 989 web_app::GenerateApplicationNameFromExtensionId(extension2->id()); 990 991 // Create 2 panels from extension1. Expect that these 2 panels stack together. 992 CreatePanelParams params1( 993 extension1_app_name, gfx::Rect(50, 50, 100, 100), SHOW_AS_ACTIVE); 994 params1.create_mode = PanelManager::CREATE_AS_DETACHED; 995 Panel* panel1 = CreatePanelWithParams(params1); 996 CreatePanelParams params2( 997 extension1_app_name, gfx::Rect(100, 100, 200, 100), SHOW_AS_ACTIVE); 998 params2.create_mode = PanelManager::CREATE_AS_DETACHED; 999 Panel* panel2 = CreatePanelWithParams(params2); 1000 EXPECT_EQ(2, panel_manager->num_panels()); 1001 EXPECT_EQ(1, panel_manager->num_stacks()); 1002 StackedPanelCollection* stack1 = panel_manager->stacks().back(); 1003 EXPECT_TRUE(stack1->HasPanel(panel1)); 1004 EXPECT_TRUE(stack1->HasPanel(panel2)); 1005 1006 // Create 2 panels from extension2. Expect that these 2 panels form a separate 1007 // stack. 1008 CreatePanelParams params3( 1009 extension2_app_name, gfx::Rect(350, 350, 100, 100), SHOW_AS_ACTIVE); 1010 params3.create_mode = PanelManager::CREATE_AS_DETACHED; 1011 Panel* panel3 = CreatePanelWithParams(params3); 1012 CreatePanelParams params4( 1013 extension2_app_name, gfx::Rect(100, 100, 200, 100), SHOW_AS_ACTIVE); 1014 params4.create_mode = PanelManager::CREATE_AS_DETACHED; 1015 Panel* panel4 = CreatePanelWithParams(params4); 1016 EXPECT_EQ(4, panel_manager->num_panels()); 1017 EXPECT_EQ(2, panel_manager->num_stacks()); 1018 StackedPanelCollection* stack2 = panel_manager->stacks().back(); 1019 EXPECT_TRUE(stack2->HasPanel(panel3)); 1020 EXPECT_TRUE(stack2->HasPanel(panel4)); 1021 1022 // Create one more panel from extension1. Expect that new panel should join 1023 // with the stack of panel1 and panel2. 1024 CreatePanelParams params5( 1025 extension1_app_name, gfx::Rect(0, 0, 100, 100), SHOW_AS_ACTIVE); 1026 params5.create_mode = PanelManager::CREATE_AS_DETACHED; 1027 Panel* panel5 = CreatePanelWithParams(params5); 1028 EXPECT_EQ(5, panel_manager->num_panels()); 1029 EXPECT_EQ(2, panel_manager->num_stacks()); 1030 EXPECT_TRUE(stack1->HasPanel(panel5)); 1031 1032 // Create one more panel from extension2. Expect that new panel should join 1033 // with the stack of panel3 and panel4. 1034 CreatePanelParams params6( 1035 extension2_app_name, gfx::Rect(0, 0, 100, 100), SHOW_AS_ACTIVE); 1036 params6.create_mode = PanelManager::CREATE_AS_DETACHED; 1037 Panel* panel6 = CreatePanelWithParams(params6); 1038 EXPECT_EQ(6, panel_manager->num_panels()); 1039 EXPECT_EQ(2, panel_manager->num_stacks()); 1040 EXPECT_TRUE(stack2->HasPanel(panel6)); 1041 1042 panel_manager->CloseAll(); 1043 } 1044 1045 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 1046 AddNewPanelFromDifferentProfile) { 1047 PanelManager* panel_manager = PanelManager::GetInstance(); 1048 1049 // Create a new profile. 1050 Profile* profile1 = browser()->profile(); 1051 scoped_ptr<TestingProfile> profile2(new TestingProfile()); 1052 1053 // Create 2 panels from profile1. Expect that these 2 panels stack together. 1054 CreatePanelParams params1( 1055 "1", gfx::Rect(50, 50, 100, 100), SHOW_AS_ACTIVE); 1056 params1.create_mode = PanelManager::CREATE_AS_DETACHED; 1057 params1.profile = profile1; 1058 Panel* panel1 = CreatePanelWithParams(params1); 1059 CreatePanelParams params2( 1060 "2", gfx::Rect(100, 100, 200, 100), SHOW_AS_ACTIVE); 1061 params2.create_mode = PanelManager::CREATE_AS_DETACHED; 1062 params2.profile = profile1; 1063 Panel* panel2 = CreatePanelWithParams(params2); 1064 EXPECT_EQ(2, panel_manager->num_panels()); 1065 EXPECT_EQ(1, panel_manager->num_stacks()); 1066 StackedPanelCollection* stack1 = panel_manager->stacks().back(); 1067 EXPECT_TRUE(stack1->HasPanel(panel1)); 1068 EXPECT_TRUE(stack1->HasPanel(panel2)); 1069 1070 // Create 2 panels from profile2. Expect that these 2 panels form a separate 1071 // stack. 1072 CreatePanelParams params3( 1073 "3", gfx::Rect(350, 350, 100, 100), SHOW_AS_ACTIVE); 1074 params3.create_mode = PanelManager::CREATE_AS_DETACHED; 1075 params3.profile = profile2.get(); 1076 Panel* panel3 = CreatePanelWithParams(params3); 1077 CreatePanelParams params4( 1078 "4", gfx::Rect(100, 100, 200, 100), SHOW_AS_ACTIVE); 1079 params4.create_mode = PanelManager::CREATE_AS_DETACHED; 1080 params4.profile = profile2.get(); 1081 Panel* panel4 = CreatePanelWithParams(params4); 1082 EXPECT_EQ(4, panel_manager->num_panels()); 1083 EXPECT_EQ(2, panel_manager->num_stacks()); 1084 StackedPanelCollection* stack2 = panel_manager->stacks().back(); 1085 EXPECT_TRUE(stack2->HasPanel(panel3)); 1086 EXPECT_TRUE(stack2->HasPanel(panel4)); 1087 1088 // Create one more panel from profile1. Expect that new panel should join 1089 // with the stack of panel1 and panel2. 1090 CreatePanelParams params5( 1091 "5", gfx::Rect(0, 0, 100, 100), SHOW_AS_ACTIVE); 1092 params5.create_mode = PanelManager::CREATE_AS_DETACHED; 1093 params5.profile = profile1; 1094 Panel* panel5 = CreatePanelWithParams(params5); 1095 EXPECT_EQ(5, panel_manager->num_panels()); 1096 EXPECT_EQ(2, panel_manager->num_stacks()); 1097 EXPECT_TRUE(stack1->HasPanel(panel5)); 1098 1099 // Create one more panel from profile2. Expect that new panel should join 1100 // with the stack of panel3 and panel4. 1101 CreatePanelParams params6( 1102 "6", gfx::Rect(0, 0, 100, 100), SHOW_AS_ACTIVE); 1103 params6.create_mode = PanelManager::CREATE_AS_DETACHED; 1104 params6.profile = profile2.get(); 1105 Panel* panel6 = CreatePanelWithParams(params6); 1106 EXPECT_EQ(6, panel_manager->num_panels()); 1107 EXPECT_EQ(2, panel_manager->num_stacks()); 1108 EXPECT_TRUE(stack2->HasPanel(panel6)); 1109 1110 // Wait until all panels created from profile2 get fully closed since profile2 1111 // is going out of scope at the exit of this function. 1112 CloseWindowAndWait(panel3); 1113 CloseWindowAndWait(panel4); 1114 CloseWindowAndWait(panel6); 1115 1116 panel_manager->CloseAll(); 1117 } 1118 1119 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 1120 AddNewPanelNotWithSystemMinimizedDetachedPanel) { 1121 PanelManager* panel_manager = PanelManager::GetInstance(); 1122 1123 // Create 1 detached panel. 1124 Panel* panel1 = CreateDetachedPanel("1", gfx::Rect(200, 50, 250, 150)); 1125 EXPECT_EQ(1, panel_manager->num_panels()); 1126 EXPECT_EQ(0, panel_manager->num_stacks()); 1127 EXPECT_EQ(1, panel_manager->detached_collection()->num_panels()); 1128 EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); 1129 1130 // Minimize the detached panel by system. 1131 panel1->OnMinimizeButtonClicked(panel::NO_MODIFIER); 1132 1133 // Create new panel. Expect that new panel will open as a separate detached 1134 // panel, instead of being grouped with the system-minimized detached panel. 1135 CreatePanelParams params("N", gfx::Rect(50, 50, 150, 100), SHOW_AS_ACTIVE); 1136 params.create_mode = PanelManager::CREATE_AS_DETACHED; 1137 Panel* new_panel = CreatePanelWithParams(params); 1138 EXPECT_EQ(2, panel_manager->num_panels()); 1139 EXPECT_EQ(2, panel_manager->detached_collection()->num_panels()); 1140 EXPECT_EQ(0, panel_manager->num_stacks()); 1141 EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); 1142 EXPECT_EQ(PanelCollection::DETACHED, new_panel->collection()->type()); 1143 1144 panel_manager->CloseAll(); 1145 } 1146 1147 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 1148 AddNewPanelNotWithSystemMinimizedStack) { 1149 PanelManager* panel_manager = PanelManager::GetInstance(); 1150 1151 // Create one stack with 2 panels. 1152 StackedPanelCollection* stack = panel_manager->CreateStack(); 1153 Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 90, 200, 150), stack); 1154 Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack); 1155 EXPECT_EQ(2, panel_manager->num_panels()); 1156 EXPECT_EQ(0, panel_manager->detached_collection()->num_panels()); 1157 EXPECT_EQ(1, panel_manager->num_stacks()); 1158 EXPECT_EQ(2, stack->num_panels()); 1159 EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); 1160 EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); 1161 1162 // Minimize the stack by system. 1163 stack->OnMinimizeButtonClicked(panel1, panel::NO_MODIFIER); 1164 1165 // Create new panel. Expect that new panel will open as a separate detached 1166 // panel, instead of appending to the system-minimized stack. 1167 CreatePanelParams params("N", gfx::Rect(50, 50, 150, 100), SHOW_AS_ACTIVE); 1168 params.create_mode = PanelManager::CREATE_AS_DETACHED; 1169 Panel* new_panel = CreatePanelWithParams(params); 1170 EXPECT_EQ(3, panel_manager->num_panels()); 1171 EXPECT_EQ(1, panel_manager->detached_collection()->num_panels()); 1172 EXPECT_EQ(1, panel_manager->num_stacks()); 1173 EXPECT_EQ(2, stack->num_panels()); 1174 EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type()); 1175 EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); 1176 EXPECT_EQ(PanelCollection::DETACHED, new_panel->collection()->type()); 1177 1178 panel_manager->CloseAll(); 1179 } 1180 1181 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, ClosePanels) { 1182 PanelManager* panel_manager = PanelManager::GetInstance(); 1183 1184 // Create 3 stacked panels. 1185 StackedPanelCollection* stack = panel_manager->CreateStack(); 1186 gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); 1187 Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); 1188 gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); 1189 Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); 1190 gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 250, 120); 1191 Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack); 1192 ASSERT_EQ(3, panel_manager->num_panels()); 1193 ASSERT_EQ(1, panel_manager->num_stacks()); 1194 ASSERT_EQ(3, stack->num_panels()); 1195 1196 gfx::Rect panel1_expected_bounds(panel1_initial_bounds); 1197 EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds()); 1198 gfx::Rect panel2_expected_bounds(panel1_expected_bounds.x(), 1199 panel1_expected_bounds.bottom(), 1200 panel1_expected_bounds.width(), 1201 panel2_initial_bounds.height()); 1202 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 1203 gfx::Rect panel3_expected_bounds(panel2_expected_bounds.x(), 1204 panel2_expected_bounds.bottom(), 1205 panel2_expected_bounds.width(), 1206 panel3_initial_bounds.height()); 1207 EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); 1208 1209 // Close P1. Expect that P2 and P3 should move up. 1210 CloseWindowAndWait(panel1); 1211 WaitForBoundsAnimationFinished(panel2); 1212 WaitForBoundsAnimationFinished(panel3); 1213 ASSERT_EQ(2, panel_manager->num_panels()); 1214 ASSERT_EQ(1, panel_manager->num_stacks()); 1215 ASSERT_EQ(2, stack->num_panels()); 1216 EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type()); 1217 EXPECT_EQ(PanelCollection::STACKED, panel3->collection()->type()); 1218 1219 panel2_expected_bounds.set_y(panel1_expected_bounds.y()); 1220 EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds()); 1221 panel3_expected_bounds.set_y(panel2_expected_bounds.bottom()); 1222 EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); 1223 1224 // Close P2. Expect that P3 should become detached and move up. 1225 CloseWindowAndWait(panel2); 1226 WaitForBoundsAnimationFinished(panel3); 1227 ASSERT_EQ(1, panel_manager->num_panels()); 1228 ASSERT_EQ(0, panel_manager->num_stacks()); 1229 EXPECT_EQ(PanelCollection::DETACHED, panel3->collection()->type()); 1230 1231 panel3_expected_bounds.set_y(panel2_expected_bounds.y()); 1232 EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds()); 1233 1234 panel_manager->CloseAll(); 1235 } 1236 1237 // Skip the test since active state might not be fully supported for some window 1238 // managers. 1239 #if defined(OS_MACOSX) 1240 #define MAYBE_FocusNextPanelOnPanelClose DISABLED_FocusNextPanelOnPanelClose 1241 #else 1242 #define MAYBE_FocusNextPanelOnPanelClose FocusNextPanelOnPanelClose 1243 #endif 1244 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 1245 MAYBE_FocusNextPanelOnPanelClose) { 1246 PanelManager* panel_manager = PanelManager::GetInstance(); 1247 1248 // Create 3 stacked panels. 1249 StackedPanelCollection* stack = panel_manager->CreateStack(); 1250 Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 50, 200, 200), stack); 1251 Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack); 1252 Panel* panel3 = CreateStackedPanel("3", gfx::Rect(0, 0, 150, 120), stack); 1253 ASSERT_EQ(3, stack->num_panels()); 1254 ASSERT_FALSE(panel1->IsActive()); 1255 ASSERT_FALSE(panel2->IsActive()); 1256 ASSERT_TRUE(panel3->IsActive()); 1257 1258 // Close P3. Expect P2 should become active. 1259 CloseWindowAndWait(panel3); 1260 EXPECT_FALSE(panel1->IsActive()); 1261 EXPECT_TRUE(panel2->IsActive()); 1262 1263 // Close P2. Expect P1 should become active. 1264 CloseWindowAndWait(panel2); 1265 EXPECT_TRUE(panel1->IsActive()); 1266 1267 panel_manager->CloseAll(); 1268 } 1269 1270 // Skip the test since active state might not be fully supported for some window 1271 // managers. 1272 #if defined(OS_MACOSX) 1273 #define MAYBE_FocusNextUnminimizedPanelOnPanelClose \ 1274 DISABLED_FocusNextUnminimizedPanelOnPanelClose 1275 #else 1276 #define MAYBE_FocusNextUnminimizedPanelOnPanelClose \ 1277 FocusNextUnminimizedPanelOnPanelClose 1278 #endif 1279 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 1280 MAYBE_FocusNextUnminimizedPanelOnPanelClose) { 1281 PanelManager* panel_manager = PanelManager::GetInstance(); 1282 1283 // Create 3 stacked panels. 1284 StackedPanelCollection* stack = panel_manager->CreateStack(); 1285 Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 50, 200, 200), stack); 1286 Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack); 1287 Panel* panel3 = CreateStackedPanel("3", gfx::Rect(0, 0, 150, 120), stack); 1288 ASSERT_EQ(3, stack->num_panels()); 1289 ASSERT_FALSE(panel1->IsActive()); 1290 ASSERT_FALSE(panel2->IsActive()); 1291 ASSERT_TRUE(panel3->IsActive()); 1292 1293 // Minimize P2. 1294 panel2->Minimize(); 1295 WaitForBoundsAnimationFinished(panel2); 1296 1297 // Close P3. Expect P1, not P2, should become active. 1298 CloseWindowAndWait(panel3); 1299 EXPECT_TRUE(panel1->IsActive()); 1300 EXPECT_FALSE(panel2->IsActive()); 1301 1302 panel_manager->CloseAll(); 1303 } 1304 1305 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 1306 ExpandCollapsedTopPanelOnBottomPanelClose) { 1307 PanelManager* panel_manager = PanelManager::GetInstance(); 1308 1309 // Create 2 stacked panels. 1310 StackedPanelCollection* stack = panel_manager->CreateStack(); 1311 gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); 1312 Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack); 1313 gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); 1314 Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); 1315 ASSERT_EQ(2, panel_manager->num_panels()); 1316 ASSERT_EQ(1, panel_manager->num_stacks()); 1317 ASSERT_EQ(2, stack->num_panels()); 1318 1319 // Collapse top panel. 1320 int original_panel1_height = panel1->GetBounds().height(); 1321 panel1->Minimize(); 1322 WaitForBoundsAnimationFinished(panel2); 1323 EXPECT_TRUE(panel1->IsMinimized()); 1324 EXPECT_FALSE(panel2->IsMinimized()); 1325 1326 // Close bottom panel. Expect that top panel should become detached and 1327 // expanded. 1328 CloseWindowAndWait(panel2); 1329 WaitForBoundsAnimationFinished(panel1); 1330 EXPECT_EQ(1, panel_manager->num_panels()); 1331 EXPECT_EQ(0, panel_manager->num_stacks()); 1332 EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type()); 1333 EXPECT_FALSE(panel1->IsMinimized()); 1334 EXPECT_EQ(Panel::EXPANDED, panel1->expansion_state()); 1335 EXPECT_EQ(original_panel1_height, panel1->GetBounds().height()); 1336 1337 panel_manager->CloseAll(); 1338 } 1339 1340 // The activation waiting logic does not work well on MacOSX. Disabled for now. 1341 #if defined(OS_MACOSX) 1342 #define MAYBE_FocusCollapsedStackedPanel DISABLED_FocusCollapsedStackedPanel 1343 #else 1344 #define MAYBE_FocusCollapsedStackedPanel FocusCollapsedStackedPanel 1345 #endif 1346 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 1347 MAYBE_FocusCollapsedStackedPanel) { 1348 PanelManager* panel_manager = PanelManager::GetInstance(); 1349 1350 // Create 2 stacked panels. 1351 StackedPanelCollection* stack = panel_manager->CreateStack(); 1352 gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150); 1353 CreateStackedPanel("1", panel1_initial_bounds, stack); 1354 gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100); 1355 Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack); 1356 ASSERT_EQ(2, panel_manager->num_panels()); 1357 ASSERT_EQ(1, panel_manager->num_stacks()); 1358 ASSERT_EQ(2, stack->num_panels()); 1359 1360 // Collapse a panel. 1361 panel2->Minimize(); 1362 WaitForBoundsAnimationFinished(panel2); 1363 EXPECT_TRUE(panel2->IsMinimized()); 1364 EXPECT_FALSE(panel2->IsActive()); 1365 1366 // Focus the panel. Expect the panel is expanded. 1367 panel2->Activate(); 1368 WaitForPanelActiveState(panel2, SHOW_AS_ACTIVE); 1369 EXPECT_FALSE(panel2->IsMinimized()); 1370 1371 panel_manager->CloseAll(); 1372 } 1373 1374 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 1375 UpdateStackedPanelsOnPrimaryDisplayChange) { 1376 PanelManager* panel_manager = PanelManager::GetInstance(); 1377 1378 // Create one stack with 5 panels. 1379 StackedPanelCollection* stack = panel_manager->CreateStack(); 1380 Panel* panel1 = CreateStackedPanel("1", gfx::Rect(50, 50, 700, 100), stack); 1381 Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 100, 100), stack); 1382 Panel* panel3 = CreateStackedPanel("3", gfx::Rect(0, 0, 100, 100), stack); 1383 Panel* panel4 = CreateStackedPanel("4", gfx::Rect(0, 0, 100, 100), stack); 1384 Panel* panel5 = CreateStackedPanel("5", gfx::Rect(0, 0, 100, 100), stack); 1385 ASSERT_EQ(5, panel_manager->num_panels()); 1386 ASSERT_EQ(1, panel_manager->num_stacks()); 1387 ASSERT_EQ(5, stack->num_panels()); 1388 1389 // Make the primary display smaller. 1390 // Expect that all panels except P5 should be collapsed and their bounds 1391 // should be updated. 1392 int new_primary_area_width = 500; 1393 gfx::Rect primary_display_area(0, 0, new_primary_area_width, 300); 1394 gfx::Rect primary_work_area(0, 0, new_primary_area_width, 280); 1395 mock_display_settings_provider()->SetPrimaryDisplay( 1396 primary_display_area, primary_work_area); 1397 WaitForBoundsAnimationFinished(panel1); 1398 WaitForBoundsAnimationFinished(panel2); 1399 WaitForBoundsAnimationFinished(panel3); 1400 WaitForBoundsAnimationFinished(panel4); 1401 WaitForBoundsAnimationFinished(panel5); 1402 1403 EXPECT_TRUE(panel1->IsMinimized()); 1404 EXPECT_TRUE(panel2->IsMinimized()); 1405 EXPECT_TRUE(panel3->IsMinimized()); 1406 EXPECT_TRUE(panel4->IsMinimized()); 1407 EXPECT_FALSE(panel5->IsMinimized()); 1408 1409 gfx::Rect bounds1 = panel1->GetBounds(); 1410 EXPECT_EQ(primary_work_area.x(), bounds1.x()); 1411 EXPECT_LE(bounds1.x(), primary_work_area.right()); 1412 EXPECT_LE(primary_work_area.y(), bounds1.y()); 1413 EXPECT_EQ(new_primary_area_width, bounds1.width()); 1414 1415 gfx::Rect bounds2 = panel2->GetBounds(); 1416 EXPECT_EQ(bounds1.x(), bounds2.x()); 1417 EXPECT_EQ(bounds1.width(), bounds2.width()); 1418 EXPECT_EQ(bounds1.bottom(), bounds2.y()); 1419 1420 gfx::Rect bounds3 = panel3->GetBounds(); 1421 EXPECT_EQ(bounds2.x(), bounds3.x()); 1422 EXPECT_EQ(bounds2.width(), bounds3.width()); 1423 EXPECT_EQ(bounds2.bottom(), bounds3.y()); 1424 1425 gfx::Rect bounds4 = panel4->GetBounds(); 1426 EXPECT_EQ(bounds3.x(), bounds4.x()); 1427 EXPECT_EQ(bounds3.width(), bounds4.width()); 1428 EXPECT_EQ(bounds3.bottom(), bounds4.y()); 1429 1430 gfx::Rect bounds5 = panel5->GetBounds(); 1431 EXPECT_EQ(bounds4.x(), bounds5.x()); 1432 EXPECT_EQ(bounds4.width(), bounds5.width()); 1433 EXPECT_EQ(bounds4.bottom(), bounds5.y()); 1434 EXPECT_LE(bounds5.bottom(), primary_work_area.bottom()); 1435 1436 panel_manager->CloseAll(); 1437 } 1438 1439 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, 1440 KeepShowingStackedPanelCreatedBeforeFullScreenMode) { 1441 PanelManager* panel_manager = PanelManager::GetInstance(); 1442 1443 // Create 2 stacked panels. 1444 StackedPanelCollection* stack = panel_manager->CreateStack(); 1445 Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 50, 200, 150), stack); 1446 Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack); 1447 scoped_ptr<NativePanelTesting> panel1_testing( 1448 CreateNativePanelTesting(panel1)); 1449 scoped_ptr<NativePanelTesting> panel2_testing( 1450 CreateNativePanelTesting(panel2)); 1451 1452 // Panels should be visible at first. 1453 EXPECT_TRUE(panel1_testing->IsWindowVisible()); 1454 EXPECT_TRUE(panel2_testing->IsWindowVisible()); 1455 1456 // Panels' visibility should not be affected when entering full-screen mode. 1457 mock_display_settings_provider()->EnableFullScreenMode(true); 1458 EXPECT_TRUE(panel1_testing->IsWindowVisible()); 1459 EXPECT_TRUE(panel2_testing->IsWindowVisible()); 1460 1461 // Panels' visibility should not be affected when leaving full-screen mode. 1462 mock_display_settings_provider()->EnableFullScreenMode(false); 1463 EXPECT_TRUE(panel1_testing->IsWindowVisible()); 1464 EXPECT_TRUE(panel2_testing->IsWindowVisible()); 1465 1466 panel_manager->CloseAll(); 1467 } 1468
