UI: Rename MediaState to AlertState

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

 // Copyright (c) 2012 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 "chrome/browser/ui/views/tabs/tab.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/ui/layout_constants.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
-#include "chrome/browser/ui/views/tabs/media_indicator_button.h"
+#include "chrome/browser/ui/views/tabs/alert_indicator_button.h"
 #include "chrome/browser/ui/views/tabs/tab_controller.h"
 #include "grit/theme_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/test/views_test_base.h"
 #include "ui/views/widget/widget.h"
 
 using views::Widget;
@@ skipping 85 matching lines @@
     return tab.title_->bounds().width();
   }
 
   static void LayoutTab(Tab* tab) { tab->Layout(); }
 
   static void CheckForExpectedLayoutAndVisibilityOfElements(const Tab& tab) {
     // Check whether elements are visible when they are supposed to be, given
     // Tab size and TabRendererData state.
     if (tab.data_.pinned) {
       EXPECT_EQ(1, tab.IconCapacity());
-      if (tab.data_.media_state != TAB_MEDIA_STATE_NONE) {
+      if (tab.data_.alert_state != TabAlertState::NONE) {
         EXPECT_FALSE(tab.ShouldShowIcon());
-        EXPECT_TRUE(tab.ShouldShowMediaIndicator());
+        EXPECT_TRUE(tab.ShouldShowAlertIndicator());
       } else {
         EXPECT_TRUE(tab.ShouldShowIcon());
-        EXPECT_FALSE(tab.ShouldShowMediaIndicator());
+        EXPECT_FALSE(tab.ShouldShowAlertIndicator());
       }
       EXPECT_FALSE(tab.ShouldShowCloseBox());
     } else if (tab.IsActive()) {
       EXPECT_TRUE(tab.ShouldShowCloseBox());
       switch (tab.IconCapacity()) {
         case 0:
         case 1:
           EXPECT_FALSE(tab.ShouldShowIcon());
-          EXPECT_FALSE(tab.ShouldShowMediaIndicator());
+          EXPECT_FALSE(tab.ShouldShowAlertIndicator());
           break;
         case 2:
-          if (tab.data_.media_state != TAB_MEDIA_STATE_NONE) {
+          if (tab.data_.alert_state != TabAlertState::NONE) {
             EXPECT_FALSE(tab.ShouldShowIcon());
-            EXPECT_TRUE(tab.ShouldShowMediaIndicator());
+            EXPECT_TRUE(tab.ShouldShowAlertIndicator());
           } else {
             EXPECT_TRUE(tab.ShouldShowIcon());
-            EXPECT_FALSE(tab.ShouldShowMediaIndicator());
+            EXPECT_FALSE(tab.ShouldShowAlertIndicator());
           }
           break;
         default:
           EXPECT_LE(3, tab.IconCapacity());
           EXPECT_TRUE(tab.ShouldShowIcon());
-          if (tab.data_.media_state != TAB_MEDIA_STATE_NONE)
-            EXPECT_TRUE(tab.ShouldShowMediaIndicator());
+          if (tab.data_.alert_state != TabAlertState::NONE)
+            EXPECT_TRUE(tab.ShouldShowAlertIndicator());
           else
-            EXPECT_FALSE(tab.ShouldShowMediaIndicator());
+            EXPECT_FALSE(tab.ShouldShowAlertIndicator());
           break;
       }
     } else {  // Tab not active and not pinned tab.
       switch (tab.IconCapacity()) {
         case 0:
           EXPECT_FALSE(tab.ShouldShowCloseBox());
           EXPECT_FALSE(tab.ShouldShowIcon());
-          EXPECT_FALSE(tab.ShouldShowMediaIndicator());
+          EXPECT_FALSE(tab.ShouldShowAlertIndicator());
           break;
         case 1:
           EXPECT_FALSE(tab.ShouldShowCloseBox());
-          if (tab.data_.media_state != TAB_MEDIA_STATE_NONE) {
+          if (tab.data_.alert_state != TabAlertState::NONE) {
             EXPECT_FALSE(tab.ShouldShowIcon());
-            EXPECT_TRUE(tab.ShouldShowMediaIndicator());
+            EXPECT_TRUE(tab.ShouldShowAlertIndicator());
           } else {
             EXPECT_TRUE(tab.ShouldShowIcon());
-            EXPECT_FALSE(tab.ShouldShowMediaIndicator());
+            EXPECT_FALSE(tab.ShouldShowAlertIndicator());
           }
           break;
         default:
           EXPECT_LE(2, tab.IconCapacity());
           EXPECT_TRUE(tab.ShouldShowIcon());
-          if (tab.data_.media_state != TAB_MEDIA_STATE_NONE)
-            EXPECT_TRUE(tab.ShouldShowMediaIndicator());
+          if (tab.data_.alert_state != TabAlertState::NONE)
+            EXPECT_TRUE(tab.ShouldShowAlertIndicator());
           else
-            EXPECT_FALSE(tab.ShouldShowMediaIndicator());
+            EXPECT_FALSE(tab.ShouldShowAlertIndicator());
           break;
       }
     }
 
     // Check positioning of elements with respect to each other, and that they
     // are fully within the contents bounds.
     const gfx::Rect contents_bounds = tab.GetContentsBounds();
     if (tab.ShouldShowIcon()) {
       EXPECT_LE(contents_bounds.x(), tab.favicon_bounds_.x());
       if (tab.title_->width() > 0)
         EXPECT_LE(tab.favicon_bounds_.right(), tab.title_->x());
       EXPECT_LE(contents_bounds.y(), tab.favicon_bounds_.y());
       EXPECT_LE(tab.favicon_bounds_.bottom(), contents_bounds.bottom());
     }
-    if (tab.ShouldShowIcon() && tab.ShouldShowMediaIndicator())
-      EXPECT_LE(tab.favicon_bounds_.right(), GetMediaIndicatorBounds(tab).x());
-    if (tab.ShouldShowMediaIndicator()) {
+    if (tab.ShouldShowIcon() && tab.ShouldShowAlertIndicator())
+      EXPECT_LE(tab.favicon_bounds_.right(), GetAlertIndicatorBounds(tab).x());
+    if (tab.ShouldShowAlertIndicator()) {
       if (tab.title_->width() > 0) {
         EXPECT_LE(tab.title_->bounds().right(),
-                  GetMediaIndicatorBounds(tab).x());
+                  GetAlertIndicatorBounds(tab).x());
       }
-      EXPECT_LE(GetMediaIndicatorBounds(tab).right(), contents_bounds.right());
-      EXPECT_LE(contents_bounds.y(), GetMediaIndicatorBounds(tab).y());
-      EXPECT_LE(GetMediaIndicatorBounds(tab).bottom(),
+      EXPECT_LE(GetAlertIndicatorBounds(tab).right(), contents_bounds.right());
+      EXPECT_LE(contents_bounds.y(), GetAlertIndicatorBounds(tab).y());
+      EXPECT_LE(GetAlertIndicatorBounds(tab).bottom(),
                 contents_bounds.bottom());
     }
-    if (tab.ShouldShowMediaIndicator() && tab.ShouldShowCloseBox()) {
-      // Note: The media indicator can overlap the left-insets of the close box,
+    if (tab.ShouldShowAlertIndicator() && tab.ShouldShowCloseBox()) {
+      // Note: The alert indicator can overlap the left-insets of the close box,
       // but should otherwise be to the left of the close button.
-      EXPECT_LE(GetMediaIndicatorBounds(tab).right(),
+      EXPECT_LE(GetAlertIndicatorBounds(tab).right(),
                 tab.close_button_->bounds().x() +
                     tab.close_button_->GetInsets().left());
     }
     if (tab.ShouldShowCloseBox()) {
       // Note: The title bounds can overlap the left-insets of the close box,
       // but should otherwise be to the left of the close button.
       if (tab.title_->width() > 0) {
         EXPECT_LE(tab.title_->bounds().right(),
                   tab.close_button_->bounds().x() +
                       tab.close_button_->GetInsets().left());
@@ skipping 12 matching lines @@
 
  protected:
   void InitWidget(Widget* widget) {
     Widget::InitParams params(CreateParams(Widget::InitParams::TYPE_WINDOW));
     params.ownership = Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
     params.bounds.SetRect(10, 20, 300, 400);
     widget->Init(params);
   }
 
  private:
-  static gfx::Rect GetMediaIndicatorBounds(const Tab& tab) {
-    if (!tab.media_indicator_button_) {
+  static gfx::Rect GetAlertIndicatorBounds(const Tab& tab) {
+    if (!tab.alert_indicator_button_) {
       ADD_FAILURE();
       return gfx::Rect();
     }
-    return tab.media_indicator_button_->bounds();
+    return tab.alert_indicator_button_->bounds();
   }
 
   std::string original_locale_;
 };
 
 TEST_F(TabTest, HitTestTopPixel) {
   Widget widget;
   InitWidget(&widget);
 
   FakeTabController tab_controller;
@@ skipping 16 matching lines @@
   // select the tab.
   widget.Maximize();
   EXPECT_TRUE(tab.HitTestPoint(gfx::Point(middle_x, 0)));
 
   // But clicks in the area above the slanted sides should still miss.
   EXPECT_FALSE(tab.HitTestPoint(gfx::Point(0, 0)));
   EXPECT_FALSE(tab.HitTestPoint(gfx::Point(tab.width() - 1, 0)));
 }
 
 TEST_F(TabTest, LayoutAndVisibilityOfElements) {
-  static const TabMediaState kMediaStatesToTest[] = {
-    TAB_MEDIA_STATE_NONE, TAB_MEDIA_STATE_CAPTURING,
-    TAB_MEDIA_STATE_AUDIO_PLAYING, TAB_MEDIA_STATE_AUDIO_MUTING
-  };
+  static const TabAlertState kAlertStatesToTest[] = {
+      TabAlertState::NONE, TabAlertState::TAB_CAPTURING,
+      TabAlertState::AUDIO_PLAYING, TabAlertState::AUDIO_MUTING};
 
   Widget widget;
   InitWidget(&widget);
 
   FakeTabController controller;
   Tab tab(&controller, nullptr);
   widget.GetContentsView()->AddChildView(&tab);
 
   SkBitmap bitmap;
   bitmap.allocN32Pixels(16, 16);
   TabRendererData data;
   data.favicon = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
 
   // Perform layout over all possible combinations, checking for correct
   // results.
   for (int is_pinned_tab = 0; is_pinned_tab < 2; ++is_pinned_tab) {
     for (int is_active_tab = 0; is_active_tab < 2; ++is_active_tab) {
-      for (size_t media_state_index = 0;
-           media_state_index < arraysize(kMediaStatesToTest);
-           ++media_state_index) {
-        const TabMediaState media_state = kMediaStatesToTest[media_state_index];
+      for (size_t alert_state_index = 0;
+           alert_state_index < arraysize(kAlertStatesToTest);
+           ++alert_state_index) {
+        const TabAlertState alert_state = kAlertStatesToTest[alert_state_index];
         SCOPED_TRACE(::testing::Message()
                      << (is_active_tab ? "Active" : "Inactive") << ' '
                      << (is_pinned_tab ? "Pinned " : "")
-                     << "Tab with media indicator state " << media_state);
+                     << "Tab with alert indicator state "
+                     << static_cast<uint8_t>(alert_state));
 
         data.pinned = !!is_pinned_tab;
         controller.set_active_tab(!!is_active_tab);
-        data.media_state = media_state;
+        data.alert_state = alert_state;
         tab.SetData(data);
 
         // Test layout for every width from standard to minimum.
         gfx::Rect bounds(gfx::Point(0, 0), Tab::GetStandardSize());
         int min_width;
         if (is_pinned_tab) {
           bounds.set_width(Tab::GetPinnedWidth());
           min_width = Tab::GetPinnedWidth();
         } else {
           min_width = is_active_tab ? Tab::GetMinimumActiveSize().width()
@@ skipping 26 matching lines @@
   bitmap.allocN32Pixels(16, 16);
   TabRendererData data;
   data.favicon = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
 
   data.title = base::UTF8ToUTF16(
       "This is a really long tab title that would case views::Label to provide "
       "its own tooltip; but Tab should disable that feature so it can provide "
       "the tooltip instead.");
 
   // Test both with and without an indicator showing since the tab tooltip text
-  // should include a description of the media state when the indicator is
+  // should include a description of the alert state when the indicator is
   // present.
   for (int i = 0; i < 2; ++i) {
-    data.media_state =
-        (i == 0 ? TAB_MEDIA_STATE_NONE : TAB_MEDIA_STATE_AUDIO_PLAYING);
+    data.alert_state =
+        (i == 0 ? TabAlertState::NONE : TabAlertState::AUDIO_PLAYING);
     SCOPED_TRACE(::testing::Message()
-                 << "Tab with media indicator state " << data.media_state);
+                 << "Tab with alert indicator state "
+                 << static_cast<uint8_t>(data.alert_state));
     tab.SetData(data);
 
     for (int j = 0; j < tab.child_count(); ++j) {
       views::View& child = *tab.child_at(j);
       if (!strcmp(child.GetClassName(), "TabCloseButton"))
         continue;  // Close button is excepted.
       if (!child.visible())
         continue;
       SCOPED_TRACE(::testing::Message() << "child_at(" << j << "): "
                    << child.GetClassName());
 
       const gfx::Point midpoint(child.width() / 2, child.height() / 2);
       EXPECT_FALSE(child.GetTooltipHandlerForPoint(midpoint));
       const gfx::Point mouse_hover_point =
           midpoint + child.GetMirroredPosition().OffsetFromOrigin();
       base::string16 tooltip;
       EXPECT_TRUE(static_cast<views::View&>(tab).GetTooltipText(
           mouse_hover_point, &tooltip));
-      EXPECT_EQ(chrome::AssembleTabTooltipText(data.title, data.media_state),
+      EXPECT_EQ(chrome::AssembleTabTooltipText(data.title, data.alert_state),
                 tooltip);
     }
   }
 }
 
 // Regression test for http://crbug.com/226253. Calling Layout() more than once
 // shouldn't change the insets of the close button.
 TEST_F(TabTest, CloseButtonLayout) {
   FakeTabController tab_controller;
   Tab tab(&tab_controller, nullptr);
@@ skipping 68 matching lines @@
 }
 
 TEST_F(TabTest, TitleHiddenWhenSmall) {
   FakeTabController tab_controller;
   Tab tab(&tab_controller, nullptr);
   tab.SetBounds(0, 0, 100, 50);
   EXPECT_GT(GetTitleWidth(tab), 0);
   tab.SetBounds(0, 0, 0, 50);
   EXPECT_EQ(0, GetTitleWidth(tab));
 }