Chromium Code Reviews Chromium Code Reviews
Issue 9195003:
Move IN_OVERFLOW from Panel::ExpansionState to new enum. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src| Index: chrome/browser/ui/panels/panel_overflow_browsertest.cc |
| diff --git a/chrome/browser/ui/panels/panel_overflow_browsertest.cc b/chrome/browser/ui/panels/panel_overflow_browsertest.cc |
| index 920dab19855ff33dc3932cc64d01c81424bbb349..9432d40090a13c6d8de3388aad4a04866fd2cb3b 100644 |
| --- a/chrome/browser/ui/panels/panel_overflow_browsertest.cc |
| +++ b/chrome/browser/ui/panels/panel_overflow_browsertest.cc |
| @@ -27,28 +27,36 @@ const int kMaxVisibleOverflowPanelsOnHoverForTesting = 6; |
| // when we do the overflow testing. |
| struct PanelData { |
| Panel* panel; |
| + Panel::LayoutState layout_state; |
| Panel::ExpansionState expansion_state; |
| bool visible; |
| bool active; |
| explicit PanelData(Panel* panel) |
| : panel(panel), |
| + layout_state(panel->layout_state()), |
| expansion_state(panel->expansion_state()), |
| visible(!panel->GetBounds().IsEmpty()), |
| active(panel->IsActive()) { |
| } |
| - PanelData(Panel* panel, Panel::ExpansionState expansion_state, |
| + PanelData(Panel* panel, Panel::LayoutState layout_state, |
| + Panel::ExpansionState expansion_state, |
| bool visible, bool active) |
| : panel(panel), |
| + layout_state(layout_state), |
| expansion_state(expansion_state), |
| visible(visible), |
| active(active) { |
| } |
| bool operator==(const PanelData& another) const { |
| + if (layout_state != another.layout_state) |
| + return false; |
| + if (layout_state == Panel::DOCKED && |
| + expansion_state != another.expansion_state) |
| + return false; |
| return panel == another.panel && |
| - expansion_state == another.expansion_state && |
| visible == another.visible && |
| active == another.active; |
| } |
| @@ -59,19 +67,30 @@ struct PanelData { |
| }; |
| // For gtest printing. |
| -::std::ostream& operator<<(::std::ostream& os, const PanelData& data); |
| ::std::ostream& operator<<(::std::ostream& os, const PanelData& data) { |
| return os << "(" << data.panel->browser()->app_name() << ", " |
| - << data.expansion_state << ", " << data.visible << ", " |
| - << data.active << ")"; |
| + << data.layout_state << ", " << data.expansion_state << ", " |
| + << data.visible << ", " << data.active << ")"; |
| } |
| - |
| class PanelDataList : public std::vector<PanelData> { |
| +}; |
| + |
| +class DockedPanelDataList : public PanelDataList { |
| public: |
| void Add(Panel* panel, Panel::ExpansionState expansion_state, |
| bool visible, bool active) { |
|
jennb
2012/01/20 02:01:54
Still need to drop this 'visible' param and change
|
| - push_back(PanelData(panel, expansion_state, visible, active)); |
| + push_back(PanelData(panel, Panel::DOCKED, expansion_state, |
| + visible, active)); |
| + } |
| +}; |
| + |
| +class OverflowPanelDataList : public PanelDataList { |
| + public: |
| + void Add(Panel* panel, bool visible, bool active) { |
| + // Note that the expansion state is ignored when we check overflow panel. |
| + push_back(PanelData(panel, Panel::IN_OVERFLOW, Panel::EXPANDED, |
| + visible, active)); |
| } |
| }; |
| @@ -102,8 +121,8 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest { |
| } |
| protected: |
| - static PanelDataList GetAllNormalPanelData() { |
| - PanelDataList panel_data_list; |
| + static DockedPanelDataList GetAllDockedPanelData() { |
| + DockedPanelDataList panel_data_list; |
| PanelStrip::Panels panels = |
| PanelManager::GetInstance()->panel_strip()->panels(); |
| for (PanelStrip::Panels::const_iterator iter = panels.begin(); |
| @@ -114,8 +133,8 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest { |
| return panel_data_list; |
| } |
| - static PanelDataList GetAllOverflowPanelData() { |
| - PanelDataList panel_data_list; |
| + static OverflowPanelDataList GetAllOverflowPanelData() { |
| + OverflowPanelDataList panel_data_list; |
| PanelOverflowStrip::Panels panels = |
| PanelManager::GetInstance()->panel_overflow_strip()->panels(); |
| for (PanelOverflowStrip::Panels::const_iterator iter = panels.begin(); |
| @@ -152,15 +171,15 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest { |
| return expected_x == bounds.x() && expected_size == bounds.size(); |
| } |
| - std::vector<Panel*> CreateOverflowPanels(int num_normal_panels, |
| + std::vector<Panel*> CreateOverflowPanels(int num_docked_panels, |
| int num_overflow_panels, |
| const int* panel_widths) { |
| const int kTestPanelHeight = 200; |
| std::vector<Panel*> panels; |
| - // First, create normal panels to fill the panel strip. |
| + // First, create docked panels to fill the panel strip. |
| int i = 0; |
| - for (; i < num_normal_panels; ++i) { |
| + for (; i < num_docked_panels; ++i) { |
| CreatePanelParams params( |
| MakePanelName(i), |
| gfx::Rect(0, 0, panel_widths[i], kTestPanelHeight), |
| @@ -170,14 +189,14 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest { |
| } |
| // Then, create panels that would be placed in the overflow strip. |
| - int num_panels = num_normal_panels + num_overflow_panels; |
| + int num_panels = num_docked_panels + num_overflow_panels; |
| for (; i < num_panels; ++i) { |
| CreatePanelParams params( |
| MakePanelName(i), |
| gfx::Rect(0, 0, panel_widths[i], kTestPanelHeight), |
| SHOW_AS_INACTIVE); |
| Panel* panel = CreatePanelWithParams(params); |
| - WaitForExpansionStateChanged(panel, Panel::IN_OVERFLOW); |
| + WaitForLayoutStateChanged(panel, Panel::IN_OVERFLOW); |
| panels.push_back(panel); |
| } |
| @@ -195,8 +214,9 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest { |
| // http://crbug.com/107230 |
| #define MAYBE_CreatePanelOnDelayedOverflow CreatePanelOnDelayedOverflow |
| #define MAYBE_CloseOverflowPanels CloseOverflowPanels |
| -#define MAYBE_CloseNormalPanels CloseNormalPanels |
| +#define MAYBE_CloseDockedPanels CloseDockedPanels |
| #define MAYBE_CloseWithDelayedOverflow CloseWithDelayedOverflow |
| +#define MAYBE_ClickOverflowPanels ClickOverflowPanels |
| #define MAYBE_ActivateOverflowPanels ActivateOverflowPanels |
| #define MAYBE_MoveMinimizedPanelToOverflowAndBringBackByActivate \ |
| MoveMinimizedPanelToOverflowAndBringBackByActivate |
| @@ -216,8 +236,9 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest { |
| #define MAYBE_CreateMoreOverflowPanels DISABLED_CreateMoreOverflowPanels |
| #define MAYBE_CreatePanelOnDelayedOverflow DISABLED_CreatePanelOnDelayedOverflow |
| #define MAYBE_CloseOverflowPanels DISABLED_CloseOverflowPanels |
| -#define MAYBE_CloseNormalPanels DISABLED_CloseNormalPanels |
| +#define MAYBE_CloseDockedPanels DISABLED_CloseDockedPanels |
| #define MAYBE_CloseWithDelayedOverflow DISABLED_CloseWithDelayedOverflow |
| +#define MAYBE_ClickOverflowPanels DISABLED_ClickOverflowPanels |
| #define MAYBE_ActivateOverflowPanels DISABLED_ActivateOverflowPanels |
| #define MAYBE_MoveMinimizedPanelToOverflowAndBringBackByActivate \ |
| DISABLED_MoveMinimizedPanelToOverflowAndBringBackByActivate |
| @@ -261,7 +282,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CheckPanelProperties) { |
| EXPECT_FALSE(panel4->draggable()); |
| // Make sure last panel really did overflow. |
| - WaitForExpansionStateChanged(panel4, Panel::IN_OVERFLOW); |
| + WaitForLayoutStateChanged(panel4, Panel::IN_OVERFLOW); |
| EXPECT_FALSE(panel4->has_temporary_layout()); |
| EXPECT_FALSE(panel4->draggable()); |
| @@ -271,9 +292,9 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CheckPanelProperties) { |
| IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_UpdateDraggableStatus) { |
| Panel* panel = CreatePanel("panel"); |
| EXPECT_TRUE(panel->draggable()); |
| - panel->SetExpansionState(Panel::IN_OVERFLOW); |
| + panel->SetLayoutState(Panel::IN_OVERFLOW); |
| EXPECT_FALSE(panel->draggable()); |
| - panel->SetExpansionState(Panel::EXPANDED); |
| + panel->SetLayoutState(Panel::DOCKED); |
| EXPECT_TRUE(panel->draggable()); |
| panel->Close(); |
| } |
| @@ -289,7 +310,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CreateOverflowPanels) { |
| EXPECT_EQ(0, panel_overflow_strip->num_panels()); |
| EXPECT_FALSE(panel_overflow_strip->overflow_indicator()); |
| - // Create 3 normal panels. |
| + // Create 3 docked panels. |
| Panel* panel0 = CreatePanelWithBounds("Panel0", gfx::Rect(0, 0, 250, 200)); |
| Panel* panel1 = CreatePanelWithBounds("Panel1", gfx::Rect(0, 0, 260, 200)); |
| Panel* panel2 = CreatePanelWithBounds("Panel2", gfx::Rect(0, 0, 200, 200)); |
| @@ -306,7 +327,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CreateOverflowPanels) { |
| CreatePanelParams params( |
| "Panel3", gfx::Rect(0, 0, 255, 200), SHOW_AS_INACTIVE); |
| Panel* panel3 = CreatePanelWithParams(params); |
| - WaitForExpansionStateChanged(panel3, Panel::IN_OVERFLOW); |
| + WaitForLayoutStateChanged(panel3, Panel::IN_OVERFLOW); |
| EXPECT_EQ(4, panel_manager->num_panels()); |
| EXPECT_EQ(3, panel_strip->num_panels()); |
| @@ -319,7 +340,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CreateOverflowPanels) { |
| // Create 1 more overflow panel. |
| params.name = "Panel4"; |
| Panel* panel4 = CreatePanelWithParams(params); |
| - WaitForExpansionStateChanged(panel4, Panel::IN_OVERFLOW); |
| + WaitForLayoutStateChanged(panel4, Panel::IN_OVERFLOW); |
| EXPECT_EQ(5, panel_manager->num_panels()); |
| EXPECT_EQ(3, panel_strip->num_panels()); |
| @@ -338,7 +359,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, |
| panel_manager->panel_overflow_strip(); |
| const int panel_widths[] = { |
| - 250, 260, 200, // normal |
| + 250, 260, 200, // docked |
| 255, 220, 210, // overflow |
| 220, 230 // overflow-on-overflow |
| }; |
| @@ -349,15 +370,15 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, |
| EXPECT_EQ(3, panel_strip->num_panels()); |
| EXPECT_EQ(5, panel_overflow_strip->num_panels()); |
| EXPECT_EQ(2, panel_overflow_strip->overflow_indicator()->GetCount()); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panels[3]->expansion_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panels[3]->layout_state()); |
| EXPECT_TRUE(IsPanelVisible(panels[3])); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panels[4]->expansion_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panels[4]->layout_state()); |
| EXPECT_TRUE(IsPanelVisible(panels[4])); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panels[5]->expansion_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panels[5]->layout_state()); |
| EXPECT_TRUE(IsPanelVisible(panels[5])); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panels[6]->expansion_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panels[6]->layout_state()); |
| EXPECT_FALSE(IsPanelVisible(panels[6])); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panels[7]->expansion_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panels[7]->layout_state()); |
| EXPECT_FALSE(IsPanelVisible(panels[7])); |
| PanelManager::GetInstance()->RemoveAll(); |
| @@ -385,7 +406,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, |
| EXPECT_EQ(Panel::EXPANDED, panel3->expansion_state()); |
| EXPECT_FALSE(panel3->has_temporary_layout()); |
| - WaitForExpansionStateChanged(overflow_panel, Panel::IN_OVERFLOW); |
| + WaitForLayoutStateChanged(overflow_panel, Panel::IN_OVERFLOW); |
| EXPECT_FALSE(overflow_panel->has_temporary_layout()); |
| PanelManager::GetInstance()->RemoveAll(); |
| } |
| @@ -396,216 +417,216 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) { |
| PanelOverflowStrip* panel_overflow_strip = |
| panel_manager->panel_overflow_strip(); |
| - // Create normal and overflow panels. |
| - // normal: P0, P1, P2 |
| + // Create docked and overflow panels. |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4, P5 |
| // overflow-on-overflow: P6, P7 |
| - int num_normal_panels = 3; |
| + int num_docked_panels = 3; |
| int num_overflow_panels = 5; |
| const int panel_widths[] = { |
| - 260, 250, 200, // normal |
| + 260, 250, 200, // docked |
| 255, 260, 120, // overflow |
| 240, 210 // overflow-on-overflow |
| }; |
| std::vector<Panel*> panels = CreateOverflowPanels( |
| - num_normal_panels, num_overflow_panels, panel_widths); |
| - |
| - PanelDataList expected_normal_list; |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| - |
| - PanelDataList expected_overflow_list; |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[6], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false); |
| + num_docked_panels, num_overflow_panels, panel_widths); |
| + |
| + DockedPanelDataList expected_docked_list; |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| + |
| + OverflowPanelDataList expected_overflow_list; |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| + expected_overflow_list.Add(panels[6], false, false); |
| + expected_overflow_list.Add(panels[7], false, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| // Close an overflow-on-overflow panel. Expect only that panel is closed. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4, P5, |
| // overflow-on-overflow: P7 |
| CloseWindowAndWait(panels[6]->browser()); |
| num_overflow_panels--; |
| - ASSERT_EQ(num_normal_panels + num_overflow_panels, |
| + ASSERT_EQ(num_docked_panels + num_overflow_panels, |
| panel_manager->num_panels()); |
| - EXPECT_EQ(num_normal_panels, panel_strip->num_panels()); |
| + EXPECT_EQ(num_docked_panels, panel_strip->num_panels()); |
| EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels()); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false); |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| + expected_overflow_list.Add(panels[7], false, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| // Close an overflow panel. Expect an overflow-on-overflow panel to become |
| // visible in the overflow strip. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P3, P5, P7 |
| CloseWindowAndWait(panels[4]->browser()); |
| num_overflow_panels--; |
| - ASSERT_EQ(num_normal_panels + num_overflow_panels, |
| + ASSERT_EQ(num_docked_panels + num_overflow_panels, |
| panel_manager->num_panels()); |
| - EXPECT_EQ(num_normal_panels, panel_strip->num_panels()); |
| + EXPECT_EQ(num_docked_panels, panel_strip->num_panels()); |
| EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels()); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| + expected_overflow_list.Add(panels[7], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| // Close an overflow panel. Expect only that panel is closed. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P5, P7 |
| CloseWindowAndWait(panels[3]->browser()); |
| num_overflow_panels--; |
| - ASSERT_EQ(num_normal_panels + num_overflow_panels, |
| + ASSERT_EQ(num_docked_panels + num_overflow_panels, |
| panel_manager->num_panels()); |
| - EXPECT_EQ(num_normal_panels, panel_strip->num_panels()); |
| + EXPECT_EQ(num_docked_panels, panel_strip->num_panels()); |
| EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels()); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| + expected_overflow_list.Add(panels[7], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| panel_manager->RemoveAll(); |
| } |
| -IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) { |
| +IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseDockedPanels) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| PanelStrip* panel_strip = panel_manager->panel_strip(); |
| PanelOverflowStrip* panel_overflow_strip = |
| panel_manager->panel_overflow_strip(); |
| - // Create normal and overflow panels. |
| - // normal: P0, P1, P2 |
| + // Create docked and overflow panels. |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4, P5 |
| // overflow-on-overflow: P6, P7, P8 |
| - int num_normal_panels = 3; |
| + int num_docked_panels = 3; |
| int num_overflow_panels = 6; |
| const int panel_widths[] = { |
| - 260, 250, 200, // normal |
| + 260, 250, 200, // docked |
| 255, 260, 120, // overflow |
| 240, 210, 258 // overflow-on-overflow |
| }; |
| std::vector<Panel*> panels = CreateOverflowPanels( |
| - num_normal_panels, num_overflow_panels, panel_widths); |
| - |
| - PanelDataList expected_normal_list; |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| - |
| - PanelDataList expected_overflow_list; |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[6], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[8], Panel::IN_OVERFLOW, false, false); |
| + num_docked_panels, num_overflow_panels, panel_widths); |
| + |
| + DockedPanelDataList expected_docked_list; |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| + |
| + OverflowPanelDataList expected_overflow_list; |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| + expected_overflow_list.Add(panels[6], false, false); |
| + expected_overflow_list.Add(panels[7], false, false); |
| + expected_overflow_list.Add(panels[8], false, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| - // Close a normal panel. Expect an overflow panel to move over and an |
| + // Close a docked panel. Expect an overflow panel to move over and an |
| // overflow-on-overflow panel to become visible. |
| - // normal: P0, P2, P3 |
| + // docked: P0, P2, P3 |
| // overflow: P4, P5, P6 |
| // overflow-on-overflow: P7, P8 |
| CloseWindowAndWait(panels[1]->browser()); |
| num_overflow_panels--; |
| - ASSERT_EQ(num_normal_panels + num_overflow_panels, |
| + ASSERT_EQ(num_docked_panels + num_overflow_panels, |
| panel_manager->num_panels()); |
| - EXPECT_EQ(num_normal_panels, panel_strip->num_panels()); |
| + EXPECT_EQ(num_docked_panels, panel_strip->num_panels()); |
| EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels()); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[3], Panel::EXPANDED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[3], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[6], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[8], Panel::IN_OVERFLOW, false, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| + expected_overflow_list.Add(panels[6], true, false); |
| + expected_overflow_list.Add(panels[7], false, false); |
| + expected_overflow_list.Add(panels[8], false, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| - // Close another normal panel. Remaining overflow panels cannot move over |
| + // Close another docked panel. Remaining overflow panels cannot move over |
| // due to not enough room. |
| - // normal: P0, P3 |
| + // docked: P0, P3 |
| // overflow: P4, P5, P6 |
| // overflow-on-overflow: P7, P8 |
| CloseWindowAndWait(panels[2]->browser()); |
| - num_normal_panels--; |
| - ASSERT_EQ(num_normal_panels + num_overflow_panels, |
| + num_docked_panels--; |
| + ASSERT_EQ(num_docked_panels + num_overflow_panels, |
| panel_manager->num_panels()); |
| - EXPECT_EQ(num_normal_panels, panel_strip->num_panels()); |
| + EXPECT_EQ(num_docked_panels, panel_strip->num_panels()); |
| EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels()); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[3], Panel::EXPANDED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[3], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| - // Close one more normal panel. Expect two overflow panels to move over and |
| + // Close one more docked panel. Expect two overflow panels to move over and |
| // two overflow-on-overflow panels to become visible. |
| - // normal: P0, P4, P5 |
| + // docked: P0, P4, P5 |
| // overflow: P6, P7, P8 |
| CloseWindowAndWait(panels[3]->browser()); |
| - num_normal_panels++; |
| + num_docked_panels++; |
| num_overflow_panels -= 2; |
| - ASSERT_EQ(num_normal_panels + num_overflow_panels, |
| + ASSERT_EQ(num_docked_panels + num_overflow_panels, |
| panel_manager->num_panels()); |
| - EXPECT_EQ(num_normal_panels, panel_strip->num_panels()); |
| + EXPECT_EQ(num_docked_panels, panel_strip->num_panels()); |
| EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels()); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[4], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[5], Panel::EXPANDED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[4], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[5], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[6], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[8], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[6], true, false); |
| + expected_overflow_list.Add(panels[7], true, false); |
| + expected_overflow_list.Add(panels[8], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| - // Close another normal panel. Expect one overflow panel to move over. |
| - // normal: P4, P5, P6 |
| + // Close another docked panel. Expect one overflow panel to move over. |
| + // docked: P4, P5, P6 |
| // overflow: P7, P8 |
| CloseWindowAndWait(panels[0]->browser()); |
| num_overflow_panels--; |
| - ASSERT_EQ(num_normal_panels + num_overflow_panels, |
| + ASSERT_EQ(num_docked_panels + num_overflow_panels, |
| panel_manager->num_panels()); |
| - EXPECT_EQ(num_normal_panels, panel_strip->num_panels()); |
| + EXPECT_EQ(num_docked_panels, panel_strip->num_panels()); |
| EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels()); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[4], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[5], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[6], Panel::EXPANDED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[4], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[5], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[6], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[8], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[7], true, false); |
| + expected_overflow_list.Add(panels[8], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| panel_manager->RemoveAll(); |
| @@ -652,7 +673,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, |
| EXPECT_TRUE(overflow_panel->has_temporary_layout()); |
| // Make sure the overflow panel actually moves to overflow. |
| - WaitForExpansionStateChanged(overflow_panel, Panel::IN_OVERFLOW); |
| + WaitForLayoutStateChanged(overflow_panel, Panel::IN_OVERFLOW); |
| EXPECT_EQ(0, panel_strip->num_temporary_layout_panels()); |
| // Hack. Put the "falsely closed" panel back into the panel strip |
| @@ -664,58 +685,146 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, |
| overflow_panel->Close(); |
| } |
| +IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ClickOverflowPanels) { |
| + PanelManager* panel_manager = PanelManager::GetInstance(); |
| + |
| + // Create docked and overflow panels. |
| + // docked: P0, P1, P2 |
| + // overflow: P3, P4 |
| + const int panel_widths[] = { |
| + 240, 240, 240, // docked |
| + 240, 240 // overflow |
| + }; |
| + std::vector<Panel*> panels = CreateOverflowPanels(3, 2, panel_widths); |
| + |
| + DockedPanelDataList expected_docked_list; |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| + |
| + OverflowPanelDataList expected_overflow_list; |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| + |
| + // Minimize a docked panel. |
| + panels[2]->SetExpansionState(Panel::MINIMIZED); |
| + WaitForExpansionStateChanged(panels[2], Panel::MINIMIZED); |
| + |
| + // Clicking an overflow panel that was previously expanded should bring it |
| + // out of the overflow as expanded. |
| + // docked: P0, P1, P3 |
| + // overflow: P2, P4 |
| + ClickPanelTitlebar(panels[3]); |
| + WaitForExpansionStateChanged(panels[3], Panel::EXPANDED); |
| + |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[3], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| + |
| + expected_overflow_list.clear(); |
| + expected_overflow_list.Add(panels[2], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| + |
| + // Make a docked panel as title-only. |
| + panels[3]->SetExpansionState(Panel::TITLE_ONLY); |
| + WaitForExpansionStateChanged(panels[3], Panel::TITLE_ONLY); |
| + |
| + // Clicking an overflow panel that was previously minimized should bring it |
| + // out of the overflow as expanded. |
| + // docked: P0, P1, P2 |
| + // overflow: P3, P4 |
| + ClickPanelTitlebar(panels[2]); |
| + WaitForExpansionStateChanged(panels[2], Panel::EXPANDED); |
| + |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| + |
| + expected_overflow_list.clear(); |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| + |
| + // Clicking an overflow panel that was previously title-only should bring it |
| + // out of the overflow as expanded. |
| + // docked: P0, P1, P3 |
| + // overflow: P2, P4 |
| + ClickPanelTitlebar(panels[3]); |
| + WaitForExpansionStateChanged(panels[3], Panel::EXPANDED); |
| + |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[3], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| + |
| + expected_overflow_list.clear(); |
| + expected_overflow_list.Add(panels[2], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| + |
| + PanelManager::GetInstance()->RemoveAll(); |
| +} |
| + |
| IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) { |
| - // Create normal and overflow panels. |
| - // normal: P0, P1, P2 |
| + // Create docked and overflow panels. |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4, P5 |
| // overflow-on-overflow: P6, P7 |
| const int panel_widths[] = { |
| - 250, 260, 200, // normal |
| + 250, 260, 200, // docked |
| 210, 260, 230, // overflow |
| 255, 210 // overflow-on-overflow |
| }; |
| std::vector<Panel*> panels = CreateOverflowPanels(3, 5, panel_widths); |
| - PanelDataList expected_normal_list; |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| - |
| - PanelDataList expected_overflow_list; |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[6], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false); |
| + DockedPanelDataList expected_docked_list; |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| + |
| + OverflowPanelDataList expected_overflow_list; |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| + expected_overflow_list.Add(panels[6], false, false); |
| + expected_overflow_list.Add(panels[7], false, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| - // Activate an overflow panel. Expect one normal panel is swapped into the |
| + // Activate an overflow panel. Expect one docked panel is swapped into the |
| // overflow strip. |
| - // normal: P0, P1, P3 |
| + // docked: P0, P1, P3 |
| // overflow: P2, P4, P5 |
| // overflow-on-overflow: P6, P7 |
| panels[3]->Activate(); |
| WaitForPanelActiveState(panels[3], SHOW_AS_ACTIVE); |
| WaitForExpansionStateChanged(panels[3], Panel::EXPANDED); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[3], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[3], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[6], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false); |
| + expected_overflow_list.Add(panels[2], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| + expected_overflow_list.Add(panels[6], false, false); |
| + expected_overflow_list.Add(panels[7], false, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| - // Activate an overflow panel. Expect two normal panels are swapped into the |
| + // Activate an overflow panel. Expect two docked panels are swapped into the |
| // overflow strip and one overflow panel to become hidden. |
| - // normal: P0, P4 |
| + // docked: P0, P4 |
| // overflow: P1, P3, P2 |
| // overflow-on-overflow: P5, P6, P7 |
| panels[4]->Activate(); |
| @@ -723,23 +832,23 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) { |
| WaitForExpansionStateChanged(panels[4], Panel::EXPANDED); |
| WaitForPanelActiveState(panels[3], SHOW_AS_INACTIVE); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[4], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[4], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[1], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[6], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false); |
| + expected_overflow_list.Add(panels[1], true, false); |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[2], true, false); |
| + expected_overflow_list.Add(panels[5], false, false); |
| + expected_overflow_list.Add(panels[6], false, false); |
| + expected_overflow_list.Add(panels[7], false, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| - // Activate an overflow-on-overflow panel. Expect one normal panel is swapped |
| + // Activate an overflow-on-overflow panel. Expect one docked panel is swapped |
| // into the overflow strip. |
| - // normal: P0, P6 |
| + // docked: P0, P6 |
| // overflow: P4, P1, P3, |
| // overflow-on-overflow: P2, P5, P7 |
| panels[6]->Activate(); |
| @@ -747,23 +856,23 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) { |
| WaitForExpansionStateChanged(panels[6], Panel::EXPANDED); |
| WaitForPanelActiveState(panels[4], SHOW_AS_INACTIVE); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[6], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[6], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[1], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[7], Panel::IN_OVERFLOW, false, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[1], true, false); |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[2], false, false); |
| + expected_overflow_list.Add(panels[5], false, false); |
| + expected_overflow_list.Add(panels[7], false, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| - // Activate an overflow-on-overflow panel. No normal panel is swapped |
| + // Activate an overflow-on-overflow panel. No docked panel is swapped |
| // since there has already been enough space in the panel strip. |
| - // normal: P0, P6, P7 |
| + // docked: P0, P6, P7 |
| // overflow: P4, P1, P3, |
| // overflow-on-overflow: P2, P5 |
| panels[7]->Activate(); |
| @@ -771,18 +880,18 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) { |
| WaitForExpansionStateChanged(panels[7], Panel::EXPANDED); |
| WaitForPanelActiveState(panels[6], SHOW_AS_INACTIVE); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[6], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[7], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[6], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[7], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[1], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, false, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, false, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[1], true, false); |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[2], false, false); |
| + expected_overflow_list.Add(panels[5], false, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| PanelManager::GetInstance()->RemoveAll(); |
| @@ -791,100 +900,101 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) { |
| IN_PROC_BROWSER_TEST_F( |
| PanelOverflowBrowserTest, |
| MAYBE_MoveMinimizedPanelToOverflowAndBringBackByActivate) { |
| - // Create normal and overflow panels. |
| - // normal: P0, P1, P2 |
| + // Create docked and overflow panels. |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4 |
| const int panel_widths[] = { |
| - 250, 260, 200, // normal |
| + 250, 260, 200, // docked |
| 210, 260 // overflow |
| }; |
| std::vector<Panel*> panels = CreateOverflowPanels(3, 2, panel_widths); |
| - PanelDataList expected_normal_list; |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + DockedPanelDataList expected_docked_list; |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| - PanelDataList expected_overflow_list; |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| + OverflowPanelDataList expected_overflow_list; |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| - // Minimize a normal panel and then bump it to overflow by activating an |
| + // Minimize a docked panel and then bump it to overflow by activating an |
| // overflow panel. |
| - // normal: P0, P1, P3 |
| + // docked: P0, P1, P3 |
| // overflow: P2, P4 |
| panels[2]->SetExpansionState(Panel::MINIMIZED); |
| panels[3]->Activate(); |
| WaitForPanelActiveState(panels[3], SHOW_AS_ACTIVE); |
| WaitForExpansionStateChanged(panels[3], Panel::EXPANDED); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[3], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[3], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[2], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| // Reactivate the formerly minimized panel. It will return to the panel |
| // strip in expanded state. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4 |
| panels[2]->Activate(); |
| WaitForPanelActiveState(panels[2], SHOW_AS_ACTIVE); |
| WaitForExpansionStateChanged(panels[2], Panel::EXPANDED); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[2], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| // Minimize a panel to title only mode, then bump it to overflow. |
| - // normal: P0, P1, P3 |
| + // docked: P0, P1, P3 |
| // overflow: P2, P4 |
| panels[2]->SetExpansionState(Panel::TITLE_ONLY); |
| panels[3]->Activate(); |
| WaitForPanelActiveState(panels[3], SHOW_AS_ACTIVE); |
| WaitForExpansionStateChanged(panels[3], Panel::EXPANDED); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[3], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[3], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[2], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| // Reactivate the formerly minimized panel. It will return to the panel |
| // strip in expanded state. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4 |
| panels[2]->Activate(); |
| WaitForPanelActiveState(panels[2], SHOW_AS_ACTIVE); |
| WaitForExpansionStateChanged(panels[2], Panel::EXPANDED); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[2], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| PanelManager::GetInstance()->RemoveAll(); |
| @@ -895,86 +1005,86 @@ IN_PROC_BROWSER_TEST_F( |
| MAYBE_MoveMinimizedPanelToOverflowAndBringBackByCloseOrResize) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| - // Create normal and overflow panels. |
| - // normal: P0, P1, P2 |
| + // Create docked and overflow panels. |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4, P5 |
| const int panel_widths[] = { |
| - 240, 240, 120, // normal |
| + 240, 240, 120, // docked |
| 240, 240, 240 // overflow |
| }; |
| std::vector<Panel*> panels = CreateOverflowPanels(3, 3, panel_widths); |
| - PanelDataList expected_normal_list; |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[2], Panel::EXPANDED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + DockedPanelDataList expected_docked_list; |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::EXPANDED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| - PanelDataList expected_overflow_list; |
| - expected_overflow_list.Add(panels[3], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| + OverflowPanelDataList expected_overflow_list; |
| + expected_overflow_list.Add(panels[3], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| // Test case 1: restoring minimized to minimized. |
| { |
| - // Minimize a normal panel and then bump it to overflow by activating an |
| + // Minimize a docked panel and then bump it to overflow by activating an |
| // overflow panel. |
| - // normal: P0, P1, P3 |
| + // docked: P0, P1, P3 |
| // overflow: P2, P4, P5 |
| panels[2]->SetExpansionState(Panel::MINIMIZED); |
| panels[3]->Activate(); |
| WaitForPanelActiveState(panels[3], SHOW_AS_ACTIVE); |
| WaitForExpansionStateChanged(panels[3], Panel::EXPANDED); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[3], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[3], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[2], true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| // Bring back the formerly minimized panel by closing a panel. It will |
| // return to the panel strip in the minimized state. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P4, P5 |
| CloseWindowAndWait(panels[3]->browser()); |
| WaitForExpansionStateChanged(panels[2], Panel::MINIMIZED); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[2], Panel::MINIMIZED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::MINIMIZED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[4], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[4], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| } |
| // Test case 2: restoring minimized to title-only. |
| { |
| // Bump the minimized panel to overflow by activating an overflow panel. |
| - // normal: P0, P1, P4 |
| + // docked: P0, P1, P4 |
| // overflow: P2, P5 |
| panels[4]->Activate(); |
| WaitForPanelActiveState(panels[4], SHOW_AS_ACTIVE); |
| WaitForExpansionStateChanged(panels[4], Panel::EXPANDED); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[4], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[4], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[2], true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| // Minimize another panel and hover the mouse over it. This should bring up |
| @@ -987,54 +1097,54 @@ IN_PROC_BROWSER_TEST_F( |
| // Bring back the formerly minimized panel by closing a panel. It will |
| // return to the panel strip in the title-only state. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P5 |
| CloseWindowAndWait(panels[4]->browser()); |
| WaitForExpansionStateChanged(panels[2], Panel::TITLE_ONLY); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::TITLE_ONLY, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[2], Panel::TITLE_ONLY, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::TITLE_ONLY, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[2], Panel::TITLE_ONLY, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[5], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[5], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| } |
| // Test case 3: restoring title-only to title-only. |
| { |
| // Bump the title-only panel to overflow by activating an overflow panel. |
| - // normal: P0, P1, P5 |
| + // docked: P0, P1, P5 |
| // overflow: P2 |
| panels[5]->Activate(); |
| WaitForPanelActiveState(panels[5], SHOW_AS_ACTIVE); |
| WaitForExpansionStateChanged(panels[5], Panel::EXPANDED); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::TITLE_ONLY, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[5], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::TITLE_ONLY, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[5], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[2], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| // Bring back the formerly title-only panel by shrinking a panel. It will |
| // return to the panel strip in the title-only state. |
| - // normal: P0, P1, P5, P2 |
| + // docked: P0, P1, P5, P2 |
| panel_manager->ResizePanel(panels[5], gfx::Size( |
| panels[5]->GetBounds().width() / 2, |
| panels[5]->GetBounds().height() / 2)); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::TITLE_ONLY, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[5], Panel::EXPANDED, true, true); |
| - expected_normal_list.Add(panels[2], Panel::TITLE_ONLY, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::TITLE_ONLY, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[5], Panel::EXPANDED, true, true); |
| + expected_docked_list.Add(panels[2], Panel::TITLE_ONLY, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| @@ -1043,20 +1153,20 @@ IN_PROC_BROWSER_TEST_F( |
| // Test case 4: restoring title-only to minimized. |
| { |
| // Bump the minimized panel to overflow by enlarging a panel. |
| - // normal: P0, P1, P5 |
| + // docked: P0, P1, P5 |
| // overflow: P2 |
| panel_manager->ResizePanel(panels[5], gfx::Size( |
| panels[5]->GetBounds().width() * 2, |
| panels[5]->GetBounds().height() * 2)); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::TITLE_ONLY, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[5], Panel::EXPANDED, true, true); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::TITLE_ONLY, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[5], Panel::EXPANDED, true, true); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| - expected_overflow_list.Add(panels[2], Panel::IN_OVERFLOW, true, false); |
| + expected_overflow_list.Add(panels[2], true, false); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| // Move the mouse away. This should bring down all currently title-only |
| @@ -1067,17 +1177,17 @@ IN_PROC_BROWSER_TEST_F( |
| // Bring back the formerly title-only panel by shrinking a panel. It will |
| // return to the panel strip in the minimized state. |
| - // normal: P0, P1, P5, P2 |
| + // docked: P0, P1, P5, P2 |
| panel_manager->ResizePanel(panels[5], gfx::Size( |
| panels[5]->GetBounds().width() / 2, |
| panels[5]->GetBounds().height() / 2)); |
| - expected_normal_list.clear(); |
| - expected_normal_list.Add(panels[0], Panel::MINIMIZED, true, false); |
| - expected_normal_list.Add(panels[1], Panel::EXPANDED, true, false); |
| - expected_normal_list.Add(panels[5], Panel::EXPANDED, true, true); |
| - expected_normal_list.Add(panels[2], Panel::MINIMIZED, true, false); |
| - EXPECT_EQ(expected_normal_list, GetAllNormalPanelData()); |
| + expected_docked_list.clear(); |
| + expected_docked_list.Add(panels[0], Panel::MINIMIZED, true, false); |
| + expected_docked_list.Add(panels[1], Panel::EXPANDED, true, false); |
| + expected_docked_list.Add(panels[5], Panel::EXPANDED, true, true); |
| + expected_docked_list.Add(panels[2], Panel::MINIMIZED, true, false); |
| + EXPECT_EQ(expected_docked_list, GetAllDockedPanelData()); |
| expected_overflow_list.clear(); |
| EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData()); |
| @@ -1093,11 +1203,11 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, |
| panel_manager->panel_overflow_strip(); |
| int iconified_width = panel_overflow_strip->current_display_width(); |
| - // Create normal and overflow panels. |
| - // normal: P0, P1, P2 |
| + // Create docked and overflow panels. |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4 |
| const int panel_widths[] = { |
| - 250, 260, 200, // normal |
| + 250, 260, 200, // docked |
| 255, 220 // overflow |
| }; |
| std::vector<Panel*> panels = CreateOverflowPanels(3, 2, panel_widths); |
| @@ -1164,12 +1274,12 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, |
| panel_manager->panel_overflow_strip(); |
| int iconified_width = panel_overflow_strip->current_display_width(); |
| - // Create normal and overflow panels. |
| - // normal: P0, P1, P2 |
| + // Create docked and overflow panels. |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4, P5 |
| // overflow-on-overflow: P6, P7 |
| const int panel_widths[] = { |
| - 250, 260, 200, // normal |
| + 250, 260, 200, // docked |
| 255, 220, 260, // overflow |
| 140, 210 // overflow-on-overflow |
| }; |
| @@ -1270,7 +1380,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) { |
| PanelOverflowStrip* overflow_strip = panel_manager->panel_overflow_strip(); |
| // Create 4 panels that fit. |
| - // normal: P1 (250), P2 (200), P3 (100), P4 (100) |
| + // docked: P1 (250), P2 (200), P3 (100), P4 (100) |
| // overflow: empty |
| Panel* panel1 = CreatePanelWithBounds("1", gfx::Rect(0, 0, 250, 200)); |
| Panel* panel2 = CreatePanelWithBounds("2", gfx::Rect(0, 0, 200, 200)); |
| @@ -1280,70 +1390,70 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) { |
| EXPECT_EQ(0, overflow_strip->num_panels()); |
| // Resize last panel so that it is too big to fit and overflows. |
| - // normal: P1 (250), P2 (200), P3 (100) |
| + // docked: P1 (250), P2 (200), P3 (100) |
| // overflow: P4 (250)* |
| gfx::Size new_size(250, 200); |
| panel_manager->OnPreferredWindowSizeChanged(panel4, new_size); |
| EXPECT_EQ(3, panel_strip->num_panels()); |
| EXPECT_EQ(1, overflow_strip->num_panels()); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panel4->layout_state()); |
| EXPECT_TRUE(IsPanelInOverflowStrip(panel4)); |
| EXPECT_EQ(new_size, panel4->restored_size()); |
| // Open another panel that will fit. |
| - // normal: P1 (250), P2 (200), P3 (100), P5 (100)* |
| + // docked: P1 (250), P2 (200), P3 (100), P5 (100)* |
| // overflow: P4 (250) |
| Panel* panel5 = CreatePanelWithBounds("5", gfx::Rect(0, 0, 100, 200)); |
| EXPECT_EQ(4, panel_strip->num_panels()); |
| EXPECT_EQ(1, overflow_strip->num_panels()); |
| EXPECT_EQ(Panel::EXPANDED, panel5->expansion_state()); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state()); // no change |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panel4->layout_state()); // no change |
| // Resize a panel from the middle of the strip so that it causes a |
| // panel to overflow. |
| - // normal: P1 (250), P2 (200), P3 (250)* |
| + // docked: P1 (250), P2 (200), P3 (250)* |
| // overflow: P5 (100), P4 (250) |
| panel_manager->OnPreferredWindowSizeChanged(panel3, gfx::Size(250, 200)); |
| EXPECT_EQ(3, panel_strip->num_panels()); |
| EXPECT_EQ(2, overflow_strip->num_panels()); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state()); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panel5->expansion_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panel4->layout_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panel5->layout_state()); |
| const PanelOverflowStrip::Panels& overflow = overflow_strip->panels(); |
| EXPECT_EQ(panel5, overflow[0]); // new overflow panel is first |
| EXPECT_EQ(panel4, overflow[1]); |
| // Resize panel smaller so that panel from overflow can fit. |
| - // normal: P1 (250), P2 (200), P3 (100)*, P5 (100) |
| + // docked: P1 (250), P2 (200), P3 (100)*, P5 (100) |
| // overflow: P4 (250) |
| panel_manager->OnPreferredWindowSizeChanged(panel3, gfx::Size(100, 200)); |
| EXPECT_EQ(4, panel_strip->num_panels()); |
| EXPECT_EQ(1, overflow_strip->num_panels()); |
| EXPECT_EQ(Panel::EXPANDED, panel5->expansion_state()); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panel4->layout_state()); |
| // Resize smaller again but not small enough to fit overflow panel. |
| - // normal: P1 (250), P2 (100)*, P3 (100), P5 (100) |
| + // docked: P1 (250), P2 (100)*, P3 (100), P5 (100) |
| // overflow: P4 (250) |
| panel_manager->OnPreferredWindowSizeChanged(panel2, gfx::Size(100, 200)); |
| EXPECT_EQ(4, panel_strip->num_panels()); |
| EXPECT_EQ(1, overflow_strip->num_panels()); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state()); // no change |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panel4->layout_state()); // no change |
| // Resize overflow panel bigger. It should stay in overflow and bounds |
| // should not change. |
| - // normal: P1 (250), P2 (100), P3 (100), P5 (100) |
| + // docked: P1 (250), P2 (100), P3 (100), P5 (100) |
| // overflow: P4 (251)* |
| gfx::Rect bounds_before_resize = panel4->GetBounds(); |
| new_size.SetSize(251, 200); |
| panel_manager->OnPreferredWindowSizeChanged(panel4, new_size); |
| EXPECT_EQ(4, panel_strip->num_panels()); |
| EXPECT_EQ(1, overflow_strip->num_panels()); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panel4->layout_state()); |
| EXPECT_EQ(bounds_before_resize, panel4->GetBounds()); |
| EXPECT_EQ(new_size, panel4->restored_size()); |
| // Resize overflow panel to make it fit. |
| - // normal: P1 (250), P2 (100), P3 (100), P5 (100), P4 (100)* |
| + // docked: P1 (250), P2 (100), P3 (100), P5 (100), P4 (100)* |
| // overflow: empty |
| panel_manager->OnPreferredWindowSizeChanged(panel4, gfx::Size(100, 200)); |
| EXPECT_EQ(5, panel_strip->num_panels()); |
| @@ -1351,20 +1461,20 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) { |
| EXPECT_EQ(Panel::EXPANDED, panel4->expansion_state()); |
| // Resize a panel bigger, but not enough to cause overflow. |
| - // normal: P1 (250), P2 (100), P3 (150)*, P5 (100), P4 (100) |
| + // docked: P1 (250), P2 (100), P3 (150)*, P5 (100), P4 (100) |
| // overflow: empty |
| panel_manager->OnPreferredWindowSizeChanged(panel3, gfx::Size(150, 200)); |
| EXPECT_EQ(5, panel_strip->num_panels()); |
| EXPECT_EQ(0, overflow_strip->num_panels()); |
| // Resize a panel to bump more than one panel to overflow. |
| - // normal: P1 (250), P2 (250)*, P3 (150) |
| + // docked: P1 (250), P2 (250)*, P3 (150) |
| // overflow: P5 (100), P4 (100) |
| panel_manager->OnPreferredWindowSizeChanged(panel2, gfx::Size(250, 200)); |
| EXPECT_EQ(3, panel_strip->num_panels()); |
| EXPECT_EQ(2, overflow_strip->num_panels()); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state()); |
| - EXPECT_EQ(Panel::IN_OVERFLOW, panel5->expansion_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panel4->layout_state()); |
| + EXPECT_EQ(Panel::IN_OVERFLOW, panel5->layout_state()); |
| const PanelOverflowStrip::Panels& overflow2 = overflow_strip->panels(); |
| EXPECT_EQ(panel5, overflow2[0]); // strip order is preserved |
| EXPECT_EQ(panel4, overflow2[1]); |
| @@ -1380,11 +1490,11 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) { |
| PanelManager* panel_manager = PanelManager::GetInstance(); |
| PanelOverflowStrip* overflow_strip = panel_manager->panel_overflow_strip(); |
| - // Create normal and overflow panels. |
| - // normal: P0, P1, P2 |
| + // Create docked and overflow panels. |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4, P5 |
| const int panel_widths[] = { |
| - 250, 250, 210, // normal |
| + 250, 250, 210, // docked |
| 250, 250, 260 // overflow |
| }; |
| std::vector<Panel*> panels = CreateOverflowPanels(3, 3, panel_widths); |
| @@ -1392,7 +1502,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) { |
| EXPECT_FALSE(overflow_strip->overflow_indicator()); |
| // Create 5 overflow-on-overflow panels. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4, P5, (P6, P7, P8, P9, P10) |
| // The panels enclosed in parentheses are hidden. |
| int num_existing_panels = panel_manager->num_panels(); |
| @@ -1402,14 +1512,14 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) { |
| gfx::Rect(0, 0, 250, 200), |
| SHOW_AS_INACTIVE); |
| Panel* panel = CreatePanelWithParams(params); |
| - WaitForExpansionStateChanged(panel, Panel::IN_OVERFLOW); |
| + WaitForLayoutStateChanged(panel, Panel::IN_OVERFLOW); |
| EXPECT_EQ(i + 1, overflow_strip->overflow_indicator()->GetCount()); |
| panels.push_back(panel); |
| } |
| // Expand the overflow area by moving mouse over it. |
| // Expect the overflow indicator count gets updated. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P3, P4, P5, P6, P7, P8, (P9, P10) |
| MoveMouseAndWaitForOverflowAnimationEnded(panels[3]->GetBounds().origin()); |
| EXPECT_TRUE(IsPanelVisible(panels[6])); |
| @@ -1421,7 +1531,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) { |
| // Close an overflow panel that makes one overflow-on-overflow panel become |
| // visible. Expect the overflow indicator count gets decreased by 1. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P4, P5, P6, P7, P8, P9, (P10) |
| CloseWindowAndWait(panels[3]->browser()); |
| EXPECT_TRUE(IsPanelVisible(panels[6])); |
| @@ -1433,7 +1543,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) { |
| // Shrink the overflow area by stopping hovering the mouse over the overflow |
| // area. Expect the overflow indicator count gets updated. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P4, P5, P6, (P7, P8, P9, P10) |
| MoveMouseAndWaitForOverflowAnimationEnded(gfx::Point( |
| panels[4]->GetBounds().right() + 5, panels[4]->GetBounds().y())); |
| @@ -1446,7 +1556,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) { |
| // Close an overflow panel. |
| // Expect the overflow indicator count gets decreased by 1. |
| - // normal: P0, P1, P2 |
| + // docked: P0, P1, P2 |
| // overflow: P5, P6, P7, (P8, P9, P10) |
| CloseWindowAndWait(panels[4]->browser()); |
| EXPECT_TRUE(IsPanelVisible(panels[6])); |
| @@ -1456,11 +1566,11 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) { |
| EXPECT_FALSE(IsPanelVisible(panels[10])); |
| EXPECT_EQ(3, overflow_strip->overflow_indicator()->GetCount()); |
| - // Activating a big overflow panel will cause 2 normal panels to move to the |
| + // Activating a big overflow panel will cause 2 docked panels to move to the |
| // oevrflow area and also get the top visible overflow panel bumped to the |
| // overflow-on-overflow. |
| // Expect the overflow indicator count gets increased by 1. |
| - // normal: P0, P5 |
| + // docked: P0, P5 |
| // overflow: P1, P2, P6, (P7, P8, P9, P10) |
| panels[5]->Activate(); |
| WaitForPanelActiveState(panels[5], SHOW_AS_ACTIVE); |
| @@ -1480,12 +1590,12 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) { |
| PanelStrip* panel_strip = panel_manager->panel_strip(); |
| PanelOverflowStrip* overflow_strip = panel_manager->panel_overflow_strip(); |
| - // Create normal and overflow panels. |
| - // normal: P0, P1, P2, P3 |
| + // Create docked and overflow panels. |
| + // docked: P0, P1, P2, P3 |
| // overflow: P4, P5, P6, (P7, P8, P9, P10, P11) |
| // The panels enclosed in parentheses are hidden. |
| const int panel_widths[] = { |
| - 100, 210, 210, 210, // normal |
| + 100, 210, 210, 210, // docked |
| 210, 260, 210, // overflow |
| 210, 210, 210, // overflow-on-overflow on shrunk |
| 210, 210 // overflow-on-overflow on expanded |
| @@ -1498,7 +1608,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) { |
| // Draw attention for a visible overflow panel. |
| // Expect no impact to the overflow indicator. |
| - // normal: P0, P1, P2, P3 |
| + // docked: P0, P1, P2, P3 |
| // overflow: P4, *P5, P6, (P7, P8, P9, P10, P11) |
| EXPECT_FALSE(panels[5]->IsDrawingAttention()); |
| panels[5]->FlashFrame(true); |
| @@ -1507,7 +1617,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) { |
| // Activating this overflow panel will clear its attention. |
| // Expect no impact to the overflow indicator. |
| - // normal: P0, P1, P2, P5 |
| + // docked: P0, P1, P2, P5 |
| // overflow: P3, P4, P6, (P7, P8, P9, P10, P11) |
| panels[5]->Activate(); |
| WaitForPanelActiveState(panels[5], SHOW_AS_ACTIVE); |
| @@ -1516,7 +1626,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) { |
| // Draw attention for an overflow-on-overflow panel. |
| // Expect the overflow indicator is showing attention. |
| - // normal: P0, P1, P2, P5 |
| + // docked: P0, P1, P2, P5 |
| // overflow: P3, P4, P6, (P7, *P8, P9, P10, P11) |
| EXPECT_FALSE(panels[8]->IsDrawingAttention()); |
| panels[8]->FlashFrame(true); |
| @@ -1525,7 +1635,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) { |
| // Draw attention for another overflow-on-overflow panel. |
| // Expect the overflow indicator is still showing attention. |
| - // normal: P0, P1, P2, P5 |
| + // docked: P0, P1, P2, P5 |
| // overflow: P3, P4, P6, (P7, *P8, P9, *P10, P11) |
| EXPECT_FALSE(panels[10]->IsDrawingAttention()); |
| panels[10]->FlashFrame(true); |
| @@ -1534,7 +1644,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) { |
| // Stop drawing attention for an overflow-on-overflow panel by activating it. |
| // Expect the overflow indicator is still showing attention. |
| - // normal: P0, P1, P2, P8 |
| + // docked: P0, P1, P2, P8 |
| // overflow: P5, P3, P4, (P6, P7, P9, *P10, P11) |
| panels[8]->Activate(); |
| WaitForPanelActiveState(panels[8], SHOW_AS_ACTIVE); |
| @@ -1543,7 +1653,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) { |
| // Stop drawing attention for another overflow-on-overflow panel by activating |
| // it. Expect the overflow indicator is not showing attention. |
| - // normal: P0, P1, P2, P10 |
| + // docked: P0, P1, P2, P10 |
| // overflow: P8, P5, P3, (P4, P6, P7, P9, P11) |
| panels[10]->Activate(); |
| WaitForPanelActiveState(panels[10], SHOW_AS_ACTIVE); |
| @@ -1552,7 +1662,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) { |
| // Draw attention for the top overflow panel. |
| // Expect no impact to the overflow indicator. |
| - // normal: P0, P1, P2, P10 |
| + // docked: P0, P1, P2, P10 |
| // overflow: P8, P5, *P3, (P4, P6, P7, P9, P11) |
| EXPECT_TRUE(IsPanelVisible(panels[3])); |
| EXPECT_FALSE(panels[3]->IsDrawingAttention()); |
| @@ -1560,11 +1670,11 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) { |
| EXPECT_TRUE(panels[3]->IsDrawingAttention()); |
| EXPECT_FALSE(overflow_indicator->IsDrawingAttention()); |
| - // Activating a big overflow panel will cause 2 normal panels to move to the |
| + // Activating a big overflow panel will cause 2 docked panels to move to the |
| // overflow area and also get the top visible overflow panel bumped to the |
| // overflow-on-overflow. |
| // Expect the overflow indicator is showing attention. |
| - // normal: P0, P1, P5 |
| + // docked: P0, P1, P5 |
| // overflow: P2, P10, P8, (*P3, P4, P6, P7, P9, P11) |
| panels[5]->Activate(); |
| WaitForPanelActiveState(panels[5], SHOW_AS_ACTIVE); |
| @@ -1577,7 +1687,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) { |
| // Close an overflow panel that would move the first oveflow-on-overflow panel |
| // to become visible. Expect the overflow indicator is not showing attention. |
| - // normal: P0, P1, P5 |
| + // docked: P0, P1, P5 |
| // overflow: P2, P10, P3, (P4, P6, P7, P9, P11) |
| CloseWindowAndWait(panels[8]->browser()); |
| EXPECT_EQ(3, panel_strip->num_panels()); |
