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/strings/string16.h"
   8 #include "chrome/browser/media/audio_stream_indicator.h"
   9 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
  10 #include "chrome/browser/media/media_stream_capture_indicator.h"
  11 #include "grit/generated_resources.h"
  12 #include "grit/theme_resources.h"
  13 #include "ui/base/l10n/l10n_util.h"
  14 #include "ui/base/resource/resource_bundle.h"
  15 #include "ui/gfx/animation/multi_animation.h"
  16
  17 namespace chrome {
  18
  19 namespace {
  20
  21 // Interval between frame updates of the tab indicator animations.  This is not
  22 // the usual 60 FPS because a trade-off must be made between tab UI animation
  23 // smoothness and media recording/playback performance on low-end hardware.
  24 const int kIndicatorFrameIntervalMs = 50;  // 20 FPS
  25
  26 // Fade-in/out duration for the tab indicator animations.  Fade-in is quick to
  27 // immediately notify the user.  Fade-out is more gradual, so that the user has
  28 // a chance of finding a tab that has quickly "blipped" on and off.
  29 const int kIndicatorFadeInDurationMs = 200;
  30 const int kIndicatorFadeOutDurationMs = 1000;
  31
  32 // Animation that throbs in (towards 1.0) and out (towards 0.0), and ends in the
  33 // "in" state.
  34 class TabRecordingIndicatorAnimation : public gfx::MultiAnimation {
  35  public:
  36   virtual ~TabRecordingIndicatorAnimation() {}
  37
  38   // Overridden to provide alternating "towards in" and "towards out" behavior.
  39   virtual double GetCurrentValue() const OVERRIDE;
  40
  41   static scoped_ptr<TabRecordingIndicatorAnimation> Create();
  42
  43  private:
  44   TabRecordingIndicatorAnimation(const gfx::MultiAnimation::Parts& parts,
  45                                  const base::TimeDelta interval)
  46       : MultiAnimation(parts, interval) {}
  47
  48   // Number of times to "toggle throb" the recording and tab capture indicators
  49   // when they first appear.
  50   static const int kCaptureIndicatorThrobCycles = 5;
  51 };
  52
  53 double TabRecordingIndicatorAnimation::GetCurrentValue() const {
  54   return current_part_index() % 2 ?
  55       1.0 - MultiAnimation::GetCurrentValue() :
  56       MultiAnimation::GetCurrentValue();
  57 }
  58
  59 scoped_ptr<TabRecordingIndicatorAnimation>
  60 TabRecordingIndicatorAnimation::Create() {
  61   MultiAnimation::Parts parts;
  62   COMPILE_ASSERT(kCaptureIndicatorThrobCycles % 2 != 0,
  63                  must_be_odd_so_animation_finishes_in_showing_state);
  64   for (int i = 0; i < kCaptureIndicatorThrobCycles; ++i) {
  65     parts.push_back(MultiAnimation::Part(
  66         i % 2 ? kIndicatorFadeOutDurationMs : kIndicatorFadeInDurationMs,
  67         gfx::Tween::EASE_IN));
  68   }
  69   const base::TimeDelta interval =
  70       base::TimeDelta::FromMilliseconds(kIndicatorFrameIntervalMs);
  71   scoped_ptr<TabRecordingIndicatorAnimation> animation(
  72       new TabRecordingIndicatorAnimation(parts, interval));
  73   animation->set_continuous(false);
  74   return animation.Pass();
  75 }
  76
  77 }  // namespace
  78
  79 bool ShouldTabShowFavicon(int capacity,
  80                           bool is_pinned_tab,
  81                           bool is_active_tab,
  82                           bool has_favicon,
  83                           TabMediaState media_state) {
  84   if (!has_favicon)
  85     return false;
  86   int required_capacity = 1;
  87   if (ShouldTabShowCloseButton(capacity, is_pinned_tab, is_active_tab))
  88     ++required_capacity;
  89   if (ShouldTabShowMediaIndicator(
  90           capacity, is_pinned_tab, is_active_tab, has_favicon, media_state)) {
  91     ++required_capacity;
  92   }
  93   return capacity >= required_capacity;
  94 }
  95
  96 bool ShouldTabShowMediaIndicator(int capacity,
  97                                  bool is_pinned_tab,
  98                                  bool is_active_tab,
  99                                  bool has_favicon,
 100                                  TabMediaState media_state) {
 101   if (media_state == TAB_MEDIA_STATE_NONE)
 102     return false;
 103   if (ShouldTabShowCloseButton(capacity, is_pinned_tab, is_active_tab))
 104     return capacity >= 2;
 105   return capacity >= 1;
 106 }
 107
 108 bool ShouldTabShowCloseButton(int capacity,
 109                               bool is_pinned_tab,
 110                               bool is_active_tab) {
 111   if (is_pinned_tab)
 112     return false;
 113   else if (is_active_tab)
 114     return true;
 115   else
 116     return capacity >= 3;
 117 }
 118
 119 bool IsPlayingAudio(content::WebContents* contents) {
 120   AudioStreamIndicator* audio_indicator =
 121       MediaCaptureDevicesDispatcher::GetInstance()->GetAudioStreamIndicator()
 122           .get();
 123   return audio_indicator && audio_indicator->IsPlayingAudio(contents);
 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) {
 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 (IsPlayingAudio(contents))
 141     return TAB_MEDIA_STATE_AUDIO_PLAYING;
 142
 143   return TAB_MEDIA_STATE_NONE;
 144 }
 145
 146 const gfx::Image& GetTabMediaIndicatorImage(TabMediaState media_state) {
 147   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 148   switch (media_state) {
 149     case TAB_MEDIA_STATE_AUDIO_PLAYING:
 150       return rb.GetNativeImageNamed(IDR_TAB_AUDIO_INDICATOR);
 151     case TAB_MEDIA_STATE_RECORDING:
 152       return rb.GetNativeImageNamed(IDR_TAB_RECORDING_INDICATOR);
 153     case TAB_MEDIA_STATE_CAPTURING:
 154       return rb.GetNativeImageNamed(IDR_TAB_CAPTURE_INDICATOR);
 155     case TAB_MEDIA_STATE_NONE:
 156       break;
 157   }
 158   NOTREACHED();
 159   return rb.GetNativeImageNamed(IDR_SAD_FAVICON);
 160 }
 161
 162 scoped_ptr<gfx::Animation> CreateTabMediaIndicatorFadeAnimation(
 163     TabMediaState media_state) {
 164   if (media_state == TAB_MEDIA_STATE_RECORDING ||
 165       media_state == TAB_MEDIA_STATE_CAPTURING) {
 166     return TabRecordingIndicatorAnimation::Create().PassAs<gfx::Animation>();
 167   }
 168
 169   // Note: While it seems silly to use a one-part MultiAnimation, it's the only
 170   // gfx::Animation implementation that lets us control the frame interval.
 171   gfx::MultiAnimation::Parts parts;
 172   const bool is_for_fade_in = (media_state != TAB_MEDIA_STATE_NONE);
 173   parts.push_back(gfx::MultiAnimation::Part(
 174       is_for_fade_in ? kIndicatorFadeInDurationMs : kIndicatorFadeOutDurationMs,
 175       gfx::Tween::EASE_IN));
 176   const base::TimeDelta interval =
 177       base::TimeDelta::FromMilliseconds(kIndicatorFrameIntervalMs);
 178   scoped_ptr<gfx::MultiAnimation> animation(
 179       new gfx::MultiAnimation(parts, interval));
 180   animation->set_continuous(false);
 181   return animation.PassAs<gfx::Animation>();
 182 }
 183
 184 base::string16 AssembleTabTooltipText(const base::string16& title,
 185                                       TabMediaState media_state) {
 186   if (media_state == TAB_MEDIA_STATE_NONE)
 187     return title;
 188
 189   base::string16 result = title;
 190   if (!result.empty())
 191     result.append(1, '\n');
 192   switch (media_state) {
 193     case TAB_MEDIA_STATE_AUDIO_PLAYING:
 194       result.append(
 195           l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_AUDIO_PLAYING));
 196       break;
 197     case TAB_MEDIA_STATE_RECORDING:
 198       result.append(
 199           l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_RECORDING));
 200       break;
 201     case TAB_MEDIA_STATE_CAPTURING:
 202       result.append(
 203           l10n_util::GetStringUTF16(IDS_TOOLTIP_TAB_MEDIA_STATE_CAPTURING));
 204       break;
 205     case TAB_MEDIA_STATE_NONE:
 206       NOTREACHED();
 207       break;
 208   }
 209   return result;
 210 }
 211
 212 }  // namespace chrome