[Cocoa] Tab audio mute control, behind a switch (off by default).

chrome/browser/ui/cocoa/tabs/tab_controller.mm

 // 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.
 
 #import "chrome/browser/ui/cocoa/tabs/tab_controller.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/i18n/rtl.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/mac_util.h"
 #import "chrome/browser/themes/theme_properties.h"
 #import "chrome/browser/themes/theme_service.h"
 #import "chrome/browser/ui/cocoa/sprite_view.h"
-#import "chrome/browser/ui/cocoa/tabs/media_indicator_view.h"
+#import "chrome/browser/ui/cocoa/tabs/media_indicator_button.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_controller_target.h"
 #import "chrome/browser/ui/cocoa/tabs/tab_view.h"
 #import "chrome/browser/ui/cocoa/themed_window.h"
+#include "content/public/browser/user_metrics.h"
 #import "extensions/common/extension.h"
 #import "ui/base/cocoa/menu_controller.h"
 
 @implementation TabController
 
 @synthesize action = action_;
 @synthesize app = app_;
 @synthesize loadingState = loadingState_;
 @synthesize mini = mini_;
 @synthesize pinned = pinned_;
@@ skipping 90 matching lines @@
                       selector:@selector(themeChangedNotification:)
                           name:kBrowserThemeDidChangeNotification
                         object:nil];
 
     [self internalSetSelected:selected_];
   }
   return self;
 }
 
 - (void)dealloc {
-  [mediaIndicatorView_ setAnimationDoneCallbackObject:nil withSelector:nil];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [[self tabView] setController:nil];
   [super dealloc];
 }
 
 // The internals of |-setSelected:| and |-setActive:| but doesn't set the
 // backing variables. This updates the drawing state and marks self as needing
 // a re-draw.
 - (void)internalSetSelected:(BOOL)selected {
   TabView* tabView = [self tabView];
@@ skipping 15 matching lines @@
       new TabControllerInternal::MenuDelegate(target_, self));
   contextMenuModel_.reset(
       [target_ contextMenuModelForController:self
                                 menuDelegate:contextMenuDelegate_.get()]);
   contextMenuController_.reset(
       [[MenuController alloc] initWithModel:contextMenuModel_.get()
                      useWithPopUpButtonCell:NO]);
   return [contextMenuController_ menu];
 }
 
+- (void)toggleMute:(id)sender {
+  if ([[self target] respondsToSelector:@selector(toggleMute:)]) {
+    [[self target] performSelector:@selector(toggleMute:)
+                        withObject:[self view]];
+  }
+}
+
 - (void)closeTab:(id)sender {
+  using base::UserMetricsAction;
+
+  if (mediaIndicatorButton_ && ![mediaIndicatorButton_ isHidden]) {
+    if ([mediaIndicatorButton_ isEnabled]) {
+      content::RecordAction(UserMetricsAction("CloseTab_MuteToggleAvailable"));
+    } else if ([mediaIndicatorButton_ showingMediaState] ==
+                   TAB_MEDIA_STATE_AUDIO_PLAYING) {
+      content::RecordAction(UserMetricsAction("CloseTab_AudioIndicator"));
+    } else {
+      content::RecordAction(UserMetricsAction("CloseTab_RecordingIndicator"));
+    }
+  } else {
+    content::RecordAction(UserMetricsAction("CloseTab_NoMediaIndicator"));
+  }
+
   if ([[self target] respondsToSelector:@selector(closeTab:)]) {
     [[self target] performSelector:@selector(closeTab:)
                         withObject:[self view]];
   }
 }
 
 - (void)selectTab:(id)sender {
   if ([[self tabView] isClosing])
     return;
   if ([[self target] respondsToSelector:[self action]]) {
@@ skipping 46 matching lines @@
 }
 
 - (void)setIconView:(SpriteView*)iconView {
   [iconView_ removeFromSuperview];
   iconView_.reset([iconView retain]);
 
   if (iconView_)
     [[self view] addSubview:iconView_];
 }
 
-- (MediaIndicatorView*)mediaIndicatorView {
-  return mediaIndicatorView_;
+- (MediaIndicatorButton*)mediaIndicatorButton {
+  return mediaIndicatorButton_;
 }
 
-- (void)setMediaIndicatorView:(MediaIndicatorView*)mediaIndicatorView {
-  [mediaIndicatorView_ removeFromSuperview];
-  mediaIndicatorView_.reset([mediaIndicatorView retain]);
-  [self updateVisibility];
-  if (mediaIndicatorView_) {
-    [[self view] addSubview:mediaIndicatorView_];
-    [mediaIndicatorView_
-      setAnimationDoneCallbackObject:self
-                        withSelector:@selector(updateVisibility)];
-
+- (void)setMediaState:(TabMediaState)mediaState {
+  if (!mediaIndicatorButton_ && mediaState != TAB_MEDIA_STATE_NONE) {
+    mediaIndicatorButton_.reset([[MediaIndicatorButton alloc] init]);
+    [self updateVisibility];  // Do layout and visibility before adding subview.
+    [[self view] addSubview:mediaIndicatorButton_];
+    [mediaIndicatorButton_ setAnimationDoneTarget:self
+                                       withAction:@selector(updateVisibility)];
+    [mediaIndicatorButton_ setClickTarget:self
+                               withAction:@selector(toggleMute:)];
   }
+  [mediaIndicatorButton_ transitionToMediaState:mediaState];
 }
 
 - (HoverCloseButton*)closeButton {
   return closeButton_;
 }
 
 - (NSString*)toolTip {
   return [[self tabView] toolTipText];
 }
 
 // Return a rough approximation of the number of icons we could fit in the
 // tab. We never actually do this, but it's a helpful guide for determining
 // how much space we have available.
 - (int)iconCapacity {
   const CGFloat availableWidth = std::max<CGFloat>(
       0, NSMaxX([closeButton_ frame]) - NSMinX(originalIconFrame_));
   const CGFloat widthPerIcon = NSWidth(originalIconFrame_);
   const int kPaddingBetweenIcons = 2;
   if (availableWidth >= widthPerIcon &&
       availableWidth < (widthPerIcon + kPaddingBetweenIcons)) {
     return 1;
   }
   return availableWidth / (widthPerIcon + kPaddingBetweenIcons);
 }
 
 - (BOOL)shouldShowIcon {
   return chrome::ShouldTabShowFavicon(
       [self iconCapacity], [self mini], [self active], iconView_ != nil,
-      !mediaIndicatorView_ ? TAB_MEDIA_STATE_NONE :
-          [mediaIndicatorView_ animatingMediaState]);
+      !mediaIndicatorButton_ ? TAB_MEDIA_STATE_NONE :
+          [mediaIndicatorButton_ showingMediaState]);
 }
 
 - (BOOL)shouldShowMediaIndicator {
-  if (!mediaIndicatorView_)
-    return NO;
   return chrome::ShouldTabShowMediaIndicator(
       [self iconCapacity], [self mini], [self active], iconView_ != nil,
-      [mediaIndicatorView_ animatingMediaState]);
+      !mediaIndicatorButton_ ? TAB_MEDIA_STATE_NONE :
+          [mediaIndicatorButton_ showingMediaState]);
 }
 
 - (BOOL)shouldShowCloseButton {
   return chrome::ShouldTabShowCloseButton(
       [self iconCapacity], [self mini], [self active]);
 }
 
 - (void)setIconImage:(NSImage*)image {
   [self setIconImage:image withToastAnimation:NO];
 }
@@ skipping 18 matching lines @@
                                           : [TabController miniTabWidth];
 
       // Center the icon.
       appIconFrame.origin.x =
           std::floor((tabWidth - NSWidth(appIconFrame)) / 2.0);
       [iconView_ setFrame:appIconFrame];
     } else {
       [iconView_ setFrame:originalIconFrame_];
     }
   }
-  // Ensure that the icon is suppressed if no icon is set or if the tab is too
-  // narrow to display one.
-  [self updateVisibility];
 }
 
 - (void)updateVisibility {
   // iconView_ may have been replaced or it may be nil, so [iconView_ isHidden]
   // won't work.  Instead, the state of the icon is tracked separately in
   // isIconShowing_.
   BOOL newShowIcon = [self shouldShowIcon];
 
   [iconView_ setHidden:!newShowIcon];
   isIconShowing_ = newShowIcon;
 
   // If the tab is a mini-tab, hide the title.
   TabView* tabView = [self tabView];
   [tabView setTitleHidden:[self mini]];
 
   BOOL newShowCloseButton = [self shouldShowCloseButton];
 
   [closeButton_ setHidden:!newShowCloseButton];
 
   BOOL newShowMediaIndicator = [self shouldShowMediaIndicator];
 
-  [mediaIndicatorView_ setHidden:!newShowMediaIndicator];
+  [mediaIndicatorButton_ setHidden:!newShowMediaIndicator];
 
   if (newShowMediaIndicator) {
-    NSRect newFrame = [mediaIndicatorView_ frame];
+    NSRect newFrame = [mediaIndicatorButton_ frame];
+    newFrame.size = [[mediaIndicatorButton_ image] size];
     if ([self app] || [self mini]) {
       // Tab is pinned: Position the media indicator in the center.
       const CGFloat tabWidth = [self app] ?
           [TabController appTabWidth] : [TabController miniTabWidth];
       newFrame.origin.x = std::floor((tabWidth - NSWidth(newFrame)) / 2);
       newFrame.origin.y = NSMinY(originalIconFrame_) -
           std::floor((NSHeight(newFrame) - NSHeight(originalIconFrame_)) / 2);
     } else {
-      // The Frame for the mediaIndicatorView_ depends on whether iconView_
+      // The Frame for the mediaIndicatorButton_ depends on whether iconView_
       // and/or closeButton_ are visible, and where they have been positioned.
       const NSRect closeButtonFrame = [closeButton_ frame];
       newFrame.origin.x = NSMinX(closeButtonFrame);
       // Position to the left of the close button when it is showing.
       if (newShowCloseButton)
         newFrame.origin.x -= NSWidth(newFrame);
       // Media indicator is centered vertically, with respect to closeButton_.
       newFrame.origin.y = NSMinY(closeButtonFrame) -
           std::floor((NSHeight(newFrame) - NSHeight(closeButtonFrame)) / 2);
     }
-    [mediaIndicatorView_ setFrame:newFrame];
+    [mediaIndicatorButton_ setFrame:newFrame];
   }
 
   // Adjust the title view based on changes to the icon's and close button's
   // visibility.
   NSRect oldTitleFrame = [tabView titleFrame];
   NSRect newTitleFrame;
   newTitleFrame.size.height = oldTitleFrame.size.height;
   newTitleFrame.origin.y = oldTitleFrame.origin.y;
 
   if (newShowIcon) {
     newTitleFrame.origin.x = NSMaxX([iconView_ frame]);
   } else {
     newTitleFrame.origin.x = originalIconFrame_.origin.x;
   }
 
   if (newShowMediaIndicator) {
-    newTitleFrame.size.width = NSMinX([mediaIndicatorView_ frame]) -
+    newTitleFrame.size.width = NSMinX([mediaIndicatorButton_ frame]) -
                                newTitleFrame.origin.x;
   } else if (newShowCloseButton) {
     newTitleFrame.size.width = NSMinX([closeButton_ frame]) -
                                newTitleFrame.origin.x;
   } else {
     newTitleFrame.size.width = NSMaxX([closeButton_ frame]) -
                                newTitleFrame.origin.x;
   }
 
   [tabView setTitleFrame:newTitleFrame];
@@ skipping 27 matching lines @@
 // TabStripDragController.
 - (BOOL)tabCanBeDragged:(TabController*)controller {
   return [[target_ dragController] tabCanBeDragged:controller];
 }
 
 - (void)maybeStartDrag:(NSEvent*)event forTab:(TabController*)tab {
   [[target_ dragController] maybeStartDrag:event forTab:tab];
 }
 
 @end