chrome/browser/ui/panels/panel_browsertest.cc

   1 // Copyright (c) 2012 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 "base/bind.h"
   6 #include "base/prefs/pref_service.h"
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "chrome/app/chrome_command_ids.h"
   9 #include "chrome/browser/chrome_notification_types.h"
  10 #include "chrome/browser/devtools/devtools_window.h"
  11 #include "chrome/browser/extensions/extension_apitest.h"
  12 #include "chrome/browser/net/url_request_mock_util.h"
  13 #include "chrome/browser/prefs/browser_prefs.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/ui/app_modal_dialogs/app_modal_dialog.h"
  16 #include "chrome/browser/ui/app_modal_dialogs/native_app_modal_dialog.h"
  17 #include "chrome/browser/ui/browser.h"
  18 #include "chrome/browser/ui/browser_commands.h"
  19 #include "chrome/browser/ui/browser_finder.h"
  20 #include "chrome/browser/ui/browser_iterator.h"
  21 #include "chrome/browser/ui/browser_window.h"
  22 #include "chrome/browser/ui/panels/base_panel_browser_test.h"
  23 #include "chrome/browser/ui/panels/docked_panel_collection.h"
  24 #include "chrome/browser/ui/panels/native_panel.h"
  25 #include "chrome/browser/ui/panels/panel.h"
  26 #include "chrome/browser/ui/panels/panel_manager.h"
  27 #include "chrome/browser/ui/panels/test_panel_active_state_observer.h"
  28 #include "chrome/browser/web_applications/web_app.h"
  29 #include "chrome/common/chrome_switches.h"
  30 #include "chrome/common/extensions/extension_manifest_constants.h"
  31 #include "chrome/common/pref_names.h"
  32 #include "chrome/common/url_constants.h"
  33 #include "chrome/test/base/interactive_test_utils.h"
  34 #include "chrome/test/base/ui_test_utils.h"
  35 #include "content/public/browser/native_web_keyboard_event.h"
  36 #include "content/public/browser/notification_service.h"
  37 #include "content/public/browser/web_contents.h"
  38 #include "content/public/common/url_constants.h"
  39 #include "content/public/test/browser_test_utils.h"
  40 #include "content/test/net/url_request_mock_http_job.h"
  41 #include "extensions/common/constants.h"
  42 #include "net/base/net_util.h"
  43 #include "testing/gtest/include/gtest/gtest.h"
  44 #include "ui/base/events/event_utils.h"
  45 #include "ui/gfx/screen.h"
  46
  47 using content::WebContents;
  48
  49 class PanelBrowserTest : public BasePanelBrowserTest {
  50  public:
  51   PanelBrowserTest() : BasePanelBrowserTest() {
  52   }
  53
  54  protected:
  55   // Helper function for debugging.
  56   void PrintAllPanelBounds() {
  57     const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels();
  58     DLOG(WARNING) << "PanelBounds:";
  59     for (size_t i = 0; i < panels.size(); ++i) {
  60       DLOG(WARNING) << "#=" << i
  61                     << ", ptr=" << panels[i]
  62                     << ", x=" << panels[i]->GetBounds().x()
  63                     << ", y=" << panels[i]->GetBounds().y()
  64                     << ", width=" << panels[i]->GetBounds().width()
  65                     << ", height" << panels[i]->GetBounds().height();
  66     }
  67   }
  68
  69   std::vector<gfx::Rect> GetAllPanelBounds() {
  70     std::vector<Panel*> panels = PanelManager::GetInstance()->panels();
  71     std::vector<gfx::Rect> bounds;
  72     for (size_t i = 0; i < panels.size(); i++)
  73       bounds.push_back(panels[i]->GetBounds());
  74     return bounds;
  75   }
  76
  77   std::vector<gfx::Rect> AddXDeltaToBounds(const std::vector<gfx::Rect>& bounds,
  78                                            const std::vector<int>& delta_x) {
  79     std::vector<gfx::Rect> new_bounds = bounds;
  80     for (size_t i = 0; i < bounds.size(); ++i)
  81       new_bounds[i].Offset(delta_x[i], 0);
  82     return new_bounds;
  83   }
  84
  85   std::vector<Panel::ExpansionState> GetAllPanelExpansionStates() {
  86     std::vector<Panel*> panels = PanelManager::GetInstance()->panels();
  87     std::vector<Panel::ExpansionState> expansion_states;
  88     for (size_t i = 0; i < panels.size(); i++)
  89       expansion_states.push_back(panels[i]->expansion_state());
  90     return expansion_states;
  91   }
  92
  93   std::vector<bool> GetAllPanelActiveStates() {
  94     std::vector<Panel*> panels = PanelManager::GetInstance()->panels();
  95     std::vector<bool> active_states;
  96     for (size_t i = 0; i < panels.size(); i++)
  97       active_states.push_back(panels[i]->IsActive());
  98     return active_states;
  99   }
 100
 101   std::vector<bool> ProduceExpectedActiveStates(
 102       int expected_active_panel_index) {
 103     std::vector<Panel*> panels = PanelManager::GetInstance()->panels();
 104     std::vector<bool> active_states;
 105     for (int i = 0; i < static_cast<int>(panels.size()); i++)
 106       active_states.push_back(i == expected_active_panel_index);
 107     return active_states;
 108   }
 109
 110   void WaitForPanelActiveStates(const std::vector<bool>& old_states,
 111                                 const std::vector<bool>& new_states) {
 112     DCHECK(old_states.size() == new_states.size());
 113     std::vector<Panel*> panels = PanelManager::GetInstance()->panels();
 114     for (size_t i = 0; i < old_states.size(); i++) {
 115       if (old_states[i] != new_states[i]){
 116         WaitForPanelActiveState(
 117             panels[i], new_states[i] ? SHOW_AS_ACTIVE : SHOW_AS_INACTIVE);
 118       }
 119     }
 120   }
 121
 122   void TestMinimizeRestore() {
 123     // This constant is used to generate a point 'sufficiently higher then
 124     // top edge of the panel'. On some platforms (Mac) we extend hover area
 125     // a bit above the minimized panel as well, so it takes significant
 126     // distance to 'move mouse out' of the hover-sensitive area.
 127     const int kFarEnoughFromHoverArea = 153;
 128
 129     PanelManager* panel_manager = PanelManager::GetInstance();
 130     std::vector<Panel*> panels = panel_manager->panels();
 131     std::vector<gfx::Rect> test_begin_bounds = GetAllPanelBounds();
 132     std::vector<gfx::Rect> expected_bounds = test_begin_bounds;
 133     std::vector<Panel::ExpansionState> expected_expansion_states(
 134         panels.size(), Panel::EXPANDED);
 135     std::vector<NativePanelTesting*> native_panels_testing(panels.size());
 136     for (size_t i = 0; i < panels.size(); ++i) {
 137       native_panels_testing[i] = CreateNativePanelTesting(panels[i]);
 138     }
 139
 140     // Verify titlebar click does not minimize.
 141     for (size_t index = 0; index < panels.size(); ++index) {
 142       // Press left mouse button.  Verify nothing changed.
 143       native_panels_testing[index]->PressLeftMouseButtonTitlebar(
 144           panels[index]->GetBounds().origin());
 145       EXPECT_EQ(expected_bounds, GetAllPanelBounds());
 146       EXPECT_EQ(expected_expansion_states, GetAllPanelExpansionStates());
 147
 148       // Release mouse button.  Verify nothing changed.
 149       native_panels_testing[index]->ReleaseMouseButtonTitlebar();
 150       EXPECT_EQ(expected_bounds, GetAllPanelBounds());
 151       EXPECT_EQ(expected_expansion_states, GetAllPanelExpansionStates());
 152     }
 153
 154     // Minimize all panels for next stage in test.
 155     for (size_t index = 0; index < panels.size(); ++index) {
 156       panels[index]->Minimize();
 157       expected_bounds[index].set_height(panel::kMinimizedPanelHeight);
 158       expected_bounds[index].set_y(
 159           test_begin_bounds[index].y() +
 160           test_begin_bounds[index].height() - panel::kMinimizedPanelHeight);
 161       expected_expansion_states[index] = Panel::MINIMIZED;
 162       EXPECT_EQ(expected_bounds, GetAllPanelBounds());
 163       EXPECT_EQ(expected_expansion_states, GetAllPanelExpansionStates());
 164     }
 165
 166     // Setup bounds and expansion states for minimized and titlebar-only
 167     // states.
 168     std::vector<Panel::ExpansionState> titlebar_exposed_states(
 169         panels.size(), Panel::TITLE_ONLY);
 170     std::vector<gfx::Rect> minimized_bounds = expected_bounds;
 171     std::vector<Panel::ExpansionState> minimized_states(
 172         panels.size(), Panel::MINIMIZED);
 173     std::vector<gfx::Rect> titlebar_exposed_bounds = test_begin_bounds;
 174     for (size_t index = 0; index < panels.size(); ++index) {
 175       titlebar_exposed_bounds[index].set_height(
 176           panels[index]->native_panel()->TitleOnlyHeight());
 177       titlebar_exposed_bounds[index].set_y(
 178           test_begin_bounds[index].y() +
 179           test_begin_bounds[index].height() -
 180           panels[index]->native_panel()->TitleOnlyHeight());
 181     }
 182
 183     // Test hover.  All panels are currently in minimized state.
 184     EXPECT_EQ(minimized_states, GetAllPanelExpansionStates());
 185     for (size_t index = 0; index < panels.size(); ++index) {
 186       // Hover mouse on minimized panel.
 187       // Verify titlebar is exposed on all panels.
 188       gfx::Point hover_point(panels[index]->GetBounds().origin());
 189       MoveMouseAndWaitForExpansionStateChange(panels[index], hover_point);
 190       EXPECT_EQ(titlebar_exposed_bounds, GetAllPanelBounds());
 191       EXPECT_EQ(titlebar_exposed_states, GetAllPanelExpansionStates());
 192
 193       // Hover mouse above the panel. Verify all panels are minimized.
 194       hover_point.set_y(
 195           panels[index]->GetBounds().y() - kFarEnoughFromHoverArea);
 196       MoveMouseAndWaitForExpansionStateChange(panels[index], hover_point);
 197       EXPECT_EQ(minimized_bounds, GetAllPanelBounds());
 198       EXPECT_EQ(minimized_states, GetAllPanelExpansionStates());
 199
 200       // Hover mouse below minimized panel.
 201       // Verify titlebar is exposed on all panels.
 202       hover_point.set_y(panels[index]->GetBounds().y() +
 203                         panels[index]->GetBounds().height() + 5);
 204       MoveMouseAndWaitForExpansionStateChange(panels[index], hover_point);
 205       EXPECT_EQ(titlebar_exposed_bounds, GetAllPanelBounds());
 206       EXPECT_EQ(titlebar_exposed_states, GetAllPanelExpansionStates());
 207
 208       // Hover below titlebar exposed panel.  Verify nothing changed.
 209       hover_point.set_y(panels[index]->GetBounds().y() +
 210                         panels[index]->GetBounds().height() + 6);
 211       MoveMouse(hover_point);
 212       EXPECT_EQ(titlebar_exposed_bounds, GetAllPanelBounds());
 213       EXPECT_EQ(titlebar_exposed_states, GetAllPanelExpansionStates());
 214
 215       // Hover mouse above panel.  Verify all panels are minimized.
 216       hover_point.set_y(
 217           panels[index]->GetBounds().y() - kFarEnoughFromHoverArea);
 218       MoveMouseAndWaitForExpansionStateChange(panels[index], hover_point);
 219       EXPECT_EQ(minimized_bounds, GetAllPanelBounds());
 220       EXPECT_EQ(minimized_states, GetAllPanelExpansionStates());
 221     }
 222
 223     // Test restore.  All panels are currently in minimized state.
 224     for (size_t index = 0; index < panels.size(); ++index) {
 225       // Hover on the last panel.  This is to test the case of clicking on the
 226       // panel when it's in titlebar exposed state.
 227       if (index == panels.size() - 1)
 228         MoveMouse(minimized_bounds[index].origin());
 229
 230       // Click minimized or title bar exposed panel as the case may be.
 231       // Verify panel is restored to its original size.
 232       native_panels_testing[index]->PressLeftMouseButtonTitlebar(
 233           panels[index]->GetBounds().origin());
 234       native_panels_testing[index]->ReleaseMouseButtonTitlebar();
 235       expected_bounds[index].set_height(
 236           test_begin_bounds[index].height());
 237       expected_bounds[index].set_y(test_begin_bounds[index].y());
 238       expected_expansion_states[index] = Panel::EXPANDED;
 239       EXPECT_EQ(expected_bounds, GetAllPanelBounds());
 240       EXPECT_EQ(expected_expansion_states, GetAllPanelExpansionStates());
 241
 242       // Hover again on the last panel which is now restored, to reset the
 243       // titlebar exposed state.
 244       if (index == panels.size() - 1)
 245         MoveMouse(minimized_bounds[index].origin());
 246     }
 247
 248     // The below could be separate tests, just adding a TODO here for tracking.
 249     // TODO(prasadt): Add test for dragging when in titlebar exposed state.
 250     // TODO(prasadt): Add test in presence of auto hiding task bar.
 251
 252     for (size_t i = 0; i < panels.size(); ++i)
 253       delete native_panels_testing[i];
 254   }
 255 };
 256
 257 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CheckDockedPanelProperties) {
 258   PanelManager* panel_manager = PanelManager::GetInstance();
 259   DockedPanelCollection* docked_collection = panel_manager->docked_collection();
 260
 261   // Create 3 docked panels that are in expanded, title-only or minimized states
 262   // respectively.
 263   Panel* panel1 = CreatePanelWithBounds("1", gfx::Rect(0, 0, 100, 100));
 264   Panel* panel2 = CreatePanelWithBounds("2", gfx::Rect(0, 0, 100, 100));
 265   Panel* panel3 = CreatePanelWithBounds("3", gfx::Rect(0, 0, 100, 100));
 266   panel2->SetExpansionState(Panel::TITLE_ONLY);
 267   EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state());
 268   panel3->SetExpansionState(Panel::MINIMIZED);
 269   EXPECT_EQ(Panel::MINIMIZED, panel3->expansion_state());
 270   scoped_ptr<NativePanelTesting> panel1_testing(
 271       CreateNativePanelTesting(panel1));
 272   scoped_ptr<NativePanelTesting> panel2_testing(
 273       CreateNativePanelTesting(panel2));
 274   scoped_ptr<NativePanelTesting> panel3_testing(
 275       CreateNativePanelTesting(panel3));
 276
 277   // Ensure that the layout message can get a chance to be processed so that
 278   // the button visibility can be updated.
 279   base::MessageLoop::current()->RunUntilIdle();
 280
 281   EXPECT_EQ(3, panel_manager->num_panels());
 282   EXPECT_TRUE(docked_collection->HasPanel(panel1));
 283   EXPECT_TRUE(docked_collection->HasPanel(panel2));
 284   EXPECT_TRUE(docked_collection->HasPanel(panel3));
 285
 286   EXPECT_EQ(Panel::EXPANDED, panel1->expansion_state());
 287   EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state());
 288   EXPECT_EQ(Panel::MINIMIZED, panel3->expansion_state());
 289
 290   EXPECT_TRUE(panel1->IsAlwaysOnTop());
 291   EXPECT_TRUE(panel2->IsAlwaysOnTop());
 292   EXPECT_TRUE(panel3->IsAlwaysOnTop());
 293
 294   EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::CLOSE_BUTTON));
 295   EXPECT_TRUE(panel2_testing->IsButtonVisible(panel::CLOSE_BUTTON));
 296   EXPECT_TRUE(panel3_testing->IsButtonVisible(panel::CLOSE_BUTTON));
 297
 298   EXPECT_TRUE(panel1_testing->IsButtonVisible(panel::MINIMIZE_BUTTON));
 299   EXPECT_FALSE(panel2_testing->IsButtonVisible(panel::MINIMIZE_BUTTON));
 300   EXPECT_FALSE(panel3_testing->IsButtonVisible(panel::MINIMIZE_BUTTON));
 301
 302   EXPECT_FALSE(panel1_testing->IsButtonVisible(panel::RESTORE_BUTTON));
 303   EXPECT_TRUE(panel2_testing->IsButtonVisible(panel::RESTORE_BUTTON));
 304   EXPECT_TRUE(panel3_testing->IsButtonVisible(panel::RESTORE_BUTTON));
 305
 306   // Expanded panel cannot be resized at the bottom.
 307   EXPECT_EQ(panel::RESIZABLE_EXCEPT_BOTTOM, panel1->CanResizeByMouse());
 308   EXPECT_EQ(panel::NOT_RESIZABLE, panel2->CanResizeByMouse());
 309   EXPECT_EQ(panel::NOT_RESIZABLE, panel3->CanResizeByMouse());
 310
 311   EXPECT_EQ(panel::TOP_ROUNDED, panel1_testing->GetWindowCornerStyle());
 312   EXPECT_EQ(panel::TOP_ROUNDED, panel1_testing->GetWindowCornerStyle());
 313   EXPECT_EQ(panel::TOP_ROUNDED, panel3_testing->GetWindowCornerStyle());
 314
 315   EXPECT_EQ(Panel::USE_PANEL_ATTENTION, panel1->attention_mode());
 316   EXPECT_EQ(Panel::USE_PANEL_ATTENTION, panel2->attention_mode());
 317   EXPECT_EQ(Panel::USE_PANEL_ATTENTION, panel3->attention_mode());
 318
 319   panel_manager->CloseAll();
 320 }
 321
 322 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreatePanel) {
 323   PanelManager* panel_manager = PanelManager::GetInstance();
 324   EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially.
 325
 326   Panel* panel = CreatePanel("PanelTest");
 327   EXPECT_EQ(1, panel_manager->num_panels());
 328
 329   gfx::Rect bounds = panel->GetBounds();
 330   EXPECT_GT(bounds.x(), 0);
 331   EXPECT_GT(bounds.y(), 0);
 332   EXPECT_GT(bounds.width(), 0);
 333   EXPECT_GT(bounds.height(), 0);
 334
 335   EXPECT_EQ(bounds.right(),
 336             panel_manager->docked_collection()->StartingRightPosition());
 337
 338   CloseWindowAndWait(panel);
 339
 340   EXPECT_EQ(0, panel_manager->num_panels());
 341 }
 342
 343 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreateBigPanel) {
 344   gfx::Rect work_area = PanelManager::GetInstance()->
 345       display_settings_provider()->GetPrimaryWorkArea();
 346   Panel* panel = CreatePanelWithBounds("BigPanel", work_area);
 347   gfx::Rect bounds = panel->GetBounds();
 348   EXPECT_EQ(panel->max_size().width(), bounds.width());
 349   EXPECT_LT(bounds.width(), work_area.width());
 350   EXPECT_EQ(panel->max_size().height(), bounds.height());
 351   EXPECT_LT(bounds.height(), work_area.height());
 352   panel->Close();
 353 }
 354
 355 class WaitForStableInitialSize : public TestPanelNotificationObserver {
 356  public:
 357   explicit WaitForStableInitialSize(Panel* panel)
 358       : TestPanelNotificationObserver(
 359           chrome::NOTIFICATION_PANEL_COLLECTION_UPDATED,
 360           content::NotificationService::AllSources()),
 361         panel_(panel) {}
 362   virtual ~WaitForStableInitialSize() {}
 363
 364  protected:
 365   virtual bool AtExpectedState() OVERRIDE {
 366     return panel_->GetBounds().height() > panel_->TitleOnlyHeight();
 367   }
 368   Panel* panel_;
 369 };
 370
 371 class WaitForAutoResizeWider : public TestPanelNotificationObserver {
 372  public:
 373   explicit WaitForAutoResizeWider(Panel* panel)
 374       : TestPanelNotificationObserver(
 375           chrome::NOTIFICATION_PANEL_COLLECTION_UPDATED,
 376           content::NotificationService::AllSources()),
 377         panel_(panel),
 378         initial_size_(panel->GetBounds().size()) {}
 379   virtual ~WaitForAutoResizeWider() {}
 380
 381  protected:
 382   virtual bool AtExpectedState() OVERRIDE {
 383     return panel_->GetBounds().width() > initial_size_.width();
 384   }
 385   Panel* panel_;
 386   gfx::Size initial_size_;
 387 };
 388
 389 class WaitForAutoResizeNarrower : public TestPanelNotificationObserver {
 390  public:
 391   explicit WaitForAutoResizeNarrower(Panel* panel)
 392       : TestPanelNotificationObserver(
 393           chrome::NOTIFICATION_PANEL_COLLECTION_UPDATED,
 394           content::NotificationService::AllSources()),
 395         panel_(panel),
 396         initial_size_(panel->GetBounds().size()) {}
 397   virtual ~WaitForAutoResizeNarrower() {}
 398
 399  protected:
 400   virtual bool AtExpectedState() OVERRIDE {
 401     return panel_->GetBounds().width() < initial_size_.width();
 402   }
 403   Panel* panel_;
 404   gfx::Size initial_size_;
 405 };
 406
 407 // crbug.com/160504
 408 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DISABLED_AutoResize) {
 409   PanelManager* panel_manager = PanelManager::GetInstance();
 410   panel_manager->enable_auto_sizing(true);
 411   // Bigger space is needed by this test.
 412   mock_display_settings_provider()->SetPrimaryDisplay(
 413       gfx::Rect(0, 0, 1200, 900), gfx::Rect(0, 0, 1200, 900));
 414
 415   // Create a test panel with web contents loaded.
 416   CreatePanelParams params("PanelTest1", gfx::Rect(), SHOW_AS_ACTIVE);
 417   GURL url(ui_test_utils::GetTestUrl(
 418       base::FilePath(kTestDir),
 419       base::FilePath(FILE_PATH_LITERAL("update-preferred-size.html"))));
 420   params.url = url;
 421   Panel* panel = CreatePanelWithParams(params);
 422
 423   // Ensure panel has auto resized to original web content size.
 424   // The resize will update the docked panel collection.
 425   WaitForStableInitialSize initial_resize(panel);
 426   initial_resize.Wait();
 427   gfx::Rect initial_bounds = panel->GetBounds();
 428
 429   // Expand the test page. The resize will update the docked panel collection.
 430   WaitForAutoResizeWider enlarge(panel);
 431   EXPECT_TRUE(content::ExecuteScript(
 432       panel->GetWebContents(), "changeSize(50);"));
 433   enlarge.Wait();
 434   gfx::Rect bounds_on_grow = panel->GetBounds();
 435   EXPECT_GT(bounds_on_grow.width(), initial_bounds.width());
 436   EXPECT_EQ(bounds_on_grow.height(), initial_bounds.height());
 437
 438   // Shrink the test page. The resize will update the docked panel collection.
 439   WaitForAutoResizeNarrower shrink(panel);
 440   EXPECT_TRUE(content::ExecuteScript(
 441       panel->GetWebContents(), "changeSize(-30);"));
 442   shrink.Wait();
 443   gfx::Rect bounds_on_shrink = panel->GetBounds();
 444   EXPECT_LT(bounds_on_shrink.width(), bounds_on_grow.width());
 445   EXPECT_GT(bounds_on_shrink.width(), initial_bounds.width());
 446   EXPECT_EQ(bounds_on_shrink.height(), initial_bounds.height());
 447
 448   // Verify resizing turns off auto-resizing and panel no longer auto-resizes.
 449   gfx::Rect previous_bounds = panel->GetBounds();
 450   // These should be identical because the panel is expanded.
 451   EXPECT_EQ(previous_bounds.size(), panel->GetRestoredBounds().size());
 452   gfx::Size new_size(previous_bounds.size());
 453   new_size.Enlarge(5, 5);
 454   gfx::Rect new_bounds(previous_bounds.origin(), new_size);
 455   panel->SetBounds(new_bounds);
 456   EXPECT_FALSE(panel->auto_resizable());
 457   EXPECT_EQ(new_bounds.size(), panel->GetBounds().size());
 458   EXPECT_EQ(new_bounds.size(), panel->GetRestoredBounds().size());
 459
 460   // Turn back on auto-resize and verify that panel auto resizes.
 461   content::WindowedNotificationObserver auto_resize_enabled(
 462       chrome::NOTIFICATION_PANEL_COLLECTION_UPDATED,
 463       content::NotificationService::AllSources());
 464   panel->SetAutoResizable(true);
 465   auto_resize_enabled.Wait();
 466   gfx::Rect bounds_auto_resize_enabled = panel->GetBounds();
 467   EXPECT_EQ(bounds_on_shrink.width(), bounds_auto_resize_enabled.width());
 468   EXPECT_EQ(bounds_on_shrink.height(), bounds_auto_resize_enabled.height());
 469
 470   panel->Close();
 471 }
 472
 473 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, ResizePanel) {
 474   PanelManager* panel_manager = PanelManager::GetInstance();
 475   panel_manager->enable_auto_sizing(true);
 476
 477   Panel* panel = CreatePanel("TestPanel");
 478   EXPECT_TRUE(panel->auto_resizable());
 479   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
 480
 481   // Verify resizing turns off auto-resizing and that it works.
 482   gfx::Rect original_bounds = panel->GetBounds();
 483   // These should be identical because the panel is expanded.
 484   EXPECT_EQ(original_bounds.size(), panel->GetRestoredBounds().size());
 485   gfx::Size new_size(original_bounds.size());
 486   new_size.Enlarge(5, 5);
 487   gfx::Rect new_bounds(original_bounds.origin(), new_size);
 488   panel->SetBounds(new_bounds);
 489   EXPECT_FALSE(panel->auto_resizable());
 490   EXPECT_EQ(new_bounds.size(), panel->GetBounds().size());
 491   EXPECT_EQ(new_bounds.size(), panel->GetRestoredBounds().size());
 492
 493   // Verify current height unaffected when panel is not expanded.
 494   panel->SetExpansionState(Panel::MINIMIZED);
 495   int original_height = panel->GetBounds().height();
 496   new_size.Enlarge(5, 5);
 497   new_bounds.set_size(new_size);
 498   panel->SetBounds(new_bounds);
 499   EXPECT_EQ(new_bounds.size().width(), panel->GetBounds().width());
 500   EXPECT_EQ(original_height, panel->GetBounds().height());
 501   EXPECT_EQ(new_bounds.size(), panel->GetRestoredBounds().size());
 502
 503   panel->Close();
 504 }
 505
 506 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, AnimateBounds) {
 507   // Create a detached panel, instead of docked panel because it cannot be
 508   // moved to any location.
 509   Panel* panel = CreateDetachedPanel("1", gfx::Rect(200, 100, 100, 100));
 510   scoped_ptr<NativePanelTesting> panel_testing(
 511       CreateNativePanelTesting(panel));
 512
 513   // Validates that no animation should be triggered when the panel is being
 514   // dragged.
 515   gfx::Point mouse_location(panel->GetBounds().origin());
 516   panel_testing->PressLeftMouseButtonTitlebar(mouse_location);
 517   panel_testing->DragTitlebar(mouse_location + gfx::Vector2d(-100, 5));
 518   EXPECT_FALSE(panel_testing->IsAnimatingBounds());
 519   panel_testing->FinishDragTitlebar();
 520
 521   // Set bounds with animation.
 522   gfx::Rect bounds = gfx::Rect(10, 20, 150, 160);
 523   panel->SetPanelBounds(bounds);
 524   // There is no animation on Linux, by design.
 525 #if !defined(OS_LINUX)
 526   EXPECT_TRUE(panel_testing->IsAnimatingBounds());
 527   WaitForBoundsAnimationFinished(panel);
 528 #endif
 529   EXPECT_FALSE(panel_testing->IsAnimatingBounds());
 530   EXPECT_EQ(bounds, panel->GetBounds());
 531
 532   // Set bounds without animation.
 533   bounds = gfx::Rect(30, 40, 200, 220);
 534   panel->SetPanelBoundsInstantly(bounds);
 535   EXPECT_FALSE(panel_testing->IsAnimatingBounds());
 536   EXPECT_EQ(bounds, panel->GetBounds());
 537
 538   panel->Close();
 539 }
 540
 541 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, RestoredBounds) {
 542   Panel* panel = CreatePanelWithBounds("PanelTest", gfx::Rect(0, 0, 100, 100));
 543   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
 544   EXPECT_EQ(panel->GetBounds(), panel->GetRestoredBounds());
 545
 546   panel->SetExpansionState(Panel::MINIMIZED);
 547   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
 548   gfx::Rect bounds = panel->GetBounds();
 549   gfx::Rect restored = panel->GetRestoredBounds();
 550   EXPECT_EQ(bounds.x(), restored.x());
 551   EXPECT_GT(bounds.y(), restored.y());
 552   EXPECT_EQ(bounds.width(), restored.width());
 553   EXPECT_LT(bounds.height(), restored.height());
 554
 555   panel->SetExpansionState(Panel::TITLE_ONLY);
 556   EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state());
 557   bounds = panel->GetBounds();
 558   restored = panel->GetRestoredBounds();
 559   EXPECT_EQ(bounds.x(), restored.x());
 560   EXPECT_GT(bounds.y(), restored.y());
 561   EXPECT_EQ(bounds.width(), restored.width());
 562   EXPECT_LT(bounds.height(), restored.height());
 563
 564   panel->SetExpansionState(Panel::MINIMIZED);
 565   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
 566   bounds = panel->GetBounds();
 567   restored = panel->GetRestoredBounds();
 568   EXPECT_EQ(bounds.x(), restored.x());
 569   EXPECT_GT(bounds.y(), restored.y());
 570   EXPECT_EQ(bounds.width(), restored.width());
 571   EXPECT_LT(bounds.height(), restored.height());
 572
 573   panel->SetExpansionState(Panel::EXPANDED);
 574   EXPECT_EQ(panel->GetBounds(), panel->GetRestoredBounds());
 575
 576   // Verify that changing the panel bounds does not affect the restored height.
 577   int saved_restored_height = restored.height();
 578   panel->SetExpansionState(Panel::MINIMIZED);
 579   bounds = gfx::Rect(10, 20, 300, 400);
 580   panel->SetPanelBounds(bounds);
 581   EXPECT_EQ(saved_restored_height, panel->GetRestoredBounds().height());
 582
 583   panel->SetExpansionState(Panel::TITLE_ONLY);
 584   bounds = gfx::Rect(20, 30, 100, 200);
 585   panel->SetPanelBounds(bounds);
 586   EXPECT_EQ(saved_restored_height, panel->GetRestoredBounds().height());
 587
 588   panel->SetExpansionState(Panel::EXPANDED);
 589   bounds = gfx::Rect(40, 60, 300, 400);
 590   panel->SetPanelBounds(bounds);
 591   EXPECT_EQ(saved_restored_height, panel->GetRestoredBounds().height());
 592   panel->set_full_size(bounds.size());
 593   EXPECT_NE(saved_restored_height, panel->GetRestoredBounds().height());
 594
 595   panel->Close();
 596 }
 597
 598 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestore) {
 599   // Test with one panel.
 600   CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
 601   TestMinimizeRestore();
 602
 603   PanelManager::GetInstance()->CloseAll();
 604 }
 605
 606 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreTwoPanels) {
 607   // Test with two panels.
 608   CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
 609   CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 110, 110));
 610   TestMinimizeRestore();
 611
 612   PanelManager::GetInstance()->CloseAll();
 613 }
 614
 615 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreThreePanels) {
 616   // Test with three panels.
 617   CreatePanelWithBounds("PanelTest1", gfx::Rect(0, 0, 100, 100));
 618   CreatePanelWithBounds("PanelTest2", gfx::Rect(0, 0, 110, 110));
 619   CreatePanelWithBounds("PanelTest3", gfx::Rect(0, 0, 120, 120));
 620   TestMinimizeRestore();
 621
 622   PanelManager::GetInstance()->CloseAll();
 623 }
 624
 625 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MinimizeRestoreButtonClick) {
 626   // Test with three panels.
 627   Panel* panel1 = CreatePanel("PanelTest1");
 628   Panel* panel2 = CreatePanel("PanelTest2");
 629   Panel* panel3 = CreatePanel("PanelTest3");
 630   EXPECT_FALSE(panel1->IsMinimized());
 631   EXPECT_FALSE(panel2->IsMinimized());
 632   EXPECT_FALSE(panel3->IsMinimized());
 633
 634   // Click restore button on an expanded panel. Expect no change.
 635   panel1->OnRestoreButtonClicked(panel::NO_MODIFIER);
 636   EXPECT_FALSE(panel1->IsMinimized());
 637   EXPECT_FALSE(panel2->IsMinimized());
 638   EXPECT_FALSE(panel3->IsMinimized());
 639
 640   // Click minimize button on an expanded panel. Only that panel will minimize.
 641   panel1->OnMinimizeButtonClicked(panel::NO_MODIFIER);
 642   EXPECT_TRUE(panel1->IsMinimized());
 643   EXPECT_FALSE(panel2->IsMinimized());
 644   EXPECT_FALSE(panel3->IsMinimized());
 645
 646   // Click minimize button on a minimized panel. Expect no change.
 647   panel1->OnMinimizeButtonClicked(panel::NO_MODIFIER);
 648   EXPECT_TRUE(panel1->IsMinimized());
 649   EXPECT_FALSE(panel2->IsMinimized());
 650   EXPECT_FALSE(panel3->IsMinimized());
 651
 652   // Minimize all panels by clicking minimize button on an expanded panel
 653   // with the apply-all modifier.
 654   panel2->OnMinimizeButtonClicked(panel::APPLY_TO_ALL);
 655   EXPECT_TRUE(panel1->IsMinimized());
 656   EXPECT_TRUE(panel2->IsMinimized());
 657   EXPECT_TRUE(panel3->IsMinimized());
 658
 659   // Click restore button on a minimized panel. Only that panel will restore.
 660   panel2->OnRestoreButtonClicked(panel::NO_MODIFIER);
 661   EXPECT_TRUE(panel1->IsMinimized());
 662   EXPECT_FALSE(panel2->IsMinimized());
 663   EXPECT_TRUE(panel3->IsMinimized());
 664
 665   // Restore all panels by clicking restore button on a minimized panel.
 666   panel3->OnRestoreButtonClicked(panel::APPLY_TO_ALL);
 667   EXPECT_FALSE(panel1->IsMinimized());
 668   EXPECT_FALSE(panel2->IsMinimized());
 669   EXPECT_FALSE(panel3->IsMinimized());
 670 }
 671
 672 // http://crbug.com/243891 flaky on Linux
 673 #if defined(OS_LINUX)
 674 #define MAYBE_RestoreAllWithTitlebarClick DISABLED_RestoreAllWithTitlebarClick
 675 #else
 676 #define MAYBE_RestoreAllWithTitlebarClick RestoreAllWithTitlebarClick
 677 #endif
 678 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_RestoreAllWithTitlebarClick) {
 679   // Test with three panels.
 680   Panel* panel1 = CreatePanel("PanelTest1");
 681   Panel* panel2 = CreatePanel("PanelTest2");
 682   Panel* panel3 = CreatePanel("PanelTest3");
 683   EXPECT_FALSE(panel1->IsMinimized());
 684   EXPECT_FALSE(panel2->IsMinimized());
 685   EXPECT_FALSE(panel3->IsMinimized());
 686
 687   scoped_ptr<NativePanelTesting> test_panel1(
 688       CreateNativePanelTesting(panel1));
 689   scoped_ptr<NativePanelTesting> test_panel2(
 690       CreateNativePanelTesting(panel2));
 691   scoped_ptr<NativePanelTesting> test_panel3(
 692       CreateNativePanelTesting(panel3));
 693
 694   // Click on an expanded panel's titlebar using the apply-all modifier.
 695   // Verify expansion state is unchanged.
 696   test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(),
 697                                             panel::APPLY_TO_ALL);
 698   test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
 699   EXPECT_FALSE(panel1->IsMinimized());
 700   EXPECT_FALSE(panel2->IsMinimized());
 701   EXPECT_FALSE(panel3->IsMinimized());
 702
 703   // Click on a minimized panel's titlebar using the apply-all modifier.
 704   panel1->Minimize();
 705   panel2->Minimize();
 706   panel3->Minimize();
 707   EXPECT_TRUE(panel1->IsMinimized());
 708   EXPECT_TRUE(panel2->IsMinimized());
 709   EXPECT_TRUE(panel3->IsMinimized());
 710
 711   // Nothing changes until mouse is released.
 712   test_panel1->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin(),
 713                                             panel::APPLY_TO_ALL);
 714   EXPECT_TRUE(panel1->IsMinimized());
 715   EXPECT_TRUE(panel2->IsMinimized());
 716   EXPECT_TRUE(panel3->IsMinimized());
 717   // Verify all panels restored when mouse is released.
 718   test_panel1->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
 719   EXPECT_FALSE(panel1->IsMinimized());
 720   EXPECT_FALSE(panel2->IsMinimized());
 721   EXPECT_FALSE(panel3->IsMinimized());
 722
 723   // Minimize a single panel. Then click on expanded panel with apply-all
 724   // modifier. Verify nothing changes.
 725   panel1->Minimize();
 726   EXPECT_TRUE(panel1->IsMinimized());
 727   EXPECT_FALSE(panel2->IsMinimized());
 728   EXPECT_FALSE(panel3->IsMinimized());
 729
 730   test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(),
 731                                             panel::APPLY_TO_ALL);
 732   test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
 733   EXPECT_TRUE(panel1->IsMinimized());
 734   EXPECT_FALSE(panel2->IsMinimized());
 735   EXPECT_FALSE(panel3->IsMinimized());
 736
 737   // Minimize another panel. Then click on a minimized panel with apply-all
 738   // modifier to restore all panels.
 739   panel2->Minimize();
 740   EXPECT_TRUE(panel1->IsMinimized());
 741   EXPECT_TRUE(panel2->IsMinimized());
 742   EXPECT_FALSE(panel3->IsMinimized());
 743
 744   test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(),
 745                                             panel::APPLY_TO_ALL);
 746   test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
 747   EXPECT_FALSE(panel1->IsMinimized());
 748   EXPECT_FALSE(panel2->IsMinimized());
 749   EXPECT_FALSE(panel3->IsMinimized());
 750
 751   // Click on the single minimized panel. Verify all are restored.
 752   panel1->Minimize();
 753   EXPECT_TRUE(panel1->IsMinimized());
 754   EXPECT_FALSE(panel2->IsMinimized());
 755   EXPECT_FALSE(panel3->IsMinimized());
 756
 757   test_panel1->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin(),
 758                                             panel::APPLY_TO_ALL);
 759   test_panel1->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
 760   EXPECT_FALSE(panel1->IsMinimized());
 761   EXPECT_FALSE(panel2->IsMinimized());
 762   EXPECT_FALSE(panel3->IsMinimized());
 763
 764   // Click on the single expanded panel. Verify nothing changes.
 765   panel1->Minimize();
 766   panel3->Minimize();
 767   EXPECT_TRUE(panel1->IsMinimized());
 768   EXPECT_FALSE(panel2->IsMinimized());
 769   EXPECT_TRUE(panel3->IsMinimized());
 770
 771   test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(),
 772                                             panel::APPLY_TO_ALL);
 773   test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
 774   EXPECT_TRUE(panel1->IsMinimized());
 775   EXPECT_FALSE(panel2->IsMinimized());
 776   EXPECT_TRUE(panel3->IsMinimized());
 777
 778   // Hover over a minimized panel and click on the titlebar while it is in
 779   // title-only mode. Should restore all panels.
 780   panel2->Minimize();
 781   EXPECT_TRUE(panel1->IsMinimized());
 782   EXPECT_TRUE(panel2->IsMinimized());
 783   EXPECT_TRUE(panel3->IsMinimized());
 784
 785   MoveMouseAndWaitForExpansionStateChange(panel2, panel2->GetBounds().origin());
 786   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
 787   EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state());
 788   EXPECT_EQ(Panel::TITLE_ONLY, panel3->expansion_state());
 789
 790   test_panel3->PressLeftMouseButtonTitlebar(panel3->GetBounds().origin(),
 791                                             panel::APPLY_TO_ALL);
 792   test_panel3->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
 793   EXPECT_FALSE(panel1->IsMinimized());
 794   EXPECT_FALSE(panel2->IsMinimized());
 795   EXPECT_FALSE(panel3->IsMinimized());
 796
 797   // Draw attention to a minimized panel. Click on a minimized panel that is
 798   // not drawing attention. Verify restore all applies without affecting
 799   // draw attention.
 800   panel1->Minimize();
 801   panel2->Minimize();
 802   panel3->Minimize();
 803   EXPECT_TRUE(panel1->IsMinimized());
 804   EXPECT_TRUE(panel2->IsMinimized());
 805   EXPECT_TRUE(panel3->IsMinimized());
 806
 807   panel1->FlashFrame(true);
 808   EXPECT_TRUE(panel1->IsDrawingAttention());
 809
 810   test_panel2->PressLeftMouseButtonTitlebar(panel2->GetBounds().origin(),
 811                                             panel::APPLY_TO_ALL);
 812   test_panel2->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
 813   EXPECT_FALSE(panel1->IsMinimized());
 814   EXPECT_FALSE(panel2->IsMinimized());
 815   EXPECT_FALSE(panel3->IsMinimized());
 816   EXPECT_TRUE(panel1->IsDrawingAttention());
 817
 818   // Restore all panels by clicking on the minimized panel that is drawing
 819   // attention. Verify restore all applies and clears draw attention.
 820   panel1->Minimize();
 821   panel2->Minimize();
 822   panel3->Minimize();
 823   EXPECT_TRUE(panel1->IsMinimized());
 824   EXPECT_TRUE(panel2->IsMinimized());
 825   EXPECT_TRUE(panel3->IsMinimized());
 826
 827   test_panel1->PressLeftMouseButtonTitlebar(panel1->GetBounds().origin(),
 828                                             panel::APPLY_TO_ALL);
 829   test_panel1->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
 830   EXPECT_FALSE(panel1->IsMinimized());
 831   EXPECT_FALSE(panel2->IsMinimized());
 832   EXPECT_FALSE(panel3->IsMinimized());
 833   EXPECT_FALSE(panel1->IsDrawingAttention());
 834
 835   PanelManager::GetInstance()->CloseAll();
 836 }
 837
 838 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
 839                        MinimizeRestoreOnAutoHidingDesktopBar) {
 840   PanelManager* panel_manager = PanelManager::GetInstance();
 841   DockedPanelCollection* docked_collection = panel_manager->docked_collection();
 842   int expected_bottom_on_expanded = docked_collection->work_area().bottom();
 843   int expected_bottom_on_title_only = expected_bottom_on_expanded;
 844   int expected_bottom_on_minimized = expected_bottom_on_expanded;
 845
 846   // Turn on auto-hiding.
 847   static const int bottom_bar_thickness = 40;
 848   mock_display_settings_provider()->EnableAutoHidingDesktopBar(
 849       DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_BOTTOM,
 850       true,
 851       bottom_bar_thickness);
 852   expected_bottom_on_title_only -= bottom_bar_thickness;
 853
 854   Panel* panel = CreatePanel("1");
 855   int initial_height = panel->GetBounds().height();
 856
 857   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
 858   EXPECT_EQ(expected_bottom_on_expanded, panel->GetBounds().bottom());
 859
 860   panel->Minimize();
 861   WaitForBoundsAnimationFinished(panel);
 862   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
 863   EXPECT_EQ(panel::kMinimizedPanelHeight, panel->GetBounds().height());
 864   EXPECT_EQ(expected_bottom_on_minimized, panel->GetBounds().bottom());
 865
 866   panel->SetExpansionState(Panel::TITLE_ONLY);
 867   WaitForBoundsAnimationFinished(panel);
 868   EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state());
 869   EXPECT_EQ(panel::kTitlebarHeight, panel->GetBounds().height());
 870   EXPECT_EQ(expected_bottom_on_title_only, panel->GetBounds().bottom());
 871
 872   panel->Restore();
 873   WaitForBoundsAnimationFinished(panel);
 874   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
 875   EXPECT_EQ(initial_height, panel->GetBounds().height());
 876   EXPECT_EQ(expected_bottom_on_expanded, panel->GetBounds().bottom());
 877
 878   panel->Close();
 879 }
 880
 881 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, ChangeAutoHideTaskBarThickness) {
 882   PanelManager* manager = PanelManager::GetInstance();
 883   DockedPanelCollection* docked_collection = manager->docked_collection();
 884   int initial_starting_right_position =
 885       docked_collection->StartingRightPosition();
 886
 887   int bottom_bar_thickness = 20;
 888   int right_bar_thickness = 30;
 889   mock_display_settings_provider()->EnableAutoHidingDesktopBar(
 890       DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_BOTTOM,
 891       true,
 892       bottom_bar_thickness);
 893   mock_display_settings_provider()->EnableAutoHidingDesktopBar(
 894       DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_RIGHT,
 895       true,
 896       right_bar_thickness);
 897   EXPECT_EQ(initial_starting_right_position,
 898             docked_collection->StartingRightPosition());
 899
 900   Panel* panel = CreatePanel("PanelTest");
 901   panel->SetExpansionState(Panel::TITLE_ONLY);
 902   WaitForBoundsAnimationFinished(panel);
 903
 904   EXPECT_EQ(docked_collection->work_area().bottom() - bottom_bar_thickness,
 905             panel->GetBounds().bottom());
 906   EXPECT_EQ(docked_collection->StartingRightPosition(),
 907             panel->GetBounds().right());
 908
 909   initial_starting_right_position = docked_collection->StartingRightPosition();
 910   int bottom_bar_thickness_delta = 10;
 911   bottom_bar_thickness += bottom_bar_thickness_delta;
 912   int right_bar_thickness_delta = 15;
 913   right_bar_thickness += right_bar_thickness_delta;
 914   mock_display_settings_provider()->SetDesktopBarThickness(
 915       DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_BOTTOM,
 916       bottom_bar_thickness);
 917   mock_display_settings_provider()->SetDesktopBarThickness(
 918       DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_RIGHT,
 919       right_bar_thickness);
 920   base::MessageLoopForUI::current()->RunUntilIdle();
 921   EXPECT_EQ(initial_starting_right_position,
 922             docked_collection->StartingRightPosition());
 923   EXPECT_EQ(docked_collection->work_area().bottom() - bottom_bar_thickness,
 924             panel->GetBounds().bottom());
 925   EXPECT_EQ(docked_collection->StartingRightPosition(),
 926             panel->GetBounds().right());
 927
 928   initial_starting_right_position = docked_collection->StartingRightPosition();
 929   bottom_bar_thickness_delta = 20;
 930   bottom_bar_thickness -= bottom_bar_thickness_delta;
 931   right_bar_thickness_delta = 10;
 932   right_bar_thickness -= right_bar_thickness_delta;
 933   mock_display_settings_provider()->SetDesktopBarThickness(
 934       DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_BOTTOM,
 935       bottom_bar_thickness);
 936   mock_display_settings_provider()->SetDesktopBarThickness(
 937       DisplaySettingsProvider::DESKTOP_BAR_ALIGNED_RIGHT,
 938       right_bar_thickness);
 939   base::MessageLoopForUI::current()->RunUntilIdle();
 940   EXPECT_EQ(docked_collection->StartingRightPosition(),
 941             initial_starting_right_position);
 942   EXPECT_EQ(docked_collection->work_area().bottom() - bottom_bar_thickness,
 943             panel->GetBounds().bottom());
 944   EXPECT_EQ(docked_collection->StartingRightPosition(),
 945             panel->GetBounds().right());
 946
 947   panel->Close();
 948 }
 949
 950 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, ActivatePanelOrTabbedWindow) {
 951   if (!WmSupportWindowActivation()) {
 952     LOG(WARNING) << "Skipping test due to WM problems.";
 953     return;
 954   }
 955
 956   Panel* panel1 = CreatePanel("Panel1");
 957   Panel* panel2 = CreatePanel("Panel2");
 958
 959   // Activate main tabbed window.
 960   browser()->window()->Activate();
 961   WaitForPanelActiveState(panel2, SHOW_AS_INACTIVE);
 962
 963   // Activate a panel.
 964   panel2->Activate();
 965   WaitForPanelActiveState(panel2, SHOW_AS_ACTIVE);
 966
 967   // Activate the main tabbed window back.
 968   browser()->window()->Activate();
 969   WaitForPanelActiveState(panel2, SHOW_AS_INACTIVE);
 970
 971   // Activate another panel.
 972   panel1->Activate();
 973   WaitForPanelActiveState(panel1, SHOW_AS_ACTIVE);
 974   WaitForPanelActiveState(panel2, SHOW_AS_INACTIVE);
 975
 976   // Switch focus between panels.
 977   panel2->Activate();
 978   WaitForPanelActiveState(panel2, SHOW_AS_ACTIVE);
 979   WaitForPanelActiveState(panel1, SHOW_AS_INACTIVE);
 980
 981   PanelManager::GetInstance()->CloseAll();
 982 }
 983
 984 // TODO(jianli): To be enabled for other platforms.
 985 #if defined(OS_WIN) || defined(OS_LINUX)
 986 #define MAYBE_ActivateDeactivateBasic ActivateDeactivateBasic
 987 #else
 988 #define MAYBE_ActivateDeactivateBasic DISABLED_ActivateDeactivateBasic
 989 #endif
 990 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_ActivateDeactivateBasic) {
 991   if (!WmSupportWindowActivation()) {
 992     LOG(WARNING) << "Skipping test due to WM problems.";
 993     return;
 994   }
 995
 996   // Create an active panel.
 997   Panel* panel = CreatePanel("PanelTest");
 998   scoped_ptr<NativePanelTesting> native_panel_testing(
 999       CreateNativePanelTesting(panel));
1000
1001   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);  // doublecheck active state
1002   EXPECT_TRUE(native_panel_testing->VerifyActiveState(true));
1003
1004   // Deactivate the panel.
1005   panel->Deactivate();
1006   WaitForPanelActiveState(panel, SHOW_AS_INACTIVE);
1007
1008   // On GTK there is no way to deactivate a window. So the Deactivate() call
1009   // above does not actually deactivate the window, but simply lowers it.
1010 #if !defined(OS_LINUX)
1011   EXPECT_TRUE(native_panel_testing->VerifyActiveState(false));
1012 #endif
1013
1014   // This test does not reactivate the panel because the panel might not be
1015   // reactivated programmatically once it is deactivated.
1016 }
1017
1018 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, ActivateDeactivateMultiple) {
1019   if (!WmSupportWindowActivation()) {
1020     LOG(WARNING) << "Skipping test due to WM problems.";
1021     return;
1022   }
1023
1024   BrowserWindow* tabbed_window = browser()->window();
1025
1026   // Create 4 panels in the following screen layout:
1027   //    P3  P2  P1  P0
1028   const int kNumPanels = 4;
1029   for (int i = 0; i < kNumPanels; ++i)
1030     CreatePanelWithBounds(MakePanelName(i), gfx::Rect(0, 0, 100, 100));
1031   const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels();
1032
1033   std::vector<bool> expected_active_states;
1034   std::vector<bool> last_active_states;
1035
1036   // The last created panel, P3, should be active.
1037   expected_active_states = ProduceExpectedActiveStates(3);
1038   EXPECT_EQ(expected_active_states, GetAllPanelActiveStates());
1039   EXPECT_FALSE(tabbed_window->IsActive());
1040
1041   // Activating P1 should cause P3 to lose focus.
1042   panels[1]->Activate();
1043   last_active_states = expected_active_states;
1044   expected_active_states = ProduceExpectedActiveStates(1);
1045   WaitForPanelActiveStates(last_active_states, expected_active_states);
1046   EXPECT_EQ(expected_active_states, GetAllPanelActiveStates());
1047
1048   // Minimizing inactive panel P2 should not affect other panels' active states.
1049   panels[2]->SetExpansionState(Panel::MINIMIZED);
1050   EXPECT_EQ(expected_active_states, GetAllPanelActiveStates());
1051   EXPECT_FALSE(tabbed_window->IsActive());
1052 }
1053
1054 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionBasic) {
1055   Panel* panel = CreateInactivePanel("P1");
1056   scoped_ptr<NativePanelTesting> native_panel_testing(
1057       CreateNativePanelTesting(panel));
1058
1059   // Test that the attention is drawn when the expanded panel is not in focus.
1060   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
1061   EXPECT_FALSE(panel->IsActive());
1062   EXPECT_FALSE(panel->IsDrawingAttention());
1063   panel->FlashFrame(true);
1064   EXPECT_TRUE(panel->IsDrawingAttention());
1065   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
1066
1067   // Stop drawing attention.
1068   panel->FlashFrame(false);
1069   EXPECT_FALSE(panel->IsDrawingAttention());
1070   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
1071
1072   // Draw attention, then minimize. Titlebar should remain visible.
1073   panel->FlashFrame(true);
1074   EXPECT_TRUE(panel->IsDrawingAttention());
1075
1076   panel->Minimize();
1077   EXPECT_TRUE(panel->IsDrawingAttention());
1078   EXPECT_EQ(Panel::TITLE_ONLY, panel->expansion_state());
1079
1080   // Stop drawing attention. Titlebar should no longer be visible.
1081   panel->FlashFrame(false);
1082   EXPECT_FALSE(panel->IsDrawingAttention());
1083   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
1084
1085   panel->Close();
1086 }
1087
1088 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionWhileMinimized) {
1089   Panel* panel1 = CreateInactivePanel("P1");
1090   Panel* panel2 = CreateInactivePanel("P2");
1091
1092   scoped_ptr<NativePanelTesting> native_panel1_testing(
1093       CreateNativePanelTesting(panel1));
1094
1095   // Test that the attention is drawn and the title-bar is brought up when the
1096   // minimized panel is drawing attention.
1097   panel1->Minimize();
1098   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
1099   panel1->FlashFrame(true);
1100   EXPECT_TRUE(panel1->IsDrawingAttention());
1101   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
1102   EXPECT_TRUE(native_panel1_testing->VerifyDrawingAttention());
1103
1104   // Test that we cannot bring up other minimized panel if the mouse is over
1105   // the panel that draws attension.
1106   panel2->Minimize();
1107   gfx::Point hover_point(panel1->GetBounds().origin());
1108   MoveMouse(hover_point);
1109   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
1110   EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state());
1111
1112   // Test that we cannot bring down the panel that is drawing the attention.
1113   hover_point.set_y(hover_point.y() - 200);
1114   MoveMouse(hover_point);
1115   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
1116
1117   // Test that the attention is cleared when activated.
1118   panel1->Activate();
1119   WaitForPanelActiveState(panel1, SHOW_AS_ACTIVE);
1120   EXPECT_FALSE(panel1->IsDrawingAttention());
1121   EXPECT_EQ(Panel::EXPANDED, panel1->expansion_state());
1122   EXPECT_FALSE(native_panel1_testing->VerifyDrawingAttention());
1123
1124   PanelManager::GetInstance()->CloseAll();
1125 }
1126
1127 // Verify that minimized state of a panel is correct after draw attention
1128 // is stopped when there are other minimized panels.
1129 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, StopDrawingAttentionWhileMinimized) {
1130   Panel* panel1 = CreateInactivePanel("P1");
1131   Panel* panel2 = CreateInactivePanel("P2");
1132
1133   panel1->Minimize();
1134   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
1135   panel2->Minimize();
1136   EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state());
1137
1138   // Verify panel returns to minimized state when no longer drawing attention.
1139   panel1->FlashFrame(true);
1140   EXPECT_TRUE(panel1->IsDrawingAttention());
1141   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
1142
1143   panel1->FlashFrame(false);
1144   EXPECT_FALSE(panel1->IsDrawingAttention());
1145   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
1146
1147   // Hover over other minimized panel to bring up titlebars.
1148   gfx::Point hover_point(panel2->GetBounds().origin());
1149   MoveMouseAndWaitForExpansionStateChange(panel1, hover_point);
1150   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
1151   EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state());
1152
1153   // Verify panel keeps titlebar visible when no longer drawing attention
1154   // if titlebars are up.
1155   panel1->FlashFrame(true);
1156   EXPECT_TRUE(panel1->IsDrawingAttention());
1157   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
1158
1159   panel1->FlashFrame(false);
1160   EXPECT_FALSE(panel1->IsDrawingAttention());
1161   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
1162
1163   // Move mouse away. All panels should return to minimized state.
1164   hover_point.set_y(hover_point.y() - 200);
1165   MoveMouseAndWaitForExpansionStateChange(panel1, hover_point);
1166   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
1167   EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state());
1168
1169   // Verify minimized panel that is drawing attention stays in title-only mode
1170   // after attention is cleared if mouse is in the titlebar area.
1171   panel1->FlashFrame(true);
1172   EXPECT_TRUE(panel1->IsDrawingAttention());
1173   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
1174
1175   gfx::Point hover_point_in_panel(panel1->GetBounds().origin());
1176   MoveMouse(hover_point_in_panel);
1177
1178   panel1->FlashFrame(false);
1179   EXPECT_FALSE(panel1->IsDrawingAttention());
1180   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
1181   EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state());
1182
1183   // Typical user scenario will detect the mouse in the panel
1184   // after attention is cleared, causing titles to pop up, so
1185   // we simulate that here.
1186   MoveMouseAndWaitForExpansionStateChange(panel2, hover_point_in_panel);
1187   EXPECT_EQ(Panel::TITLE_ONLY, panel1->expansion_state());
1188   EXPECT_EQ(Panel::TITLE_ONLY, panel2->expansion_state());
1189
1190   // Move mouse away and panels should go back to fully minimized state.
1191   MoveMouseAndWaitForExpansionStateChange(panel1, hover_point);
1192   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
1193   EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state());
1194
1195   PanelManager::GetInstance()->CloseAll();
1196 }
1197
1198 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionWhenActive) {
1199   // Create an active panel.
1200   Panel* panel = CreatePanel("P1");
1201   scoped_ptr<NativePanelTesting> native_panel_testing(
1202       CreateNativePanelTesting(panel));
1203
1204   // Test that the attention should not be drawn if the expanded panel is in
1205   // focus.
1206   panel->FlashFrame(true);
1207   EXPECT_FALSE(panel->IsDrawingAttention());
1208   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
1209
1210   panel->Close();
1211 }
1212
1213 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionResetOnActivate) {
1214   Panel* panel = CreateInactivePanel("P1");
1215   scoped_ptr<NativePanelTesting> native_panel_testing(
1216       CreateNativePanelTesting(panel));
1217
1218   panel->FlashFrame(true);
1219   EXPECT_TRUE(panel->IsDrawingAttention());
1220   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
1221
1222   // Test that the attention is cleared when panel gets focus.
1223   panel->Activate();
1224   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
1225   EXPECT_FALSE(panel->IsDrawingAttention());
1226   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
1227
1228   panel->Close();
1229 }
1230
1231 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
1232                        DrawAttentionMinimizedNotResetOnActivate) {
1233   Panel* panel = CreateInactivePanel("P1");
1234
1235   panel->Minimize();
1236   EXPECT_TRUE(panel->IsMinimized());
1237   panel->FlashFrame(true);
1238   EXPECT_TRUE(panel->IsDrawingAttention());
1239
1240   // Simulate panel being activated while minimized. Cannot call
1241   // Activate() as that expands the panel.
1242   panel->OnActiveStateChanged(true);
1243   EXPECT_TRUE(panel->IsDrawingAttention());  // Unchanged.
1244
1245   // Unminimize panel to show that attention would have been cleared
1246   // if panel had not been minimized.
1247   panel->Restore();
1248   EXPECT_FALSE(panel->IsMinimized());
1249   EXPECT_TRUE(panel->IsDrawingAttention());  // Unchanged.
1250
1251   panel->OnActiveStateChanged(true);
1252   EXPECT_FALSE(panel->IsDrawingAttention());  // Attention cleared.
1253
1254   panel->Close();
1255 }
1256
1257 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DrawAttentionResetOnClick) {
1258   Panel* panel = CreateInactivePanel("P1");
1259   scoped_ptr<NativePanelTesting> native_panel_testing(
1260       CreateNativePanelTesting(panel));
1261
1262   panel->FlashFrame(true);
1263   EXPECT_TRUE(panel->IsDrawingAttention());
1264   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
1265
1266   // Test that the attention is cleared when panel gets focus.
1267   native_panel_testing->PressLeftMouseButtonTitlebar(
1268       panel->GetBounds().origin());
1269   native_panel_testing->ReleaseMouseButtonTitlebar();
1270
1271   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
1272   EXPECT_FALSE(panel->IsDrawingAttention());
1273   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
1274
1275   panel->Close();
1276 }
1277
1278 // http://crbug.com/175760; several panel tests failing regularly on mac.
1279 #if defined(OS_MACOSX)
1280 #define MAYBE_MinimizeImmediatelyAfterRestore \
1281   DISABLED_MinimizeImmediatelyAfterRestore
1282 #else
1283 #define MAYBE_MinimizeImmediatelyAfterRestore MinimizeImmediatelyAfterRestore
1284 #endif
1285 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
1286                        MAYBE_MinimizeImmediatelyAfterRestore) {
1287   CreatePanelParams params("Panel Test", gfx::Rect(), SHOW_AS_ACTIVE);
1288   Panel* panel = CreatePanelWithParams(params);
1289   scoped_ptr<NativePanelTesting> native_panel_testing(
1290       CreateNativePanelTesting(panel));
1291
1292   PanelActiveStateObserver signal(panel, false);
1293   panel->Minimize();  // this should deactivate.
1294   signal.Wait();
1295   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
1296
1297   panel->Restore();
1298   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
1299
1300   // Verify that minimizing a panel right after expansion works.
1301   panel->Minimize();
1302   EXPECT_EQ(Panel::MINIMIZED, panel->expansion_state());
1303
1304   panel->Close();
1305 }
1306
1307 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, FocusLostOnMinimize) {
1308   CreatePanelParams params("Initially Active", gfx::Rect(), SHOW_AS_ACTIVE);
1309   Panel* panel = CreatePanelWithParams(params);
1310   EXPECT_EQ(Panel::EXPANDED, panel->expansion_state());
1311
1312   PanelActiveStateObserver signal(panel, false);
1313   panel->Minimize();
1314   signal.Wait();
1315   panel->Close();
1316 }
1317
1318 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, CreateInactiveSwitchToActive) {
1319   Panel* panel = CreateInactivePanel("1");
1320
1321   panel->Activate();
1322   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
1323
1324   panel->Close();
1325 }
1326
1327 // TODO(dimich): try/enable on other platforms. See bug 103253 for details on
1328 // why this is disabled on windows.
1329 #if defined(OS_MACOSX)
1330 #define MAYBE_MinimizeTwoPanelsWithoutTabbedWindow \
1331     MinimizeTwoPanelsWithoutTabbedWindow
1332 #else
1333 #define MAYBE_MinimizeTwoPanelsWithoutTabbedWindow \
1334     DISABLED_MinimizeTwoPanelsWithoutTabbedWindow
1335 #endif
1336
1337 // When there are 2 panels and no chrome window, minimizing one panel does
1338 // not expand/focuses another.
1339 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
1340                        MAYBE_MinimizeTwoPanelsWithoutTabbedWindow) {
1341   CreatePanelParams params("Initially Inactive", gfx::Rect(), SHOW_AS_INACTIVE);
1342   Panel* panel1 = CreatePanelWithParams(params);
1343   Panel* panel2 = CreatePanelWithParams(params);
1344
1345   // Close main tabbed window.
1346   content::WindowedNotificationObserver signal(
1347       chrome::NOTIFICATION_BROWSER_CLOSED,
1348       content::Source<Browser>(browser()));
1349   chrome::CloseWindow(browser());
1350   signal.Wait();
1351
1352   EXPECT_EQ(Panel::EXPANDED, panel1->expansion_state());
1353   EXPECT_EQ(Panel::EXPANDED, panel2->expansion_state());
1354   panel1->Activate();
1355   WaitForPanelActiveState(panel1, SHOW_AS_ACTIVE);
1356
1357   panel1->SetExpansionState(Panel::MINIMIZED);
1358   base::MessageLoop::current()->RunUntilIdle();
1359   WaitForPanelActiveState(panel1, SHOW_AS_INACTIVE);
1360   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
1361
1362   panel2->SetExpansionState(Panel::MINIMIZED);
1363   base::MessageLoop::current()->RunUntilIdle();
1364   WaitForPanelActiveState(panel2, SHOW_AS_INACTIVE);
1365   EXPECT_EQ(Panel::MINIMIZED, panel2->expansion_state());
1366
1367   // Verify that panel1 is still minimized and not active.
1368   WaitForPanelActiveState(panel1, SHOW_AS_INACTIVE);
1369   EXPECT_EQ(Panel::MINIMIZED, panel1->expansion_state());
1370
1371   // Another check for the same.
1372   EXPECT_FALSE(panel1->IsActive());
1373   EXPECT_FALSE(panel2->IsActive());
1374
1375   panel1->Close();
1376   panel2->Close();
1377 }
1378
1379 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
1380                        NonExtensionDomainPanelsCloseOnUninstall) {
1381   // Create a test extension.
1382   DictionaryValue empty_value;
1383   scoped_refptr<extensions::Extension> extension =
1384       CreateExtension(FILE_PATH_LITERAL("TestExtension"),
1385                       extensions::Manifest::INTERNAL, empty_value);
1386   std::string extension_app_name =
1387       web_app::GenerateApplicationNameFromExtensionId(extension->id());
1388
1389   PanelManager* panel_manager = PanelManager::GetInstance();
1390   EXPECT_EQ(0, panel_manager->num_panels());
1391
1392   // Create a panel with the extension as host.
1393   CreatePanelParams params(extension_app_name, gfx::Rect(), SHOW_AS_ACTIVE);
1394   std::string extension_domain_url(extensions::kExtensionScheme);
1395   extension_domain_url += "://";
1396   extension_domain_url += extension->id();
1397   extension_domain_url += "/hello.html";
1398   params.url = GURL(extension_domain_url);
1399   Panel* panel = CreatePanelWithParams(params);
1400   EXPECT_EQ(1, panel_manager->num_panels());
1401
1402   // Create a panel with a non-extension host.
1403   CreatePanelParams params1(extension_app_name, gfx::Rect(), SHOW_AS_ACTIVE);
1404   params1.url = GURL(content::kAboutBlankURL);
1405   Panel* panel1 = CreatePanelWithParams(params1);
1406   EXPECT_EQ(2, panel_manager->num_panels());
1407
1408   // Create another extension and a panel from that extension.
1409   scoped_refptr<extensions::Extension> extension_other =
1410       CreateExtension(FILE_PATH_LITERAL("TestExtensionOther"),
1411                       extensions::Manifest::INTERNAL, empty_value);
1412   std::string extension_app_name_other =
1413       web_app::GenerateApplicationNameFromExtensionId(extension_other->id());
1414   Panel* panel_other = CreatePanel(extension_app_name_other);
1415
1416   content::WindowedNotificationObserver signal(
1417       chrome::NOTIFICATION_PANEL_CLOSED,
1418       content::Source<Panel>(panel));
1419   content::WindowedNotificationObserver signal1(
1420       chrome::NOTIFICATION_PANEL_CLOSED,
1421       content::Source<Panel>(panel1));
1422
1423   // Send unload notification on the first extension.
1424   extensions::UnloadedExtensionInfo details(
1425       extension.get(), extension_misc::UNLOAD_REASON_UNINSTALL);
1426   content::NotificationService::current()->Notify(
1427       chrome::NOTIFICATION_EXTENSION_UNLOADED,
1428       content::Source<Profile>(browser()->profile()),
1429       content::Details<extensions::UnloadedExtensionInfo>(&details));
1430
1431   // Wait for the panels opened by the first extension to close.
1432   signal.Wait();
1433   signal1.Wait();
1434
1435   // Verify that the panel that's left is the panel from the second extension.
1436   EXPECT_EQ(panel_other, panel_manager->panels()[0]);
1437   panel_other->Close();
1438 }
1439
1440 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, OnBeforeUnloadOnClose) {
1441   PanelManager* panel_manager = PanelManager::GetInstance();
1442   EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially.
1443
1444   const string16 title_first_close = UTF8ToUTF16("TitleFirstClose");
1445   const string16 title_second_close = UTF8ToUTF16("TitleSecondClose");
1446
1447   // Create a test panel with web contents loaded.
1448   CreatePanelParams params("PanelTest1", gfx::Rect(0, 0, 300, 300),
1449                            SHOW_AS_ACTIVE);
1450   params.url = ui_test_utils::GetTestUrl(
1451       base::FilePath(kTestDir),
1452       base::FilePath(FILE_PATH_LITERAL("onbeforeunload.html")));
1453   Panel* panel = CreatePanelWithParams(params);
1454   EXPECT_EQ(1, panel_manager->num_panels());
1455
1456   // Close panel and verify it closes despite having a onbeforeunload handler.
1457   CloseWindowAndWait(panel);
1458   EXPECT_EQ(0, panel_manager->num_panels());
1459 }
1460
1461 // http://crbug.com/175760; several panel tests failing regularly on mac.
1462 #if defined(OS_MACOSX)
1463 #define MAYBE_SizeClamping DISABLED_SizeClamping
1464 #else
1465 #define MAYBE_SizeClamping SizeClamping
1466 #endif
1467 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_SizeClamping) {
1468   // Using '0' sizes is equivalent of not providing sizes in API and causes
1469   // minimum sizes to be applied to facilitate auto-sizing.
1470   CreatePanelParams params("Panel", gfx::Rect(), SHOW_AS_ACTIVE);
1471   Panel* panel = CreatePanelWithParams(params);
1472   EXPECT_EQ(panel->min_size().width(), panel->GetBounds().width());
1473   EXPECT_EQ(panel->min_size().height(), panel->GetBounds().height());
1474   int reasonable_width = panel->min_size().width() + 10;
1475   int reasonable_height = panel->min_size().height() + 20;
1476
1477   panel->Close();
1478
1479   // Using reasonable actual sizes should avoid clamping.
1480   CreatePanelParams params1("Panel1",
1481                             gfx::Rect(0, 0,
1482                                       reasonable_width, reasonable_height),
1483                             SHOW_AS_ACTIVE);
1484   panel = CreatePanelWithParams(params1);
1485   EXPECT_EQ(reasonable_width, panel->GetBounds().width());
1486   EXPECT_EQ(reasonable_height, panel->GetBounds().height());
1487   panel->Close();
1488
1489   // Using just one size should auto-compute some reasonable other size.
1490   int given_height = 200;
1491   CreatePanelParams params2("Panel2", gfx::Rect(0, 0, 0, given_height),
1492                             SHOW_AS_ACTIVE);
1493   panel = CreatePanelWithParams(params2);
1494   EXPECT_GT(panel->GetBounds().width(), 0);
1495   EXPECT_EQ(given_height, panel->GetBounds().height());
1496   panel->Close();
1497 }
1498
1499 // http://crbug.com/175760; several panel tests failing regularly on mac.
1500 // http://crbug.com/179890; TightAutosizeAroundSingleLine broken on Windows by
1501 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
1502                        DISABLED_TightAutosizeAroundSingleLine) {
1503   PanelManager::GetInstance()->enable_auto_sizing(true);
1504   // Using 0 sizes triggers auto-sizing.
1505   CreatePanelParams params("Panel", gfx::Rect(), SHOW_AS_ACTIVE);
1506   params.url = GURL("data:text/html;charset=utf-8,<!doctype html><body>");
1507   Panel* panel = CreatePanelWithParams(params);
1508
1509   // Ensure panel has auto resized to original web content size.
1510   WaitForStableInitialSize initial_resize(panel);
1511   initial_resize.Wait();
1512
1513   int initial_width = panel->GetBounds().width();
1514   int initial_height = panel->GetBounds().height();
1515
1516   // Inject some HTML content into the panel.
1517   WaitForAutoResizeWider enlarge(panel);
1518   EXPECT_TRUE(content::ExecuteScript(
1519       panel->GetWebContents(),
1520       "document.body.innerHTML ="
1521       "    '<nobr>line of text and a <button>Button</button>';"));
1522   enlarge.Wait();
1523
1524   // The panel should have become larger in both dimensions (the minimums
1525   // has to be set to be smaller then a simple 1-line content, so the autosize
1526   // can work correctly.
1527   EXPECT_GT(panel->GetBounds().width(), initial_width);
1528   EXPECT_GT(panel->GetBounds().height(), initial_height);
1529
1530   panel->Close();
1531 }
1532
1533 // http://crbug.com/175760; several panel tests failing regularly on mac.
1534 #if defined(OS_MACOSX)
1535 #define MAYBE_DefaultMaxSizeOnDisplaySettingsChange \
1536         DISABLED_DefaultMaxSizeOnDisplaySettingsChange
1537 #else
1538 #define MAYBE_DefaultMaxSizeOnDisplaySettingsChange \
1539         DefaultMaxSizeOnDisplaySettingsChange
1540 #endif
1541 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
1542                        MAYBE_DefaultMaxSizeOnDisplaySettingsChange) {
1543   Panel* panel = CreatePanelWithBounds("1", gfx::Rect(0, 0, 240, 220));
1544
1545   gfx::Size old_max_size = panel->max_size();
1546   gfx::Size old_full_size = panel->full_size();
1547
1548   // Shrink the work area. Expect max size and full size become smaller.
1549   gfx::Rect smaller_work_area(0, 0, 500, 300);
1550   mock_display_settings_provider()->SetPrimaryDisplay(
1551       smaller_work_area, smaller_work_area);
1552   EXPECT_GT(old_max_size.width(), panel->max_size().width());
1553   EXPECT_GT(old_max_size.height(), panel->max_size().height());
1554   EXPECT_GT(smaller_work_area.width(), panel->max_size().width());
1555   EXPECT_GT(smaller_work_area.height(), panel->max_size().height());
1556   EXPECT_GT(old_full_size.width(), panel->full_size().width());
1557   EXPECT_GT(old_full_size.height(), panel->full_size().height());
1558   EXPECT_GE(panel->max_size().width(), panel->full_size().width());
1559   EXPECT_GE(panel->max_size().height(), panel->full_size().height());
1560
1561   panel->Close();
1562 }
1563
1564 // http://crbug.com/175760; several panel tests failing regularly on mac.
1565 #if defined(OS_MACOSX)
1566 #define MAYBE_CustomMaxSizeOnDisplaySettingsChange \
1567         DISABLED_CustomMaxSizeOnDisplaySettingsChange
1568 #else
1569 #define MAYBE_CustomMaxSizeOnDisplaySettingsChange \
1570         CustomMaxSizeOnDisplaySettingsChange
1571 #endif
1572 IN_PROC_BROWSER_TEST_F(PanelBrowserTest,
1573                        MAYBE_CustomMaxSizeOnDisplaySettingsChange) {
1574   PanelManager* panel_manager = PanelManager::GetInstance();
1575   Panel* panel = CreatePanelWithBounds("1", gfx::Rect(0, 0, 240, 220));
1576
1577   // Trigger custom max size by user resizing.
1578   gfx::Size bigger_size = gfx::Size(550, 400);
1579   gfx::Point mouse_location = panel->GetBounds().origin();
1580   panel_manager->StartResizingByMouse(panel,
1581                                       mouse_location,
1582                                       panel::RESIZE_TOP_LEFT);
1583   mouse_location.Offset(panel->GetBounds().width() - bigger_size.width(),
1584                         panel->GetBounds().height() - bigger_size.height());
1585   panel_manager->ResizeByMouse(mouse_location);
1586   panel_manager->EndResizingByMouse(false);
1587
1588   gfx::Size old_max_size = panel->max_size();
1589   EXPECT_EQ(bigger_size, old_max_size);
1590   gfx::Size old_full_size = panel->full_size();
1591   EXPECT_EQ(bigger_size, old_full_size);
1592
1593   // Shrink the work area. Expect max size and full size become smaller.
1594   gfx::Rect smaller_work_area(0, 0, 500, 300);
1595   mock_display_settings_provider()->SetPrimaryDisplay(
1596       smaller_work_area, smaller_work_area);
1597   EXPECT_GT(old_max_size.width(), panel->max_size().width());
1598   EXPECT_GT(old_max_size.height(), panel->max_size().height());
1599   EXPECT_GE(smaller_work_area.width(), panel->max_size().width());
1600   EXPECT_EQ(smaller_work_area.height(), panel->max_size().height());
1601   EXPECT_GT(old_full_size.width(), panel->full_size().width());
1602   EXPECT_GT(old_full_size.height(), panel->full_size().height());
1603   EXPECT_GE(panel->max_size().width(), panel->full_size().width());
1604   EXPECT_GE(panel->max_size().height(), panel->full_size().height());
1605   EXPECT_EQ(smaller_work_area.height(), panel->full_size().height());
1606
1607   panel->Close();
1608 }
1609
1610 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DevTools) {
1611   // Create a test panel with web contents loaded.
1612   CreatePanelParams params("1", gfx::Rect(0, 0, 200, 220), SHOW_AS_ACTIVE);
1613   GURL url(ui_test_utils::GetTestUrl(
1614       base::FilePath(kTestDir),
1615       base::FilePath(FILE_PATH_LITERAL("update-preferred-size.html"))));
1616   params.url = url;
1617   Panel* panel = CreatePanelWithParams(params);
1618
1619   // Open devtools.
1620   size_t num_browsers = 1;
1621   EXPECT_EQ(num_browsers, chrome::GetBrowserCount(
1622                               browser()->profile(),
1623                               browser()->host_desktop_type()));
1624   content::WindowedNotificationObserver signal(
1625       chrome::NOTIFICATION_BROWSER_WINDOW_READY,
1626       content::NotificationService::AllSources());
1627   EXPECT_TRUE(panel->ExecuteCommandIfEnabled(IDC_DEV_TOOLS));
1628   signal.Wait();
1629
1630   // Check that the new browser window that opened is dev tools window.
1631   ++num_browsers;
1632   EXPECT_EQ(num_browsers, chrome::GetBrowserCount(
1633                               browser()->profile(),
1634                               browser()->host_desktop_type()));
1635   for (chrome::BrowserIterator iter; !iter.done(); iter.Next()) {
1636     if (*iter == browser())
1637       continue;
1638     ASSERT_TRUE((*iter)->is_devtools());
1639   }
1640
1641   panel->Close();
1642 }
1643
1644 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DevToolsConsole) {
1645   // Create a test panel with web contents loaded.
1646   CreatePanelParams params("1", gfx::Rect(0, 0, 200, 220), SHOW_AS_ACTIVE);
1647   GURL url(ui_test_utils::GetTestUrl(
1648       base::FilePath(kTestDir),
1649       base::FilePath(FILE_PATH_LITERAL("update-preferred-size.html"))));
1650   params.url = url;
1651   Panel* panel = CreatePanelWithParams(params);
1652
1653   // Open devtools console.
1654   size_t num_browsers = 1;
1655   EXPECT_EQ(num_browsers, chrome::GetBrowserCount(
1656                               browser()->profile(),
1657                               browser()->host_desktop_type()));
1658   content::WindowedNotificationObserver signal(
1659       chrome::NOTIFICATION_BROWSER_WINDOW_READY,
1660       content::NotificationService::AllSources());
1661   EXPECT_TRUE(panel->ExecuteCommandIfEnabled(IDC_DEV_TOOLS_CONSOLE));
1662   signal.Wait();
1663
1664   // Check that the new browser window that opened is dev tools window.
1665   ++num_browsers;
1666   EXPECT_EQ(num_browsers, chrome::GetBrowserCount(
1667                               browser()->profile(),
1668                               browser()->host_desktop_type()));
1669   for (chrome::BrowserIterator iter; !iter.done(); iter.Next()) {
1670     if (*iter == browser())
1671       continue;
1672     ASSERT_TRUE((*iter)->is_devtools());
1673   }
1674
1675   panel->Close();
1676 }
1677
1678 #if defined(OS_WIN)
1679 #define MAYBE_Accelerator Accelerator
1680 #else
1681 #define MAYBE_Accelerator DISABLED_Accelerator
1682 #endif
1683 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_Accelerator) {
1684   PanelManager* panel_manager = PanelManager::GetInstance();
1685
1686   // Create a test panel with web contents loaded.
1687   CreatePanelParams params("1", gfx::Rect(), SHOW_AS_ACTIVE);
1688   GURL url(ui_test_utils::GetTestUrl(
1689       base::FilePath(kTestDir),
1690       base::FilePath(FILE_PATH_LITERAL("update-preferred-size.html"))));
1691   params.url = url;
1692   Panel* panel = CreatePanelWithParams(params);
1693   EXPECT_EQ(1, panel_manager->num_panels());
1694
1695   // Close the panel by acclerator.
1696   content::WindowedNotificationObserver signal(
1697       chrome::NOTIFICATION_PANEL_CLOSED,
1698       content::Source<Panel>(panel));
1699 #if defined(USE_AURA)
1700   double now = ui::EventTimeForNow().InSecondsF();
1701   content::NativeWebKeyboardEvent key_event(
1702       ui::ET_KEY_PRESSED,
1703       false,
1704       ui::VKEY_W,
1705       ui::EF_CONTROL_DOWN,
1706       now);
1707 #elif defined(OS_WIN)
1708   ::MSG key_msg = { NULL, WM_KEYDOWN, ui::VKEY_W, 0 };
1709   content::NativeWebKeyboardEvent key_event(key_msg);
1710   key_event.modifiers = content::NativeWebKeyboardEvent::ControlKey;
1711 #else
1712   content::NativeWebKeyboardEvent key_event;
1713 #endif
1714   panel->HandleKeyboardEvent(key_event);
1715   signal.Wait();
1716   EXPECT_EQ(0, panel_manager->num_panels());
1717 }
1718
1719 class PanelExtensionApiTest : public ExtensionApiTest {
1720  protected:
1721   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
1722     ExtensionApiTest::SetUpCommandLine(command_line);
1723     command_line->AppendSwitch(switches::kEnablePanels);
1724   }
1725 };
1726
1727 #if defined(OS_LINUX) || (!defined(OS_WIN) && defined(USE_AURA)) || \
1728     defined(OS_MACOSX)
1729 // Focus test fails if there is no window manager on Linux.
1730 // Aura panels have different behavior that do not apply to this test.
1731 #define MAYBE_FocusChangeEventOnMinimize DISABLED_FocusChangeEventOnMinimize
1732 #else
1733 #define MAYBE_FocusChangeEventOnMinimize FocusChangeEventOnMinimize
1734 #endif
1735 IN_PROC_BROWSER_TEST_F(PanelExtensionApiTest,
1736                        MAYBE_FocusChangeEventOnMinimize) {
1737   // This is needed so the subsequently created panels can be activated.
1738   // On a Mac, it transforms background-only test process into foreground one.
1739   ASSERT_TRUE(ui_test_utils::BringBrowserWindowToFront(browser()));
1740   ASSERT_TRUE(RunExtensionTest("panels/focus_change_on_minimize")) << message_;
1741 }