UI: Rename MediaState to AlertState

chrome/browser/ui/views/tabs/tab.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 <limits>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/macros.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/layout_constants.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/browser/ui/view_ids.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 "chrome/browser/ui/views/touch_uma/touch_uma.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/components_scaled_resources.h"
 #include "grit/components_strings.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
@@ skipping 453 matching lines @@
       closing_(false),
       dragging_(false),
       detached_(false),
       favicon_hiding_offset_(0),
       immersive_loading_step_(0),
       should_display_crashed_favicon_(false),
       pulse_animation_(new gfx::ThrobAnimation(this)),
       crash_icon_animation_(new FaviconCrashAnimation(this)),
       animation_container_(container),
       throbber_(nullptr),
-      media_indicator_button_(nullptr),
+      alert_indicator_button_(nullptr),
       close_button_(nullptr),
       title_(new views::Label()),
       tab_activated_with_last_tap_down_(false),
       hover_controller_(this),
       showing_icon_(false),
-      showing_media_indicator_(false),
+      showing_alert_indicator_(false),
       showing_close_button_(false),
       button_color_(SK_ColorTRANSPARENT) {
   DCHECK(controller);
   InitTabResources();
 
   // So we get don't get enter/exit on children and don't prematurely stop the
   // hover.
   set_notify_enter_exit_on_child(true);
 
   set_id(VIEW_ID_TAB);
 
   SetBorder(views::Border::CreateEmptyBorder(GetLayoutInsets(TAB)));
 
   title_->SetHorizontalAlignment(gfx::ALIGN_TO_HEAD);
   title_->SetElideBehavior(gfx::FADE_TAIL);
   title_->SetHandlesTooltips(false);
   title_->SetAutoColorReadabilityEnabled(false);
   title_->SetText(CoreTabHelper::GetDefaultTitle());
   AddChildView(title_);
 
   SetEventTargeter(
       scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(this)));
 
   throbber_ = new ThrobberView(this);
   throbber_->SetVisible(false);
   AddChildView(throbber_);
 
-  media_indicator_button_ = new MediaIndicatorButton(this);
-  AddChildView(media_indicator_button_);
+  alert_indicator_button_ = new AlertIndicatorButton(this);
+  AddChildView(alert_indicator_button_);
 
   close_button_ = new TabCloseButton(this);
   close_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_CLOSE));
   // The normal image is set by OnButtonColorMaybeChanged() because it depends
   // on the current theme and active state.  The hovered and pressed images
   // don't depend on the these, so we can set them here.
   const gfx::ImageSkia& hovered = gfx::CreateVectorIcon(
       gfx::VectorIconId::TAB_CLOSE_HOVERED_PRESSED, kTabCloseButtonSize,
       SkColorSetRGB(0xDB, 0x44, 0x37));
@@ skipping 47 matching lines @@
 
 Tab::~Tab() {
 }
 
 bool Tab::IsActive() const {
   return controller_->IsActiveTab(this);
 }
 
 void Tab::ActiveStateChanged() {
   OnButtonColorMaybeChanged();
-  media_indicator_button_->UpdateEnabledForMuteToggle();
+  alert_indicator_button_->UpdateEnabledForMuteToggle();
   Layout();
 }
 
-void Tab::MediaStateChanged() {
+void Tab::AlertStateChanged() {
   Layout();
 }
 
 bool Tab::IsSelected() const {
   return controller_->IsTabSelected(this);
 }
 
 void Tab::SetData(const TabRendererData& data) {
   DCHECK(GetWidget());
 
@@ skipping 13 matching lines @@
     Browser::FormatTitleForDisplay(&title);
   }
   title_->SetText(title);
 
   if (!data_.IsCrashed()) {
     crash_icon_animation_->Stop();
     should_display_crashed_favicon_ = false;
     favicon_hiding_offset_ = 0;
   } else if (!should_display_crashed_favicon_ &&
              !crash_icon_animation_->is_animating()) {
-    data_.media_state = TAB_MEDIA_STATE_NONE;
+    data_.alert_state = TabAlertState::NONE;
     crash_icon_animation_->Start();
   }
 
-  if (data_.media_state != old.media_state)
-    media_indicator_button_->TransitionToMediaState(data_.media_state);
+  if (data_.alert_state != old.alert_state)
+    alert_indicator_button_->TransitionToAlertState(data_.alert_state);
 
   if (old.pinned != data_.pinned)
     StopPinnedTabTitleAnimation();
 
   DataChanged(old);
 
   Layout();
   SchedulePaint();
 }
 
@@ skipping 20 matching lines @@
 void Tab::StartPinnedTabTitleAnimation() {
   if (data().pinned)
     pinned_title_change_animation_->Start();
 }
 
 void Tab::StopPinnedTabTitleAnimation() {
   pinned_title_change_animation_->Stop();
 }
 
 int Tab::GetWidthOfLargestSelectableRegion() const {
-  // Assume the entire region to the left of the media indicator and/or close
+  // Assume the entire region to the left of the alert indicator and/or close
   // buttons is available for click-to-select.  If neither are visible, the
   // entire tab region is available.
-  const int indicator_left = showing_media_indicator_ ?
-      media_indicator_button_->x() : width();
+  const int indicator_left =
+      showing_alert_indicator_ ? alert_indicator_button_->x() : width();
   const int close_button_left = showing_close_button_ ?
       close_button_->x() : width();
   return std::min(indicator_left, close_button_left);
 }
 
 // static
 gfx::Size Tab::GetMinimumInactiveSize() {
   return gfx::Size(GetLayoutInsets(TAB).width(), GetLayoutConstant(TAB_HEIGHT));
 }
 
@@ skipping 69 matching lines @@
 }
 
 void Tab::AnimationEnded(const gfx::Animation* animation) {
   SchedulePaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, views::ButtonListener overrides:
 
 void Tab::ButtonPressed(views::Button* sender, const ui::Event& event) {
-  if (!media_indicator_button_ || !media_indicator_button_->visible())
-    content::RecordAction(UserMetricsAction("CloseTab_NoMediaIndicator"));
-  else if (media_indicator_button_->enabled())
+  if (!alert_indicator_button_ || !alert_indicator_button_->visible())
+    content::RecordAction(UserMetricsAction("CloseTab_NoAlertIndicator"));
+  else if (alert_indicator_button_->enabled())
     content::RecordAction(UserMetricsAction("CloseTab_MuteToggleAvailable"));
-  else if (data_.media_state == TAB_MEDIA_STATE_AUDIO_PLAYING)
+  else if (data_.alert_state == TabAlertState::AUDIO_PLAYING)
     content::RecordAction(UserMetricsAction("CloseTab_AudioIndicator"));
   else
     content::RecordAction(UserMetricsAction("CloseTab_RecordingIndicator"));
 
   const CloseTabSource source =
       (event.type() == ui::ET_MOUSE_RELEASED &&
        !(event.flags() & ui::EF_FROM_TOUCH)) ? CLOSE_TAB_FROM_MOUSE
                                              : CLOSE_TAB_FROM_TOUCH;
   DCHECK_EQ(close_button_, sender);
   controller_->CloseTab(this, source);
@@ skipping 161 matching lines @@
     close_button_->SetPosition(
         gfx::Point(close_button_end - close_button_size.width() - left, 0));
     const int bottom = height() - close_button_size.height() - top;
     const int right = width() - close_button_end;
     close_button_->SetBorder(
         views::Border::CreateEmptyBorder(top, left, bottom, right));
     close_button_->SizeToPreferredSize();
   }
   close_button_->SetVisible(showing_close_button_);
 
-  showing_media_indicator_ = ShouldShowMediaIndicator();
-  if (showing_media_indicator_) {
-    const gfx::Size image_size(media_indicator_button_->GetPreferredSize());
+  showing_alert_indicator_ = ShouldShowAlertIndicator();
+  if (showing_alert_indicator_) {
+    const gfx::Size image_size(alert_indicator_button_->GetPreferredSize());
     const int right = showing_close_button_ ?
         close_button_->x() + close_button_->GetInsets().left() : lb.right();
     gfx::Rect bounds(
         std::max(lb.x(), right - image_size.width()),
         lb.y() + (lb.height() - image_size.height() + 1) / 2,
         image_size.width(),
         image_size.height());
     MaybeAdjustLeftForPinnedTab(&bounds);
-    media_indicator_button_->SetBoundsRect(bounds);
+    alert_indicator_button_->SetBoundsRect(bounds);
   }
-  media_indicator_button_->SetVisible(showing_media_indicator_);
+  alert_indicator_button_->SetVisible(showing_alert_indicator_);
 
   // Size the title to fill the remaining width and use all available height.
   const bool show_title = ShouldRenderAsNormalTab();
   if (show_title) {
     const int title_spacing = GetLayoutConstant(TAB_FAVICON_TITLE_SPACING);
     int title_left = showing_icon_ ?
         (favicon_bounds_.right() + title_spacing) : start;
     int title_width = lb.right() - title_left;
-    if (showing_media_indicator_) {
+    if (showing_alert_indicator_) {
       title_width =
-          media_indicator_button_->x() - kAfterTitleSpacing - title_left;
+          alert_indicator_button_->x() - kAfterTitleSpacing - title_left;
     } else if (close_button_->visible()) {
       // Allow the title to overlay the close button's empty border padding.
       title_width = close_button_->x() + close_button_->GetInsets().left() -
           kAfterTitleSpacing - title_left;
     }
     // The Label will automatically center the font's cap height within the
     // provided vertical space.
     title_->SetBoundsRect(
         gfx::Rect(title_left, lb.y(), std::max(title_width, 0), lb.height()));
   }
   title_->SetVisible(show_title);
 }
 
 void Tab::OnThemeChanged() {
   LoadTabImages();
   OnButtonColorMaybeChanged();
 }
 
 const char* Tab::GetClassName() const {
   return kViewClassName;
 }
 
 bool Tab::GetTooltipText(const gfx::Point& p, base::string16* tooltip) const {
   // Note: Anything that affects the tooltip text should be accounted for when
   // calling TooltipTextChanged() from Tab::DataChanged().
-  *tooltip = chrome::AssembleTabTooltipText(data_.title, data_.media_state);
+  *tooltip = chrome::AssembleTabTooltipText(data_.title, data_.alert_state);
   return !tooltip->empty();
 }
 
 bool Tab::GetTooltipTextOrigin(const gfx::Point& p, gfx::Point* origin) const {
   origin->set_x(title_->x() + 10);
   origin->set_y(-4);
   return true;
 }
 
 bool Tab::OnMousePressed(const ui::MouseEvent& event) {
@@ skipping 66 matching lines @@
       if (closest_tab)
         controller_->CloseTab(closest_tab, CLOSE_TAB_FROM_MOUSE);
     }
   } else if (event.IsOnlyLeftMouseButton() && !event.IsShiftDown() &&
              !event.IsControlDown()) {
     // If the tab was already selected mouse pressed doesn't change the
     // selection. Reset it now to handle the case where multiple tabs were
     // selected.
     controller_->SelectTab(this);
 
-    if (media_indicator_button_ && media_indicator_button_->visible() &&
-        media_indicator_button_->bounds().Contains(event.location())) {
-      content::RecordAction(UserMetricsAction("TabMediaIndicator_Clicked"));
+    if (alert_indicator_button_ && alert_indicator_button_->visible() &&
+        alert_indicator_button_->bounds().Contains(event.location())) {
+      content::RecordAction(UserMetricsAction("TabAlertIndicator_Clicked"));
     }
   }
 }
 
 void Tab::OnMouseCaptureLost() {
   controller_->EndDrag(END_DRAG_CAPTURE_LOST);
 }
 
 void Tab::OnMouseEntered(const ui::MouseEvent& event) {
   hover_controller_.Show(views::GlowHoverController::SUBTLE);
@@ skipping 63 matching lines @@
   const int ideal_delta = width() - GetPinnedWidth();
   const int ideal_x = (GetPinnedWidth() - bounds->width()) / 2;
   bounds->set_x(
       bounds->x() + static_cast<int>(
           (1 - static_cast<float>(ideal_delta) /
               static_cast<float>(kPinnedTabExtraWidthToRenderAsNormal)) *
           (ideal_x - bounds->x())));
 }
 
 void Tab::DataChanged(const TabRendererData& old) {
-  if (data().media_state != old.media_state || data().title != old.title)
+  if (data().alert_state != old.alert_state || data().title != old.title)
     TooltipTextChanged();
 
   if (data().blocked == old.blocked)
     return;
 
   if (data().blocked)
     StartPulse();
   else
     StopPulse();
 }
@@ skipping 371 matching lines @@
   if (visible_icons < 3)
     return visible_icons;
   const int padding = controller_->ShouldHideCloseButtonForInactiveTabs() ?
       0 : kExtraLeftPaddingToBalanceCloseButtonPadding;
   return (available_width - padding) / icon_width;
 }
 
 bool Tab::ShouldShowIcon() const {
   return chrome::ShouldTabShowFavicon(
       IconCapacity(), data().pinned, IsActive(), data().show_icon,
-      media_indicator_button_ ? media_indicator_button_->showing_media_state() :
-                                data_.media_state);
+      alert_indicator_button_ ? alert_indicator_button_->showing_alert_state()
+                              : data_.alert_state);
 }
 
-bool Tab::ShouldShowMediaIndicator() const {
-  return chrome::ShouldTabShowMediaIndicator(
+bool Tab::ShouldShowAlertIndicator() const {
+  return chrome::ShouldTabShowAlertIndicator(
       IconCapacity(), data().pinned, IsActive(), data().show_icon,
-      media_indicator_button_ ? media_indicator_button_->showing_media_state() :
-                                data_.media_state);
+      alert_indicator_button_ ? alert_indicator_button_->showing_alert_state()
+                              : data_.alert_state);
 }
 
 bool Tab::ShouldShowCloseBox() const {
   if (!IsActive() && controller_->ShouldHideCloseButtonForInactiveTabs())
     return false;
 
   return chrome::ShouldTabShowCloseButton(
       IconCapacity(), data().pinned, IsActive());
 }
 
@@ skipping 31 matching lines @@
   if (!theme_provider)
     return;
 
   const SkColor title_color = theme_provider->GetColor(IsActive() ?
       ThemeProperties::COLOR_TAB_TEXT :
       ThemeProperties::COLOR_BACKGROUND_TAB_TEXT);
   const SkColor new_button_color = SkColorSetA(title_color, 0xA0);
   if (button_color_ != new_button_color) {
     button_color_ = new_button_color;
     title_->SetEnabledColor(title_color);
-    media_indicator_button_->OnParentTabButtonColorChanged();
+    alert_indicator_button_->OnParentTabButtonColorChanged();
     const gfx::ImageSkia& close_button_normal_image = gfx::CreateVectorIcon(
         gfx::VectorIconId::TAB_CLOSE_NORMAL, kTabCloseButtonSize,
         button_color_);
     close_button_->SetImage(views::CustomButton::STATE_NORMAL,
                             &close_button_normal_image);
   }
 }
 
 void Tab::ScheduleIconPaint() {
   gfx::Rect bounds = favicon_bounds_;
@@ skipping 113 matching lines @@
   inactive_images_.image_c = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_CENTER);
   inactive_images_.image_r = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_RIGHT);
   inactive_images_.l_width = inactive_images_.image_l->width();
   inactive_images_.r_width = inactive_images_.image_r->width();
 
   mask_images_.image_l = rb.GetImageSkiaNamed(IDR_TAB_ALPHA_LEFT);
   mask_images_.image_r = rb.GetImageSkiaNamed(IDR_TAB_ALPHA_RIGHT);
   mask_images_.l_width = mask_images_.image_l->width();
   mask_images_.r_width = mask_images_.image_r->width();
 }