Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(4144)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/ui/panels/panel_overflow_browsertest.cc

Issue 9195003: Move IN_OVERFLOW from Panel::ExpansionState to new enum. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Fix per feedback Created 8 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/browser/ui/panels/panel_manager.cc ('k') | chrome/browser/ui/panels/panel_overflow_strip.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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..970fbbee22362508962863ea725348dfc8da7cf6 100644
--- a/chrome/browser/ui/panels/panel_overflow_browsertest.cc
+++ b/chrome/browser/ui/panels/panel_overflow_browsertest.cc
@@ -27,29 +27,24 @@ const int kMaxVisibleOverflowPanelsOnHoverForTesting = 6;
// when we do the overflow testing.
struct PanelData {
Panel* panel;
- Panel::ExpansionState expansion_state;
- bool visible;
+ Panel::LayoutState layout_state;
bool active;
explicit PanelData(Panel* panel)
: panel(panel),
- expansion_state(panel->expansion_state()),
- visible(!panel->GetBounds().IsEmpty()),
+ layout_state(panel->layout_state()),
active(panel->IsActive()) {
}
- PanelData(Panel* panel, Panel::ExpansionState expansion_state,
- bool visible, bool active)
+ PanelData(Panel* panel, Panel::LayoutState layout_state, bool active)
: panel(panel),
- expansion_state(expansion_state),
- visible(visible),
+ layout_state(layout_state),
active(active) {
}
bool operator==(const PanelData& another) const {
return panel == another.panel &&
- expansion_state == another.expansion_state &&
- visible == another.visible &&
+ layout_state == another.layout_state &&
active == another.active;
}
@@ -58,20 +53,82 @@ struct PanelData {
}
};
+struct DockedPanelData : public PanelData {
+ Panel::ExpansionState expansion_state;
+
+ explicit DockedPanelData(Panel* panel)
+ : PanelData(panel),
+ expansion_state(panel->expansion_state()) {
+ }
+
+ DockedPanelData(Panel* panel, Panel::ExpansionState expansion_state,
+ bool active)
+ : PanelData(panel, Panel::DOCKED, active),
+ expansion_state(expansion_state) {
+ }
+
+ bool operator==(const DockedPanelData& another) const {
+ if (*(static_cast<const PanelData*>(this)) !=
+ *(static_cast<const PanelData*>(&another)))
+ return false;
+ return expansion_state == another.expansion_state;
+ }
+
+ bool operator!=(const DockedPanelData& another) const {
+ return !(*this == another);
+ }
+};
+
// For gtest printing.
-::std::ostream& operator<<(::std::ostream& os, const PanelData& data);
-::std::ostream& operator<<(::std::ostream& os, const PanelData& data) {
+::std::ostream& operator<<(::std::ostream& os, const DockedPanelData& data) {
return os << "(" << data.panel->browser()->app_name() << ", "
- << data.expansion_state << ", " << data.visible << ", "
+ << data.layout_state << ", " << data.expansion_state << ", "
<< data.active << ")";
}
+struct OverflowPanelData : public PanelData {
+ bool visible;
+
+ explicit OverflowPanelData(Panel* panel)
+ : PanelData(panel),
+ visible(!panel->GetBounds().IsEmpty()) {
+ }
-class PanelDataList : public std::vector<PanelData> {
+ OverflowPanelData(Panel* panel, bool visible, bool active)
+ : PanelData(panel, Panel::IN_OVERFLOW, active),
+ visible(visible) {
+ }
+
+ bool operator==(const OverflowPanelData& another) const {
+ if (*(static_cast<const PanelData*>(this)) !=
+ *(static_cast<const PanelData*>(&another)))
+ return false;
+ return visible == another.visible;
+ }
+
+ bool operator!=(const OverflowPanelData& another) const {
+ return !(*this == another);
+ }
+};
+
+// For gtest printing.
+::std::ostream& operator<<(::std::ostream& os, const OverflowPanelData& data) {
+ return os << "(" << data.panel->browser()->app_name() << ", "
+ << data.layout_state << ", " << data.visible << ", "
+ << data.active << ")";
+}
+
+class DockedPanelDataList : public std::vector<DockedPanelData> {
+ public:
+ void Add(Panel* panel, Panel::ExpansionState expansion_state, bool active) {
+ push_back(DockedPanelData(panel, expansion_state, active));
+ }
+};
+
+class OverflowPanelDataList : public std::vector<OverflowPanelData> {
public:
- void Add(Panel* panel, Panel::ExpansionState expansion_state,
- bool visible, bool active) {
- push_back(PanelData(panel, expansion_state, visible, active));
+ void Add(Panel* panel, bool visible, bool active) {
+ push_back(OverflowPanelData(panel, visible, active));
}
};
@@ -102,26 +159,26 @@ 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();
iter != panels.end(); ++iter) {
Panel* panel = *iter;
- panel_data_list.push_back(PanelData(panel));
+ panel_data_list.push_back(DockedPanelData(panel));
}
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();
iter != panels.end(); ++iter) {
Panel* panel = *iter;
- panel_data_list.push_back(PanelData(panel));
+ panel_data_list.push_back(OverflowPanelData(panel));
}
return panel_data_list;
}
@@ -152,15 +209,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 +227,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 +252,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 +274,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 +320,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 +330,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 +348,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 +365,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 +378,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 +397,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 +408,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 +444,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 +455,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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[2], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[3], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[3], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[4], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[5], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[5], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[6], Panel::EXPANDED, 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 +711,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 +723,144 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
overflow_panel->Close();
}
+IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ClickOverflowPanels) {
+ // 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[3], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[3], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[3], Panel::EXPANDED, 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 +868,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, false);
+ expected_docked_list.Add(panels[4], Panel::EXPANDED, 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 +892,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, false);
+ expected_docked_list.Add(panels[6], Panel::EXPANDED, 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 +916,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, false);
+ expected_docked_list.Add(panels[6], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[7], Panel::EXPANDED, 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 +936,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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[3], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[3], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::EXPANDED, 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 +1041,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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[3], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::MINIMIZED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[4], Panel::EXPANDED, 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 +1133,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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[2], Panel::TITLE_ONLY, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[5], Panel::EXPANDED, 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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[5], Panel::EXPANDED, true);
+ expected_docked_list.Add(panels[2], Panel::TITLE_ONLY, false);
+ EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
expected_overflow_list.clear();
EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
@@ -1043,20 +1189,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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[5], Panel::EXPANDED, 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 +1213,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, false);
+ expected_docked_list.Add(panels[1], Panel::EXPANDED, false);
+ expected_docked_list.Add(panels[5], Panel::EXPANDED, true);
+ expected_docked_list.Add(panels[2], Panel::MINIMIZED, false);
+ EXPECT_EQ(expected_docked_list, GetAllDockedPanelData());
expected_overflow_list.clear();
EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
@@ -1093,11 +1239,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 +1310,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 +1416,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 +1426,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 +1497,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 +1526,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 +1538,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 +1548,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 +1567,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 +1579,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 +1592,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 +1602,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 +1626,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 +1644,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 +1653,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 +1662,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 +1671,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 +1680,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 +1689,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 +1698,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 +1706,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 +1723,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());
« no previous file with comments | « chrome/browser/ui/panels/panel_manager.cc ('k') | chrome/browser/ui/panels/panel_overflow_strip.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698