Add test cases for panel overflow handling.

chrome/browser/ui/panels/overflow_panel_browsertest.cc

Index: chrome/browser/ui/panels/overflow_panel_browsertest.cc
diff --git a/chrome/browser/ui/panels/overflow_panel_browsertest.cc b/chrome/browser/ui/panels/overflow_panel_browsertest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f68d51869766ac8c1704c9e872051184b84be61d
--- /dev/null
+++ b/chrome/browser/ui/panels/overflow_panel_browsertest.cc
@@ -0,0 +1,663 @@
+// 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 kMaxVisibleOverflow = 3;

[jennb, 2011/12/10 00:42:46]

nit: kMaxVisibleOverflowForTesting (so I don't go looking in
panel_overflow_strip.h when I see it in the code)

[jianli, 2011/12/13 23:23:40]

Done.

+
+// Encapsulates all the info we care about a panel when we do the testing.
+// We want to verify

[jennb, 2011/12/10 00:42:46]

unfinished sentence?

[jianli, 2011/12/13 23:23:40]

Done.

+struct PanelData {
+  Panel* panel;
+  std::string name;
+  Panel::ExpansionState expansion_state;

[jennb, 2011/12/10 00:42:46]

prefix the things that you're checking with expected_?

[jianli, 2011/12/13 23:23:40]

I rather prefix the struct variable with expected_. See below.

+  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()) {
+  }
+
+
+  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;
+  }
+
+ protected:
+  using std::deque<PanelData>::push_back;
+  using std::deque<PanelData>::push_front;
+
+  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;
+  }
+};
+
+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;
+  }
+
+  virtual PanelData remove(Panel* panel) OVERRIDE {
+    return BasePanelDataList::remove(panel);

[jennb, 2011/12/10 00:42:46]

Why override if only calling base class?

[jianli, 2011/12/13 23:23:40]

Removed.

+  }
+};
+
+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() <= kMaxVisibleOverflow;
+  }
+
+  void push_front(const PanelData& panel_data) {
+    BasePanelDataList::push_front(panel_data);
+    front().expansion_state = Panel::IN_OVERFLOW;
+    front().visible = true;
+    if (size() > kMaxVisibleOverflow)
+      (*this)[kMaxVisibleOverflow].visible = false;

[jennb, 2011/12/10 00:42:46]

Ah, so this is why you use deque, instead of std::list, which would have saved
you from reimplementing remove().

[jianli, 2011/12/13 23:23:40]

Yes, using list will save us from reimplmenting remove, but it will make us not
able to access the element at specific location directly.

+  }
+
+  virtual PanelData remove(Panel* panel) OVERRIDE {
+    PanelData panel_data = BasePanelDataList::remove(panel);
+    if (size() >= kMaxVisibleOverflow)
+      (*this)[kMaxVisibleOverflow - 1].visible = true;
+    return panel_data;
+  }
+};
+
+}  // namespace
+
+class OverflowPanelBrowserTest : public BasePanelBrowserTest {
+ public:
+  OverflowPanelBrowserTest() : BasePanelBrowserTest() {
+  }
+
+  virtual ~OverflowPanelBrowserTest() {
+  }
+
+  virtual void SetUpOnMainThread() OVERRIDE {
+    BasePanelBrowserTest::SetUpOnMainThread();
+
+    PanelManager::GetInstance()->panel_overflow_strip()->
+        set_max_visible_panels(kMaxVisibleOverflow);
+  }
+
+ 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();
+  }
+
+  void CreateOverflowPanels(int num_normal_panels,
+                            int num_overflow_panels,
+                            const int* panel_widthes) {

[jennb, 2011/12/10 00:42:46]

typo: widths

[jianli, 2011/12/13 23:23:40]

Done.

+    const int kTestPanelHeight = 200;
+
+    // First, create normal panels to fill the panel strip.
+    int i = 0;
+    for (i = 0; i < num_normal_panels; ++i) {

[jennb, 2011/12/10 00:42:46]

i already initialized to 0

[jianli, 2011/12/13 23:23:40]

Done.

+      CreatePanelParams params(
+          GetPanelName(i),
+          gfx::Rect(0, 0, panel_widthes[i], kTestPanelHeight),
+          SHOW_AS_INACTIVE);
+      CreatePanelWithParams(params);
+    }
+
+    // Then, create panels that would be placed in the overflow strip.
+    for (; i < num_normal_panels + num_overflow_panels; ++i) {

[jennb, 2011/12/10 00:42:46]

nit: sum once and use var in conditional

[jianli, 2011/12/13 23:23:40]

Done.

+      CreatePanelParams params(
+          GetPanelName(i),
+          gfx::Rect(0, 0, panel_widthes[i], kTestPanelHeight),
+          SHOW_AS_INACTIVE);
+      Panel* panel = CreatePanelWithParams(params);
+      WaitForExpansionStateChanged(panel, Panel::IN_OVERFLOW);
+    }
+  }
+};
+
+// TODO(jianli): remove the guard when overflow support is enabled on other

[jennb, 2011/12/10 00:42:46]

Or just #if this entire file for OS_WIN.

[jianli, 2011/12/13 23:23:40]

I would like to have this file compiled also for other platforms, not we do not
run the tests now.

+// platforms. http://crbug.com/105073
+#if defined(OS_WIN)
+#define MAYBE_CreateOverflowPanels CreateOverflowPanels
+#define MAYBE_CreateMoreOverflowPanels CreateMoreOverflowPanels
+#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(OverflowPanelBrowserTest, 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_widthes[] = {
+      250, 260, 200,  // normal
+      255, 220        // overflow
+  };
+  CreateOverflowPanels(3, 2, panel_widthes);
+
+  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(OverflowPanelBrowserTest,
+                       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_widthes[] = {
+      250, 260, 200,  // normal
+      255, 220, 210,  // overflow
+      220, 230        // overflow-on-overflow
+  };
+  CreateOverflowPanels(3, 5, panel_widthes);
+
+  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(OverflowPanelBrowserTest,

[jennb, 2011/12/10 00:42:46]

Log bug for this one and comment here?

[jianli, 2011/12/13 23:23:40]

Done. Comment added at the line "#define MAYBE_CreatePanelOnDelayedOverflow
FAILS_CreatePanelOnDelayedOverflow"

+                       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 them to be moved to overflow.

[jennb, 2011/12/10 00:42:46]

grammar: waiting them

[jianli, 2011/12/13 23:23:40]

Done.

+  CreatePanelParams params(
+      "Panel2", gfx::Rect(0, 0, 255, 200), SHOW_AS_INACTIVE);

[jennb, 2011/12/10 00:42:46]

Does it need to be SHOW_AS_INACTIVE for this test to pass? 

[jianli, 2011/12/13 23:23:40]

No. Change to SHOW_AS_ACTIVE.

+  Panel* panel2 = CreatePanelWithParams(params);
+  CreatePanelParams params2(
+      "Panel3", gfx::Rect(0, 0, 255, 200), SHOW_AS_INACTIVE);
+  Panel* panel3 = CreatePanelWithParams(params2);
+
+  // 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(OverflowPanelBrowserTest, 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_widthes[] = {
+      260, 250, 200,  // normal
+      255, 260, 120,  // overflow
+      240, 210        // overflow-on-overflow
+  };
+  CreateOverflowPanels(num_normal_panels, num_overflow_panels, panel_widthes);
+  NormalPanelDataList normal_panel_data_list = GetAllNormalPanelData();
+  ASSERT_EQ(3, normal_panel_data_list.size());
+  OverflowPanelDataList overflow_panel_data_list = GetAllOverflowPanelData();
+  ASSERT_EQ(5, overflow_panel_data_list.size());
+  Panel* panel3 = overflow_panel_data_list[1].panel;

[jennb, 2011/12/10 00:42:46]

isn't panel3 at index 0, and panel4 at index 1?

[jianli, 2011/12/13 23:23:40]

Done.

+  Panel* panel4 = overflow_panel_data_list[2].panel;
+  Panel* panel6 = overflow_panel_data_list[3].panel;
+  Panel* panel7 = overflow_panel_data_list[4].panel;
+
+  // 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(panel6->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());
+  overflow_panel_data_list.remove(panel6);
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());

[jennb, 2011/12/10 00:42:46]

It doesn't look like these actually check the current expansion_state of the
panels, rather it checks that the test code sets the same expansion state each
time it builds the list. Ditto for visible and active. It only checks that the
test code computed the correct visible/active values.

[jianli, 2011/12/13 23:23:40]

I added the check before we perform the 1st close action.

+  EXPECT_EQ(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(panel4->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());
+  overflow_panel_data_list.remove(panel4);
+  overflow_panel_data_list.get(panel7)->visible = true;
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(overflow_panel_data_list, GetAllOverflowPanelData());
+
+  // Close an overflow panel. Expect only that panel is closed.
+  CloseWindowAndWait(panel3->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());
+  overflow_panel_data_list.remove(panel3);
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(overflow_panel_data_list, GetAllOverflowPanelData());
+
+  panel_manager->RemoveAll();
+}
+
+IN_PROC_BROWSER_TEST_F(OverflowPanelBrowserTest, 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_widthes[] = {
+      260, 250, 200,  // normal
+      255, 260, 120,  // overflow
+      240, 210, 258   // overflow-on-overflow
+  };
+  CreateOverflowPanels(num_normal_panels, num_overflow_panels, panel_widthes);
+  NormalPanelDataList normal_panel_data_list = GetAllNormalPanelData();
+  ASSERT_EQ(3, normal_panel_data_list.size());
+  OverflowPanelDataList overflow_panel_data_list = GetAllOverflowPanelData();
+  ASSERT_EQ(6, overflow_panel_data_list.size());
+  Panel* panel0 = normal_panel_data_list[0].panel;
+  Panel* panel1 = normal_panel_data_list[1].panel;
+  Panel* panel2 = normal_panel_data_list[2].panel;
+  Panel* panel3 = overflow_panel_data_list[0].panel;
+  Panel* panel4 = overflow_panel_data_list[1].panel;
+  Panel* panel5 = overflow_panel_data_list[2].panel;
+  Panel* panel6 = overflow_panel_data_list[3].panel;
+  Panel* panel7 = overflow_panel_data_list[4].panel;
+  Panel* panel8 = overflow_panel_data_list[5].panel;
+
+  // 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(panel1->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());
+  normal_panel_data_list.remove(panel1);
+  normal_panel_data_list.push_back(overflow_panel_data_list.remove(panel3));
+  overflow_panel_data_list.get(panel6)->visible = true;
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(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(panel2->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());
+  normal_panel_data_list.remove(panel2);
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(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(panel3->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());
+  normal_panel_data_list.remove(panel3);
+  normal_panel_data_list.push_back(overflow_panel_data_list.remove(panel4));
+  normal_panel_data_list.push_back(overflow_panel_data_list.remove(panel5));
+  overflow_panel_data_list.get(panel7)->visible = true;
+  overflow_panel_data_list.get(panel8)->visible = true;
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(overflow_panel_data_list, GetAllOverflowPanelData());
+
+  // Close another normal panel. Expect one overflow panel to move over.
+  //   normal:               P4, P5, P6
+  //   overflow:             P7, P8
+  CloseWindowAndWait(panel0->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());
+  normal_panel_data_list.remove(panel0);
+  normal_panel_data_list.push_back(overflow_panel_data_list.remove(panel6));
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(overflow_panel_data_list, GetAllOverflowPanelData());
+
+  panel_manager->RemoveAll();
+}
+
+IN_PROC_BROWSER_TEST_F(OverflowPanelBrowserTest, 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_widthes[] = {
+      250, 260, 200,  // normal
+      210, 260, 230,  // overflow
+      255, 210        // overflow-on-overflow
+  };
+  int num_normal_panels = 3;
+  int num_overflow_panels = 5;
+  CreateOverflowPanels(num_normal_panels, num_overflow_panels, panel_widthes);
+  NormalPanelDataList normal_panel_data_list = GetAllNormalPanelData();
+  ASSERT_EQ(3, normal_panel_data_list.size());
+  OverflowPanelDataList overflow_panel_data_list = GetAllOverflowPanelData();
+  ASSERT_EQ(5, overflow_panel_data_list.size());
+  Panel* panel1 = normal_panel_data_list[1].panel;
+  Panel* panel2 = normal_panel_data_list[2].panel;
+  Panel* panel3 = overflow_panel_data_list[0].panel;
+  Panel* panel4 = overflow_panel_data_list[1].panel;
+  Panel* panel5 = overflow_panel_data_list[2].panel;
+  Panel* panel6 = overflow_panel_data_list[3].panel;
+  Panel* panel7 = overflow_panel_data_list[4].panel;
+
+  // 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
+  panel3->Activate();
+  WaitForPanelActiveState(panel3, SHOW_AS_ACTIVE);

[jennb, 2011/12/10 00:42:46]

Should be waiting for expansion state change to IN_OVERFLOW/EXPANDED for various
panels throughout this test.

[jianli, 2011/12/13 23:23:40]

Done.

+  overflow_panel_data_list.push_front(normal_panel_data_list.remove(panel2));
+  normal_panel_data_list.push_back(overflow_panel_data_list.remove(panel3));
+  normal_panel_data_list.get(panel3)->active = true;
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(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
+  panel4->Activate();
+  WaitForPanelActiveState(panel4, SHOW_AS_ACTIVE);
+  WaitForPanelActiveState(panel3, SHOW_AS_INACTIVE);
+  overflow_panel_data_list.push_front(normal_panel_data_list.remove(panel3));
+  overflow_panel_data_list.push_front(normal_panel_data_list.remove(panel1));
+  normal_panel_data_list.push_back(overflow_panel_data_list.remove(panel4));
+  normal_panel_data_list.get(panel4)->active = true;
+  overflow_panel_data_list.get(panel3)->active = false;
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(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
+  panel6->Activate();
+  WaitForPanelActiveState(panel6, SHOW_AS_ACTIVE);
+  WaitForPanelActiveState(panel4, SHOW_AS_INACTIVE);
+  overflow_panel_data_list.push_front(normal_panel_data_list.remove(panel4));
+  normal_panel_data_list.push_back(overflow_panel_data_list.remove(panel6));
+  normal_panel_data_list.get(panel6)->active = true;
+  overflow_panel_data_list.get(panel4)->active = false;
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(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
+  panel7->Activate();
+  WaitForPanelActiveState(panel7, SHOW_AS_ACTIVE);
+  WaitForPanelActiveState(panel6, SHOW_AS_INACTIVE);
+  normal_panel_data_list.push_back(overflow_panel_data_list.remove(panel7));
+  normal_panel_data_list.get(panel7)->active = true;
+  normal_panel_data_list.get(panel6)->active = false;
+  EXPECT_EQ(normal_panel_data_list, GetAllNormalPanelData());
+  EXPECT_EQ(overflow_panel_data_list, GetAllOverflowPanelData());
+
+  panel_manager->RemoveAll();
+}
+
+IN_PROC_BROWSER_TEST_F(OverflowPanelBrowserTest, 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 hover_width = PanelOverflowStrip::kOverflowAreaHoverWidth;
+
+  // Create normal and overflow panels.
+  //   normal:               P0, P1, P2
+  //   overflow:             P3, P4, P5
+  //   overflow-on-overflow: P6, P7
+  const int panel_widthes[] = {
+      250, 260, 200,  // normal
+      255, 220, 260,  // overflow
+      140, 210        // overflow-on-overflow
+  };
+  int num_normal_panels = 3;
+  int num_overflow_panels = 5;
+  CreateOverflowPanels(num_normal_panels, num_overflow_panels, panel_widthes);
+  OverflowPanelDataList overflow_panel_data_list = GetAllOverflowPanelData();
+  ASSERT_EQ(5, overflow_panel_data_list.size());
+  Panel* panel3 = overflow_panel_data_list[0].panel;
+  Panel* panel4 = overflow_panel_data_list[1].panel;
+  Panel* panel5 = overflow_panel_data_list[2].panel;
+  Panel* panel6 = overflow_panel_data_list[3].panel;
+  Panel* panel7 = overflow_panel_data_list[4].panel;
+  int iconified_width = panel4->GetBounds().width();
+  gfx::Rect iconified_bounds3 = overflow_panel_data_list[0].panel->GetBounds();
+  gfx::Rect iconified_bounds5 = overflow_panel_data_list[2].panel->GetBounds();
+
+  // Test that only the mouse point within the shrunk overflow area will
+  // expand the overflow area.
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(

[jennb, 2011/12/10 00:42:46]

Should be able to use MouseMove() in this test if you can get current width of
overflow strip.

[jianli, 2011/12/13 23:23:40]

Done.

+      iconified_bounds5.origin()));
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(iconified_bounds5.x() - 1, iconified_bounds5.y())));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(iconified_bounds5.right() + 1, iconified_bounds5.y())));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(iconified_bounds5.x(), iconified_bounds5.y() - 1)));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(iconified_bounds3.x(), iconified_bounds3.bottom() + 1)));
+
+  // Hover mouse on an overflow panel.
+  gfx::Point hover_point(panel4->GetBounds().origin());
+  MoveMouseAndWaitForOverflowAnimationEnded(hover_point);
+  EXPECT_EQ(hover_width, panel3->GetBounds().width());

[jennb, 2011/12/10 00:42:46]

Could iterate over all panels in overflow strip to ensure width is same as strip
width and that strip width is bigger than before MouseMove.

[jianli, 2011/12/13 23:23:40]

Done.

+  EXPECT_EQ(hover_width, panel4->GetBounds().width());
+  EXPECT_EQ(hover_width, panel5->GetBounds().width());
+  EXPECT_EQ(hover_width, panel6->GetBounds().width());
+  EXPECT_EQ(hover_width, panel7->GetBounds().width());
+
+  // Test that only the mouse outside the expanded overflow area will
+  // shrink the overflow area.
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      iconified_bounds5.origin()));
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(iconified_bounds5.x() - 1, iconified_bounds5.y())));
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(iconified_bounds5.x() + hover_width, iconified_bounds5.y())));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(iconified_bounds5.x() + hover_width + 1,

[jennb, 2011/12/10 00:42:46]

instead of iconified.x+hover_width, could you just do
panel5->GetBounds().right()?

[jianli, 2011/12/13 23:23:40]

Done.

+                 iconified_bounds5.y())));
+
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      panel7->GetBounds().origin()));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(panel7->GetBounds().x(), panel7->GetBounds().y() - 1)));
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(iconified_bounds3.x(), iconified_bounds3.bottom())));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(iconified_bounds3.x(), iconified_bounds3.bottom() + 1)));
+
+  // Move mouse away from the expanded overflow area.
+  hover_point.set_x(hover_point.x() + hover_width + 10);
+  MoveMouseAndWaitForOverflowAnimationEnded(hover_point);
+  EXPECT_EQ(iconified_width, panel3->GetBounds().width());
+  EXPECT_EQ(iconified_width, panel4->GetBounds().width());
+  EXPECT_EQ(iconified_width, panel5->GetBounds().width());
+  EXPECT_EQ(0, panel6->GetBounds().width());
+  EXPECT_EQ(0, panel7->GetBounds().width());
+
+  panel_manager->RemoveAll();
+}