chrome/browser/ui/views/tabs/tab_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/views/tabs/tab.h"
   6 #include "chrome/browser/ui/views/tabs/tab_controller.h"
   7
   8 #include "base/strings/utf_string_conversions.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10 #include "ui/base/models/list_selection_model.h"
  11 #include "ui/views/controls/button/image_button.h"
  12 #include "ui/views/test/views_test_base.h"
  13 #include "ui/views/widget/widget.h"
  14
  15 using views::Widget;
  16
  17 class FakeTabController : public TabController {
  18  public:
  19   FakeTabController() : immersive_style_(false), active_tab_(false) {
  20   }
  21   virtual ~FakeTabController() {}
  22
  23   void set_immersive_style(bool value) { immersive_style_ = value; }
  24   void set_active_tab(bool value) { active_tab_ = value; }
  25
  26   virtual const ui::ListSelectionModel& GetSelectionModel() OVERRIDE {
  27     return selection_model_;
  28   }
  29   virtual bool SupportsMultipleSelection() OVERRIDE { return false; }
  30   virtual void SelectTab(Tab* tab) OVERRIDE {}
  31   virtual void ExtendSelectionTo(Tab* tab) OVERRIDE {}
  32   virtual void ToggleSelected(Tab* tab) OVERRIDE {}
  33   virtual void AddSelectionFromAnchorTo(Tab* tab) OVERRIDE {}
  34   virtual void CloseTab(Tab* tab, CloseTabSource source) OVERRIDE {}
  35   virtual void ShowContextMenuForTab(Tab* tab,
  36                                      const gfx::Point& p,
  37                                      ui::MenuSourceType source_type) OVERRIDE {}
  38   virtual bool IsActiveTab(const Tab* tab) const OVERRIDE {
  39     return active_tab_;
  40   }
  41   virtual bool IsTabSelected(const Tab* tab) const OVERRIDE {
  42     return false;
  43   }
  44   virtual bool IsTabPinned(const Tab* tab) const OVERRIDE { return false; }
  45   virtual void MaybeStartDrag(
  46       Tab* tab,
  47       const ui::LocatedEvent& event,
  48       const ui::ListSelectionModel& original_selection) OVERRIDE {}
  49   virtual void ContinueDrag(views::View* view,
  50                             const ui::LocatedEvent& event) OVERRIDE {}
  51   virtual bool EndDrag(EndDragReason reason) OVERRIDE { return false; }
  52   virtual Tab* GetTabAt(Tab* tab,
  53                         const gfx::Point& tab_in_tab_coordinates) OVERRIDE {
  54     return NULL;
  55   }
  56   virtual void OnMouseEventInTab(views::View* source,
  57                                  const ui::MouseEvent& event) OVERRIDE {}
  58   virtual bool ShouldPaintTab(const Tab* tab, gfx::Rect* clip) OVERRIDE {
  59     return true;
  60   }
  61   virtual bool IsImmersiveStyle() const OVERRIDE { return immersive_style_; }
  62
  63  private:
  64   ui::ListSelectionModel selection_model_;
  65   bool immersive_style_;
  66   bool active_tab_;
  67
  68   DISALLOW_COPY_AND_ASSIGN(FakeTabController);
  69 };
  70
  71 class TabTest : public views::ViewsTestBase {
  72  public:
  73   TabTest() {}
  74   virtual ~TabTest() {}
  75
  76   static void DisableMediaIndicatorAnimation(Tab* tab) {
  77     tab->media_indicator_animation_.reset();
  78     tab->animating_media_state_ = tab->data_.media_state;
  79   }
  80
  81   static void CheckForExpectedLayoutAndVisibilityOfElements(const Tab& tab) {
  82     // Check whether elements are visible when they are supposed to be, given
  83     // Tab size and TabRendererData state.
  84     if (tab.data_.mini) {
  85       EXPECT_EQ(1, tab.IconCapacity());
  86       if (tab.data_.media_state != TAB_MEDIA_STATE_NONE) {
  87         EXPECT_FALSE(tab.ShouldShowIcon());
  88         EXPECT_TRUE(tab.ShouldShowMediaIndicator());
  89       } else {
  90         EXPECT_TRUE(tab.ShouldShowIcon());
  91         EXPECT_FALSE(tab.ShouldShowMediaIndicator());
  92       }
  93       EXPECT_FALSE(tab.ShouldShowCloseBox());
  94     } else if (tab.IsActive()) {
  95       EXPECT_TRUE(tab.ShouldShowCloseBox());
  96       switch (tab.IconCapacity()) {
  97         case 0:
  98         case 1:
  99           EXPECT_FALSE(tab.ShouldShowIcon());
 100           EXPECT_FALSE(tab.ShouldShowMediaIndicator());
 101           break;
 102         case 2:
 103           if (tab.data_.media_state != TAB_MEDIA_STATE_NONE) {
 104             EXPECT_FALSE(tab.ShouldShowIcon());
 105             EXPECT_TRUE(tab.ShouldShowMediaIndicator());
 106           } else {
 107             EXPECT_TRUE(tab.ShouldShowIcon());
 108             EXPECT_FALSE(tab.ShouldShowMediaIndicator());
 109           }
 110           break;
 111         default:
 112           EXPECT_LE(3, tab.IconCapacity());
 113           EXPECT_TRUE(tab.ShouldShowIcon());
 114           if (tab.data_.media_state != TAB_MEDIA_STATE_NONE)
 115             EXPECT_TRUE(tab.ShouldShowMediaIndicator());
 116           else
 117             EXPECT_FALSE(tab.ShouldShowMediaIndicator());
 118           break;
 119       }
 120     } else {  // Tab not active and not mini tab.
 121       switch (tab.IconCapacity()) {
 122         case 0:
 123           EXPECT_FALSE(tab.ShouldShowCloseBox());
 124           EXPECT_FALSE(tab.ShouldShowIcon());
 125           EXPECT_FALSE(tab.ShouldShowMediaIndicator());
 126           break;
 127         case 1:
 128           EXPECT_FALSE(tab.ShouldShowCloseBox());
 129           if (tab.data_.media_state != TAB_MEDIA_STATE_NONE) {
 130             EXPECT_FALSE(tab.ShouldShowIcon());
 131             EXPECT_TRUE(tab.ShouldShowMediaIndicator());
 132           } else {
 133             EXPECT_TRUE(tab.ShouldShowIcon());
 134             EXPECT_FALSE(tab.ShouldShowMediaIndicator());
 135           }
 136           break;
 137         default:
 138           EXPECT_LE(2, tab.IconCapacity());
 139           EXPECT_TRUE(tab.ShouldShowIcon());
 140           if (tab.data_.media_state != TAB_MEDIA_STATE_NONE)
 141             EXPECT_TRUE(tab.ShouldShowMediaIndicator());
 142           else
 143             EXPECT_FALSE(tab.ShouldShowMediaIndicator());
 144           break;
 145       }
 146     }
 147
 148     // Check positioning of elements with respect to each other, and that they
 149     // are fully within the contents bounds.
 150     const gfx::Rect contents_bounds = tab.GetContentsBounds();
 151     if (tab.ShouldShowIcon()) {
 152       EXPECT_LE(contents_bounds.x(), tab.favicon_bounds_.x());
 153       if (tab.title_bounds_.width() > 0)
 154         EXPECT_LE(tab.favicon_bounds_.right(), tab.title_bounds_.x());
 155       EXPECT_LE(contents_bounds.y(), tab.favicon_bounds_.y());
 156       EXPECT_LE(tab.favicon_bounds_.bottom(), contents_bounds.bottom());
 157     }
 158     if (tab.ShouldShowIcon() && tab.ShouldShowMediaIndicator())
 159       EXPECT_LE(tab.favicon_bounds_.right(), tab.media_indicator_bounds_.x());
 160     if (tab.ShouldShowMediaIndicator()) {
 161       if (tab.title_bounds_.width() > 0)
 162         EXPECT_LE(tab.title_bounds_.right(), tab.media_indicator_bounds_.x());
 163       EXPECT_LE(tab.media_indicator_bounds_.right(), contents_bounds.right());
 164       EXPECT_LE(contents_bounds.y(), tab.media_indicator_bounds_.y());
 165       EXPECT_LE(tab.media_indicator_bounds_.bottom(), contents_bounds.bottom());
 166     }
 167     if (tab.ShouldShowMediaIndicator() && tab.ShouldShowCloseBox()) {
 168       // Note: The media indicator can overlap the left-insets of the close box,
 169       // but should otherwise be to the left of the close button.
 170       EXPECT_LE(tab.media_indicator_bounds_.right(),
 171                 tab.close_button_->bounds().x() +
 172                     tab.close_button_->GetInsets().left());
 173     }
 174     if (tab.ShouldShowCloseBox()) {
 175       // Note: The title bounds can overlap the left-insets of the close box,
 176       // but should otherwise be to the left of the close button.
 177       if (tab.title_bounds_.width() > 0) {
 178         EXPECT_LE(tab.title_bounds_.right(),
 179                   tab.close_button_->bounds().x() +
 180                       tab.close_button_->GetInsets().left());
 181       }
 182       EXPECT_LE(tab.close_button_->bounds().right(), contents_bounds.right());
 183       EXPECT_LE(contents_bounds.y(), tab.close_button_->bounds().y());
 184       EXPECT_LE(tab.close_button_->bounds().bottom(), contents_bounds.bottom());
 185     }
 186   }
 187 };
 188
 189 TEST_F(TabTest, HitTestTopPixel) {
 190   Widget widget;
 191   Widget::InitParams params(CreateParams(Widget::InitParams::TYPE_WINDOW));
 192   params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
 193   params.bounds.SetRect(10, 20, 300, 400);
 194   widget.Init(params);
 195
 196   FakeTabController tab_controller;
 197   Tab tab(&tab_controller);
 198   widget.GetContentsView()->AddChildView(&tab);
 199   tab.SetBoundsRect(gfx::Rect(gfx::Point(0, 0), Tab::GetStandardSize()));
 200
 201   // Tabs have some shadow in the top, so by default we don't hit the tab there.
 202   int middle_x = tab.width() / 2;
 203   EXPECT_FALSE(tab.HitTestPoint(gfx::Point(middle_x, 0)));
 204
 205   // Tabs are slanted, so a click halfway down the left edge won't hit it.
 206   int middle_y = tab.height() / 2;
 207   EXPECT_FALSE(tab.HitTestPoint(gfx::Point(0, middle_y)));
 208
 209   // If the window is maximized, however, we want clicks in the top edge to
 210   // select the tab.
 211   widget.Maximize();
 212   EXPECT_TRUE(tab.HitTestPoint(gfx::Point(middle_x, 0)));
 213
 214   // But clicks in the area above the slanted sides should still miss.
 215   EXPECT_FALSE(tab.HitTestPoint(gfx::Point(0, 0)));
 216   EXPECT_FALSE(tab.HitTestPoint(gfx::Point(tab.width() - 1, 0)));
 217 }
 218
 219 TEST_F(TabTest, LayoutAndVisibilityOfElements) {
 220   static const TabMediaState kMediaStatesToTest[] = {
 221     TAB_MEDIA_STATE_NONE, TAB_MEDIA_STATE_CAPTURING,
 222     TAB_MEDIA_STATE_AUDIO_PLAYING
 223   };
 224
 225   FakeTabController controller;
 226   Tab tab(&controller);
 227
 228   SkBitmap bitmap;
 229   bitmap.setConfig(SkBitmap::kARGB_8888_Config, 16, 16);
 230   bitmap.allocPixels();
 231   TabRendererData data;
 232   data.favicon = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
 233
 234   // Perform layout over all possible combinations, checking for correct
 235   // results.
 236   for (int is_mini_tab = 0; is_mini_tab < 2; ++is_mini_tab) {
 237     for (int is_active_tab = 0; is_active_tab < 2; ++is_active_tab) {
 238       for (size_t media_state_index = 0;
 239            media_state_index < arraysize(kMediaStatesToTest);
 240            ++media_state_index) {
 241         const TabMediaState media_state = kMediaStatesToTest[media_state_index];
 242         SCOPED_TRACE(::testing::Message()
 243                      << (is_active_tab ? "Active" : "Inactive") << ' '
 244                      << (is_mini_tab ? "Mini " : "")
 245                      << "Tab with media indicator state " << media_state);
 246
 247         data.mini = !!is_mini_tab;
 248         controller.set_active_tab(!!is_active_tab);
 249         data.media_state = media_state;
 250         tab.SetData(data);
 251
 252         // Disable the media indicator animation so that the layout/visibility
 253         // logic can be tested effectively.  If the animation was left enabled,
 254         // the ShouldShowMediaIndicator() method would return true during
 255         // fade-out transitions.
 256         DisableMediaIndicatorAnimation(&tab);
 257
 258         // Test layout for every width from standard to minimum.
 259         gfx::Rect bounds(gfx::Point(0, 0), Tab::GetStandardSize());
 260         int min_width;
 261         if (is_mini_tab) {
 262           bounds.set_width(Tab::GetMiniWidth());
 263           min_width = Tab::GetMiniWidth();
 264         } else {
 265           min_width = is_active_tab ? Tab::GetMinimumSelectedSize().width() :
 266               Tab::GetMinimumUnselectedSize().width();
 267         }
 268         while (bounds.width() >= min_width) {
 269           SCOPED_TRACE(::testing::Message() << "bounds=" << bounds.ToString());
 270           tab.SetBoundsRect(bounds);  // Invokes Tab::Layout().
 271           CheckForExpectedLayoutAndVisibilityOfElements(tab);
 272           bounds.set_width(bounds.width() - 1);
 273         }
 274       }
 275     }
 276   }
 277 }
 278
 279 // Regression test for http://crbug.com/226253. Calling Layout() more than once
 280 // shouldn't change the insets of the close button.
 281 TEST_F(TabTest, CloseButtonLayout) {
 282   FakeTabController tab_controller;
 283   Tab tab(&tab_controller);
 284   tab.SetBounds(0, 0, 100, 50);
 285   tab.Layout();
 286   gfx::Insets close_button_insets = tab.close_button_->GetInsets();
 287   tab.Layout();
 288   gfx::Insets close_button_insets_2 = tab.close_button_->GetInsets();
 289   EXPECT_EQ(close_button_insets.top(), close_button_insets_2.top());
 290   EXPECT_EQ(close_button_insets.left(), close_button_insets_2.left());
 291   EXPECT_EQ(close_button_insets.bottom(), close_button_insets_2.bottom());
 292   EXPECT_EQ(close_button_insets.right(), close_button_insets_2.right());
 293
 294   // Also make sure the close button is sized as large as the tab.
 295   EXPECT_EQ(50, tab.close_button_->bounds().height());
 296 }