Tab audio mute control (views UI), behind a switch (off by default).

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"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tabs/tab_resources.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/browser/ui/view_ids.h"
+#include "chrome/browser/ui/views/tabs/media_indicator_button.h"
 #include "chrome/browser/ui/views/tabs/tab_controller.h"
 #include "chrome/browser/ui/views/theme_image_mapper.h"
 #include "chrome/browser/ui/views/touch_uma/touch_uma.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
+#include "content/public/browser/user_metrics.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/aura/env.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/animation/animation_container.h"
 #include "ui/gfx/animation/multi_animation.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_analysis.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/rect_based_targeting_utils.h"
 #include "ui/views/view_targeter.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/non_client_view.h"
 
+using base::UserMetricsAction;
+
 namespace {
 
 // Padding around the "content" of a tab, occupied by the tab border graphics.
 const int kLeftPadding = 22;
 const int kTopPadding = 4;
 const int kRightPadding = 17;
 const int kBottomPadding = 2;
 
 // Height of the shadow at the top of the tab image assets.
 const int kDropShadowHeight = 4;
@@ skipping 340 matching lines @@
 
 Tab::Tab(TabController* controller)
     : controller_(controller),
       closing_(false),
       dragging_(false),
       detached_(false),
       favicon_hiding_offset_(0),
       loading_animation_frame_(0),
       immersive_loading_step_(0),
       should_display_crashed_favicon_(false),
-      animating_media_state_(TAB_MEDIA_STATE_NONE),
       close_button_(NULL),
+      media_indicator_button_(NULL),
       title_(new views::Label()),
       tab_activated_with_last_tap_down_(false),
       hover_controller_(this),
       showing_icon_(false),
       showing_media_indicator_(false),
       showing_close_button_(false),
       close_button_color_(0) {
   DCHECK(controller);
   InitTabResources();
 
@@ skipping 78 matching lines @@
 #else
       StartCrashAnimation();
 #endif
     }
   } else {
     if (IsPerformingCrashAnimation())
       StopCrashAnimation();
     ResetCrashedFavicon();
   }
 
-  if (data_.media_state != old.media_state) {
-    if (data_.media_state != TAB_MEDIA_STATE_NONE)
-      animating_media_state_ = data_.media_state;
-    StartMediaIndicatorAnimation();
-  }
+  if (data_.media_state != old.media_state)
+    GetMediaIndicatorButton()->TransitionToMediaState(data_.media_state);
 
   if (old.mini != data_.mini) {
     StopAndDeleteAnimation(
         mini_title_change_animation_.PassAs<gfx::Animation>());
   }
 
   DataChanged(old);
 
   Layout();
   SchedulePaint();
@@ skipping 108 matching lines @@
 
 void Tab::AnimationProgressed(const gfx::Animation* animation) {
   // Ignore if the pulse animation is being performed on active tab because
   // it repaints the same image. See |Tab::PaintTabBackground()|.
   if (animation == pulse_animation_.get() && IsActive())
     return;
   SchedulePaint();
 }
 
 void Tab::AnimationCanceled(const gfx::Animation* animation) {
-  if (media_indicator_animation_ == animation)
-    animating_media_state_ = data_.media_state;
   SchedulePaint();
 }
 
 void Tab::AnimationEnded(const gfx::Animation* animation) {
-  if (media_indicator_animation_ == animation)
-    animating_media_state_ = data_.media_state;
   SchedulePaint();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, views::ButtonListener overrides:
 
 void Tab::ButtonPressed(views::Button* sender, const ui::Event& event) {
+  if (media_indicator_button_ && media_indicator_button_->visible()) {
+    if (media_indicator_button_->enabled())
+      content::RecordAction(UserMetricsAction("CloseTab_MuteToggleAvailable"));
+    else if (data_.media_state == TAB_MEDIA_STATE_AUDIO_PLAYING)
+      content::RecordAction(UserMetricsAction("CloseTab_AudioIndicator"));
+    else
+      content::RecordAction(UserMetricsAction("CloseTab_RecordingIndicator"));
+  } else {
+    content::RecordAction(UserMetricsAction("CloseTab_NoMediaIndicator"));
+  }
+
   const CloseTabSource source =
       (event.type() == ui::ET_MOUSE_RELEASED &&
        (event.flags() & ui::EF_FROM_TOUCH) == 0) ? CLOSE_TAB_FROM_MOUSE :
       CLOSE_TAB_FROM_TOUCH;
   DCHECK_EQ(close_button_, sender);
   controller_->CloseTab(this, source);
   if (event.type() == ui::ET_GESTURE_TAP)
     TouchUMA::RecordGestureAction(TouchUMA::GESTURE_TABCLOSE_TAP);
 }
 
@@ skipping 93 matching lines @@
     const int left = kViewSpacing;
     const int right = width() - (lb.width() + close_button_size.width() + left);
     close_button_->SetBorder(
         views::Border::CreateEmptyBorder(top, left, bottom, right));
     close_button_->SetPosition(gfx::Point(lb.width(), 0));
     close_button_->SizeToPreferredSize();
   }
   close_button_->SetVisible(showing_close_button_);
 
   showing_media_indicator_ = ShouldShowMediaIndicator();
-  media_indicator_bounds_.SetRect(lb.x(), lb.y(), 0, 0);
   if (showing_media_indicator_) {
-    const gfx::Image& media_indicator_image =
-        chrome::GetTabMediaIndicatorImage(animating_media_state_);
-    media_indicator_bounds_.set_width(media_indicator_image.Width());
-    media_indicator_bounds_.set_height(media_indicator_image.Height());
-    media_indicator_bounds_.set_y(
-        lb.y() + (lb.height() - media_indicator_bounds_.height() + 1) / 2);
+    views::ImageButton* const button = GetMediaIndicatorButton();
+    const gfx::Size image_size(button->GetPreferredSize());
     const int right = showing_close_button_ ?
         close_button_->x() + close_button_->GetInsets().left() : lb.right();
-    media_indicator_bounds_.set_x(
-        std::max(lb.x(), right - media_indicator_bounds_.width()));
-    MaybeAdjustLeftForMiniTab(&media_indicator_bounds_);
+    gfx::Rect bounds(
+        std::max(lb.x(), right - image_size.width()),
+        lb.y() + (lb.height() - image_size.height() + 1) / 2,
+        image_size.width(),
+        image_size.height());
+    MaybeAdjustLeftForMiniTab(&bounds);
+    button->SetBoundsRect(bounds);
+    button->SetVisible(true);
+  } else if (media_indicator_button_) {
+    media_indicator_button_->SetVisible(false);
   }
 
   // Size the title to fill the remaining width and use all available height.
   bool show_title = !data().mini || width() >= kMiniTabRendererAsNormalTabWidth;
   if (show_title) {
     int title_left = favicon_bounds_.right() + kFaviconTitleSpacing;
     int title_width = lb.width() - title_left;
     if (showing_media_indicator_) {
-      title_width = media_indicator_bounds_.x() - kViewSpacing - title_left;
+      title_width = media_indicator_button_->x() - kViewSpacing - title_left;
     } else if (close_button_->visible()) {
       // Allow the title to overlay the close button's empty border padding.
       title_width = close_button_->x() + close_button_->GetInsets().left() -
           kViewSpacing - title_left;
     }
     gfx::Rect rect(title_left, lb.y(), std::max(title_width, 0), lb.height());
     const int title_height = title_->GetPreferredSize().height();
     if (title_height > rect.height()) {
       rect.set_y(lb.y() - (title_height - rect.height()) / 2);
       rect.set_height(title_height);
     }
-    rect.set_x(GetMirroredXForRect(rect));
     title_->SetBoundsRect(rect);
   }
   title_->SetVisible(show_title);
 }
 
 void Tab::OnThemeChanged() {
   LoadTabImages();
 }
 
 const char* Tab::GetClassName() const {
@@ skipping 80 matching lines @@
       Tab* closest_tab = controller_->GetTabAt(this, event.location());
       if (closest_tab)
         controller_->CloseTab(closest_tab, CLOSE_TAB_FROM_MOUSE);
     }
   } else if (event.IsOnlyLeftMouseButton() && !event.IsShiftDown() &&
              !event.IsControlDown()) {
     // If the tab was already selected mouse pressed doesn't change the
     // selection. Reset it now to handle the case where multiple tabs were
     // selected.
     controller_->SelectTab(this);
+
+    if (media_indicator_button_ && media_indicator_button_->visible() &&
+        media_indicator_button_->bounds().Contains(event.location())) {
+      content::RecordAction(UserMetricsAction("TabMediaIndicator_Clicked"));
+    }
   }
 }
 
 void Tab::OnMouseCaptureLost() {
   controller_->EndDrag(END_DRAG_CAPTURE_LOST);
 }
 
 void Tab::OnMouseEntered(const ui::MouseEvent& event) {
   hover_controller_.Show(views::GlowHoverController::SUBTLE);
 }
@@ skipping 96 matching lines @@
   const SkColor title_color = GetThemeProvider()->GetColor(IsSelected() ?
       ThemeProperties::COLOR_TAB_TEXT :
       ThemeProperties::COLOR_BACKGROUND_TAB_TEXT);
   title_->SetVisible(!data().mini ||
                      width() > kMiniTabRendererAsNormalTabWidth);
   title_->SetEnabledColor(title_color);
 
   if (show_icon)
     PaintIcon(canvas);
 
-  if (show_media_indicator)
-    PaintMediaIndicator(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 298 matching lines @@
                    bounds, true, SkPaint());
   } else if (!data().favicon.isNull()) {
     // Paint the normal favicon.
     DrawIconCenter(canvas, data().favicon, 0,
                    data().favicon.width(),
                    data().favicon.height(),
                    bounds, true, SkPaint());
   }
 }
 
-void Tab::PaintMediaIndicator(gfx::Canvas* canvas) {
-  if (media_indicator_bounds_.IsEmpty() || !media_indicator_animation_)
-    return;
-
-  gfx::Rect bounds = media_indicator_bounds_;
-  bounds.set_x(GetMirroredXForRect(bounds));
-
-  SkPaint paint;
-  paint.setAntiAlias(true);
-  double opaqueness = media_indicator_animation_->GetCurrentValue();
-  if (data_.media_state == TAB_MEDIA_STATE_NONE)
-    opaqueness = 1.0 - opaqueness;  // Fading out, not in.
-  paint.setAlpha(opaqueness * SK_AlphaOPAQUE);
-
-  const gfx::ImageSkia& media_indicator_image =
-      *(chrome::GetTabMediaIndicatorImage(animating_media_state_).
-            ToImageSkia());
-  DrawIconAtLocation(canvas, media_indicator_image, 0,
-                     bounds.x(), bounds.y(), media_indicator_image.width(),
-                     media_indicator_image.height(), true, paint);
-}
-
 void Tab::AdvanceLoadingAnimation(TabRendererData::NetworkState old_state,
                                   TabRendererData::NetworkState state) {
   static bool initialized = false;
   static int loading_animation_frame_count = 0;
   static int waiting_animation_frame_count = 0;
   static int waiting_to_loading_frame_count_ratio = 0;
   if (!initialized) {
     initialized = true;
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     gfx::ImageSkia loading_animation(*rb.GetImageSkiaNamed(IDR_THROBBER));
@@ skipping 56 matching lines @@
   if (available_width >= width_per_icon &&
       available_width < (width_per_icon + kPaddingBetweenIcons)) {
     return 1;
   }
   return available_width / (width_per_icon + kPaddingBetweenIcons);
 }
 
 bool Tab::ShouldShowIcon() const {
   return chrome::ShouldTabShowFavicon(
       IconCapacity(), data().mini, IsActive(), data().show_icon,
-      animating_media_state_);
+      media_indicator_button_ ? media_indicator_button_->showing_media_state() :
+                                data_.media_state);
 }
 
 bool Tab::ShouldShowMediaIndicator() const {
   return chrome::ShouldTabShowMediaIndicator(
       IconCapacity(), data().mini, IsActive(), data().show_icon,
-      animating_media_state_);
+      media_indicator_button_ ? media_indicator_button_->showing_media_state() :
+                                data_.media_state);
 }
 
 bool Tab::ShouldShowCloseBox() const {
   return chrome::ShouldTabShowCloseButton(
       IconCapacity(), data().mini, IsActive());
 }
 
 double Tab::GetThrobValue() {
   const bool is_selected = IsSelected();
   const double min = is_selected ? kSelectedTabOpacity : 0;
@@ skipping 34 matching lines @@
 
 void Tab::StartCrashAnimation() {
   crash_icon_animation_.reset(new FaviconCrashAnimation(this));
   crash_icon_animation_->Start();
 }
 
 bool Tab::IsPerformingCrashAnimation() const {
   return crash_icon_animation_.get() && data_.IsCrashed();
 }
 
-void Tab::StartMediaIndicatorAnimation() {
-  media_indicator_animation_ =
-      chrome::CreateTabMediaIndicatorFadeAnimation(data_.media_state);
-  media_indicator_animation_->set_delegate(this);
-  media_indicator_animation_->Start();
-}
-
 void Tab::ScheduleIconPaint() {
   gfx::Rect bounds = favicon_bounds_;
   if (bounds.IsEmpty())
     return;
 
   // Extends the area to the bottom when sad_favicon is animating.
   if (IsPerformingCrashAnimation())
     bounds.set_height(height() - bounds.y());
   bounds.set_x(GetMirroredXForRect(bounds));
   SchedulePaintInRect(bounds);
@@ skipping 19 matching lines @@
     *frame_id = 0;
   } else if (data().incognito) {
     *tab_id = IDR_THEME_TAB_BACKGROUND_INCOGNITO;
     *frame_id = IDR_THEME_FRAME_INCOGNITO;
   } else {
     *tab_id = IDR_THEME_TAB_BACKGROUND;
     *frame_id = IDR_THEME_FRAME;
   }
 }
 
+MediaIndicatorButton* Tab::GetMediaIndicatorButton() {
+  if (!media_indicator_button_) {
+    media_indicator_button_ = new MediaIndicatorButton();
+    AddChildView(media_indicator_button_);  // Takes ownership.
+  }
+  return media_indicator_button_;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, private static:
 
 // static
 void Tab::InitTabResources() {
   static bool initialized = false;
   if (initialized)
     return;
 
   initialized = true;
@@ skipping 44 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();
 }