Move IN_OVERFLOW from Panel::ExpansionState to new enum.

chrome/browser/ui/panels/panel_overflow_browsertest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <vector>
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/panels/base_panel_browser_test.h"
 #include "chrome/browser/ui/panels/native_panel.h"
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/panels/panel_overflow_indicator.h"
 #include "chrome/browser/ui/panels/panel_overflow_strip.h"
 #include "chrome/browser/ui/panels/panel_settings_menu_model.h"
 #include "chrome/browser/ui/panels/panel_strip.h"
 #include "chrome/browser/ui/panels/test_panel_mouse_watcher.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // We override the default value for testing purpose.
 const int kMaxVisibleOverflowPanelsForTesting = 3;
 const int kMaxVisibleOverflowPanelsOnHoverForTesting = 6;
 
 // Encapsulates all the info we need to verify if a panel behaves as expected
 // 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;
   }
 
   bool operator!=(const PanelData& 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) {
   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 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));
+  }
+};
+
 }  // namespace
 
 class PanelOverflowBrowserTest : public BasePanelBrowserTest {
  public:
   PanelOverflowBrowserTest() : BasePanelBrowserTest() {
   }
 
   virtual ~PanelOverflowBrowserTest() {
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
     BasePanelBrowserTest::SetUpOnMainThread();
 
     PanelManager* panel_manager = PanelManager::GetInstance();
     panel_manager->panel_overflow_strip()->set_max_visible_panels(
         kMaxVisibleOverflowPanelsForTesting);
     panel_manager->panel_overflow_strip()->set_max_visible_panels_on_hover(
         kMaxVisibleOverflowPanelsOnHoverForTesting);
 
     PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
     panel_manager->SetMouseWatcherForTesting(mouse_watcher);
 
     // All the overflow tests assume 800x600 work area. Do the check now.
     DCHECK(PanelManager::GetInstance()->work_area().width() == 800);
   }
 
  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();
          iter != panels.end(); ++iter) {
       Panel* panel = *iter;
       panel_data_list.push_back(PanelData(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));
     }
     return panel_data_list;
   }
 
@@ skipping 41 matching lines @@
     }
 
     // Then, create panels that would be placed in the overflow strip.
     int num_panels = num_normal_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);
+      WaitForStripOwnerChanged(panel, Panel::IN_OVERFLOW);
       panels.push_back(panel);
     }
 
     return panels;
   }
 };
 
 // TODO(jianli): remove the guard when overflow support is enabled on other
 // platforms. http://crbug.com/105073
 #if defined(OS_WIN)
@@ skipping 63 matching lines @@
   EXPECT_FALSE(panel2->has_temporary_layout());
   EXPECT_FALSE(panel3->has_temporary_layout());
   EXPECT_TRUE(panel4->has_temporary_layout());
 
   EXPECT_TRUE(panel1->draggable());
   EXPECT_TRUE(panel2->draggable());
   EXPECT_TRUE(panel3->draggable());
   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());
 
   PanelManager::GetInstance()->RemoveAll();
 }
 
 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();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CreateOverflowPanels) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   PanelStrip* panel_strip = panel_manager->panel_strip();
   PanelOverflowStrip* panel_overflow_strip =
       panel_manager->panel_overflow_strip();
 
@@ skipping 12 matching lines @@
   EXPECT_EQ(0, panel_overflow_strip->num_panels());
   EXPECT_FALSE(panel_overflow_strip->overflow_indicator());
   EXPECT_EQ(Panel::EXPANDED, panel0->expansion_state());
   EXPECT_EQ(Panel::EXPANDED, panel1->expansion_state());
   EXPECT_EQ(Panel::EXPANDED, panel2->expansion_state());
 
   // Create 1 overflow panel.
   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());
   EXPECT_EQ(1, panel_overflow_strip->num_panels());
   EXPECT_FALSE(panel_overflow_strip->overflow_indicator());
   EXPECT_TRUE(IsPanelVisible(panel3));
   EXPECT_TRUE(IsPanelInOverflowStrip(panel3));
   EXPECT_EQ(gfx::Size(255, 200), panel3->restored_size());
 
   // 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());
   EXPECT_EQ(2, panel_overflow_strip->num_panels());
   EXPECT_FALSE(panel_overflow_strip->overflow_indicator());
   EXPECT_TRUE(IsPanelVisible(panel4));
 
   PanelManager::GetInstance()->RemoveAll();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
                        MAYBE_CreateMoreOverflowPanels) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   PanelStrip* panel_strip = panel_manager->panel_strip();
   PanelOverflowStrip* panel_overflow_strip =
       panel_manager->panel_overflow_strip();
 
   const int panel_widths[] = {
       250, 260, 200,  // normal
       255, 220, 210,  // overflow
       220, 230        // overflow-on-overflow
   };
   CreateOverflowPanels(3, 5, panel_widths);
 
   std::vector<Panel*> panels = panel_manager->panels();
   ASSERT_EQ(8u, panels.size());
   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();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
                        MAYBE_CreatePanelOnDelayedOverflow) {
   // Create 2 big panels.
   CreatePanelWithBounds("Panel0", gfx::Rect(0, 0, 260, 200));
   CreatePanelWithBounds("Panel1", gfx::Rect(0, 0, 260, 200));
 
   // Create an overflow panel without waiting for it to be moved to overflow.
   CreatePanelParams params(
       "Panel2", gfx::Rect(0, 0, 255, 200), SHOW_AS_INACTIVE);
   params.wait_for_fully_created = false;
   Panel* overflow_panel = CreatePanelWithParams(params);
   EXPECT_EQ(Panel::EXPANDED, overflow_panel->expansion_state());
   EXPECT_TRUE(overflow_panel->has_temporary_layout());
 
   // Create a small panel that could fit within the available space in the
   // panel strip.
   CreatePanelParams params2(
       "Panel3", gfx::Rect(0, 0, 110, 200), SHOW_AS_INACTIVE);
   Panel* panel3 = CreatePanelWithParams(params2);
   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();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseOverflowPanels) {
   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, P5
   //   overflow-on-overflow: P6, P7
   int num_normal_panels = 3;
   int num_overflow_panels = 5;
   const int panel_widths[] = {
       260, 250, 200,  // normal
       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;
+  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.
   //   normal:               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,
             panel_manager->num_panels());
   EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
   EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels());
 
   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
   // visible in the overflow strip.
   //   normal:               P0, P1, P2
   //   overflow:             P3, P5, P7
   CloseWindowAndWait(panels[4]->browser());
   num_overflow_panels--;
   ASSERT_EQ(num_normal_panels + num_overflow_panels,
             panel_manager->num_panels());
   EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
   EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels());
 
   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.
   //   normal:               P0, P1, P2
   //   overflow:             P5, P7
   CloseWindowAndWait(panels[3]->browser());
   num_overflow_panels--;
   ASSERT_EQ(num_normal_panels + num_overflow_panels,
             panel_manager->num_panels());
   EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
   EXPECT_EQ(num_overflow_panels, panel_overflow_strip->num_panels());
 
   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();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_CloseNormalPanels) {
   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, P5
   //   overflow-on-overflow: P6, P7, P8
   int num_normal_panels = 3;
   int num_overflow_panels = 6;
   const int panel_widths[] = {
       260, 250, 200,  // normal
       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;
+  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
   // overflow-on-overflow panel to become visible.
   //   normal:               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,
             panel_manager->num_panels());
   EXPECT_EQ(num_normal_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_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
   // due to not enough room.
   //   normal:               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,
@@ skipping 20 matching lines @@
   EXPECT_EQ(num_normal_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_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
   //   overflow:             P7, P8
   CloseWindowAndWait(panels[0]->browser());
   num_overflow_panels--;
   ASSERT_EQ(num_normal_panels + num_overflow_panels,
             panel_manager->num_panels());
   EXPECT_EQ(num_normal_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_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();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
                        MAYBE_CloseWithDelayedOverflow) {
   PanelManager* panel_manager = PanelManager::GetInstance();
   PanelStrip* panel_strip = panel_manager->panel_strip();
 
@@ skipping 26 matching lines @@
   // panel will not be affected by the close.
   // Hack. Pretend to close panel by removing it directly. Cannot use
   // CloseWindowAndWait() here because it will allow the delayed overflow
   // to complete.
   panel_strip->Remove(panel1);
   EXPECT_EQ(1, panel_strip->num_panels());
   EXPECT_EQ(1, panel_strip->num_temporary_layout_panels());
   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
   // so we can properly close it to wrap up this test.
   panel_strip->AddPanel(panel1);
 
   panel0->Close();
   panel1->Close();
   overflow_panel->Close();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
   // Create normal and overflow panels.
   //   normal:               P0, P1, P2
   //   overflow:             P3, P4, P5
   //   overflow-on-overflow: P6, P7
   const int panel_widths[] = {
       250, 260, 200,  // normal
       210, 260, 230,  // overflow
       255, 210        // overflow-on-overflow
   };
   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
   // overflow strip.
   //   normal:               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_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
   // overflow strip and one overflow panel to become hidden.
   //   normal:               P0, P4
   //   overflow:             P1, P3, P2
   //   overflow-on-overflow: P5, P6, P7
   panels[4]->Activate();
   WaitForPanelActiveState(panels[4], SHOW_AS_ACTIVE);
   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_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
   // into the overflow strip.
   //   normal:               P0, P6
   //   overflow:             P4, P1, P3,
   //   overflow-on-overflow: P2, P5, P7
   panels[6]->Activate();
   WaitForPanelActiveState(panels[6], SHOW_AS_ACTIVE);
   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_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
   // since there has already been enough space in the panel strip.
   //   normal:               P0, P6, P7
   //   overflow:             P4, P1, P3,
   //   overflow-on-overflow: P2, P5
   panels[7]->Activate();
   WaitForPanelActiveState(panels[7], SHOW_AS_ACTIVE);
   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_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();
 }
 
 IN_PROC_BROWSER_TEST_F(
     PanelOverflowBrowserTest,
     MAYBE_MoveMinimizedPanelToOverflowAndBringBackByActivate) {
   // Create normal and overflow panels.
   //   normal:               P0, P1, P2
   //   overflow:             P3, P4
   const int panel_widths[] = {
       250, 260, 200,  // normal
       210, 260        // overflow
   };
   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.
   //   normal:               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_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
   //   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_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
   //   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_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
   //   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_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();
 }
 
 IN_PROC_BROWSER_TEST_F(
     PanelOverflowBrowserTest,
     MAYBE_MoveMinimizedPanelToOverflowAndBringBackByCloseOrResize) {
   PanelManager* panel_manager = PanelManager::GetInstance();
 
   // Create normal and overflow panels.
   //   normal:   P0, P1, P2
   //   overflow: P3, P4, P5
   const int panel_widths[] = {
       240, 240, 120, // normal
       240, 240, 240  // overflow
   };
   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.
   {
     // Minimize a normal panel and then bump it to overflow by activating an
     // overflow panel.
     //   normal:   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_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
     //   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_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
     //   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_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
     // all currently minimized panels. When a formerly minimized or title-only
     // panel is restored from the overflow area, it should also be title-only.
     panels[0]->SetExpansionState(Panel::MINIMIZED);
     MoveMouse(gfx::Point(panels[0]->GetBounds().x(),
                          panels[0]->GetBounds().y()));
     WaitForExpansionStateChanged(panels[0], Panel::TITLE_ONLY);
 
     // 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
     //   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_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
     //   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_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
     panel_manager->ResizePanel(panels[5], gfx::Size(
         panels[5]->GetBounds().width() / 2,
         panels[5]->GetBounds().height() / 2));
 
     expected_normal_list.clear();
@@ skipping 16 matching lines @@
         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_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
     // panels. When a formerly minimized or title-only panel is restored from
     // the overflow area, it should be minimized.
     MoveMouse(gfx::Point(0, 0));
     WaitForExpansionStateChanged(panels[0], Panel::MINIMIZED);
 
     // Bring back the formerly title-only panel by shrinking a panel. It will
     // return to the panel strip in the minimized state.
@@ skipping 209 matching lines @@
   EXPECT_EQ(4, panel_strip->num_panels());
   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)
   // 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->strip_owner());
   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)*
   // 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->strip_owner());  // 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)*
   // 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->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]);
 
   // Resize panel smaller so that panel from overflow can fit.
   // normal: 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->strip_owner());
 
   // Resize smaller again but not small enough to fit overflow panel.
   // normal: 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->strip_owner());  // 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)
   // 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->strip_owner());
   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)*
   // overflow: empty
   panel_manager->OnPreferredWindowSizeChanged(panel4, gfx::Size(100, 200));
   EXPECT_EQ(5, panel_strip->num_panels());
   EXPECT_EQ(0, overflow_strip->num_panels());
   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)
   // 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)
   // 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->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]);
 
   panel1->Close();
   panel2->Close();
   panel3->Close();
   panel4->Close();
   panel5->Close();
 }
@@ skipping 17 matching lines @@
   //   normal:               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();
   for (int i = 0; i < 5; ++i) {
     CreatePanelParams params(
         MakePanelName(num_existing_panels + i),
         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);
   }
 
   // Expand the overflow area by moving mouse over it.
   // Expect the overflow indicator count gets updated.
   //   normal:               P0, P1, P2
   //   overflow:             P3, P4, P5, P6, P7, P8, (P9, P10)
   MoveMouseAndWaitForOverflowAnimationEnded(panels[3]->GetBounds().origin());
   EXPECT_TRUE(IsPanelVisible(panels[6]));
@@ skipping 164 matching lines @@
   //   normal:               P0, P1, P5
   //   overflow:             P2, P10, P3, (P4, P6, P7, P9, P11)
   CloseWindowAndWait(panels[8]->browser());
   EXPECT_EQ(3, panel_strip->num_panels());
   EXPECT_EQ(8, overflow_strip->num_panels());
   EXPECT_TRUE(panels[3]->IsDrawingAttention());
   EXPECT_FALSE(overflow_indicator->IsDrawingAttention());
 
   panel_manager->RemoveAll();
 }