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

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

 // Copyright 2013 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/media_indicator_view.h"
+#import "chrome/browser/ui/cocoa/tabs/media_indicator_button.h"
 
+#include "base/logging.h"
+#include "base/thread_task_runner_handle.h"
+#include "content/public/browser/user_metrics.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/gfx/animation/animation_delegate.h"
 #include "ui/gfx/image/image.h"
 
-class MediaIndicatorViewAnimationDelegate : public gfx::AnimationDelegate {
+@implementation MediaIndicatorButton
+
+class FadeAnimationDelegate : public gfx::AnimationDelegate {
  public:
-  MediaIndicatorViewAnimationDelegate(NSView* view,
-                                      TabMediaState* mediaState,
-                                      TabMediaState* animatingMediaState)
-      : view_(view), mediaState_(mediaState),
-        animatingMediaState_(animatingMediaState),
-        doneCallbackObject_(nil), doneCallbackSelector_(nil) {}
-  ~MediaIndicatorViewAnimationDelegate() override {}
+  explicit FadeAnimationDelegate(MediaIndicatorButton* button)
+      : button_(button) {}
+  ~FadeAnimationDelegate() override {}
 
-  void SetAnimationDoneCallback(id anObject, SEL selector) {
-    doneCallbackObject_ = anObject;
-    doneCallbackSelector_ = selector;
+ private:
+  // gfx::AnimationDelegate implementation.
+  void AnimationProgressed(const gfx::Animation* animation) override {
+    [button_ setNeedsDisplay:YES];
   }
 
-  void AnimationEnded(const gfx::Animation* animation) override {
-    *animatingMediaState_ = *mediaState_;
-    [view_ setNeedsDisplay:YES];
-    [doneCallbackObject_ performSelector:doneCallbackSelector_];
-  }
-  void AnimationProgressed(const gfx::Animation* animation) override {
-    [view_ setNeedsDisplay:YES];
-  }
   void AnimationCanceled(const gfx::Animation* animation) override {
     AnimationEnded(animation);
   }
 
- private:
-  NSView* const view_;
-  TabMediaState* const mediaState_;
-  TabMediaState* const animatingMediaState_;
+  void AnimationEnded(const gfx::Animation* animation) override {
+    button_->showingMediaState_ = button_->mediaState_;
+    [button_ setNeedsDisplay:YES];
+    [button_->animationDoneTarget_
+        performSelector:button_->animationDoneAction_];
+  }
 
-  id doneCallbackObject_;
-  SEL doneCallbackSelector_;
+  MediaIndicatorButton* const button_;
+
+  DISALLOW_COPY_AND_ASSIGN(FadeAnimationDelegate);
 };
 
-@implementation MediaIndicatorView
-
-@synthesize mediaState = mediaState_;
-@synthesize animatingMediaState = animatingMediaState_;
+@synthesize showingMediaState = showingMediaState_;
 
 - (id)init {
   if ((self = [super initWithFrame:NSZeroRect])) {
-    mediaState_ = animatingMediaState_ = TAB_MEDIA_STATE_NONE;
-    delegate_.reset(new MediaIndicatorViewAnimationDelegate(
-        self, &mediaState_, &animatingMediaState_));
+    mediaState_ = TAB_MEDIA_STATE_NONE;
+    showingMediaState_ = TAB_MEDIA_STATE_NONE;
+    [self setEnabled:NO];
+    [super setTarget:self];
+    [super setAction:@selector(handleClick:)];
   }
   return self;
 }
 
-- (void)updateIndicator:(TabMediaState)mediaState {
-  if (mediaState == mediaState_)
+- (void)removeFromSuperview {
+  fadeAnimation_.reset();
+  [super removeFromSuperview];
+}
+
+- (void)transitionToMediaState:(TabMediaState)nextState {
+  if (nextState == mediaState_)
     return;
 
-  mediaState_ = mediaState;
-  animation_.reset();
-
-  // Prepare this view if the new TabMediaState is an active one.
-  if (mediaState_ != TAB_MEDIA_STATE_NONE) {
-    animatingMediaState_ = mediaState_;
-    NSImage* const image =
-        chrome::GetTabMediaIndicatorImage(mediaState_).ToNSImage();
-    NSRect frame = [self frame];
-    frame.size = [image size];
-    [self setFrame:frame];
-    [self setImage:image];
+  if (nextState != TAB_MEDIA_STATE_NONE) {
+    [self setImage:chrome::GetTabMediaIndicatorImage(nextState).ToNSImage()];
+    affordanceImage_.reset(
+        [chrome::GetTabMediaIndicatorAffordanceImage(nextState).ToNSImage()
+               retain]);
   }
 
-  // If the animation delegate is missing, that means animations were disabled
-  // for testing; so, go directly to animating completion state.
-  if (!delegate_) {
-    animatingMediaState_ = mediaState_;
-    return;
+  if ((mediaState_ == TAB_MEDIA_STATE_AUDIO_PLAYING &&
+       nextState == TAB_MEDIA_STATE_AUDIO_MUTING) ||
+      (mediaState_ == TAB_MEDIA_STATE_AUDIO_MUTING &&
+       nextState == TAB_MEDIA_STATE_AUDIO_PLAYING) ||
+      (mediaState_ == TAB_MEDIA_STATE_AUDIO_MUTING &&
+       nextState == TAB_MEDIA_STATE_NONE)) {

[Nico, 2014/10/31 21:55:00]

nit: this looks like model code that should be shared between different uis

[miu, 2014/11/01 00:43:38]

Yep.  Planning on some cleanup w.r.t. the animation logic in an upcoming change.
 (There were also some things in the views code that needed to wait on getting
the Mac impl done first.)

+    // Instant user feedback: No fade animation.
+    showingMediaState_ = nextState;
+    fadeAnimation_.reset();
+  } else {
+    if (nextState == TAB_MEDIA_STATE_NONE)
+      showingMediaState_ = mediaState_;  // Fading-out indicator.
+    else
+      showingMediaState_ = nextState;  // Fading-in to next indicator.
+    // gfx::Animation requires a task runner is available for the current
+    // thread.  Generally, only certain unit tests would not instantiate a task
+    // runner.
+    if (base::ThreadTaskRunnerHandle::IsSet()) {
+      fadeAnimation_ = chrome::CreateTabMediaIndicatorFadeAnimation(nextState);
+      if (!fadeAnimationDelegate_)
+        fadeAnimationDelegate_.reset(new FadeAnimationDelegate(self));
+      fadeAnimation_->set_delegate(fadeAnimationDelegate_.get());
+      fadeAnimation_->Start();
+    }
   }
 
-  animation_ = chrome::CreateTabMediaIndicatorFadeAnimation(mediaState_);
-  animation_->set_delegate(delegate_.get());
-  animation_->Start();
+  [self setEnabled:(chrome::IsTabAudioMutingFeatureEnabled() &&
+                    (nextState == TAB_MEDIA_STATE_AUDIO_PLAYING ||
+                     nextState == TAB_MEDIA_STATE_AUDIO_MUTING))];
+
+  // An indicator state change should be made visible immediately, instead of
+  // the user being surprised when their mouse leaves the button.
+  if ([self hoverState] == kHoverStateMouseOver)
+    [self setHoverState:kHoverStateNone];
+
+  mediaState_ = nextState;
+
+  [self setNeedsDisplay:YES];
 }
 
-- (void)setAnimationDoneCallbackObject:(id)anObject withSelector:(SEL)selector {
-  if (delegate_)
-    delegate_->SetAnimationDoneCallback(anObject, selector);
+- (void)setTarget:(id)aTarget {
+  NOTREACHED();  // See class-level comments.
 }
 
-- (void)drawRect:(NSRect)rect {
-  if (!animation_)
+- (void)setAction:(SEL)anAction {
+  NOTREACHED();  // See class-level comments.
+}
+
+- (void)setAnimationDoneTarget:(id)target withAction:(SEL)action {
+  animationDoneTarget_ = target;
+  animationDoneAction_ = action;
+}
+
+- (void)setClickTarget:(id)target withAction:(SEL)action {
+  clickTarget_ = target;
+  clickAction_ = action;
+}
+
+- (void)drawRect:(NSRect)dirtyRect {
+  NSImage* image = ([self hoverState] == kHoverStateNone || ![self isEnabled]) ?
+      [self image] : affordanceImage_.get();
+  if (!image)
     return;
-
-  double opaqueness = animation_->GetCurrentValue();
+  NSRect imageRect = NSZeroRect;
+  imageRect.size = [image size];
+  NSRect destRect = [self bounds];
+  destRect.origin.y =
+      floor((NSHeight(destRect) / 2) - (NSHeight(imageRect) / 2));
+  destRect.size = imageRect.size;
+  double opaqueness =
+      fadeAnimation_ ? fadeAnimation_->GetCurrentValue() : 1.0;
   if (mediaState_ == TAB_MEDIA_STATE_NONE)
     opaqueness = 1.0 - opaqueness;  // Fading out, not in.
-
-  [[self image] drawInRect:[self bounds]
-                  fromRect:NSZeroRect
-                 operation:NSCompositeSourceOver
-                  fraction:opaqueness];
+  [image drawInRect:destRect
+           fromRect:imageRect
+          operation:NSCompositeSourceOver
+           fraction:opaqueness
+     respectFlipped:YES
+              hints:nil];
 }
 
-- (void)disableAnimations {
-  delegate_.reset();
+// When disabled, the superview should receive all mouse events.
+- (NSView*)hitTest:(NSPoint)aPoint {
+  if ([self isEnabled] && ![self isHidden])
+    return [super hitTest:aPoint];
+  else
+    return nil;
+}
+
+- (void)handleClick:(id)sender {
+  using base::UserMetricsAction;
+
+  if (mediaState_ == TAB_MEDIA_STATE_AUDIO_PLAYING)
+    content::RecordAction(UserMetricsAction("MediaIndicatorButton_Mute"));
+  else if (mediaState_ == TAB_MEDIA_STATE_AUDIO_MUTING)
+    content::RecordAction(UserMetricsAction("MediaIndicatorButton_Unmute"));
+  else
+    NOTREACHED();
+
+  [clickTarget_ performSelector:clickAction_ withObject:self];
 }
 
 @end