UI: Rename MediaState to AlertState

chrome/browser/ui/tabs/tab_utils.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/tabs/tab_utils.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/strings/string16.h"
@@ skipping 15 matching lines @@
 
 #if defined(OS_MACOSX)
 #include "grit/theme_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #else
 #include "ui/gfx/paint_vector_icon.h"
 #endif
 
 struct LastMuteMetadata
     : public content::WebContentsUserData<LastMuteMetadata> {
-  TabMutedReason reason = TAB_MUTED_REASON_NONE;
+  TabMutedReason reason = TabMutedReason::NONE;
   std::string extension_id;
 
  private:
   explicit LastMuteMetadata(content::WebContents* contents) {}
   friend class content::WebContentsUserData<LastMuteMetadata>;
 };
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(LastMuteMetadata);
 
 namespace chrome {
@@ skipping 55 matching lines @@
   animation->set_continuous(false);
   return animation;
 }
 
 }  // namespace
 
 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;
   return capacity >= 1;
 }
 
 bool ShouldTabShowCloseButton(int capacity,
                               bool is_pinned_tab,
                               bool is_active_tab) {
   if (is_pinned_tab)
     return false;
   else if (is_active_tab)
     return true;
   else
     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)
     return gfx::Image(gfx::CreateVectorIcon(icon_id, 16, button_color));
 #endif
   NOTREACHED();
   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));
   const base::TimeDelta interval =
       base::TimeDelta::FromMilliseconds(kIndicatorFrameIntervalMs);
   scoped_ptr<gfx::MultiAnimation> animation(
       new gfx::MultiAnimation(parts, interval));
   animation->set_continuous(false);
   return std::move(animation);
 }
 
 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:
+    case TabAlertState::MEDIA_RECORDING:
+      result.append(l10n_util::GetStringUTF16(
+          IDS_TOOLTIP_TAB_ALERT_STATE_MEDIA_RECORDING));
+      break;
+    case TabAlertState::TAB_CAPTURING:
       result.append(
-          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_RECORDING));
+          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_ALERT_STATE_TAB_CAPTURING));
       break;
-    case TAB_MEDIA_STATE_CAPTURING:
-      result.append(
-          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_CAPTURING));
+    case TabAlertState::BLUETOOTH_CONNECTED:
+      result.append(l10n_util::GetStringUTF16(
+          IDS_TOOLTIP_TAB_ALERT_STATE_BLUETOOTH_CONNECTED));
       break;
-    case TAB_MEDIA_STATE_BLUETOOTH_CONNECTED:
-      result.append(
-          l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_BLUETOOTH_CONNECTED));
-      break;
-    case TAB_MEDIA_STATE_NONE:
+    case TabAlertState::NONE:
       NOTREACHED();
       break;
   }
   return result;
 }
 
 bool AreExperimentalMuteControlsEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableTabAudioMuting);
 }
 
 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();
   return false;
 }
 
 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;
 }
 
 TabMutedResult SetTabAudioMuted(content::WebContents* contents,
                                 bool mute,
                                 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);
 
   LastMuteMetadata::CreateForWebContents(contents);  // Ensures metadata exists.
   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,
                               const std::string& extension_id) {
   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);
   }
 }
 
 bool AreAllTabsMuted(const TabStripModel& tab_strip,
                      const std::vector<int>& indices) {
   for (std::vector<int>::const_iterator i = indices.begin(); i != indices.end();
        ++i) {
     if (!tab_strip.GetWebContentsAt(*i)->IsAudioMuted())
       return false;
   }
   return true;
 }
 
 }  // namespace chrome