Add overflow indicator count on Windows.

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 <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 kMaxVisibleOverflowForTesting = 3;
+// We override the default value for testing purpose.
+const int kMaxVisibleOnShrunkForTesting = 3;

[jennb, 2011/12/19 22:24:50]

"OnShrunk" and "OnExpanded" aren't as self-explanatory. Suggest keep the
original name and then have kMaxVisibleOverflowOfOverflowForTesting. We've been
calling the feature overflow-of-overflow. Maybe you can come up with something
better. 

[jianli, 2011/12/20 01:20:41]

Done.

+const int kMaxVisibleOnExpandedForTesting = 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::ExpansionState expansion_state;
   bool visible;
   bool active;
 
   explicit PanelData(Panel* panel)
@@ skipping 46 matching lines @@
  public:
   PanelOverflowBrowserTest() : BasePanelBrowserTest() {
   }
 
   virtual ~PanelOverflowBrowserTest() {
   }
 
   virtual void SetUpOnMainThread() OVERRIDE {
     BasePanelBrowserTest::SetUpOnMainThread();
 
-    PanelManager::GetInstance()->panel_overflow_strip()->
-        set_max_visible_panels(kMaxVisibleOverflowForTesting);
+    PanelManager* panel_manager = PanelManager::GetInstance();
+    panel_manager->panel_overflow_strip()->
+        set_max_visible_panels_on_shrunk(kMaxVisibleOnShrunkForTesting);
+    panel_manager->panel_overflow_strip()->
+        set_max_visible_panels_on_expanded(kMaxVisibleOnExpandedForTesting);
+
+    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;
     PanelStrip::Panels panels =
         PanelManager::GetInstance()->panel_strip()->panels();
@@ skipping 68 matching lines @@
 // 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
+#define MAYBE_OverflowIndicatorCount OverflowIndicatorCount
+#define MAYBE_DrawOverflowAttention DrawOverflowAttention
 #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
+#define MAYBE_OverflowIndicatorCount DISABLED_OverflowIndicatorCount
+#define MAYBE_DrawOverflowAttention DISABLED_DrawOverflowAttention
 #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(5u, panels.size());
   EXPECT_EQ(3, panel_strip->num_panels());
   EXPECT_EQ(2, panel_overflow_strip->num_panels());
+  EXPECT_EQ(0, panel_overflow_strip->overflow_indicator()->GetCount());

[jennb, 2011/12/19 22:24:50]

Do you have test coverage to check that if this count is 0, no "element" is
included in the UI of the overflow strip?

[jianli, 2011/12/20 01:20:41]

Done.

   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(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_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]));
@@ skipping 364 matching lines @@
   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);
   EXPECT_EQ(expected_overflow_list, GetAllOverflowPanelData());
 
   PanelManager::GetInstance()->RemoveAll();
 }
 
 IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_HoverOverOverflowArea) {
   PanelManager* panel_manager = PanelManager::GetInstance();
-  PanelMouseWatcher* mouse_watcher = new TestPanelMouseWatcher();
-  panel_manager->SetMouseWatcherForTesting(mouse_watcher);
   PanelOverflowStrip* panel_overflow_strip =
       panel_manager->panel_overflow_strip();
   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
@@ skipping 82 matching lines @@
       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();
 }
+
+IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_OverflowIndicatorCount) {

[jennb, 2011/12/19 22:24:50]

Need case for moving a big overflow panel into normal panel strip so that it
bumps >1 panel into overflow. Test does not cover any panels moving between
strips that affects the indicator count.

[jianli, 2011/12/20 01:20:41]

Done.

+  PanelManager* panel_manager = PanelManager::GetInstance();
+  PanelOverflowStrip* panel_overflow_strip =
+      panel_manager->panel_overflow_strip();
+
+  // Create normal and overflow panels.
+  //   normal:               P0, P1, P2
+  //   overflow:             P3, P4, P5
+  const int panel_widths[] = {
+      240, 240, 240,  // normal
+      240, 240, 240   // overflow
+  };
+  std::vector<Panel*> panels = CreateOverflowPanels(3, 3, panel_widths);
+  EXPECT_EQ(3, panel_overflow_strip->num_panels());
+  PanelOverflowIndicator* overflow_indicator =
+      panel_overflow_strip->overflow_indicator();
+  EXPECT_EQ(0, overflow_indicator->GetCount());
+
+  // Create 5 overflow-on-overflow panels.
+  //   normal:               P0, P1, P2
+  //   overflow:             P3, P4, P5
+  //   overflow-on-overflow: P6, P7, P8
+  //                         P9, P10
+  for (int i = 1; i <= 5; ++i) {
+    CreatePanelParams params(
+        MakePanelName(5 + i),

[jennb, 2011/12/19 22:24:50]

Should replace this 5 with size of panels vector. That way this doesn't break if
line 744 changes. You can still do +i for the name, but you'd have to loop from
i = 0 while i < 5.

[jianli, 2011/12/20 01:20:41]

Done.

+        gfx::Rect(0, 0, 240, 200),
+        SHOW_AS_INACTIVE);
+    Panel* panel = CreatePanelWithParams(params);
+    WaitForExpansionStateChanged(panel, Panel::IN_OVERFLOW);
+    EXPECT_EQ(i, overflow_indicator->GetCount());
+    panels.push_back(panel);
+  }
+
+  // Expand the overflow area by moving mouse over it.
+  // Expect the overflow indicator count gets updated.
+  MoveMouseAndWaitForOverflowAnimationEnded(panels[3]->GetBounds().origin());
+  EXPECT_EQ(2, overflow_indicator->GetCount());
+
+  // Close an overflow panel.
+  // Expect the overflow indicator count gets updated.
+  CloseWindowAndWait(panels[3]->browser());
+  EXPECT_EQ(1, overflow_indicator->GetCount());

[jennb, 2011/12/19 22:24:50]

Check that one of the overflow-on-overflow panels is now visible.

[jianli, 2011/12/20 01:20:41]

Done.

+
+  // Shrunk the overflow area by moving mouse over it.

[jennb, 2011/12/19 22:24:50]

Stop hovering the mouse over the overflow area.

[jianli, 2011/12/20 01:20:41]

Done.

+  // Expect the overflow indicator count gets updated.
+  MoveMouseAndWaitForOverflowAnimationEnded(
+    gfx::Point(panels[4]->GetBounds().right() + 5, panels[4]->GetBounds().y()));
+  EXPECT_EQ(4, overflow_indicator->GetCount());

[jennb, 2011/12/19 22:24:50]

Verify overflow-of-overflow panels no longer visible.

[jianli, 2011/12/20 01:20:41]

Done.

+
+  // Close an overflow panel.
+  // Expect the overflow indicator count gets updated.
+  CloseWindowAndWait(panels[4]->browser());
+  EXPECT_EQ(3, overflow_indicator->GetCount());
+
+  panel_manager->RemoveAll();
+}
+
+IN_PROC_BROWSER_TEST_F(PanelOverflowBrowserTest, MAYBE_DrawOverflowAttention) {
+  PanelManager* panel_manager = PanelManager::GetInstance();
+  panel_manager->enable_auto_sizing(true);

[jennb, 2011/12/19 22:24:50]

This surprised me in a draw attention test. I actually thought it was a
cut-and-paste error. Maybe you can bump a panel to overflow using other means,
like moving a large overflow panel into the panel strip?

[jianli, 2011/12/20 01:20:41]

Done.

+  PanelStrip* panel_strip = panel_manager->panel_strip();
+  PanelOverflowStrip* overflow_strip = panel_manager->panel_overflow_strip();
+
+  // Create normal and overflow panels.
+  //   normal:               P0, P1, P2, P3
+  //   overflow:             P4, P5, P6
+  //   overflow-on-overflow: P7, P8, P9, (P10, P11)
+  const int panel_widths[] = {
+      100, 210, 210, 210,  // normal
+      210, 210, 210,       // overflow
+      210, 210, 210,       // overflow-on-overflow on shrunk
+      210, 210             // overflow-on-overflow on expanded
+  };
+  std::vector<Panel*> panels = CreateOverflowPanels(4, 8, panel_widths);
+  EXPECT_EQ(4, panel_strip->num_panels());
+  EXPECT_EQ(8, overflow_strip->num_panels());
+  PanelOverflowIndicator* overflow_indicator =
+      overflow_strip->overflow_indicator();
+
+  // Draw attention for an overflow panel.
+  // Expect no impact to the overflow indicator.
+  //   normal:               P0, P1, P2, P3
+  //   overflow:             P4, *P5, P6
+  //   overflow-on-overflow: P7, P8, P9, (P10, P11)
+  EXPECT_FALSE(panels[5]->IsDrawingAttention());
+  panels[5]->FlashFrame();
+  EXPECT_TRUE(panels[5]->IsDrawingAttention());
+  EXPECT_FALSE(overflow_indicator->IsDrawingAttention());
+
+  // Activating this overflow panel will clear its attention.
+  // Expect no impact to the overflow indicator.
+  //   normal:               P0, P1, P2, P5
+  //   overflow:             P3, P4, P6
+  //   overflow-on-overflow: P7, P8, P9, (P10, P11)
+  panels[5]->Activate();
+  WaitForPanelActiveState(panels[5], SHOW_AS_ACTIVE);
+  EXPECT_FALSE(panels[5]->IsDrawingAttention());
+  EXPECT_FALSE(overflow_indicator->IsDrawingAttention());
+
+  // Draw attention for an overflow-on-overflow panel.
+  // Expect the overflow indicator is showing attention.
+  //   normal:               P0, P1, P2, P5
+  //   overflow:             P3, P4, P6
+  //   overflow-on-overflow: P7, *P8, P9, (P10, P11)
+  EXPECT_FALSE(panels[8]->IsDrawingAttention());
+  panels[8]->FlashFrame();
+  EXPECT_TRUE(panels[8]->IsDrawingAttention());
+  EXPECT_TRUE(overflow_indicator->IsDrawingAttention());
+
+  // Draw attention for anther overflow-on-overflow panel.
+  // Expect the overflow indicator is still showing attention.
+  //   normal:               P0, P1, P2, P5
+  //   overflow:             P3, P4, P6
+  //   overflow-on-overflow: P7, *P8, P9, (*P10, P11)
+  EXPECT_FALSE(panels[10]->IsDrawingAttention());
+  panels[10]->FlashFrame();
+  EXPECT_TRUE(panels[10]->IsDrawingAttention());
+  EXPECT_TRUE(overflow_indicator->IsDrawingAttention());
+
+  // Stop drawing attention for an overflow-on-overflow panel by activating it.
+  // Expect the overflow indicator is still showing attention.
+  //   normal:               P0, P1, P2, P8
+  //   overflow:             P5, P3, P4
+  //   overflow-on-overflow: P6, P7, P9, (*P10, P11)
+  panels[8]->Activate();
+  WaitForPanelActiveState(panels[8], SHOW_AS_ACTIVE);
+  EXPECT_FALSE(panels[8]->IsDrawingAttention());
+  EXPECT_TRUE(overflow_indicator->IsDrawingAttention());
+
+  // Stop drawing attention for anther overflow-on-overflow panel by activating

[jennb, 2011/12/19 22:24:50]

anther

[jianli, 2011/12/20 01:20:41]

Done.

+  // it. Expect the overflow indicator is not showing attention.
+  //   normal:               P0, P1, P2, P10
+  //   overflow:             P8, P5, P3
+  //   overflow-on-overflow: P4, P6, P7, (P9, P11)
+  panels[10]->Activate();
+  WaitForPanelActiveState(panels[10], SHOW_AS_ACTIVE);
+  EXPECT_FALSE(panels[10]->IsDrawingAttention());
+  EXPECT_FALSE(overflow_indicator->IsDrawingAttention());
+
+  // Draw attention for the top overflow panel.
+  // Expect no impact to the overflow indicator.
+  //   normal:               P0, P1, P2, P10
+  //   overflow:             P8, P5, *P3
+  //   overflow-on-overflow: P4, P6, P7, (P9, P11)
+  EXPECT_FALSE(panels[3]->IsDrawingAttention());
+  panels[3]->FlashFrame();
+  EXPECT_TRUE(panels[3]->IsDrawingAttention());
+  EXPECT_FALSE(overflow_indicator->IsDrawingAttention());
+
+  // Enlarge a normal panel that would bump one normal panel to the overflow
+  // area and the top overflow panel gets moved to overflow-on-overflow.
+  // Expect the overflow indicator is showing attention.
+  //   normal:               P0, P1, P2
+  //   overflow:             P10, P8, P5
+  //   overflow-on-overflow: *P3, P4, P6, (P7, P9, P11)
+  panel_manager->OnPreferredWindowSizeChanged(panels[0], gfx::Size(260, 200));
+  EXPECT_EQ(3, panel_strip->num_panels());
+  EXPECT_EQ(9, overflow_strip->num_panels());
+  EXPECT_TRUE(panels[3]->IsDrawingAttention());
+  EXPECT_TRUE(overflow_indicator->IsDrawingAttention());
+
+  // Close an overflow panel that would move the first oveflow-on-overflow panel
+  // to become visible. Expect the overflow indicator is not showing attention.
+  //   normal:               P0, P1, P2
+  //   overflow:             P10, P5, P3
+  //   overflow-on-overflow: 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();
+}