src/chrome/browser/ui/tabs/tab_utils.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/tabs/tab_utils.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/strings/string16.h"
   9 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
  10 #include "chrome/browser/media/media_stream_capture_indicator.h"
  11 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  12 #include "chrome/common/chrome_switches.h"
  13 #include "chrome/grit/generated_resources.h"
  14 #include "content/public/browser/web_contents.h"
  15 #include "grit/theme_resources.h"
  16 #include "ui/base/l10n/l10n_util.h"
  17 #include "ui/base/resource/resource_bundle.h"
  18 #include "ui/gfx/animation/multi_animation.h"
  19
  20 namespace chrome {
  21
  22 namespace {
  23
  24 // Interval between frame updates of the tab indicator animations.  This is not
  25 // the usual 60 FPS because a trade-off must be made between tab UI animation
  26 // smoothness and media recording/playback performance on low-end hardware.
  27 const int kIndicatorFrameIntervalMs = 50;  // 20 FPS
  28
  29 // Fade-in/out duration for the tab indicator animations.  Fade-in is quick to
  30 // immediately notify the user.  Fade-out is more gradual, so that the user has
  31 // a chance of finding a tab that has quickly "blipped" on and off.
  32 const int kIndicatorFadeInDurationMs = 200;
  33 const int kIndicatorFadeOutDurationMs = 1000;
  34
  35 // Animation that throbs in (towards 1.0) and out (towards 0.0), and ends in the
  36 // "in" state.
  37 class TabRecordingIndicatorAnimation : public gfx::MultiAnimation {
  38  public:
  39   virtual ~TabRecordingIndicatorAnimation() {}
  40
  41   // Overridden to provide alternating "towards in" and "towards out" behavior.
  42   virtual double GetCurrentValue() const OVERRIDE;
  43
  44   static scoped_ptr<TabRecordingIndicatorAnimation> Create();
  45
  46  private:
  47   TabRecordingIndicatorAnimation(const gfx::MultiAnimation::Parts& parts,
  48                                  const base::TimeDelta interval)
  49       : MultiAnimation(parts, interval) {}
  50
  51   // Number of times to "toggle throb" the recording and tab capture indicators
  52   // when they first appear.
  53   static const int kCaptureIndicatorThrobCycles = 5;
  54 };
  55
  56 double TabRecordingIndicatorAnimation::GetCurrentValue() const {
  57   return current_part_index() % 2 ?
  58       1.0 - MultiAnimation::GetCurrentValue() :
  59       MultiAnimation::GetCurrentValue();
  60 }
  61
  62 scoped_ptr<TabRecordingIndicatorAnimation>
  63 TabRecordingIndicatorAnimation::Create() {
  64   MultiAnimation::Parts parts;
  65   COMPILE_ASSERT(kCaptureIndicatorThrobCycles % 2 != 0,
  66                  must_be_odd_so_animation_finishes_in_showing_state);
  67   for (int i = 0; i < kCaptureIndicatorThrobCycles; ++i) {
  68     parts.push_back(MultiAnimation::Part(
  69         i % 2 ? kIndicatorFadeOutDurationMs : kIndicatorFadeInDurationMs,
  70         gfx::Tween::EASE_IN));
  71   }
  72   const base::TimeDelta interval =
  73       base::TimeDelta::FromMilliseconds(kIndicatorFrameIntervalMs);
  74   scoped_ptr<TabRecordingIndicatorAnimation> animation(
  75       new TabRecordingIndicatorAnimation(parts, interval));
  76   animation->set_continuous(false);
  77   return animation.Pass();
  78 }
  79
  80 }  // namespace
  81
  82 bool ShouldTabShowFavicon(int capacity,
  83                           bool is_pinned_tab,
  84                           bool is_active_tab,
  85                           bool has_favicon,
  86                           TabMediaState media_state) {
  87   if (!has_favicon)
  88     return false;
  89   int required_capacity = 1;
  90   if (ShouldTabShowCloseButton(capacity, is_pinned_tab, is_active_tab))
  91     ++required_capacity;
  92   if (ShouldTabShowMediaIndicator(
  93           capacity, is_pinned_tab, is_active_tab, has_favicon, media_state)) {
  94     ++required_capacity;
  95   }
  96   return capacity >= required_capacity;
  97 }
  98
  99 bool ShouldTabShowMediaIndicator(int capacity,
 100                                  bool is_pinned_tab,
 101                                  bool is_active_tab,
 102                                  bool has_favicon,
 103                                  TabMediaState media_state) {
 104   if (media_state == TAB_MEDIA_STATE_NONE)
 105     return false;
 106   if (ShouldTabShowCloseButton(capacity, is_pinned_tab, is_active_tab))
 107     return capacity >= 2;
 108   return capacity >= 1;
 109 }
 110
 111 bool ShouldTabShowCloseButton(int capacity,
 112                               bool is_pinned_tab,
 113                               bool is_active_tab) {
 114   if (is_pinned_tab)
 115     return false;
 116   else if (is_active_tab)
 117     return true;
 118   else
 119     return capacity >= 3;
 120 }
 121
 122 bool IsPlayingAudio(content::WebContents* contents) {
 123   return contents->WasRecentlyAudible();
 124 }
 125
 126 TabMediaState GetTabMediaStateForContents(content::WebContents* contents) {
 127   if (!contents)
 128     return TAB_MEDIA_STATE_NONE;
 129
 130   scoped_refptr<MediaStreamCaptureIndicator> indicator =
 131       MediaCaptureDevicesDispatcher::GetInstance()->
 132           GetMediaStreamCaptureIndicator();
 133   if (indicator.get()) {
 134     if (indicator->IsBeingMirrored(contents))
 135       return TAB_MEDIA_STATE_CAPTURING;
 136     if (indicator->IsCapturingUserMedia(contents))
 137       return TAB_MEDIA_STATE_RECORDING;
 138   }
 139
 140   if (IsTabAudioMutingFeatureEnabled() && contents->IsAudioMuted())
 141     return TAB_MEDIA_STATE_AUDIO_MUTING;
 142   if (IsPlayingAudio(contents))
 143     return TAB_MEDIA_STATE_AUDIO_PLAYING;
 144
 145   return TAB_MEDIA_STATE_NONE;
 146 }
 147
 148 const gfx::Image& GetTabMediaIndicatorImage(TabMediaState media_state) {
 149   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 150   switch (media_state) {
 151     case TAB_MEDIA_STATE_AUDIO_PLAYING:
 152       return rb.GetNativeImageNamed(IDR_TAB_AUDIO_INDICATOR);
 153     case TAB_MEDIA_STATE_AUDIO_MUTING:
 154       return rb.GetNativeImageNamed(IDR_TAB_AUDIO_MUTING_INDICATOR);
 155     case TAB_MEDIA_STATE_RECORDING:
 156       return rb.GetNativeImageNamed(IDR_TAB_RECORDING_INDICATOR);
 157     case TAB_MEDIA_STATE_CAPTURING:
 158       return rb.GetNativeImageNamed(IDR_TAB_CAPTURE_INDICATOR);
 159     case TAB_MEDIA_STATE_NONE:
 160       break;
 161   }
 162   NOTREACHED();
 163   return rb.GetNativeImageNamed(IDR_SAD_FAVICON);
 164 }
 165
 166 const gfx::Image& GetTabMediaIndicatorAffordanceImage(
 167     TabMediaState media_state) {
 168   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 169   switch (media_state) {
 170     case TAB_MEDIA_STATE_AUDIO_PLAYING:
 171     case TAB_MEDIA_STATE_AUDIO_MUTING:
 172       return rb.GetNativeImageNamed(IDR_TAB_AUDIO_MUTING_AFFORDANCE);
 173     case TAB_MEDIA_STATE_NONE:
 174     case TAB_MEDIA_STATE_RECORDING:
 175     case TAB_MEDIA_STATE_CAPTURING:
 176       return GetTabMediaIndicatorImage(media_state);
 177   }
 178   NOTREACHED();
 179   return GetTabMediaIndicatorImage(media_state);
 180 }
 181
 182 scoped_ptr<gfx::Animation> CreateTabMediaIndicatorFadeAnimation(
 183     TabMediaState media_state) {
 184   if (media_state == TAB_MEDIA_STATE_RECORDING ||
 185       media_state == TAB_MEDIA_STATE_CAPTURING) {
 186     return TabRecordingIndicatorAnimation::Create().PassAs<gfx::Animation>();
 187   }
 188
 189   // Note: While it seems silly to use a one-part MultiAnimation, it's the only
 190   // gfx::Animation implementation that lets us control the frame interval.
 191   gfx::MultiAnimation::Parts parts;
 192   const bool is_for_fade_in = (media_state != TAB_MEDIA_STATE_NONE);
 193   parts.push_back(gfx::MultiAnimation::Part(
 194       is_for_fade_in ? kIndicatorFadeInDurationMs : kIndicatorFadeOutDurationMs,
 195       gfx::Tween::EASE_IN));
 196   const base::TimeDelta interval =
 197       base::TimeDelta::FromMilliseconds(kIndicatorFrameIntervalMs);
 198   scoped_ptr<gfx::MultiAnimation> animation(
 199       new gfx::MultiAnimation(parts, interval));
 200   animation->set_continuous(false);
 201   return animation.PassAs<gfx::Animation>();
 202 }
 203
 204 base::string16 AssembleTabTooltipText(const base::string16& title,
 205                                       TabMediaState media_state) {
 206   if (media_state == TAB_MEDIA_STATE_NONE)
 207     return title;
 208
 209   base::string16 result = title;
 210   if (!result.empty())
 211     result.append(1, '\n');
 212   switch (media_state) {
 213     case TAB_MEDIA_STATE_AUDIO_PLAYING:
 214       result.append(
 215           l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_AUDIO_PLAYING));
 216       break;
 217     case TAB_MEDIA_STATE_AUDIO_MUTING:
 218       result.append(
 219           l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_AUDIO_MUTING));
 220       break;
 221     case TAB_MEDIA_STATE_RECORDING:
 222       result.append(
 223           l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_RECORDING));
 224       break;
 225     case TAB_MEDIA_STATE_CAPTURING:
 226       result.append(
 227           l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_CAPTURING));
 228       break;
 229     case TAB_MEDIA_STATE_NONE:
 230       NOTREACHED();
 231       break;
 232   }
 233   return result;
 234 }
 235
 236 bool IsTabAudioMutingFeatureEnabled() {
 237 #if defined(USE_AURA)
 238   return base::CommandLine::ForCurrentProcess()->HasSwitch(
 239       switches::kEnableTabAudioMuting);
 240 #else
 241   return false;
 242 #endif
 243 }
 244
 245 bool CanToggleAudioMute(content::WebContents* contents) {
 246   switch (GetTabMediaStateForContents(contents)) {
 247     case TAB_MEDIA_STATE_NONE:
 248     case TAB_MEDIA_STATE_AUDIO_PLAYING:
 249     case TAB_MEDIA_STATE_AUDIO_MUTING:
 250       return IsTabAudioMutingFeatureEnabled();
 251     case TAB_MEDIA_STATE_RECORDING:
 252     case TAB_MEDIA_STATE_CAPTURING:
 253       return false;
 254   }
 255   NOTREACHED();
 256   return false;
 257 }
 258
 259 void SetTabAudioMuted(content::WebContents* contents, bool mute) {
 260   if (!contents || !chrome::CanToggleAudioMute(contents))
 261     return;
 262   contents->SetAudioMuted(mute);
 263 }
 264
 265 bool IsTabAudioMuted(content::WebContents* contents) {
 266   return contents && contents->IsAudioMuted();
 267 }
 268
 269 bool AreAllTabsMuted(const TabStripModel& tab_strip,
 270                      const std::vector<int>& indices) {
 271   for (std::vector<int>::const_iterator i = indices.begin(); i != indices.end();
 272        ++i) {
 273     if (!IsTabAudioMuted(tab_strip.GetWebContentsAt(*i)))
 274       return false;
 275   }
 276   return true;
 277 }
 278
 279 }  // namespace chrome