Move IN_OVERFLOW from Panel::ExpansionState to new enum.

chrome/browser/ui/panels/panel_overflow_browsertest.cc

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..ea404c930b850097830c0ca9aec5abc78cbb6c2b 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::StripOwner strip_owner;
   Panel::ExpansionState expansion_state;
   bool visible;
   bool active;
 
   explicit PanelData(Panel* panel)
       : panel(panel),
+        strip_owner(panel->strip_owner()),
         expansion_state(panel->expansion_state()),
         visible(!panel->GetBounds().IsEmpty()),
         active(panel->IsActive()) {
   }
 
-  PanelData(Panel* panel, Panel::ExpansionState expansion_state,
+  PanelData(Panel* panel, Panel::StripOwner strip_owner,
+            Panel::ExpansionState expansion_state,
             bool visible, bool active)
       : panel(panel),
+        strip_owner(strip_owner),
         expansion_state(expansion_state),
         visible(visible),
         active(active) {
   }
 
   bool operator==(const PanelData& another) const {
+    if (strip_owner != another.strip_owner)
+      return false;
+    if (strip_owner == 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,29 @@ 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.strip_owner << ", " << data.expansion_state << ", "
+            << data.visible << ", " << data.active << ")";
 }
 
-
 class PanelDataList : public std::vector<PanelData> {
+};
+
+class NormalPanelDataList : public PanelDataList {
  public:
   void Add(Panel* panel, Panel::ExpansionState expansion_state,
            bool visible, bool active) {

[jennb, 2012/01/19 18:41:21]

visible param not needed

[jianli, 2012/01/19 22:24:41]

The overflow panel might be hidden and it comes out of overflow later. So I
think it will be nice if we also verify the visible property.

[jennb, 2012/01/19 23:44:09]

Aren't all panels in the NormalPanelDataList visible? I don't see when we would
set this to anything other than true. 

-    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) {
+    push_back(PanelData(panel, Panel::IN_OVERFLOW, Panel::EXPANDED,

[jennb, 2012/01/19 18:41:21]

Some tests will be putting minimized panels into overflow.

[jianli, 2012/01/19 22:24:41]

Yes, but we don't care how the minimized state is saved. We only care the
previously minimized panel comes out the overflow as minimized.

+                        visible, active));
   }
 };
 
@@ -102,8 +120,8 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
   }
 
  protected:
-  static PanelDataList GetAllNormalPanelData() {
-    PanelDataList panel_data_list;
+  static NormalPanelDataList GetAllNormalPanelData() {
+    NormalPanelDataList panel_data_list;
     PanelStrip::Panels panels =
         PanelManager::GetInstance()->panel_strip()->panels();
     for (PanelStrip::Panels::const_iterator iter = panels.begin();
@@ -114,8 +132,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();
@@ -177,7 +195,7 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
           gfx::Rect(0, 0, panel_widths[i], kTestPanelHeight),
           SHOW_AS_INACTIVE);
       Panel* panel = CreatePanelWithParams(params);
-      WaitForExpansionStateChanged(panel, Panel::IN_OVERFLOW);
+      WaitForStripOwnerChanged(panel, Panel::IN_OVERFLOW);
       panels.push_back(panel);
     }
 
@@ -261,7 +279,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);
+  WaitForStripOwnerChanged(panel4, Panel::IN_OVERFLOW);
   EXPECT_FALSE(panel4->has_temporary_layout());
   EXPECT_FALSE(panel4->draggable());
 
@@ -271,9 +289,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->SetStripOwner(Panel::IN_OVERFLOW);
   EXPECT_FALSE(panel->draggable());
-  panel->SetExpansionState(Panel::EXPANDED);
+  panel->SetStripOwner(Panel::DOCKED);
   EXPECT_TRUE(panel->draggable());
   panel->Close();
 }
@@ -306,7 +324,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);
+  WaitForStripOwnerChanged(panel3, Panel::IN_OVERFLOW);
 
   EXPECT_EQ(4, panel_manager->num_panels());
   EXPECT_EQ(3, panel_strip->num_panels());
@@ -319,7 +337,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);
+  WaitForStripOwnerChanged(panel4, Panel::IN_OVERFLOW);
 
   EXPECT_EQ(5, panel_manager->num_panels());
   EXPECT_EQ(3, panel_strip->num_panels());
@@ -349,15 +367,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]->strip_owner());
   EXPECT_TRUE(IsPanelVisible(panels[3]));
-  EXPECT_EQ(Panel::IN_OVERFLOW, panels[4]->expansion_state());
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[4]->strip_owner());
   EXPECT_TRUE(IsPanelVisible(panels[4]));
-  EXPECT_EQ(Panel::IN_OVERFLOW, panels[5]->expansion_state());
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[5]->strip_owner());
   EXPECT_TRUE(IsPanelVisible(panels[5]));
-  EXPECT_EQ(Panel::IN_OVERFLOW, panels[6]->expansion_state());
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[6]->strip_owner());
   EXPECT_FALSE(IsPanelVisible(panels[6]));
-  EXPECT_EQ(Panel::IN_OVERFLOW, panels[7]->expansion_state());
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[7]->strip_owner());
   EXPECT_FALSE(IsPanelVisible(panels[7]));
 
   PanelManager::GetInstance()->RemoveAll();
@@ -385,7 +403,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);
+  WaitForStripOwnerChanged(overflow_panel, Panel::IN_OVERFLOW);
   EXPECT_FALSE(overflow_panel->has_temporary_layout());
   PanelManager::GetInstance()->RemoveAll();
 }
@@ -410,18 +428,18 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) {
   std::vector<Panel*> panels = CreateOverflowPanels(
       num_normal_panels, num_overflow_panels, panel_widths);
 
-  PanelDataList expected_normal_list;
+  NormalPanelDataList 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);
+  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.
@@ -438,10 +456,10 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) {
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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
@@ -458,9 +476,9 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) {
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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.
@@ -476,8 +494,8 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) {
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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();
@@ -503,19 +521,19 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) {
   std::vector<Panel*> panels = CreateOverflowPanels(
       num_normal_panels, num_overflow_panels, panel_widths);
 
-  PanelDataList expected_normal_list;
+  NormalPanelDataList 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);
+  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
@@ -537,11 +555,11 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) {
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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
@@ -582,9 +600,9 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) {
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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.
@@ -604,8 +622,8 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) {
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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 +670,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);
+  WaitForStripOwnerChanged(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
@@ -676,18 +694,18 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   };
   std::vector<Panel*> panels = CreateOverflowPanels(3, 5, panel_widths);
 
-  PanelDataList expected_normal_list;
+  NormalPanelDataList 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);
+  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
@@ -706,11 +724,11 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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
@@ -729,12 +747,12 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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
@@ -753,12 +771,12 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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
@@ -778,11 +796,11 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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();
@@ -800,15 +818,15 @@ IN_PROC_BROWSER_TEST_F(
   };
   std::vector<Panel*> panels = CreateOverflowPanels(3, 2, panel_widths);
 
-  PanelDataList expected_normal_list;
+  NormalPanelDataList 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);
+  OverflowPanelDataList expected_overflow_list;
+  expected_overflow_list.Add(panels[3], true, false);
+  expected_overflow_list.Add(panels[4], true, false);
 
   // Minimize a normal panel and then bump it to overflow by activating an
   // overflow panel.
@@ -826,8 +844,8 @@ IN_PROC_BROWSER_TEST_F(
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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
@@ -845,8 +863,8 @@ IN_PROC_BROWSER_TEST_F(
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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.
@@ -864,8 +882,8 @@ IN_PROC_BROWSER_TEST_F(
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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
@@ -883,8 +901,8 @@ IN_PROC_BROWSER_TEST_F(
   EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
   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();
@@ -904,16 +922,16 @@ IN_PROC_BROWSER_TEST_F(
   };
   std::vector<Panel*> panels = CreateOverflowPanels(3, 3, panel_widths);
 
-  PanelDataList expected_normal_list;
+  NormalPanelDataList 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);
+  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.
   {
@@ -933,9 +951,9 @@ IN_PROC_BROWSER_TEST_F(
     EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
     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
@@ -952,8 +970,8 @@ IN_PROC_BROWSER_TEST_F(
     EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
     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());
   }
 
@@ -973,8 +991,8 @@ IN_PROC_BROWSER_TEST_F(
     EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
     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
@@ -999,7 +1017,7 @@ IN_PROC_BROWSER_TEST_F(
     EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
     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());
   }
 
@@ -1019,7 +1037,7 @@ IN_PROC_BROWSER_TEST_F(
     EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
     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
@@ -1056,7 +1074,7 @@ IN_PROC_BROWSER_TEST_F(
     EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
 
     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
@@ -1286,7 +1304,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) {
   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->strip_owner());
   EXPECT_TRUE(IsPanelInOverflowStrip(panel4));
   EXPECT_EQ(new_size, panel4->restored_size());
 
@@ -1297,7 +1315,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) {
   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->strip_owner());  // no change
 
   // Resize a panel from the middle of the strip so that it causes a
   // panel to overflow.
@@ -1306,8 +1324,8 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) {
   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->strip_owner());
+  EXPECT_EQ(Panel::IN_OVERFLOW, panel5->strip_owner());
   const PanelOverflowStrip::Panels& overflow = overflow_strip->panels();
   EXPECT_EQ(panel5, overflow[0]);  // new overflow panel is first
   EXPECT_EQ(panel4, overflow[1]);
@@ -1319,7 +1337,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) {
   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->strip_owner());
 
   // Resize smaller again but not small enough to fit overflow panel.
   // normal: P1 (250), P2 (100)*, P3 (100), P5 (100)
@@ -1327,7 +1345,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) {
   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->strip_owner());  // no change
 
   // Resize overflow panel bigger. It should stay in overflow and bounds
   // should not change.
@@ -1338,7 +1356,7 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) {
   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->strip_owner());
   EXPECT_EQ(bounds_before_resize, panel4->GetBounds());
   EXPECT_EQ(new_size, panel4->restored_size());
 
@@ -1363,8 +1381,8 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ResizePanel) {
   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->strip_owner());
+  EXPECT_EQ(Panel::IN_OVERFLOW, panel5->strip_owner());
   const PanelOverflowStrip::Panels& overflow2 = overflow_strip->panels();
   EXPECT_EQ(panel5, overflow2[0]);  // strip order is preserved
   EXPECT_EQ(panel4, overflow2[1]);
@@ -1402,7 +1420,7 @@ 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);
+    WaitForStripOwnerChanged(panel, Panel::IN_OVERFLOW);
     EXPECT_EQ(i + 1, overflow_strip->overflow_indicator()->GetCount());
     panels.push_back(panel);
   }