Add test cases for panel overflow handling.

chrome/browser/ui/panels/panel_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 "base/bind.h"
-#include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/download/download_service.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/net/url_request_mock_util.h"
 #include "chrome/browser/notifications/balloon_collection_impl.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/prefs/browser_prefs.h"
@@ skipping 57 matching lines @@
 
   void MoveMouseAndWaitForExpansionStateChange(Panel* panel,
                                                const gfx::Point& position) {
     ui_test_utils::WindowedNotificationObserver signal(
         chrome::NOTIFICATION_PANEL_CHANGED_EXPANSION_STATE,
         content::Source<Panel>(panel));
     MoveMouse(position);
     signal.Wait();
   }
 
-  void TestCreatePanelOnOverflow() {
+  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();
+  }
+
+  void CreateOverflowPanels(int num_normal_panels,
+                            int num_overflow_panels,
+                            const int* panel_widthes) {
     PanelManager* panel_manager = PanelManager::GetInstance();
     PanelStrip* panel_strip = panel_manager->panel_strip();
     PanelOverflowStrip* panel_overflow_strip =
         panel_manager->panel_overflow_strip();
     EXPECT_EQ(0, panel_manager->num_panels()); // No panels initially.
 
-    // Create testing extensions.
-    DictionaryValue empty_value;
-    scoped_refptr<Extension> extension1 =
-        CreateExtension(FILE_PATH_LITERAL("extension1"),
-        Extension::INVALID, empty_value);
-    scoped_refptr<Extension> extension2 =
-        CreateExtension(FILE_PATH_LITERAL("extension2"),
-        Extension::INVALID, empty_value);
-    scoped_refptr<Extension> extension3 =
-        CreateExtension(FILE_PATH_LITERAL("extension3"),
-        Extension::INVALID, empty_value);
+    const int kTestPanelHeight = 200;
+    std::vector<Panel::ExpansionState> expected_expansion_states;
 
-    // First, create 3 panels.
-    Panel* panel1 = CreatePanelWithBounds(
-        web_app::GenerateApplicationNameFromExtensionId(extension1->id()),
-        gfx::Rect(0, 0, 250, 200));
-    Panel* panel2 = CreatePanelWithBounds(
-        web_app::GenerateApplicationNameFromExtensionId(extension2->id()),
-        gfx::Rect(0, 0, 300, 200));
-    Panel* panel3 = CreatePanelWithBounds(
-        web_app::GenerateApplicationNameFromExtensionId(extension1->id()),
-        gfx::Rect(0, 0, 200, 200));
-    ASSERT_EQ(3, panel_manager->num_panels());
-    EXPECT_EQ(3, panel_strip->num_panels());
-    EXPECT_EQ(0, panel_overflow_strip->num_panels());
+    // First, create normal panels to fill the panel strip.
+    int i = 0;
+    for (i = 0; i < num_normal_panels; ++i) {
+      CreatePanelParams params(
+          GetPanelName(i),
+          gfx::Rect(0, 0, panel_widthes[i], kTestPanelHeight),
+          SHOW_AS_INACTIVE);
+      Panel* panel = CreatePanelWithParams(params);
 
-    // Open a panel that would overflow.
-    CreatePanelParams params4(
-        web_app::GenerateApplicationNameFromExtensionId(extension2->id()),
-        gfx::Rect(0, 0, 280, 200),
-        SHOW_AS_INACTIVE);
-    Panel* panel4 = CreatePanelWithParams(params4);
-    WaitForExpansionStateChanged(panel4, Panel::IN_OVERFLOW);
-    ASSERT_EQ(4, panel_manager->num_panels());
-    EXPECT_EQ(3, panel_strip->num_panels());
-    EXPECT_EQ(1, panel_overflow_strip->num_panels());
+      EXPECT_EQ(i + 1, panel_manager->num_panels());
+      EXPECT_EQ(i + 1, panel_strip->num_panels());
+      EXPECT_EQ(0, panel_overflow_strip->num_panels());
+      expected_expansion_states.push_back(Panel::EXPANDED);
+      EXPECT_EQ(expected_expansion_states, GetAllPanelExpansionStates());
+    }
 
-    // Open another panel that would overflow.
-    CreatePanelParams params5(
-        web_app::GenerateApplicationNameFromExtensionId(extension3->id()),
-        gfx::Rect(0, 0, 300, 200),
-        SHOW_AS_INACTIVE);
-    Panel* panel5 = CreatePanelWithParams(params5);
-    WaitForExpansionStateChanged(panel5, Panel::IN_OVERFLOW);
-    ASSERT_EQ(5, panel_manager->num_panels());
-    EXPECT_EQ(3, panel_strip->num_panels());
-    EXPECT_EQ(2, panel_overflow_strip->num_panels());
-    EXPECT_EQ(Panel::IN_OVERFLOW, panel4->expansion_state());
+    // Then, create panels that would be placed in the overflow strip.
+    for (; i < num_normal_panels + num_overflow_panels; ++i) {
+      CreatePanelParams params(
+          GetPanelName(i),
+          gfx::Rect(0, 0, panel_widthes[i], kTestPanelHeight),
+          SHOW_AS_INACTIVE);
+      Panel* panel = CreatePanelWithParams(params);
+      WaitForExpansionStateChanged(panel, Panel::IN_OVERFLOW);
 
-    // Close a visible panel. Expect an overflow panel to move over.
-    CloseWindowAndWait(panel2->browser());
-    ASSERT_EQ(4, panel_manager->num_panels());
-    EXPECT_EQ(3, panel_strip->num_panels());
-    EXPECT_EQ(1, panel_overflow_strip->num_panels());
-    EXPECT_NE(Panel::IN_OVERFLOW, panel4->expansion_state());
-    EXPECT_EQ(Panel::IN_OVERFLOW, panel5->expansion_state());
-
-    // Close another visible panel. Remaining overflow panel cannot move over
-    // due to not enough room.
-    CloseWindowAndWait(panel3->browser());
-    ASSERT_EQ(3, panel_manager->num_panels());
-    EXPECT_EQ(2, panel_strip->num_panels());
-    EXPECT_EQ(1, panel_overflow_strip->num_panels());
-    EXPECT_EQ(Panel::IN_OVERFLOW, panel5->expansion_state());
-
-    // Closing one more panel makes room for all panels to fit on screen.
-    CloseWindowAndWait(panel4->browser());
-    ASSERT_EQ(2, panel_manager->num_panels());
-    EXPECT_EQ(2, panel_strip->num_panels());
-    EXPECT_EQ(0, panel_overflow_strip->num_panels());
-    EXPECT_NE(Panel::IN_OVERFLOW, panel5->expansion_state());
-
-    panel1->Close();
-    panel5->Close();
+      EXPECT_EQ(i + 1, panel_manager->num_panels());
+      EXPECT_EQ(num_normal_panels, panel_strip->num_panels());
+      EXPECT_EQ(i + 1 - num_normal_panels, panel_overflow_strip->num_panels());
+      expected_expansion_states.push_back(Panel::IN_OVERFLOW);
+      EXPECT_EQ(expected_expansion_states, GetAllPanelExpansionStates());
+    }
   }
 
   int horizontal_spacing() {
     return PanelManager::horizontal_spacing();
   }
 
   // Helper function for debugging.
   void PrintAllPanelBounds() {
     const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels();
     DLOG(WARNING) << "PanelBounds:";
@@ skipping 371 matching lines @@
   // FindBar needs tab contents.
   CreateTestTabContents(browser);
   browser->ShowFindBar();
   ASSERT_TRUE(browser->GetFindBarController()->find_bar()->IsFindBarVisible());
   panel->Close();
 }
 
 // TODO(jianli): remove the guard when overflow support is enabled on other
 // platforms. http://crbug.com/105073
 #if defined(OS_WIN)
-#define MAYBE_CreatePanelOnOverflow CreatePanelOnOverflow
+#define MAYBE_CreateOverflowPanels CreateOverflowPanels
+#define MAYBE_CloseOverflowPanels CloseOverflowPanels
+#define MAYBE_ActivateOverflowPanels ActivateOverflowPanels
+#define MAYBE_HoverOverOverflowPanels HoverOverOverflowPanels
 #else
-#define MAYBE_CreatePanelOnOverflow DISABLED_CreatePanelOnOverflow
+#define MAYBE_CreateOverflowPanels DISABLED_CreateOverflowPanels
+#define MAYBE_CloseOverflowPanels DISABLED_CloseOverflowPanels
+#define MAYBE_ActivateOverflowPanels DISABLED_ActivateOverflowPanels
+#define MAYBE_HoverOverOverflowPanels DISABLED_HoverOverOverflowPanels
 #endif
-IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_CreatePanelOnOverflow) {
-  TestCreatePanelOnOverflow();
+
+IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_CreateOverflowPanels) {
+  // Create normal and overflow panels.
+  const int panel_widthes[] = {
+      250, 260, 200,  // in panel strip.
+      255, 220        // in overflow strip.
+  };
+  CreateOverflowPanels(3, 2, panel_widthes);
+
+  PanelManager::GetInstance()->RemoveAll();
 }
 
+IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_CloseOverflowPanels) {
+  PanelManager* panel_manager = PanelManager::GetInstance();
+  PanelStrip* panel_strip = panel_manager->panel_strip();
+  PanelOverflowStrip* panel_overflow_strip =
+      panel_manager->panel_overflow_strip();
+
+  const int kMaxVisibleOverflow = 3;
+  panel_overflow_strip->set_max_visible_panels(kMaxVisibleOverflow);
+
+  // 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;  // including overflow-on-overflow panels.
+  const int panel_widthes[] = {
+      250, 260, 200,  // normal
+      255, 220, 260,  // overflow
+      140, 210, 258   // overflow-on-overflow
+  };
+  CreateOverflowPanels(num_normal_panels, num_overflow_panels, panel_widthes);
+  PanelDataList panel_data_list = GetAllPanelData();
+  Panel* panel0 = panel_data_list[0].panel;
+  Panel* panel1 = panel_data_list[1].panel;
+  Panel* panel2 = panel_data_list[2].panel;
+  Panel* panel3 = panel_data_list[3].panel;
+  Panel* panel4 = panel_data_list[4].panel;
+  Panel* panel5 = panel_data_list[5].panel;
+  Panel* panel6 = panel_data_list[6].panel;
+  Panel* panel7 = panel_data_list[7].panel;
+  Panel* panel8 = panel_data_list[8].panel;
+
+  // Close an overflow-on-overflow panel. Expect only that panel is closed.
+  //   normal:               P0, P1, P2
+  //   overflow:             P3, P4, P5,
+  //   overflow-on-overflow: P6, P8
+  CloseWindowAndWait(panel7->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());
+  panel_data_list.remove(panel7);
+  EXPECT_EQ(panel_data_list, GetAllPanelData());
+
+  // Close an overflow panel. Expect an overflow-on-overflow panel to become
+  // visible in the overflow strip.
+  //   normal:               P0, P1, P2
+  //   overflow:             P3, P5, P6
+  //   overflow-on-overflow: P8
+  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());
+  panel_data_list.remove(panel4);
+  panel_data_list.get(panel6)->visible = true;
+  EXPECT_EQ(panel_data_list, GetAllPanelData());
+
+  // 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:             P5, P6, 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());
+  panel_data_list.remove(panel1);
+  panel_data_list.get(panel3)->expansion_state = Panel::EXPANDED;
+  panel_data_list.get(panel8)->visible = true;
+  EXPECT_EQ(panel_data_list, GetAllPanelData());
+
+  // Close another normal panel. Remaining overflow panels cannot move over
+  // due to not enough room.
+  //   normal:               P0, P3
+  //   overflow:             P5, P6, 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());
+  panel_data_list.remove(panel2);
+  EXPECT_EQ(panel_data_list, GetAllPanelData());
+
+  // Closing one more normal panel makes room for two overflow panels.
+  //   normal:               P0, P5, P6
+  //   overflow:             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());
+  panel_data_list.remove(panel3);
+  panel_data_list.get(panel5)->expansion_state = Panel::EXPANDED;
+  panel_data_list.get(panel6)->expansion_state = Panel::EXPANDED;
+  EXPECT_EQ(panel_data_list, GetAllPanelData());
+
+  // Close another normal panel. The remaining overflow can also fit.
+  //   normal:               P5, P6, 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());
+  panel_data_list.remove(panel0);
+  panel_data_list.get(panel8)->expansion_state = Panel::EXPANDED;
+  EXPECT_EQ(panel_data_list, GetAllPanelData());
+
+  panel_manager->RemoveAll();
+}
+
+IN_PROC_BROWSER_TEST_F(PanelBrowserTest, 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;  // including overflow-on-overflow panels.
+  CreateOverflowPanels(num_normal_panels, num_overflow_panels, panel_widthes);
+  PanelDataList panel_data_list = GetAllPanelData();
+  Panel* panel1 = panel_data_list[1].panel;
+  Panel* panel2 = panel_data_list[2].panel;
+  Panel* panel3 = panel_data_list[3].panel;
+  Panel* panel4 = panel_data_list[4].panel;
+  Panel* panel5 = panel_data_list[5].panel;
+  Panel* panel6 = panel_data_list[6].panel;
+  Panel* panel7 = panel_data_list[7].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);
+  panel_data_list.get(panel3)->expansion_state = Panel::EXPANDED;
+  panel_data_list.get(panel3)->active = true;
+  panel_data_list.get(panel2)->expansion_state = Panel::IN_OVERFLOW;
+  PanelData temp_panel_data = panel_data_list.remove(panel3);
+  panel_data_list.insertBefore(panel2, temp_panel_data);
+  EXPECT_EQ(panel_data_list, GetAllPanelData());
+
+  // Activate an overflow panel. Expect two normal panels are swapped into the
+  // overflow strip and one more overflow-on-overflow panel.
+  //   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);
+  panel_data_list.get(panel4)->expansion_state = Panel::EXPANDED;
+  panel_data_list.get(panel4)->active = true;
+  panel_data_list.get(panel1)->expansion_state = Panel::IN_OVERFLOW;
+  panel_data_list.get(panel3)->expansion_state = Panel::IN_OVERFLOW;
+  panel_data_list.get(panel3)->active = false;
+  panel_data_list.get(panel5)->visible = false;
+  temp_panel_data = panel_data_list.remove(panel4);
+  panel_data_list.insertBefore(panel1, temp_panel_data);
+  EXPECT_EQ(panel_data_list, GetAllPanelData());
+
+  // 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);
+  panel_data_list.get(panel6)->expansion_state = Panel::EXPANDED;
+  panel_data_list.get(panel6)->visible = true;
+  panel_data_list.get(panel6)->active = true;
+  panel_data_list.get(panel4)->expansion_state = Panel::IN_OVERFLOW;
+  panel_data_list.get(panel4)->active = false;
+  panel_data_list.get(panel2)->visible = false;
+  temp_panel_data = panel_data_list.remove(panel6);
+  panel_data_list.insertBefore(panel4, temp_panel_data);
+  EXPECT_EQ(panel_data_list, GetAllPanelData());
+
+  // Activate an overflow-on-overflow panel. Not any normal panel is swapped
+  // since there is 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);
+  panel_data_list.get(panel7)->expansion_state = Panel::EXPANDED;
+  panel_data_list.get(panel7)->visible = true;
+  panel_data_list.get(panel7)->active = true;
+  panel_data_list.get(panel6)->active = false;
+  temp_panel_data = panel_data_list.remove(panel7);
+  panel_data_list.insertBefore(panel4, temp_panel_data);
+  EXPECT_EQ(panel_data_list, GetAllPanelData());
+
+  panel_manager->RemoveAll();
+}
+
+IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_HoverOverOverflowPanels) {
+  PanelManager* panel_manager = PanelManager::GetInstance();
+  PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
+  panel_manager->set_mouse_watcher(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;  // including overflow-on-overflow panels.
+  CreateOverflowPanels(num_normal_panels, num_overflow_panels, panel_widthes);
+  PanelDataList panel_data_list = GetAllPanelData();
+  Panel* panel4 = panel_data_list[4].panel;
+  int iconified_width = panel_data_list[4].panel->GetBounds().width();
+  gfx::Rect bounds3 = panel_data_list[3].panel->GetBounds();
+  gfx::Rect bounds5 = panel_data_list[5].panel->GetBounds();
+
+  // Test that only the mouse point within the shrunk overflow area will
+  // expand the overflow area.
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      bounds5.origin()));
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds5.x() - 1, bounds5.y())));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds5.right() + 1, bounds5.y())));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds5.x(), bounds5.y() - 1)));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds3.x(), bounds3.bottom() + 1)));
+
+  // Hover mouse on an overflow panel.
+  gfx::Point hover_point(panel_data_list[4].panel->GetBounds().origin());
+  MoveMouseAndWaitForOverflowAnimationEnded(hover_point);
+  EXPECT_EQ(hover_width, panel_data_list[3].panel->GetBounds().width());
+  EXPECT_EQ(hover_width, panel_data_list[4].panel->GetBounds().width());
+  EXPECT_EQ(hover_width, panel_data_list[5].panel->GetBounds().width());
+  EXPECT_EQ(hover_width, panel_data_list[6].panel->GetBounds().width());
+  EXPECT_EQ(hover_width, panel_data_list[7].panel->GetBounds().width());
+
+  // Test that only the mouse outside the expanded overflow area will
+  // shrink the overflow area.
+  gfx::Rect bounds7 = panel_data_list[7].panel->GetBounds();
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      bounds5.origin()));
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds5.x() - 1, bounds5.y())));
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds5.x() + hover_width, bounds5.y())));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds5.x() + hover_width + 1, bounds5.y())));
+
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds7.x(), bounds7.y())));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds7.x(), bounds7.y() - 1)));
+  EXPECT_TRUE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds3.x(), bounds3.bottom())));
+  EXPECT_FALSE(panel_overflow_strip->TestShouldShowOverflowTitles(
+      gfx::Point(bounds3.x(), 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, panel_data_list[3].panel->GetBounds().width());
+  EXPECT_EQ(iconified_width, panel_data_list[4].panel->GetBounds().width());
+  EXPECT_EQ(iconified_width, panel_data_list[5].panel->GetBounds().width());
+  EXPECT_EQ(0, panel_data_list[6].panel->GetBounds().width());
+  EXPECT_EQ(0, panel_data_list[7].panel->GetBounds().width());
+
+  panel_manager->RemoveAll();
+}
+
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, DragPanels) {
   static const int max_panels = 3;
   static const int zero_delta = 0;
   static const int small_delta = 10;
   static const int big_delta = 70;
   static const int bigger_delta = 120;
   static const int biggest_delta = 200;
   static const std::vector<int> zero_deltas(max_panels, zero_delta);
 
   std::vector<int> expected_delta_x_after_drag(max_panels, zero_delta);
@@ skipping 531 matching lines @@
 #else
 #define MAYBE_ActivateDeactivateMultiple DISABLED_ActivateDeactivateMultiple
 #endif
 
 IN_PROC_BROWSER_TEST_F(PanelBrowserTest, MAYBE_ActivateDeactivateMultiple) {
   BrowserWindow* tabbed_window = BrowserList::GetLastActive()->window();
 
   // Create 4 panels in the following screen layout:
   //    P3  P2  P1  P0
   const int kNumPanels = 4;
-  std::string panel_name_base("PanelTest");
-  for (int i = 0; i < kNumPanels; ++i) {
-    CreatePanelWithBounds(panel_name_base + base::IntToString(i),
-                          gfx::Rect(0, 0, 100, 100));
-  }
+  for (int i = 0; i < kNumPanels; ++i)
+    CreatePanelWithBounds(GetPanelName(i), gfx::Rect(0, 0, 100, 100));
   const std::vector<Panel*>& panels = PanelManager::GetInstance()->panels();
 
   std::vector<bool> expected_active_states;
   std::vector<bool> last_active_states;
 
   // The last created panel, P3, should be active.
   expected_active_states = ProduceExpectedActiveStates(3);
   EXPECT_EQ(expected_active_states, GetAllPanelActiveStates());
   EXPECT_FALSE(tabbed_window->IsActive());
 
@@ skipping 829 matching lines @@
   // position when tall panel brings up its titlebar.
   CloseWindowAndWait(panel1->browser());
   EXPECT_EQ(balloon_bottom_after_tall_panel_titlebar_up,
             GetBalloonBottomPosition(balloon));
 
   // Closing the remaining tall panel should move the notification balloon back
   // to its original position.
   CloseWindowAndWait(panel2->browser());
   EXPECT_EQ(original_balloon_bottom, GetBalloonBottomPosition(balloon));
 }