Add test cases for panel overflow handling.

chrome/browser/ui/panels/panel_overflow_browsertest.cc

+// Copyright (c) 2011 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 <deque>
+#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_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 kMaxVisibleOverflowForTesting = 3;
+
+// Encapsulates all the info we need to verify if a panel behaves as expected
+// when we do the overflow testing.
+struct PanelData {
+  Panel* panel;
+  std::string name;
+  Panel::ExpansionState expansion_state;
+  bool visible;
+  bool active;
+
+  PanelData()
+      : panel(NULL),
+        expansion_state(Panel::EXPANDED),
+        visible(false),
+        active(false) {
+  }
+
+  explicit PanelData(Panel* panel)
+      : panel(panel),
+        name(panel->browser()->app_name()),
+        expansion_state(panel->expansion_state()),
+        visible(!panel->GetBounds().IsEmpty()),
+        active(panel->IsActive()) {
+  }
+
+  PanelData(Panel* panel, Panel::ExpansionState expansion_state,
+            bool visible, bool active)
+      : panel(panel),
+        name(panel->browser()->app_name()),
+        expansion_state(expansion_state),
+        visible(visible),
+        active(active) {
+  }
+
+  bool operator==(const PanelData& another) const {
+    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.name << ", " << data.expansion_state << ", "
+            << data.visible << ", " << data.active << ")";
+}
+
+
+class BasePanelDataList : public std::deque<PanelData> {
+ public:
+  PanelData* get(Panel* panel) {
+    for (BasePanelDataList::iterator iter = begin(); iter != end(); ++iter) {
+      if (iter->panel == panel)
+        return &(*iter);
+    }
+    return NULL;
+  }
+
+  virtual PanelData remove(Panel* panel) {
+    PanelData panel_data;
+    for (BasePanelDataList::iterator iter = begin(); iter != end(); ++iter) {
+      if (iter->panel == panel) {
+        panel_data = *iter;
+        erase(iter);
+        break;
+      }
+    }
+    return panel_data;
+  }
+
+ protected:
+  using std::deque<PanelData>::push_back;
+  using std::deque<PanelData>::push_front;
+};
+
+class NormalPanelDataList : public BasePanelDataList {
+ public:
+  void push_back(const PanelData& panel_data) {
+    BasePanelDataList::push_back(panel_data);
+    back().expansion_state = Panel::EXPANDED;
+    back().visible = true;
+  }
+};
+
+class OverflowPanelDataList : public BasePanelDataList {
+ public:
+  void push_back(const PanelData& panel_data) {
+    BasePanelDataList::push_back(panel_data);
+    back().expansion_state = Panel::IN_OVERFLOW;
+    back().visible = size() <= kMaxVisibleOverflowForTesting;
+  }
+
+  void push_front(const PanelData& panel_data) {
+    BasePanelDataList::push_front(panel_data);
+    front().expansion_state = Panel::IN_OVERFLOW;
+    front().visible = true;
+    if (size() > kMaxVisibleOverflowForTesting)
+      (*this)[kMaxVisibleOverflowForTesting].visible = false;
+  }
+
+  virtual PanelData remove(Panel* panel) OVERRIDE {
+    PanelData panel_data = BasePanelDataList::remove(panel);
+    if (size() >= kMaxVisibleOverflowForTesting)
+      (*this)[kMaxVisibleOverflowForTesting - 1].visible = true;
+    return panel_data;
+  }
+};
+
+}  // namespace
+
+class PanelOverflowBrowserTest : public BasePanelBrowserTest {
+ public:
+  PanelOverflowBrowserTest() : BasePanelBrowserTest() {
+  }
+
+  virtual ~PanelOverflowBrowserTest() {
+  }
+
+  virtual void SetUpOnMainThread() OVERRIDE {
+    BasePanelBrowserTest::SetUpOnMainThread();
+
+    PanelManager::GetInstance()->panel_overflow_strip()->
+        set_max_visible_panels(kMaxVisibleOverflowForTesting);
+  }
+
+ protected:
+  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 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;
+  }
+
+  static void MoveMouseAndWaitForOverflowAnimationEnded(
+      const gfx::Point& position) {
+    ui_test_utils::WindowedNotificationObserver signal(
+        chrome::NOTIFICATION_PANEL_BOUNDS_ANIMATIONS_FINISHED,
+        content::Source<PanelOverflowStrip>(
+            PanelManager::GetInstance()->panel_overflow_strip()));
+    MoveMouse(position);
+    signal.Wait();
+  }
+
+  static bool IsPanelVisible(Panel* panel) {
+    return !panel->GetBounds().IsEmpty();
+  }
+
+  std::vector<Panel*> CreateOverflowPanels(int num_normal_panels,
+                                           int num_overflow_panels,
+                                           const int* panel_widths) {
+    const int kTestPanelHeight = 200;
+    std::vector<Panel*> panels;
+
+    // First, create normal panels to fill the panel strip.
+    int i = 0;
+    for (; i < num_normal_panels; ++i) {
+      CreatePanelParams params(
+          MakePanelName(i),
+          gfx::Rect(0, 0, panel_widths[i], kTestPanelHeight),
+          SHOW_AS_INACTIVE);
+      Panel* panel = CreatePanelWithParams(params);
+      panels.push_back(panel);
+    }
+
+    // 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);
+      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)
+#define MAYBE_CreateOverflowPanels CreateOverflowPanels
+#define MAYBE_CreateMoreOverflowPanels CreateMoreOverflowPanels
+// http://crbug.com/107230
+#define MAYBE_CreatePanelOnDelayedOverflow FAILS_CreatePanelOnDelayedOverflow
+#define MAYBE_CloseOverflowPanels CloseOverflowPanels
+#define MAYBE_CloseNormalPanels CloseNormalPanels
+#define MAYBE_ActivateOverflowPanels ActivateOverflowPanels
+#define MAYBE_HoverOverOverflowArea HoverOverOverflowArea
+#else
+#define MAYBE_CreateOverflowPanels DISABLED_CreateOverflowPanels
+#define MAYBE_CreateMoreOverflowPanels DISABLED_CreateMoreOverflowPanels
+#define MAYBE_CreatePanelOnDelayedOverflow DISABLED_CreatePanelOnDelayedOverflow
+#define MAYBE_CloseOverflowPanels DISABLED_CloseOverflowPanels
+#define MAYBE_CloseNormalPanels DISABLED_CloseNormalPanels
+#define MAYBE_ActivateOverflowPanels DISABLED_ActivateOverflowPanels
+#define MAYBE_HoverOverOverflowArea DISABLED_HoverOverOverflowArea
+#endif
+
+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();
+
+  const int panel_widths[] = {
+      250, 260, 200,  // normal
+      255, 220        // overflow
+  };
+  CreateOverflowPanels(3, 2, panel_widths);
+
+  std::vector<Panel*> panels = panel_manager->panels();
+  ASSERT_EQ(5, panels.size());
+  EXPECT_EQ(3, panel_strip->num_panels());
+  EXPECT_EQ(2, panel_overflow_strip->num_panels());
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[3]->expansion_state());
+  EXPECT_TRUE(IsPanelVisible(panels[3]));
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[4]->expansion_state());
+  EXPECT_TRUE(IsPanelVisible(panels[4]));
+
+  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(8, panels.size());
+  EXPECT_EQ(3, panel_strip->num_panels());
+  EXPECT_EQ(5, panel_overflow_strip->num_panels());
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[3]->expansion_state());
+  EXPECT_TRUE(IsPanelVisible(panels[3]));
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[4]->expansion_state());
+  EXPECT_TRUE(IsPanelVisible(panels[4]));
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[5]->expansion_state());
+  EXPECT_TRUE(IsPanelVisible(panels[5]));
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[6]->expansion_state());
+  EXPECT_FALSE(IsPanelVisible(panels[6]));
+  EXPECT_EQ(Panel::IN_OVERFLOW, panels[7]->expansion_state());
+  EXPECT_FALSE(IsPanelVisible(panels[7]));
+
+  PanelManager::GetInstance()->RemoveAll();
+}
+
+IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest,
+                       MAYBE_CreatePanelOnDelayedOverflow) {
+  // Create 2 big panels.
+  Panel* panel0 = CreatePanelWithBounds("Panel0", gfx::Rect(0, 0, 260, 200));
+  Panel* panel1 = CreatePanelWithBounds("Panel1", gfx::Rect(0, 0, 260, 200));
+
+  // Create 2 overflow panels without waiting for them to be moved to overflow.
+  Panel* panel2 = CreatePanelWithBounds("Panel2", gfx::Rect(0, 0, 255, 200));

[jennb, 2011/12/14 00:55:29]

CreatePanelWithBounds invokes MessageLoop RunAllPending because it waits on
signals, which may give the panel enough time to move to overflow before this
code has a chance to continue as the timeouts are shortened in tests. You need
to manually create the overflow panels instead of using the base class helper
func to keep all this executing without interruptions.

[jianli, 2011/12/14 22:36:20]

Done. Added wait_for_fully_created to CreatePanelParams.

+  Panel* panel3 = CreatePanelWithBounds("Panel3", gfx::Rect(0, 0, 255, 200));
+
+  // Create 1 small panel that could fit within the available space in the
+  // panel strip.
+  Panel* panel4 = CreatePanelWithBounds("Panel4", gfx::Rect(0, 0, 100, 200));
+  EXPECT_EQ(Panel::EXPANDED, panel4->expansion_state());
+  EXPECT_FALSE(panel4->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);
+
+  NormalPanelDataList expected_normal_panel_data_list;
+  expected_normal_panel_data_list.push_back(
+      PanelData(panels[0], Panel::EXPANDED, true, false));
+  expected_normal_panel_data_list.push_back(
+      PanelData(panels[1], Panel::EXPANDED, true, false));
+  expected_normal_panel_data_list.push_back(
+      PanelData(panels[2], Panel::EXPANDED, true, false));
+
+  OverflowPanelDataList expected_overflow_panel_data_list;
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[3], Panel::IN_OVERFLOW, true, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[4], Panel::IN_OVERFLOW, true, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[5], Panel::IN_OVERFLOW, true, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[6], Panel::IN_OVERFLOW, false, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[7], Panel::IN_OVERFLOW, false, false));
+
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());

[jennb, 2011/12/14 00:55:29]

You're still not comparing the actual values inside the Panel objects. Building
the expected values in the few lines above simply repeats the logic in
GetAllNormalPanelData() and GetAllOverflowPanelData() where you also construct
expected values in the expansion_state and visible fields. Look at the two
push_back() methods above and you'll see the actual Panel data always gets
over-written by expected values. push_front() is also  like that.

[jianli, 2011/12/14 22:36:20]

I changed to construct the expected list each time when we do the verification.

+  EXPECT_EQ(expected_overflow_panel_data_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());
+  expected_overflow_panel_data_list.remove(panels[6]);

[jennb, 2011/12/14 00:55:29]

list does not have index 6. Indexing mistakes throughout code below.

[jianli, 2011/12/14 22:36:20]

Both panels and expected_overflow_panel_data_list are filled with the panel data
before Panel6 is closed. So we need to adjust expected_overflow_panel_data_list
to remove Panel6's data from it. However, I changed to construct the expected
list each time when we do the verification.

+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_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());
+  expected_overflow_panel_data_list.remove(panels[4]);
+  expected_overflow_panel_data_list.get(panels[7])->visible = true;
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_list, GetAllOverflowPanelData());
+
+  // Close an overflow panel. Expect only that panel is closed.
+  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());
+  expected_overflow_panel_data_list.remove(panels[3]);
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_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);
+
+  NormalPanelDataList expected_normal_panel_data_list;
+  expected_normal_panel_data_list.push_back(
+      PanelData(panels[0], Panel::EXPANDED, true, false));
+  expected_normal_panel_data_list.push_back(
+      PanelData(panels[1], Panel::EXPANDED, true, false));
+  expected_normal_panel_data_list.push_back(
+      PanelData(panels[2], Panel::EXPANDED, true, false));
+
+  OverflowPanelDataList expected_overflow_panel_data_list;
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[3], Panel::IN_OVERFLOW, true, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[4], Panel::IN_OVERFLOW, true, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[5], Panel::IN_OVERFLOW, true, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[6], Panel::IN_OVERFLOW, false, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[7], Panel::IN_OVERFLOW, false, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[8], Panel::IN_OVERFLOW, false, false));
+
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_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_panel_data_list.remove(panels[1]);
+  expected_normal_panel_data_list.push_back(
+      expected_overflow_panel_data_list.remove(panels[3]));
+  expected_overflow_panel_data_list.get(panels[6])->visible = true;
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_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,
+            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_panel_data_list.remove(panels[2]);
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_list, GetAllOverflowPanelData());
+
+  // Close one more normal panel. Expect two overflow panels to move over and
+  // two overflow-on-overflow panels to become visible.
+  //   normal:               P0, P4, P5
+  //   overflow:             P6, P7, P8
+  CloseWindowAndWait(panels[3]->browser());
+  num_normal_panels++;
+  num_overflow_panels -= 2;
+  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_panel_data_list.remove(panels[3]);
+  expected_normal_panel_data_list.push_back(
+      expected_overflow_panel_data_list.remove(panels[4]));
+  expected_normal_panel_data_list.push_back(
+      expected_overflow_panel_data_list.remove(panels[5]));
+  expected_overflow_panel_data_list.get(panels[7])->visible = true;
+  expected_overflow_panel_data_list.get(panels[8])->visible = true;
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_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_panel_data_list.remove(panels[0]);
+  expected_normal_panel_data_list.push_back(
+      expected_overflow_panel_data_list.remove(panels[6]));
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_list, GetAllOverflowPanelData());
+
+  panel_manager->RemoveAll();
+}
+
+IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_ActivateOverflowPanels) {
+  PanelManager* panel_manager = PanelManager::GetInstance();
+  PanelStrip* panel_strip = panel_manager->panel_strip();
+  PanelOverflowStrip* panel_overflow_strip =
+      panel_manager->panel_overflow_strip();
+  panel_overflow_strip->set_max_visible_panels(3);
+
+  // 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);
+
+  NormalPanelDataList expected_normal_panel_data_list;
+  expected_normal_panel_data_list.push_back(
+      PanelData(panels[0], Panel::EXPANDED, true, false));
+  expected_normal_panel_data_list.push_back(
+      PanelData(panels[1], Panel::EXPANDED, true, false));
+  expected_normal_panel_data_list.push_back(
+      PanelData(panels[2], Panel::EXPANDED, true, false));
+
+  OverflowPanelDataList expected_overflow_panel_data_list;
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[3], Panel::IN_OVERFLOW, true, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[4], Panel::IN_OVERFLOW, true, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[5], Panel::IN_OVERFLOW, true, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[6], Panel::IN_OVERFLOW, false, false));
+  expected_overflow_panel_data_list.push_back(
+    PanelData(panels[7], Panel::IN_OVERFLOW, false, false));
+
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_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_overflow_panel_data_list.push_front(
+      expected_normal_panel_data_list.remove(panels[2]));
+  expected_normal_panel_data_list.push_back(
+      expected_overflow_panel_data_list.remove(panels[3]));
+  expected_normal_panel_data_list.get(panels[3])->active = true;
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_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_overflow_panel_data_list.push_front(
+      expected_normal_panel_data_list.remove(panels[3]));
+  expected_overflow_panel_data_list.push_front(
+      expected_normal_panel_data_list.remove(panels[1]));
+  expected_normal_panel_data_list.push_back(
+      expected_overflow_panel_data_list.remove(panels[4]));
+  expected_normal_panel_data_list.get(panels[4])->active = true;
+  expected_overflow_panel_data_list.get(panels[3])->active = false;
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_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_overflow_panel_data_list.push_front(
+      expected_normal_panel_data_list.remove(panels[4]));
+  expected_normal_panel_data_list.push_back(
+      expected_overflow_panel_data_list.remove(panels[6]));
+  expected_normal_panel_data_list.get(panels[6])->active = true;
+  expected_overflow_panel_data_list.get(panels[4])->active = false;
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_list, GetAllOverflowPanelData());
+
+  // Activate an overflow-on-overflow panel. Not any 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_panel_data_list.push_back(
+      expected_overflow_panel_data_list.remove(panels[7]));
+  expected_normal_panel_data_list.get(panels[7])->active = true;
+  expected_normal_panel_data_list.get(panels[6])->active = false;
+  EXPECT_EQ(expected_normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(expected_overflow_panel_data_list, GetAllOverflowPanelData());
+
+  panel_manager->RemoveAll();
+}
+
+IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_HoverOverOverflowArea) {
+  PanelManager* panel_manager = PanelManager::GetInstance();
+  PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
+  panel_manager->SetMouseWatcherForTesting(mouse_watcher);
+  PanelStrip* panel_strip = panel_manager->panel_strip();
+  PanelOverflowStrip* panel_overflow_strip =
+      panel_manager->panel_overflow_strip();
+  panel_overflow_strip->set_max_visible_panels(3);
+  int iconified_width = panel_overflow_strip->current_display_width();
+
+  // 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
+      255, 220, 260,  // overflow
+      140, 210        // overflow-on-overflow
+  };
+  std::vector<Panel*> panels = CreateOverflowPanels(3, 5, panel_widths);
+
+  // Move mouse beyond the right edge of the top overflow panel.
+  // Expect the overflow area remains shrunk.
+  MoveMouse(gfx::Point(panels[5]->GetBounds().right() + 1,
+                       panels[5]->GetBounds().y()));
+  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+
+  // Move mouse above the top overflow panel. Expect the overflow area
+  // remains shrunk.
+  MoveMouse(gfx::Point(panels[5]->GetBounds().x(),
+                       panels[5]->GetBounds().y() - 1));
+  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+
+  // Move mouse below the bottom overflow panel. Expect the overflow area
+  // remains shrunk.
+  MoveMouse(gfx::Point(panels[3]->GetBounds().right(),
+                       panels[3]->GetBounds().bottom() + 1));
+  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+
+  // Move mouse to the origin of an overflow panel. Expect the overflow area
+  // gets expanded.
+  MoveMouseAndWaitForOverflowAnimationEnded(
+      panels[4]->GetBounds().origin());
+  int hover_width = panel_overflow_strip->current_display_width();
+  EXPECT_GT(hover_width, iconified_width);
+  EXPECT_EQ(hover_width, panels[3]->GetBounds().width());
+  EXPECT_EQ(hover_width, panels[4]->GetBounds().width());
+  EXPECT_EQ(hover_width, panels[5]->GetBounds().width());
+  EXPECT_EQ(hover_width, panels[6]->GetBounds().width());
+  EXPECT_EQ(hover_width, panels[7]->GetBounds().width());
+
+  // Move mouse to the origin of another overflow panel. Expect the overflow
+  // area remains expanded.
+  MoveMouse(panels[5]->GetBounds().origin());
+  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+
+  // Move mouse beyond the left edge of an overflow panel. Expect the overflow
+  // area remains expanded.
+  MoveMouse(gfx::Point(panels[5]->GetBounds().x() - 5,
+                       panels[5]->GetBounds().y()));
+  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+
+  // Move mouse to the origin of the top overflow-on-overflow panel. Expect the
+  // overflow area remains expanded.
+  MoveMouse(panels[7]->GetBounds().origin());
+  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+
+  // Move mouse to the bottom-right corner of the bottom overflow panel.
+  // Expect the overflow area remains expanded.
+  MoveMouse(gfx::Point(panels[3]->GetBounds().right(),
+                       panels[3]->GetBounds().bottom()));
+  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+
+  // Move mouse beyond the right edge of the hover panel. Expect the overflow
+  // area gets shrunk.
+  MoveMouseAndWaitForOverflowAnimationEnded(gfx::Point(
+      panels[4]->GetBounds().right() + 5, panels[4]->GetBounds().y()));
+  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, panels[3]->GetBounds().width());
+  EXPECT_EQ(iconified_width, panels[4]->GetBounds().width());
+  EXPECT_EQ(iconified_width, panels[5]->GetBounds().width());
+  EXPECT_EQ(0, panels[6]->GetBounds().width());
+  EXPECT_EQ(0, panels[7]->GetBounds().width());
+
+  // Move mouse beyond the left edge of an overflow panel. Expect the overflow
+  // area gets expanded.
+  MoveMouseAndWaitForOverflowAnimationEnded(gfx::Point(
+      panels[4]->GetBounds().x() - 5, panels[4]->GetBounds().y()));
+  EXPECT_EQ(hover_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(hover_width, panels[3]->GetBounds().width());
+  EXPECT_EQ(hover_width, panels[4]->GetBounds().width());
+  EXPECT_EQ(hover_width, panels[5]->GetBounds().width());
+  EXPECT_EQ(hover_width, panels[6]->GetBounds().width());
+  EXPECT_EQ(hover_width, panels[7]->GetBounds().width());
+
+  // Move mouse above the top overflow-on-overflow panel. Expect the overflow
+  // area gets shrunk.
+  MoveMouseAndWaitForOverflowAnimationEnded(gfx::Point(
+      panels[7]->GetBounds().x(), panels[7]->GetBounds().y() - 1));
+  EXPECT_EQ(iconified_width, panel_overflow_strip->current_display_width());
+  EXPECT_EQ(iconified_width, panels[3]->GetBounds().width());
+  EXPECT_EQ(iconified_width, panels[4]->GetBounds().width());
+  EXPECT_EQ(iconified_width, panels[5]->GetBounds().width());
+  EXPECT_EQ(0, panels[6]->GetBounds().width());
+  EXPECT_EQ(0, panels[7]->GetBounds().width());
+
+  panel_manager->RemoveAll();
+}