Home | History | Annotate | Download | only in panels 
      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/message_loop/message_loop.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/native_panel.h"
      9 #include "chrome/browser/ui/panels/panel.h"
     10 #include "chrome/browser/ui/panels/panel_manager.h"
     11 
     12 class DetachedPanelBrowserTest : public BasePanelBrowserTest {
     13 };
     14 
     15 IN_PROC_BROWSER_TEST_F(DetachedPanelBrowserTest, CheckDetachedPanelProperties) {
     16   PanelManager* panel_manager = PanelManager::GetInstance();
     17   DetachedPanelCollection* detached_collection =
     18       panel_manager->detached_collection();
     19 
     20   // Create an initially detached panel (as opposed to other tests which create
     21   // a docked panel, then detaches it).
     22   gfx::Rect bounds(300, 200, 250, 200);
     23   CreatePanelParams params("1", bounds, SHOW_AS_ACTIVE);
     24   params.create_mode = PanelManager::CREATE_AS_DETACHED;
     25   Panel* panel = CreatePanelWithParams(params);
     26   scoped_ptr<NativePanelTesting> panel_testing(
     27       CreateNativePanelTesting(panel));
     28 
     29   EXPECT_EQ(1, panel_manager->num_panels());
     30   EXPECT_TRUE(detached_collection->HasPanel(panel));
     31 
     32   EXPECT_EQ(bounds.x(), panel->GetBounds().x());
     33   // Ignore checking y position since the detached panel will be placed near
     34   // the top if the stacking mode is enabled.
     35   if (!PanelManager::IsPanelStackingEnabled())
     36     EXPECT_EQ(bounds.y(), panel->GetBounds().y());
     37   EXPECT_EQ(bounds.width(), panel->GetBounds().width());
     38   EXPECT_EQ(bounds.height(), panel->GetBounds().height());
     39   EXPECT_FALSE(panel->IsAlwaysOnTop());
     40 
     41   EXPECT_TRUE(panel_testing->IsButtonVisible(panel::CLOSE_BUTTON));
     42   // The minimize button will not be shown on some Linux desktop environment
     43   // that does not support system minimize.
     44   if (PanelManager::CanUseSystemMinimize())
     45     EXPECT_TRUE(panel_testing->IsButtonVisible(panel::MINIMIZE_BUTTON));
     46   else
     47     EXPECT_FALSE(panel_testing->IsButtonVisible(panel::MINIMIZE_BUTTON));
     48   EXPECT_FALSE(panel_testing->IsButtonVisible(panel::RESTORE_BUTTON));
     49 
     50   EXPECT_EQ(panel::RESIZABLE_ALL, panel->CanResizeByMouse());
     51 
     52   EXPECT_EQ(panel::ALL_ROUNDED, panel_testing->GetWindowCornerStyle());
     53 
     54   Panel::AttentionMode expected_attention_mode =
     55       static_cast<Panel::AttentionMode>(Panel::USE_PANEL_ATTENTION |
     56                                          Panel::USE_SYSTEM_ATTENTION);
     57   EXPECT_EQ(expected_attention_mode, panel->attention_mode());
     58 
     59   panel_manager->CloseAll();
     60 }
     61 
     62 IN_PROC_BROWSER_TEST_F(DetachedPanelBrowserTest, DrawAttentionOnActive) {
     63   // Create a detached panel that is initially active.
     64   Panel* panel = CreateDetachedPanel("1", gfx::Rect(300, 200, 250, 200));
     65   scoped_ptr<NativePanelTesting> native_panel_testing(
     66       CreateNativePanelTesting(panel));
     67 
     68   // Test that the attention should not be drawn if the detached panel is in
     69   // focus.
     70   EXPECT_FALSE(panel->IsDrawingAttention());
     71   panel->FlashFrame(true);
     72   EXPECT_FALSE(panel->IsDrawingAttention());
     73   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
     74 
     75   panel->Close();
     76 }
     77 
     78 IN_PROC_BROWSER_TEST_F(DetachedPanelBrowserTest, DrawAttentionOnInactive) {
     79   // Create an inactive detached panel.
     80   Panel* panel =
     81       CreateInactiveDetachedPanel("1", gfx::Rect(300, 200, 250, 200));
     82   scoped_ptr<NativePanelTesting> native_panel_testing(
     83       CreateNativePanelTesting(panel));
     84 
     85   // Test that the attention is drawn when the detached panel is not in focus.
     86   EXPECT_FALSE(panel->IsActive());
     87   EXPECT_FALSE(panel->IsDrawingAttention());
     88   panel->FlashFrame(true);
     89   EXPECT_TRUE(panel->IsDrawingAttention());
     90   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
     91 
     92   // Stop drawing attention.
     93   panel->FlashFrame(false);
     94   EXPECT_FALSE(panel->IsDrawingAttention());
     95   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
     96 
     97   PanelManager::GetInstance()->CloseAll();
     98 }
     99 
    100 IN_PROC_BROWSER_TEST_F(DetachedPanelBrowserTest, DrawAttentionResetOnActivate) {
    101   // Create an inactive detached panel.
    102   Panel* panel =
    103       CreateInactiveDetachedPanel("1", gfx::Rect(300, 200, 250, 200));
    104   scoped_ptr<NativePanelTesting> native_panel_testing(
    105       CreateNativePanelTesting(panel));
    106 
    107   // Test that the attention is drawn when the detached panel is not in focus.
    108   panel->FlashFrame(true);
    109   EXPECT_TRUE(panel->IsDrawingAttention());
    110   EXPECT_TRUE(native_panel_testing->VerifyDrawingAttention());
    111 
    112   // Test that the attention is cleared when panel gets focus.
    113   panel->Activate();
    114   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
    115   EXPECT_FALSE(panel->IsDrawingAttention());
    116   EXPECT_FALSE(native_panel_testing->VerifyDrawingAttention());
    117 
    118   PanelManager::GetInstance()->CloseAll();
    119 }
    120 
    121 IN_PROC_BROWSER_TEST_F(DetachedPanelBrowserTest, ClickTitlebar) {
    122   Panel* panel = CreateDetachedPanel("1", gfx::Rect(300, 200, 250, 200));
    123   EXPECT_FALSE(panel->IsMinimized());
    124 
    125   // Clicking on an active detached panel's titlebar has no effect, regardless
    126   // of modifier.
    127   scoped_ptr<NativePanelTesting> test_panel(
    128       CreateNativePanelTesting(panel));
    129   test_panel->PressLeftMouseButtonTitlebar(panel->GetBounds().origin());
    130   test_panel->ReleaseMouseButtonTitlebar();
    131   EXPECT_TRUE(panel->IsActive());
    132   EXPECT_FALSE(panel->IsMinimized());
    133 
    134   test_panel->PressLeftMouseButtonTitlebar(panel->GetBounds().origin(),
    135                                            panel::APPLY_TO_ALL);
    136   test_panel->ReleaseMouseButtonTitlebar(panel::APPLY_TO_ALL);
    137   EXPECT_TRUE(panel->IsActive());
    138   EXPECT_FALSE(panel->IsMinimized());
    139 
    140   // Clicking on an inactive detached panel's titlebar activates it.
    141   DeactivatePanel(panel);
    142   test_panel->PressLeftMouseButtonTitlebar(panel->GetBounds().origin());
    143   test_panel->ReleaseMouseButtonTitlebar();
    144   WaitForPanelActiveState(panel, SHOW_AS_ACTIVE);
    145   EXPECT_FALSE(panel->IsMinimized());
    146 
    147   PanelManager::GetInstance()->CloseAll();
    148 }
    149 
    150 IN_PROC_BROWSER_TEST_F(DetachedPanelBrowserTest,
    151                        UpdateDetachedPanelOnPrimaryDisplayChange) {
    152   PanelManager* panel_manager = PanelManager::GetInstance();
    153 
    154   // Create a big detached panel on the primary display.
    155   gfx::Rect initial_bounds(50, 50, 700, 500);
    156   Panel* panel = CreateDetachedPanel("1", initial_bounds);
    157   EXPECT_EQ(initial_bounds, panel->GetBounds());
    158 
    159   // Make the primary display smaller.
    160   // Expect that the panel should be resized to fit within the display.
    161   gfx::Rect primary_display_area(0, 0, 500, 300);
    162   gfx::Rect primary_work_area(0, 0, 500, 280);
    163   mock_display_settings_provider()->SetPrimaryDisplay(
    164       primary_display_area, primary_work_area);
    165 
    166   gfx::Rect bounds = panel->GetBounds();
    167   EXPECT_LE(primary_work_area.x(), bounds.x());
    168   EXPECT_LE(bounds.x(), primary_work_area.right());
    169   EXPECT_LE(primary_work_area.y(), bounds.y());
    170   EXPECT_LE(bounds.y(), primary_work_area.bottom());
    171 
    172   panel_manager->CloseAll();
    173 }
    174 
    175 IN_PROC_BROWSER_TEST_F(DetachedPanelBrowserTest,
    176                        UpdateDetachedPanelOnSecondaryDisplayChange) {
    177   PanelManager* panel_manager = PanelManager::GetInstance();
    178 
    179   // Setup 2 displays with secondary display on the right side of primary
    180   // display.
    181   gfx::Rect primary_display_area(0, 0, 400, 600);
    182   gfx::Rect primary_work_area(0, 0, 400, 560);
    183   mock_display_settings_provider()->SetPrimaryDisplay(
    184       primary_display_area, primary_work_area);
    185   gfx::Rect secondary_display_area(400, 0, 400, 500);
    186   gfx::Rect secondary_work_area(400, 0, 400, 460);
    187   mock_display_settings_provider()->SetSecondaryDisplay(
    188       secondary_display_area, secondary_work_area);
    189 
    190   // Create a big detached panel on the seconday display.
    191   gfx::Rect initial_bounds(450, 50, 350, 400);
    192   Panel* panel = CreateDetachedPanel("1", initial_bounds);
    193   EXPECT_EQ(initial_bounds, panel->GetBounds());
    194 
    195   // Move down the secondary display and make it smaller.
    196   // Expect that the panel should be resized to fit within the display.
    197   secondary_display_area.SetRect(400, 100, 300, 400);
    198   secondary_work_area.SetRect(400, 100, 300, 360);
    199   mock_display_settings_provider()->SetSecondaryDisplay(
    200       secondary_display_area, secondary_work_area);
    201 
    202   gfx::Rect bounds = panel->GetBounds();
    203   EXPECT_LE(secondary_work_area.x(), bounds.x());
    204   EXPECT_LE(bounds.x(), secondary_work_area.right());
    205   EXPECT_LE(secondary_work_area.y(), bounds.y());
    206   EXPECT_LE(bounds.y(), secondary_work_area.bottom());
    207 
    208   panel_manager->CloseAll();
    209 }
    210 
    211 IN_PROC_BROWSER_TEST_F(DetachedPanelBrowserTest,
    212                        KeepShowingDetachedPanelCreatedBeforeFullScreenMode) {
    213   // Create a detached panel.
    214   CreatePanelParams params("1", gfx::Rect(300, 200, 250, 200), SHOW_AS_ACTIVE);
    215   params.create_mode = PanelManager::CREATE_AS_DETACHED;
    216   Panel* panel = CreatePanelWithParams(params);
    217   scoped_ptr<NativePanelTesting> panel_testing(CreateNativePanelTesting(panel));
    218 
    219   // Panel should be visible at first.
    220   EXPECT_TRUE(panel_testing->IsWindowVisible());
    221 
    222   // Panel's visibility should not be affected when entering full-screen mode.
    223   mock_display_settings_provider()->EnableFullScreenMode(true);
    224   EXPECT_TRUE(panel_testing->IsWindowVisible());
    225 
    226   // Panel's visibility should not be affected when leaving full-screen mode.
    227   mock_display_settings_provider()->EnableFullScreenMode(false);
    228   EXPECT_TRUE(panel_testing->IsWindowVisible());
    229 
    230   PanelManager::GetInstance()->CloseAll();
    231 }
    232 
    233 IN_PROC_BROWSER_TEST_F(DetachedPanelBrowserTest,
    234                        HideDetachedPanelCreatedOnFullScreenMode) {
    235   // Enable full-screen mode first.
    236   mock_display_settings_provider()->EnableFullScreenMode(true);
    237 
    238   // Create a detached panel without waiting it to be shown since it is not
    239   // supposed to be shown on full-screen mode.
    240   CreatePanelParams params("1", gfx::Rect(300, 200, 250, 200), SHOW_AS_ACTIVE);
    241   params.create_mode = PanelManager::CREATE_AS_DETACHED;
    242   params.wait_for_fully_created = false;
    243   Panel* panel = CreatePanelWithParams(params);
    244   scoped_ptr<NativePanelTesting> panel_testing(CreateNativePanelTesting(panel));
    245 
    246   // Panel should not be shown on full-screen mode.
    247   EXPECT_FALSE(panel_testing->IsWindowVisible());
    248 
    249   // Panel should become visible when leaving full-screen mode.
    250   mock_display_settings_provider()->EnableFullScreenMode(false);
    251   EXPECT_TRUE(panel_testing->IsWindowVisible());
    252 
    253   PanelManager::GetInstance()->CloseAll();
    254 }
    255