Replace animated tab audio indicator with static tab audio indicator.

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 <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 447 matching lines @@
       closing_(false),
       dragging_(false),
       favicon_hiding_offset_(0),
       loading_animation_frame_(0),
       immersive_loading_step_(0),
       should_display_crashed_favicon_(false),
       theme_provider_(NULL),
       tab_activated_with_last_gesture_begin_(false),
       hover_controller_(this),
       showing_icon_(false),
+      showing_audio_indicator_(false),
       showing_close_button_(false),
       close_button_color_(0) {
   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);
 
   // Add the Close Button.
   close_button_ = new TabCloseButton(this);
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   close_button_->SetImage(views::CustomButton::STATE_NORMAL,
                           rb.GetImageSkiaNamed(IDR_CLOSE_1));
   close_button_->SetImage(views::CustomButton::STATE_HOVERED,
                           rb.GetImageSkiaNamed(IDR_CLOSE_1_H));
   close_button_->SetImage(views::CustomButton::STATE_PRESSED,
                           rb.GetImageSkiaNamed(IDR_CLOSE_1_P));
   close_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_CLOSE));
   // Disable animation so that the red danger sign shows up immediately
   // to help avoid mis-clicks.
   close_button_->SetAnimationDuration(0);
   AddChildView(close_button_);
 
   set_context_menu_controller(this);
-
-  tab_audio_indicator_.reset(new TabAudioIndicator(this));
 }
 
 Tab::~Tab() {
 }
 
 void Tab::set_animation_container(ui::AnimationContainer* container) {
   animation_container_ = container;
   hover_controller_.SetAnimationContainer(container);
-  tab_audio_indicator_->SetAnimationContainer(container);
 }
 
 bool Tab::IsActive() const {
   return controller() ? controller()->IsActiveTab(this) : true;
 }
 
 bool Tab::IsSelected() const {
   return controller() ? controller()->IsTabSelected(this) : true;
 }
 
@@ skipping 33 matching lines @@
     ResetCrashedFavicon();
   }
 
   if (old.mini != data_.mini) {
     if (tab_animation_.get() && tab_animation_->is_animating()) {
       tab_animation_->Stop();
       tab_animation_.reset(NULL);
     }
   }
 
-  tab_audio_indicator_->SetIsPlayingAudio(data_.AudioActive());
-
   DataChanged(old);
 
   Layout();
   SchedulePaint();
 }
 
 void Tab::UpdateLoadingAnimation(TabRendererData::NetworkState state) {
   if (state == data_.network_state &&
       state == TabRendererData::NETWORK_STATE_NONE) {
     // If the network state is none and hasn't changed, do nothing. Otherwise we
@@ skipping 101 matching lines @@
 int Tab::GetMiniWidth() {
   return browser_defaults::kMiniTabWidth;
 }
 
 // static
 int Tab::GetImmersiveHeight() {
   return kImmersiveTabHeight;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Tab, TabAudioIndicator::Delegate overrides:
-
-void Tab::ScheduleAudioIndicatorPaint() {
-  // No need to schedule a paint if another animation is active. The other
-  // animation will do its own scheduling.
-  if (!icon_animation_)
-    ScheduleIconPaint();
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // Tab, AnimationDelegate overrides:
 
 void Tab::AnimationProgressed(const ui::Animation* animation) {
   // Ignore if the pulse animation is being performed on active tab because
   // it repaints the same image. See |Tab::PaintTabBackground()|.
   if (animation == tab_animation_.get() && IsActive())
     return;
   SchedulePaint();
 }
 
@@ skipping 72 matching lines @@
   content_height = std::max(content_height, close_button_size.height());
 
   // Size the Favicon.
   showing_icon_ = ShouldShowIcon();
   if (showing_icon_) {
     // Use the size of the favicon as apps use a bigger favicon size.
     int favicon_top = top_padding() + content_height / 2 - tab_icon_size() / 2;
     int favicon_left = lb.x();
     favicon_bounds_.SetRect(favicon_left, favicon_top,
                             tab_icon_size(), tab_icon_size());
-    if (data().mini && width() < kMiniTabRendererAsNormalTabWidth) {
-      // Adjust the location of the favicon when transitioning from a normal
-      // tab to a mini-tab.
-      int mini_delta = kMiniTabRendererAsNormalTabWidth - GetMiniWidth();
-      int ideal_delta = width() - GetMiniWidth();
-      if (ideal_delta < mini_delta) {
-        int ideal_x = (GetMiniWidth() - tab_icon_size()) / 2;
-        int x = favicon_bounds_.x() + static_cast<int>(
-            (1 - static_cast<float>(ideal_delta) /
-             static_cast<float>(mini_delta)) *
-            (ideal_x - favicon_bounds_.x()));
-        favicon_bounds_.set_x(x);
-      }
-    }
+    MaybeAdjustLeftForMiniTab(&favicon_bounds_);
   } else {
     favicon_bounds_.SetRect(lb.x(), lb.y(), 0, 0);
   }
 
   // Size the Close button.
   showing_close_button_ = ShouldShowCloseBox();
   const bool is_host_desktop_type_ash =
       GetHostDesktopType(this) == chrome::HOST_DESKTOP_TYPE_ASH;
   if (showing_close_button_) {
     const int close_button_vert_fuzz = is_host_desktop_type_ash ?
@@ skipping 16 matching lines @@
     close_button_->set_border(views::Border::CreateEmptyBorder(top_border,
         left_border, bottom_border, right_border));
     close_button_->SetPosition(gfx::Point(lb.width(), 0));
     close_button_->SizeToPreferredSize();
     close_button_->SetVisible(true);
   } else {
     close_button_->SetBounds(0, 0, 0, 0);
     close_button_->SetVisible(false);
   }
 
+  showing_audio_indicator_ = ShouldShowAudioIndicator();
+  if (showing_audio_indicator_) {
+    ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+    gfx::ImageSkia audio_indicator_image(
+        *rb.GetImageSkiaNamed(IDR_TAB_AUDIO_INDICATOR));
+    const int top =
+        top_padding() + (content_height - audio_indicator_image.height()) / 2;
+    const int right = showing_close_button_ ?

[sky, 2013/09/16 23:47:19]

Does this work when RTL?

[miu, 2013/09/19 02:37:11]

Yes.  All the layout code sets its bounds under the assumption of LTR, and at
Paint time "mirrors" everything for RTL.  I tested this by forcing
base::i18n::IsRTL() to return true, which caused the entire UI to switch into
RTL layout.

+        close_button_->x() + close_button_->GetInsets().left() : lb.right();
+    const int left = std::max(lb.x(), right - audio_indicator_image.width());
+    audio_indicator_bounds_.SetRect(left, top,
+                                    tab_icon_size(), tab_icon_size());
+    MaybeAdjustLeftForMiniTab(&audio_indicator_bounds_);
+  } else {
+    audio_indicator_bounds_.SetRect(lb.x(), lb.y(), 0, 0);
+  }
+
   const int title_text_offset = is_host_desktop_type_ash ?
       kTitleTextOffsetYAsh : kTitleTextOffsetY;
   int title_left = favicon_bounds_.right() + kFaviconTitleSpacing;
   int title_top = top_padding() + title_text_offset +
       (content_height - font_height_) / 2;
   // Size the Title text to fill the remaining space.
   if (!data().mini || width() >= kMiniTabRendererAsNormalTabWidth) {
     // If the user has big fonts, the title will appear rendered too far down
     // on the y-axis if we use the regular top padding, so we need to adjust it
     // so that the text appears centered.
     gfx::Size minimum_size = GetMinimumUnselectedSize();
     int text_height = title_top + font_height_ + bottom_padding();
     if (text_height > minimum_size.height())
       title_top -= (text_height - minimum_size.height()) / 2;
 
     int title_width;
-    if (close_button_->visible()) {
+    if (showing_audio_indicator_) {
+      title_width = audio_indicator_bounds_.x() - kTitleCloseButtonSpacing -
+          title_left;
+    } else if (close_button_->visible()) {
       // The close button has an empty border with some padding (see details
       // above where the close-button's bounds is set). Allow the title to
       // overlap the empty padding.
-      title_width = std::max(close_button_->x() +
-                             close_button_->GetInsets().left() -
-                             kTitleCloseButtonSpacing - title_left, 0);
+      title_width = close_button_->x() + close_button_->GetInsets().left() -
+          kTitleCloseButtonSpacing - title_left;
     } else {
-      title_width = std::max(lb.width() - title_left, 0);
+      title_width = lb.width() - title_left;
     }
+    title_width = std::max(title_width, 0);
     title_bounds_.SetRect(title_left, title_top, title_width, font_height_);
   } else {
     title_bounds_.SetRect(title_left, title_top, 0, 0);
   }
 
   // Certain UI elements within the Tab (the favicon, etc.) are not represented
   // as child Views (which is the preferred method).  Instead, these UI elements
   // are drawn directly on the canvas from within Tab::OnPaint(). The Tab's
   // child Views (for example, the Tab's close button which is a views::Button
   // instance) are automatically mirrored by the mirroring infrastructure in
@@ skipping 200 matching lines @@
 // Tab, private
 
 const gfx::Rect& Tab::GetTitleBounds() const {
   return title_bounds_;
 }
 
 const gfx::Rect& Tab::GetIconBounds() const {
   return favicon_bounds_;
 }
 
+void Tab::MaybeAdjustLeftForMiniTab(gfx::Rect* bounds) const {
+  if (!data().mini || width() >= kMiniTabRendererAsNormalTabWidth)
+    return;
+  const int mini_delta = kMiniTabRendererAsNormalTabWidth - GetMiniWidth();
+  const int ideal_delta = width() - GetMiniWidth();
+  const int ideal_x = (GetMiniWidth() - bounds->width()) / 2;
+  bounds->set_x(bounds->x() + static_cast<int>(

[sky, 2013/09/16 23:47:19]

Wasn't the old code conditionally doing this? (789 old).

[miu, 2013/09/19 02:37:11]

Sort of.  Yes, there was an "if (ideal_delta < mini_delta)" but if you do some
basic algebra, you find out it's completely redundant:

  ideal_delta < mini_delta

expands to:

  width() - GetMiniWidth() < kMiniTabRendererAsNormalTabWidth - GetMiniWidth()

which simplifies to:

  width() < kMiniTabRendererAsNormalTabWidth

The negation of this is being tested at the top of the method, forcing an early
return.

+      (1 - static_cast<float>(ideal_delta) / static_cast<float>(mini_delta)) *
+      (ideal_x - bounds->x())));
+}
+
 void Tab::DataChanged(const TabRendererData& old) {
   if (data().blocked == old.blocked)
     return;
 
   if (data().blocked)
     StartPulse();
   else
     StopPulse();
 }
 
 void Tab::PaintTab(gfx::Canvas* canvas) {
   // See if the model changes whether the icons should be painted.
   const bool show_icon = ShouldShowIcon();
+  const bool show_audio_indicator = ShouldShowAudioIndicator();
   const bool show_close_button = ShouldShowCloseBox();
-  if (show_icon != showing_icon_ || show_close_button != showing_close_button_)
+  if (show_icon != showing_icon_ ||
+      show_audio_indicator != showing_audio_indicator_ ||
+      show_close_button != showing_close_button_) {
     Layout();
+  }
 
   PaintTabBackground(canvas);
 
   SkColor title_color = GetThemeProvider()->
       GetColor(IsSelected() ?
           ThemeProperties::COLOR_TAB_TEXT :
           ThemeProperties::COLOR_BACKGROUND_TAB_TEXT);
 
   if (!data().mini || width() > kMiniTabRendererAsNormalTabWidth)
     PaintTitle(canvas, title_color);
 
   if (show_icon)
     PaintIcon(canvas);
 
+  if (show_audio_indicator)
+    PaintAudioIndicator(canvas);
+
   // If the close button color has changed, generate a new one.
   if (!close_button_color_ || title_color != close_button_color_) {
     close_button_color_ = title_color;
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     close_button_->SetBackground(close_button_color_,
         rb.GetImageSkiaNamed(IDR_CLOSE_1),
         rb.GetImageSkiaNamed(IDR_CLOSE_1_MASK));
   }
 }
 
@@ skipping 330 matching lines @@
                        resized_icon.height(),
                        resized_bounds, true, SkPaint());
 
         ui::ThemeProvider* tp = GetThemeProvider();
         gfx::ImageSkia projection_screen(
             *tp->GetImageSkiaNamed(IDR_TAB_CAPTURE));
         DrawIconCenter(canvas, projection_screen, 0,
                        data().favicon.width(),
                        data().favicon.height(),
                        bounds, true, SkPaint());
-      } else if (!icon_animation_ && tab_audio_indicator_->IsAnimating()) {
-        // Draw the audio indicator UI only if no other icon animation is
-        // active.
-        if (!icon_animation_ && tab_audio_indicator_->IsAnimating()) {
-          tab_audio_indicator_->set_favicon(data().favicon);
-          tab_audio_indicator_->Paint(canvas, bounds);
-        }
       } else {
         DrawIconCenter(canvas, data().favicon, 0,
                        data().favicon.width(),
                        data().favicon.height(),
                        bounds, true, SkPaint());
       }
     }
   }
   canvas->Restore();
 
@@ skipping 89 matching lines @@
 
     // Draw the recording icon.
     DrawIconBottomRight(canvas, recording_dot, 0,
                         recording_dot.width(), recording_dot.height(),
                         bounds, false, paint);
   } else {
     NOTREACHED();
   }
 }
 
+void Tab::PaintAudioIndicator(gfx::Canvas* canvas) {
+  gfx::Rect bounds = audio_indicator_bounds_;
+  if (bounds.IsEmpty())

[sky, 2013/09/16 23:47:19]

nit: do the test on audio_indicator_bounds_ and move bounds to 1585.

[miu, 2013/09/19 02:37:11]

Done.

+    return;
+
+  bounds.set_x(GetMirroredXForRect(bounds));
+
+  canvas->Save();

[sky, 2013/09/16 23:47:19]

DrawIconAtLocation?

[miu, 2013/09/19 02:37:11]

Oh, duh.  Yeah, that's much cleaner.  :)

+  canvas->ClipRect(GetLocalBounds());
+  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+  gfx::ImageSkia audio_indicator_image(
+      *rb.GetImageSkiaNamed(IDR_TAB_AUDIO_INDICATOR));
+  DrawIconCenter(canvas, audio_indicator_image, 0,
+                  audio_indicator_image.width(),
+                  audio_indicator_image.height(),
+                  bounds, true, SkPaint());
+  canvas->Restore();
+}
+
 void Tab::PaintTitle(gfx::Canvas* canvas, SkColor title_color) {
   // Paint the Title.
   const gfx::Rect& title_bounds = GetTitleBounds();
   string16 title = data().title;
 
   if (title.empty()) {
     title = data().loading ?
         l10n_util::GetStringUTF16(IDS_TAB_LOADING_TITLE) :
         CoreTabHelper::GetDefaultTitle();
   } else {
@@ skipping 59 matching lines @@
   }
   if (controller() && controller()->IsImmersiveStyle())
     SchedulePaintInRect(GetImmersiveBarRect());
   else
     ScheduleIconPaint();
 }
 
 int Tab::IconCapacity() const {
   if (height() < GetMinimumUnselectedSize().height())
     return 0;
-  return (width() - left_padding() - right_padding()) / tab_icon_size();
+  const int kPaddingBetweenIcons = 2;
+  return (width() - left_padding() - right_padding()) /
+      (tab_icon_size() + kPaddingBetweenIcons);
 }
 
 bool Tab::ShouldShowIcon() const {
+  if (!data().show_icon)
+    return false;
+  const bool should_show_audio_indicator = ShouldShowAudioIndicator();
+  if (data().mini && height() >= GetMinimumUnselectedSize().height()) {
+    // Audio indicator always takes precendence over the favicon for mini tabs.
+    return !should_show_audio_indicator;
+  }
+  int required_capacity = should_show_audio_indicator ? 2 : 1;
+  if (IsActive()) {
+    // Active tabs give priority to the close button, then the audio indicator,
+    // then the favicon.
+    ++required_capacity;
+  } else {
+    // Non-active tabs give priority to the audio indicator, then the favicon,
+    // and finally the close button.
+  }
+  return IconCapacity() >= required_capacity;
+}
+
+bool Tab::ShouldShowAudioIndicator() const {
+  // Note: If the capture indicator is active, then do not show the audio
+  // indicator.  This allows the favicon "throbber" animation to be shown in
+  // small-width situations.
+  if (!data().AudioActive() || data().CaptureActive())
+    return false;
   if (data().mini && height() >= GetMinimumUnselectedSize().height())
     return true;
-  if (!data().show_icon) {
-    return false;
-  } else if (IsActive()) {
-    // The active tab clips favicon before close button.
+  if (IsActive()) {
+    // The active tab clips the audio indicator before the close button.
     return IconCapacity() >= 2;
   }
-  // Non-selected tabs clip close button before favicon.
+  // Non-active tabs clip close button before the audio indicator.
   return IconCapacity() >= 1;
 }
 
 bool Tab::ShouldShowCloseBox() const {
   // The active tab never clips close button.
   return !data().mini && (IsActive() || IconCapacity() >= 3);
 }
 
 double Tab::GetThrobValue() {
   bool is_selected = IsSelected();
@@ skipping 156 matching lines @@
                          const gfx::ImageSkia& image) {
   DCHECK_NE(scale_factor, ui::SCALE_FACTOR_NONE);
   ImageCacheEntry entry;
   entry.resource_id = resource_id;
   entry.scale_factor = scale_factor;
   entry.image = image;
   image_cache_->push_front(entry);
   if (image_cache_->size() > kMaxImageCacheSize)
     image_cache_->pop_back();
 }