chrome/browser/ui/panels/stacked_panel_browsertest.cc

   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 // Skip the test since system-minimize might not be supported for some window
1120 // managers on Linux.
1121 #if defined(TOOLKIT_GTK)
1122 #define MAYBE_AddNewPanelNotWithSystemMinimizedDetachedPanel \
1123     DISABLED_AddNewPanelNotWithSystemMinimizedDetachedPanel
1124 #else
1125 #define MAYBE_AddNewPanelNotWithSystemMinimizedDetachedPanel \
1126     AddNewPanelNotWithSystemMinimizedDetachedPanel
1127 #endif
1128 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest,
1129                        MAYBE_AddNewPanelNotWithSystemMinimizedDetachedPanel) {
1130   PanelManager* panel_manager = PanelManager::GetInstance();
1131
1132   // Create 1 detached panel.
1133   Panel* panel1 = CreateDetachedPanel("1", gfx::Rect(200, 50, 250, 150));
1134   EXPECT_EQ(1, panel_manager->num_panels());
1135   EXPECT_EQ(0, panel_manager->num_stacks());
1136   EXPECT_EQ(1, panel_manager->detached_collection()->num_panels());
1137   EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type());
1138
1139   // Minimize the detached panel by system.
1140   panel1->OnMinimizeButtonClicked(panel::NO_MODIFIER);
1141
1142   // Create new panel. Expect that new panel will open as a separate detached
1143   // panel, instead of being grouped with the system-minimized detached panel.
1144   CreatePanelParams params("N", gfx::Rect(50, 50, 150, 100), SHOW_AS_ACTIVE);
1145   params.create_mode = PanelManager::CREATE_AS_DETACHED;
1146   Panel* new_panel = CreatePanelWithParams(params);
1147   EXPECT_EQ(2, panel_manager->num_panels());
1148   EXPECT_EQ(2, panel_manager->detached_collection()->num_panels());
1149   EXPECT_EQ(0, panel_manager->num_stacks());
1150   EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type());
1151   EXPECT_EQ(PanelCollection::DETACHED, new_panel->collection()->type());
1152
1153   panel_manager->CloseAll();
1154 }
1155
1156 // Skip the test since system-minimize might not be supported for some window
1157 // managers on Linux.
1158 #if defined(TOOLKIT_GTK)
1159 #define MAYBE_AddNewPanelNotWithSystemMinimizedStack \
1160     DISABLED_AddNewPanelNotWithSystemMinimizedStack
1161 #else
1162 #define MAYBE_AddNewPanelNotWithSystemMinimizedStack \
1163     AddNewPanelNotWithSystemMinimizedStack
1164 #endif
1165 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest,
1166                        MAYBE_AddNewPanelNotWithSystemMinimizedStack) {
1167   PanelManager* panel_manager = PanelManager::GetInstance();
1168
1169   // Create one stack with 2 panels.
1170   StackedPanelCollection* stack = panel_manager->CreateStack();
1171   Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 90, 200, 150), stack);
1172   Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack);
1173   EXPECT_EQ(2, panel_manager->num_panels());
1174   EXPECT_EQ(0, panel_manager->detached_collection()->num_panels());
1175   EXPECT_EQ(1, panel_manager->num_stacks());
1176   EXPECT_EQ(2, stack->num_panels());
1177   EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type());
1178   EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type());
1179
1180   // Minimize the stack by system.
1181   stack->OnMinimizeButtonClicked(panel1, panel::NO_MODIFIER);
1182
1183   // Create new panel. Expect that new panel will open as a separate detached
1184   // panel, instead of appending to the system-minimized stack.
1185   CreatePanelParams params("N", gfx::Rect(50, 50, 150, 100), SHOW_AS_ACTIVE);
1186   params.create_mode = PanelManager::CREATE_AS_DETACHED;
1187   Panel* new_panel = CreatePanelWithParams(params);
1188   EXPECT_EQ(3, panel_manager->num_panels());
1189   EXPECT_EQ(1, panel_manager->detached_collection()->num_panels());
1190   EXPECT_EQ(1, panel_manager->num_stacks());
1191   EXPECT_EQ(2, stack->num_panels());
1192   EXPECT_EQ(PanelCollection::STACKED, panel1->collection()->type());
1193   EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type());
1194   EXPECT_EQ(PanelCollection::DETACHED, new_panel->collection()->type());
1195
1196   panel_manager->CloseAll();
1197 }
1198
1199 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest, ClosePanels) {
1200   PanelManager* panel_manager = PanelManager::GetInstance();
1201
1202   // Create 3 stacked panels.
1203   StackedPanelCollection* stack = panel_manager->CreateStack();
1204   gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150);
1205   Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack);
1206   gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100);
1207   Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack);
1208   gfx::Rect panel3_initial_bounds = gfx::Rect(0, 0, 250, 120);
1209   Panel* panel3 = CreateStackedPanel("3", panel3_initial_bounds, stack);
1210   ASSERT_EQ(3, panel_manager->num_panels());
1211   ASSERT_EQ(1, panel_manager->num_stacks());
1212   ASSERT_EQ(3, stack->num_panels());
1213
1214   gfx::Rect panel1_expected_bounds(panel1_initial_bounds);
1215   EXPECT_EQ(panel1_expected_bounds, panel1->GetBounds());
1216   gfx::Rect panel2_expected_bounds(panel1_expected_bounds.x(),
1217                                    panel1_expected_bounds.bottom(),
1218                                    panel1_expected_bounds.width(),
1219                                    panel2_initial_bounds.height());
1220   EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds());
1221   gfx::Rect panel3_expected_bounds(panel2_expected_bounds.x(),
1222                                    panel2_expected_bounds.bottom(),
1223                                    panel2_expected_bounds.width(),
1224                                    panel3_initial_bounds.height());
1225   EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds());
1226
1227   // Close P1. Expect that P2 and P3 should move up.
1228   CloseWindowAndWait(panel1);
1229   WaitForBoundsAnimationFinished(panel2);
1230   WaitForBoundsAnimationFinished(panel3);
1231   ASSERT_EQ(2, panel_manager->num_panels());
1232   ASSERT_EQ(1, panel_manager->num_stacks());
1233   ASSERT_EQ(2, stack->num_panels());
1234   EXPECT_EQ(PanelCollection::STACKED, panel2->collection()->type());
1235   EXPECT_EQ(PanelCollection::STACKED, panel3->collection()->type());
1236
1237   panel2_expected_bounds.set_y(panel1_expected_bounds.y());
1238   EXPECT_EQ(panel2_expected_bounds, panel2->GetBounds());
1239   panel3_expected_bounds.set_y(panel2_expected_bounds.bottom());
1240   EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds());
1241
1242   // Close P2. Expect that P3 should become detached and move up.
1243   CloseWindowAndWait(panel2);
1244   WaitForBoundsAnimationFinished(panel3);
1245   ASSERT_EQ(1, panel_manager->num_panels());
1246   ASSERT_EQ(0, panel_manager->num_stacks());
1247   EXPECT_EQ(PanelCollection::DETACHED, panel3->collection()->type());
1248
1249   panel3_expected_bounds.set_y(panel2_expected_bounds.y());
1250   EXPECT_EQ(panel3_expected_bounds, panel3->GetBounds());
1251
1252   panel_manager->CloseAll();
1253 }
1254
1255 // Skip the test since active state might not be fully supported for some window
1256 // managers.
1257 #if defined(TOOLKIT_GTK) || defined(OS_MACOSX)
1258 #define MAYBE_FocusNextPanelOnPanelClose DISABLED_FocusNextPanelOnPanelClose
1259 #else
1260 #define MAYBE_FocusNextPanelOnPanelClose FocusNextPanelOnPanelClose
1261 #endif
1262 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest,
1263                        MAYBE_FocusNextPanelOnPanelClose) {
1264   PanelManager* panel_manager = PanelManager::GetInstance();
1265
1266   // Create 3 stacked panels.
1267   StackedPanelCollection* stack = panel_manager->CreateStack();
1268   Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 50, 200, 200), stack);
1269   Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack);
1270   Panel* panel3 = CreateStackedPanel("3", gfx::Rect(0, 0, 150, 120), stack);
1271   ASSERT_EQ(3, stack->num_panels());
1272   ASSERT_FALSE(panel1->IsActive());
1273   ASSERT_FALSE(panel2->IsActive());
1274   ASSERT_TRUE(panel3->IsActive());
1275
1276   // Close P3. Expect P2 should become active.
1277   CloseWindowAndWait(panel3);
1278   EXPECT_FALSE(panel1->IsActive());
1279   EXPECT_TRUE(panel2->IsActive());
1280
1281   // Close P2. Expect P1 should become active.
1282   CloseWindowAndWait(panel2);
1283   EXPECT_TRUE(panel1->IsActive());
1284
1285   panel_manager->CloseAll();
1286 }
1287
1288 // Skip the test since active state might not be fully supported for some window
1289 // managers.
1290 #if defined(TOOLKIT_GTK) || defined(OS_MACOSX)
1291 #define MAYBE_FocusNextUnminimizedPanelOnPanelClose \
1292     DISABLED_FocusNextUnminimizedPanelOnPanelClose
1293 #else
1294 #define MAYBE_FocusNextUnminimizedPanelOnPanelClose \
1295     FocusNextUnminimizedPanelOnPanelClose
1296 #endif
1297 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest,
1298                        MAYBE_FocusNextUnminimizedPanelOnPanelClose) {
1299   PanelManager* panel_manager = PanelManager::GetInstance();
1300
1301   // Create 3 stacked panels.
1302   StackedPanelCollection* stack = panel_manager->CreateStack();
1303   Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 50, 200, 200), stack);
1304   Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack);
1305   Panel* panel3 = CreateStackedPanel("3", gfx::Rect(0, 0, 150, 120), stack);
1306   ASSERT_EQ(3, stack->num_panels());
1307   ASSERT_FALSE(panel1->IsActive());
1308   ASSERT_FALSE(panel2->IsActive());
1309   ASSERT_TRUE(panel3->IsActive());
1310
1311   // Minimize P2.
1312   panel2->Minimize();
1313   WaitForBoundsAnimationFinished(panel2);
1314
1315   // Close P3. Expect P1, not P2, should become active.
1316   CloseWindowAndWait(panel3);
1317   EXPECT_TRUE(panel1->IsActive());
1318   EXPECT_FALSE(panel2->IsActive());
1319
1320   panel_manager->CloseAll();
1321 }
1322
1323 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest,
1324                        ExpandCollapsedTopPanelOnBottomPanelClose) {
1325   PanelManager* panel_manager = PanelManager::GetInstance();
1326
1327   // Create 2 stacked panels.
1328   StackedPanelCollection* stack = panel_manager->CreateStack();
1329   gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150);
1330   Panel* panel1 = CreateStackedPanel("1", panel1_initial_bounds, stack);
1331   gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100);
1332   Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack);
1333   ASSERT_EQ(2, panel_manager->num_panels());
1334   ASSERT_EQ(1, panel_manager->num_stacks());
1335   ASSERT_EQ(2, stack->num_panels());
1336
1337   // Collapse top panel.
1338   int original_panel1_height = panel1->GetBounds().height();
1339   panel1->Minimize();
1340   WaitForBoundsAnimationFinished(panel2);
1341   EXPECT_TRUE(panel1->IsMinimized());
1342   EXPECT_FALSE(panel2->IsMinimized());
1343
1344   // Close bottom panel. Expect that top panel should become detached and
1345   // expanded.
1346   CloseWindowAndWait(panel2);
1347   WaitForBoundsAnimationFinished(panel1);
1348   EXPECT_EQ(1, panel_manager->num_panels());
1349   EXPECT_EQ(0, panel_manager->num_stacks());
1350   EXPECT_EQ(PanelCollection::DETACHED, panel1->collection()->type());
1351   EXPECT_FALSE(panel1->IsMinimized());
1352   EXPECT_EQ(Panel::EXPANDED, panel1->expansion_state());
1353   EXPECT_EQ(original_panel1_height, panel1->GetBounds().height());
1354
1355   panel_manager->CloseAll();
1356 }
1357
1358 // The activation waiting logic does not work well on MacOSX. Disabled for now.
1359 #if defined(OS_MACOSX)
1360 #define MAYBE_FocusCollapsedStackedPanel DISABLED_FocusCollapsedStackedPanel
1361 #else
1362 #define MAYBE_FocusCollapsedStackedPanel FocusCollapsedStackedPanel
1363 #endif
1364 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest,
1365                        MAYBE_FocusCollapsedStackedPanel) {
1366   PanelManager* panel_manager = PanelManager::GetInstance();
1367
1368   // Create 2 stacked panels.
1369   StackedPanelCollection* stack = panel_manager->CreateStack();
1370   gfx::Rect panel1_initial_bounds = gfx::Rect(100, 50, 200, 150);
1371   CreateStackedPanel("1", panel1_initial_bounds, stack);
1372   gfx::Rect panel2_initial_bounds = gfx::Rect(0, 0, 150, 100);
1373   Panel* panel2 = CreateStackedPanel("2", panel2_initial_bounds, stack);
1374   ASSERT_EQ(2, panel_manager->num_panels());
1375   ASSERT_EQ(1, panel_manager->num_stacks());
1376   ASSERT_EQ(2, stack->num_panels());
1377
1378   // Collapse a panel.
1379   panel2->Minimize();
1380   WaitForBoundsAnimationFinished(panel2);
1381   EXPECT_TRUE(panel2->IsMinimized());
1382   EXPECT_FALSE(panel2->IsActive());
1383
1384   // Focus the panel. Expect the panel is expanded.
1385   panel2->Activate();
1386   WaitForPanelActiveState(panel2, SHOW_AS_ACTIVE);
1387   EXPECT_FALSE(panel2->IsMinimized());
1388
1389   panel_manager->CloseAll();
1390 }
1391
1392 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest,
1393                        UpdateStackedPanelsOnPrimaryDisplayChange) {
1394   PanelManager* panel_manager = PanelManager::GetInstance();
1395
1396   // Create one stack with 5 panels.
1397   StackedPanelCollection* stack = panel_manager->CreateStack();
1398   Panel* panel1 = CreateStackedPanel("1", gfx::Rect(50, 50, 700, 100), stack);
1399   Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 100, 100), stack);
1400   Panel* panel3 = CreateStackedPanel("3", gfx::Rect(0, 0, 100, 100), stack);
1401   Panel* panel4 = CreateStackedPanel("4", gfx::Rect(0, 0, 100, 100), stack);
1402   Panel* panel5 = CreateStackedPanel("5", gfx::Rect(0, 0, 100, 100), stack);
1403   ASSERT_EQ(5, panel_manager->num_panels());
1404   ASSERT_EQ(1, panel_manager->num_stacks());
1405   ASSERT_EQ(5, stack->num_panels());
1406
1407   // Make the primary display smaller.
1408   // Expect that all panels except P5 should be collapsed and their bounds
1409   // should be updated.
1410   int new_primary_area_width = 500;
1411   gfx::Rect primary_display_area(0, 0, new_primary_area_width, 300);
1412   gfx::Rect primary_work_area(0, 0, new_primary_area_width, 280);
1413   mock_display_settings_provider()->SetPrimaryDisplay(
1414       primary_display_area, primary_work_area);
1415   WaitForBoundsAnimationFinished(panel1);
1416   WaitForBoundsAnimationFinished(panel2);
1417   WaitForBoundsAnimationFinished(panel3);
1418   WaitForBoundsAnimationFinished(panel4);
1419   WaitForBoundsAnimationFinished(panel5);
1420
1421   EXPECT_TRUE(panel1->IsMinimized());
1422   EXPECT_TRUE(panel2->IsMinimized());
1423   EXPECT_TRUE(panel3->IsMinimized());
1424   EXPECT_TRUE(panel4->IsMinimized());
1425   EXPECT_FALSE(panel5->IsMinimized());
1426
1427   gfx::Rect bounds1 = panel1->GetBounds();
1428   EXPECT_EQ(primary_work_area.x(), bounds1.x());
1429   EXPECT_LE(bounds1.x(), primary_work_area.right());
1430   EXPECT_LE(primary_work_area.y(), bounds1.y());
1431   EXPECT_EQ(new_primary_area_width, bounds1.width());
1432
1433   gfx::Rect bounds2 = panel2->GetBounds();
1434   EXPECT_EQ(bounds1.x(), bounds2.x());
1435   EXPECT_EQ(bounds1.width(), bounds2.width());
1436   EXPECT_EQ(bounds1.bottom(), bounds2.y());
1437
1438   gfx::Rect bounds3 = panel3->GetBounds();
1439   EXPECT_EQ(bounds2.x(), bounds3.x());
1440   EXPECT_EQ(bounds2.width(), bounds3.width());
1441   EXPECT_EQ(bounds2.bottom(), bounds3.y());
1442
1443   gfx::Rect bounds4 = panel4->GetBounds();
1444   EXPECT_EQ(bounds3.x(), bounds4.x());
1445   EXPECT_EQ(bounds3.width(), bounds4.width());
1446   EXPECT_EQ(bounds3.bottom(), bounds4.y());
1447
1448   gfx::Rect bounds5 = panel5->GetBounds();
1449   EXPECT_EQ(bounds4.x(), bounds5.x());
1450   EXPECT_EQ(bounds4.width(), bounds5.width());
1451   EXPECT_EQ(bounds4.bottom(), bounds5.y());
1452   EXPECT_LE(bounds5.bottom(), primary_work_area.bottom());
1453
1454   panel_manager->CloseAll();
1455 }
1456
1457 IN_PROC_BROWSER_TEST_F(StackedPanelBrowserTest,
1458                        KeepShowingStackedPanelCreatedBeforeFullScreenMode) {
1459   PanelManager* panel_manager = PanelManager::GetInstance();
1460
1461   // Create 2 stacked panels.
1462   StackedPanelCollection* stack = panel_manager->CreateStack();
1463   Panel* panel1 = CreateStackedPanel("1", gfx::Rect(100, 50, 200, 150), stack);
1464   Panel* panel2 = CreateStackedPanel("2", gfx::Rect(0, 0, 150, 100), stack);
1465   scoped_ptr<NativePanelTesting> panel1_testing(
1466       CreateNativePanelTesting(panel1));
1467   scoped_ptr<NativePanelTesting> panel2_testing(
1468       CreateNativePanelTesting(panel2));
1469
1470   // Panels should be visible at first.
1471   EXPECT_TRUE(panel1_testing->IsWindowVisible());
1472   EXPECT_TRUE(panel2_testing->IsWindowVisible());
1473
1474  // Panels' visibility should not be affected when entering full-screen mode.
1475   mock_display_settings_provider()->EnableFullScreenMode(true);
1476   EXPECT_TRUE(panel1_testing->IsWindowVisible());
1477   EXPECT_TRUE(panel2_testing->IsWindowVisible());
1478
1479   // Panels' visibility should not be affected when leaving full-screen mode.
1480   mock_display_settings_provider()->EnableFullScreenMode(false);
1481   EXPECT_TRUE(panel1_testing->IsWindowVisible());
1482   EXPECT_TRUE(panel2_testing->IsWindowVisible());
1483
1484   panel_manager->CloseAll();
1485 }