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..84c6ab492c93c9f21917a2d2483657d13e5203f5 100644
--- a/chrome/browser/ui/panels/panel_overflow_browsertest.cc
+++ b/chrome/browser/ui/panels/panel_overflow_browsertest.cc
@@ -27,28 +27,36 @@ const int kMaxVisibleOverflowPanelsOnHoverForTesting = 6;
 // when we do the overflow testing.
 struct PanelData {
   Panel* panel;
+  Panel::LayoutState layout_state;
   Panel::ExpansionState expansion_state;
   bool visible;
   bool active;
 
   explicit PanelData(Panel* panel)
       : panel(panel),
+        layout_state(panel->layout_state()),
         expansion_state(panel->expansion_state()),
         visible(!panel->GetBounds().IsEmpty()),
         active(panel->IsActive()) {
   }
 
-  PanelData(Panel* panel, Panel::ExpansionState expansion_state,
+  PanelData(Panel* panel, Panel::LayoutState layout_state,
+            Panel::ExpansionState expansion_state,
             bool visible, bool active)
       : panel(panel),
+        layout_state(layout_state),
         expansion_state(expansion_state),
         visible(visible),
         active(active) {
   }
 
   bool operator==(const PanelData& another) const {
+    if (layout_state != another.layout_state)
+      return false;
+    if (layout_state == Panel::DOCKED &&
+        expansion_state != another.expansion_state)
+      return false;
     return panel == another.panel &&
-           expansion_state == another.expansion_state &&
            visible == another.visible &&
            active == another.active;
   }
@@ -59,19 +67,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.layout_state << ", " << data.expansion_state << ", "
+            << data.visible << ", " << data.active << ")";
 }
 
-
 class PanelDataList : public std::vector<PanelData> {
+};
+
+class NormalPanelDataList : public PanelDataList {

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

nit: Rename DockedPanelDataList ?

[jianli, 2012/01/20 01:16:07]

Done.

  public:
   void Add(Panel* panel, Panel::ExpansionState expansion_state,
            bool visible, bool active) {
-    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 23:44:09]

Should comment here that expected expansion state is ignored when comparing
PanelData, or maybe we should pass in expected expansion state and change
PanelData to always compare that field, regardless of layout state. 

[jianli, 2012/01/20 01:16:07]

Added comment.

+                        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);
+      WaitForLayoutStateChanged(panel, Panel::IN_OVERFLOW);
       panels.push_back(panel);
     }
 
@@ -197,6 +215,7 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
 #define MAYBE_CloseOverflowPanels CloseOverflowPanels
 #define MAYBE_CloseNormalPanels CloseNormalPanels
 #define MAYBE_CloseWithDelayedOverflow CloseWithDelayedOverflow
+#define MAYBE_ClickOverflowPanels ClickOverflowPanels
 #define MAYBE_ActivateOverflowPanels ActivateOverflowPanels
 #define MAYBE_MoveMinimizedPanelToOverflowAndBringBackByActivate \
     MoveMinimizedPanelToOverflowAndBringBackByActivate
@@ -218,6 +237,7 @@ class PanelOverflowBrowserTest : public BasePanelBrowserTest {
 #define MAYBE_CloseOverflowPanels DISABLED_CloseOverflowPanels
 #define MAYBE_CloseNormalPanels DISABLED_CloseNormalPanels
 #define MAYBE_CloseWithDelayedOverflow DISABLED_CloseWithDelayedOverflow
+#define MAYBE_ClickOverflowPanels DISABLED_ClickOverflowPanels
 #define MAYBE_ActivateOverflowPanels DISABLED_ActivateOverflowPanels
 #define MAYBE_MoveMinimizedPanelToOverflowAndBringBackByActivate \
     DISABLED_MoveMinimizedPanelToOverflowAndBringBackByActivate
@@ -261,7 +281,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 +291,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();
 }
@@ -306,7 +326,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 +339,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());
@@ -349,15 +369,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 +405,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();
 }
@@ -410,18 +430,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 +458,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 +478,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 +496,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 +523,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 +557,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 +602,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 +624,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 +672,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,6 +684,97 @@ IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
   overflow_panel->Close();
 }
 
+IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ClickOverflowPanels) {
+  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
+  //   overflow:             P3, P4
+  const int panel_widths[] = {
+      240, 240, 240,  // normal
+      240, 240        // overflow
+  };
+  std::vector<Panel*> panels = CreateOverflowPanels(3, 2, panel_widths);
+
+  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());
+
+  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.
+  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.
+  //   normal:               P0, P1, P3
+  //   overflow:             P2, P4
+  ClickPanelTitlebar(panels[3]);
+  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, false);
+  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+
+  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 normal 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.
+  //   normal:               P0, P1, P2
+  //   overflow:             P3, P4
+  ClickPanelTitlebar(panels[2]);
+  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, false);
+  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+
+  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.
+  //   normal:               P0, P1, P3
+  //   overflow:             P2, P4
+  ClickPanelTitlebar(panels[3]);
+  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, false);
+  EXPECT_EQ(expected_normal_list, GetAllNormalPanelData());
+
+  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
@@ -676,18 +787,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 +817,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 +840,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 +864,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 +889,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 +911,16 @@ 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);
+  EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
   // Minimize a normal panel and then bump it to overflow by activating an
   // overflow panel.
@@ -826,8 +938,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 +957,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 +976,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 +995,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 +1016,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 +1045,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 +1064,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 +1085,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 +1111,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 +1131,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 +1168,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 +1398,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->layout_state());
   EXPECT_TRUE(IsPanelInOverflowStrip(panel4));
   EXPECT_EQ(new_size, panel4->restored_size());
 
@@ -1297,7 +1409,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->layout_state());  // no change
 
   // Resize a panel from the middle of the strip so that it causes a
   // panel to overflow.
@@ -1306,8 +1418,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->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]);
@@ -1319,7 +1431,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->layout_state());
 
   // Resize smaller again but not small enough to fit overflow panel.
   // normal: P1 (250), P2 (100)*, P3 (100), P5 (100)
@@ -1327,7 +1439,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->layout_state());  // no change
 
   // Resize overflow panel bigger. It should stay in overflow and bounds
   // should not change.
@@ -1338,7 +1450,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->layout_state());
   EXPECT_EQ(bounds_before_resize, panel4->GetBounds());
   EXPECT_EQ(new_size, panel4->restored_size());
 
@@ -1363,8 +1475,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->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]);
@@ -1402,7 +1514,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);
+    WaitForLayoutStateChanged(panel, Panel::IN_OVERFLOW);
     EXPECT_EQ(i + 1, overflow_strip->overflow_indicator()->GetCount());
     panels.push_back(panel);
   }