UI: Rename MediaState to AlertState

chrome/browser/ui/tabs/tab_utils.cc

Index: chrome/browser/ui/tabs/tab_utils.cc
diff --git a/chrome/browser/ui/tabs/tab_utils.cc b/chrome/browser/ui/tabs/tab_utils.cc
index ada42a7a3513a9edbc2935a0224c9de65b6faf97..21e422cd68d34fd30bb2fcd57788295be99c128a 100644
--- a/chrome/browser/ui/tabs/tab_utils.cc
+++ b/chrome/browser/ui/tabs/tab_utils.cc
@@ -33,7 +33,7 @@
 
 struct LastMuteMetadata
     : public content::WebContentsUserData<LastMuteMetadata> {
-  TabMutedReason reason = TAB_MUTED_REASON_NONE;
+  TabMutedReason reason = TabMutedReason::NONE;
   std::string extension_id;
 
  private:
@@ -109,25 +109,25 @@ bool ShouldTabShowFavicon(int capacity,
                           bool is_pinned_tab,
                           bool is_active_tab,
                           bool has_favicon,
-                          TabMediaState media_state) {
+                          TabAlertState alert_state) {
   if (!has_favicon)
     return false;
   int required_capacity = 1;
   if (ShouldTabShowCloseButton(capacity, is_pinned_tab, is_active_tab))
     ++required_capacity;
-  if (ShouldTabShowMediaIndicator(
-          capacity, is_pinned_tab, is_active_tab, has_favicon, media_state)) {
+  if (ShouldTabShowAlertIndicator(capacity, is_pinned_tab, is_active_tab,
+                                  has_favicon, alert_state)) {
     ++required_capacity;
   }
   return capacity >= required_capacity;
 }
 
-bool ShouldTabShowMediaIndicator(int capacity,
+bool ShouldTabShowAlertIndicator(int capacity,
                                  bool is_pinned_tab,
                                  bool is_active_tab,
                                  bool has_favicon,
-                                 TabMediaState media_state) {
-  if (media_state == TAB_MEDIA_STATE_NONE)
+                                 TabAlertState alert_state) {
+  if (alert_state == TabAlertState::NONE)
     return false;
   if (ShouldTabShowCloseButton(capacity, is_pinned_tab, is_active_tab))
     return capacity >= 2;
@@ -145,68 +145,68 @@ bool ShouldTabShowCloseButton(int capacity,
     return capacity >= 3;
 }
 
-TabMediaState GetTabMediaStateForContents(content::WebContents* contents) {
+TabAlertState GetTabAlertStateForContents(content::WebContents* contents) {
   if (!contents)
-    return TAB_MEDIA_STATE_NONE;
+    return TabAlertState::NONE;
 
   scoped_refptr<MediaStreamCaptureIndicator> indicator =
       MediaCaptureDevicesDispatcher::GetInstance()->
           GetMediaStreamCaptureIndicator();
   if (indicator.get()) {
     if (indicator->IsBeingMirrored(contents))
-      return TAB_MEDIA_STATE_CAPTURING;
+      return TabAlertState::TAB_CAPTURING;
     if (indicator->IsCapturingUserMedia(contents))
-      return TAB_MEDIA_STATE_RECORDING;
+      return TabAlertState::MEDIA_RECORDING;
   }
 
   if (contents->IsBluetoothDeviceConnected())
-    return TAB_MEDIA_STATE_BLUETOOTH_CONNECTED;
+    return TabAlertState::BLUETOOTH_CONNECTED;
 
   if (contents->IsAudioMuted())
-    return TAB_MEDIA_STATE_AUDIO_MUTING;
+    return TabAlertState::AUDIO_MUTING;
   if (contents->WasRecentlyAudible())
-    return TAB_MEDIA_STATE_AUDIO_PLAYING;
+    return TabAlertState::AUDIO_PLAYING;
 
-  return TAB_MEDIA_STATE_NONE;
+  return TabAlertState::NONE;
 }
 
-gfx::Image GetTabMediaIndicatorImage(TabMediaState media_state,
+gfx::Image GetTabAlertIndicatorImage(TabAlertState alert_state,
                                      SkColor button_color) {
 #if defined(OS_MACOSX)
   ui::ResourceBundle* rb = &ui::ResourceBundle::GetSharedInstance();
-  switch (media_state) {
-    case TAB_MEDIA_STATE_AUDIO_PLAYING:
+  switch (alert_state) {
+    case TabAlertState::AUDIO_PLAYING:
       return rb->GetNativeImageNamed(IDR_TAB_AUDIO_INDICATOR);
-    case TAB_MEDIA_STATE_AUDIO_MUTING:
+    case TabAlertState::AUDIO_MUTING:
       return rb->GetNativeImageNamed(IDR_TAB_AUDIO_MUTING_INDICATOR);
-    case TAB_MEDIA_STATE_RECORDING:
+    case TabAlertState::MEDIA_RECORDING:
       return rb->GetNativeImageNamed(IDR_TAB_RECORDING_INDICATOR);
-    case TAB_MEDIA_STATE_CAPTURING:
+    case TabAlertState::TAB_CAPTURING:
       return rb->GetNativeImageNamed(IDR_TAB_CAPTURE_INDICATOR);
-    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
+    case TabAlertState::BLUETOOTH_CONNECTED:
       return rb->GetNativeImageNamed(IDR_TAB_BLUETOOTH_INDICATOR);
-    case TAB_MEDIA_STATE_NONE:
+    case TabAlertState::NONE:
       break;
   }
 #else
   gfx::VectorIconId icon_id = gfx::VectorIconId::VECTOR_ICON_NONE;
-  switch (media_state) {
-    case TAB_MEDIA_STATE_AUDIO_PLAYING:
+  switch (alert_state) {
+    case TabAlertState::AUDIO_PLAYING:
       icon_id = gfx::VectorIconId::TAB_AUDIO;
       break;
-    case TAB_MEDIA_STATE_AUDIO_MUTING:
+    case TabAlertState::AUDIO_MUTING:
       icon_id = gfx::VectorIconId::TAB_AUDIO_MUTING;
       break;
-    case TAB_MEDIA_STATE_RECORDING:
+    case TabAlertState::MEDIA_RECORDING:
       icon_id = gfx::VectorIconId::TAB_MEDIA_RECORDING;
       break;
-    case TAB_MEDIA_STATE_CAPTURING:
+    case TabAlertState::TAB_CAPTURING:
       icon_id = gfx::VectorIconId::TAB_MEDIA_CAPTURING;
       break;
-    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
+    case TabAlertState::BLUETOOTH_CONNECTED:
       icon_id = gfx::VectorIconId::TAB_BLUETOOTH_CONNECTED;
       break;
-    case TAB_MEDIA_STATE_NONE:
+    case TabAlertState::NONE:
       break;
   }
   if (icon_id != gfx::VectorIconId::VECTOR_ICON_NONE)
@@ -216,34 +216,34 @@ gfx::Image GetTabMediaIndicatorImage(TabMediaState media_state,
   return gfx::Image();
 }
 
-gfx::Image GetTabMediaIndicatorAffordanceImage(TabMediaState media_state,
+gfx::Image GetTabAlertIndicatorAffordanceImage(TabAlertState alert_state,
                                                SkColor button_color) {
-  switch (media_state) {
-    case TAB_MEDIA_STATE_AUDIO_PLAYING:
-      return GetTabMediaIndicatorImage(TAB_MEDIA_STATE_AUDIO_MUTING,
+  switch (alert_state) {
+    case TabAlertState::AUDIO_PLAYING:
+      return GetTabAlertIndicatorImage(TabAlertState::AUDIO_MUTING,
                                        button_color);
-    case TAB_MEDIA_STATE_AUDIO_MUTING:
-    case TAB_MEDIA_STATE_NONE:
-    case TAB_MEDIA_STATE_RECORDING:
-    case TAB_MEDIA_STATE_CAPTURING:
-    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
-      return GetTabMediaIndicatorImage(media_state, button_color);
+    case TabAlertState::AUDIO_MUTING:
+    case TabAlertState::NONE:
+    case TabAlertState::MEDIA_RECORDING:
+    case TabAlertState::TAB_CAPTURING:
+    case TabAlertState::BLUETOOTH_CONNECTED:
+      return GetTabAlertIndicatorImage(alert_state, button_color);
   }
   NOTREACHED();
-  return GetTabMediaIndicatorImage(media_state, button_color);
+  return GetTabAlertIndicatorImage(alert_state, button_color);
 }
 
-scoped_ptr<gfx::Animation> CreateTabMediaIndicatorFadeAnimation(
-    TabMediaState media_state) {
-  if (media_state == TAB_MEDIA_STATE_RECORDING ||
-      media_state == TAB_MEDIA_STATE_CAPTURING) {
+scoped_ptr<gfx::Animation> CreateTabAlertIndicatorFadeAnimation(
+    TabAlertState alert_state) {
+  if (alert_state == TabAlertState::MEDIA_RECORDING ||
+      alert_state == TabAlertState::TAB_CAPTURING) {
     return TabRecordingIndicatorAnimation::Create();
   }
 
   // Note: While it seems silly to use a one-part MultiAnimation, it's the only
   // gfx::Animation implementation that lets us control the frame interval.
   gfx::MultiAnimation::Parts parts;
-  const bool is_for_fade_in = (media_state != TAB_MEDIA_STATE_NONE);
+  const bool is_for_fade_in = (alert_state != TabAlertState::NONE);
   parts.push_back(gfx::MultiAnimation::Part(
       is_for_fade_in ? kIndicatorFadeInDurationMs : kIndicatorFadeOutDurationMs,
       gfx::Tween::EASE_IN));
@@ -256,35 +256,35 @@ scoped_ptr<gfx::Animation> CreateTabMediaIndicatorFadeAnimation(
 }
 
 base::string16 AssembleTabTooltipText(const base::string16& title,
-                                      TabMediaState media_state) {
-  if (media_state == TAB_MEDIA_STATE_NONE)
+                                      TabAlertState alert_state) {
+  if (alert_state == TabAlertState::NONE)
     return title;
 
   base::string16 result = title;
   if (!result.empty())
     result.append(1, '\n');
-  switch (media_state) {
-    case TAB_MEDIA_STATE_AUDIO_PLAYING:
+  switch (alert_state) {
+    case TabAlertState::AUDIO_PLAYING:
       result.append(
-          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_AUDIO_PLAYING));
+          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_ALERT_STATE_AUDIO_PLAYING));
       break;
-    case TAB_MEDIA_STATE_AUDIO_MUTING:
+    case TabAlertState::AUDIO_MUTING:
       result.append(
-          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_AUDIO_MUTING));
+          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_ALERT_STATE_AUDIO_MUTING));
       break;
-    case TAB_MEDIA_STATE_RECORDING:
-      result.append(
-          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_RECORDING));
+    case TabAlertState::MEDIA_RECORDING:
+      result.append(l10n_util::GetStringUTF16(
+          IDS_TOOLTIP_TAB_ALERT_STATE_MEDIA_RECORDING));
       break;
-    case TAB_MEDIA_STATE_CAPTURING:
+    case TabAlertState::TAB_CAPTURING:
       result.append(
-          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_CAPTURING));
+          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_ALERT_STATE_TAB_CAPTURING));
       break;
-    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
-      result.append(
-          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_BLUETOOTH_CONNECTED));
+    case TabAlertState::BLUETOOTH_CONNECTED:
+      result.append(l10n_util::GetStringUTF16(
+          IDS_TOOLTIP_TAB_ALERT_STATE_BLUETOOTH_CONNECTED));
       break;
-    case TAB_MEDIA_STATE_NONE:
+    case TabAlertState::NONE:
       NOTREACHED();
       break;
   }
@@ -297,14 +297,14 @@ bool AreExperimentalMuteControlsEnabled() {
 }
 
 bool CanToggleAudioMute(content::WebContents* contents) {
-  switch (GetTabMediaStateForContents(contents)) {
-    case TAB_MEDIA_STATE_NONE:
-    case TAB_MEDIA_STATE_AUDIO_PLAYING:
-    case TAB_MEDIA_STATE_AUDIO_MUTING:
+  switch (GetTabAlertStateForContents(contents)) {
+    case TabAlertState::NONE:
+    case TabAlertState::AUDIO_PLAYING:
+    case TabAlertState::AUDIO_MUTING:
       return true;
-    case TAB_MEDIA_STATE_RECORDING:
-    case TAB_MEDIA_STATE_CAPTURING:
-    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
+    case TabAlertState::MEDIA_RECORDING:
+    case TabAlertState::TAB_CAPTURING:
+    case TabAlertState::BLUETOOTH_CONNECTED:
       return false;
   }
   NOTREACHED();
@@ -315,16 +315,16 @@ TabMutedReason GetTabAudioMutedReason(content::WebContents* contents) {
   LastMuteMetadata::CreateForWebContents(contents);  // Ensures metadata exists.
   LastMuteMetadata* const metadata =
       LastMuteMetadata::FromWebContents(contents);
-  if (GetTabMediaStateForContents(contents) == TAB_MEDIA_STATE_CAPTURING) {
+  if (GetTabAlertStateForContents(contents) == TabAlertState::TAB_CAPTURING) {
     // For tab capture, libcontent forces muting off.
-    metadata->reason = TAB_MUTED_REASON_MEDIA_CAPTURE;
+    metadata->reason = TabMutedReason::MEDIA_CAPTURE;
     metadata->extension_id.clear();
   }
   return metadata->reason;
 }
 
 const std::string& GetExtensionIdForMutedTab(content::WebContents* contents) {
-  DCHECK_EQ(GetTabAudioMutedReason(contents) != TAB_MUTED_REASON_EXTENSION,
+  DCHECK_EQ(GetTabAudioMutedReason(contents) != TabMutedReason::EXTENSION,
             LastMuteMetadata::FromWebContents(contents)->extension_id.empty());
   return LastMuteMetadata::FromWebContents(contents)->extension_id;
 }
@@ -334,15 +334,15 @@ TabMutedResult SetTabAudioMuted(content::WebContents* contents,
                                 TabMutedReason reason,
                                 const std::string& extension_id) {
   DCHECK(contents);
-  DCHECK_NE(TAB_MUTED_REASON_NONE, reason);
+  DCHECK(TabMutedReason::NONE != reason);
 
-  if (reason == TAB_MUTED_REASON_AUDIO_INDICATOR &&
+  if (reason == TabMutedReason::AUDIO_INDICATOR &&
       !AreExperimentalMuteControlsEnabled()) {
-    return TAB_MUTED_RESULT_FAIL_NOT_ENABLED;
+    return TabMutedResult::FAIL_NOT_ENABLED;
   }
 
   if (!chrome::CanToggleAudioMute(contents))
-    return TAB_MUTED_RESULT_FAIL_TABCAPTURE;
+    return TabMutedResult::FAIL_TABCAPTURE;
 
   contents->SetAudioMuted(mute);
 
@@ -350,14 +350,14 @@ TabMutedResult SetTabAudioMuted(content::WebContents* contents,
   LastMuteMetadata* const metadata =
       LastMuteMetadata::FromWebContents(contents);
   metadata->reason = reason;
-  if (reason == TAB_MUTED_REASON_EXTENSION) {
+  if (reason == TabMutedReason::EXTENSION) {
     DCHECK(!extension_id.empty());
     metadata->extension_id = extension_id;
   } else {
     metadata->extension_id.clear();
   }
 
-  return TAB_MUTED_RESULT_SUCCESS;
+  return TabMutedResult::SUCCESS;
 }
 
 void UnmuteIfMutedByExtension(content::WebContents* contents,
@@ -365,9 +365,9 @@ void UnmuteIfMutedByExtension(content::WebContents* contents,
   LastMuteMetadata::CreateForWebContents(contents);  // Ensures metadata exists.
   LastMuteMetadata* const metadata =
       LastMuteMetadata::FromWebContents(contents);
-  if (metadata->reason == TAB_MUTED_REASON_EXTENSION &&
+  if (metadata->reason == TabMutedReason::EXTENSION &&
       metadata->extension_id == extension_id) {
-    SetTabAudioMuted(contents, false, TAB_MUTED_REASON_EXTENSION, extension_id);
+    SetTabAudioMuted(contents, false, TabMutedReason::EXTENSION, extension_id);
   }
 }