Fix the Mac status bubble.

chrome/browser/ui/cocoa/status_bubble_mac.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.
 
 #include "chrome/browser/ui/cocoa/status_bubble_mac.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/mac/mac_util.h"
+#include "base/mac/scoped_block.h"
+#include "base/mac/sdk_forward_declarations.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #import "chrome/browser/ui/cocoa/bubble_view.h"
 #include "chrome/browser/ui/elide_url.h"
 #include "net/base/net_util.h"
 #import "third_party/google_toolbox_for_mac/src/AppKit/GTMNSAnimation+Duration.h"
 #import "third_party/google_toolbox_for_mac/src/AppKit/GTMNSBezierPath+RoundRect.h"
 #import "third_party/google_toolbox_for_mac/src/AppKit/GTMNSColor+Luminance.h"
 #include "ui/base/cocoa/window_size_constants.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/gfx/text_utils.h"
 
 namespace {
 
 const int kWindowHeight = 18;
 
 // The width of the bubble in relation to the width of the parent window.
 const CGFloat kWindowWidthPercent = 1.0 / 3.0;
 
 // How close the mouse can get to the infobubble before it starts sliding
 // off-screen.
 const int kMousePadding = 20;
 
 const int kTextPadding = 3;
 
-// The animation key used for fade-in and fade-out transitions.
-NSString* const kFadeAnimationKey = @"alphaValue";
-
 // The status bubble's maximum opacity, when fully faded in.
 const CGFloat kBubbleOpacity = 1.0;
 
 // Delay before showing or hiding the bubble after a SetStatus or SetURL call.
 const int64 kShowDelayMS = 80;
 const int64 kHideDelayMS = 250;
 
 // How long each fade should last.
 const NSTimeInterval kShowFadeInDurationSeconds = 0.120;
 const NSTimeInterval kHideFadeOutDurationSeconds = 0.200;
 
 // The minimum representable time interval.  This can be used as the value
 // passed to +[NSAnimationContext setDuration:] to stop an in-progress
 // animation as quickly as possible.
 const NSTimeInterval kMinimumTimeInterval =
     std::numeric_limits<NSTimeInterval>::min();
 
 // How quickly the status bubble should expand.
 const CGFloat kExpansionDurationSeconds = 0.125;
 
 }  // namespace
 
 @interface StatusBubbleAnimationDelegate : NSObject {
  @private
-  StatusBubbleMac* statusBubble_;  // weak; owns us indirectly
+  base::mac::ScopedBlock<void (^)(void)> completionHandler_;
 }
 
-- (id)initWithStatusBubble:(StatusBubbleMac*)statusBubble;
-
-// Invalidates this object so that no further calls will be made to
-// statusBubble_.  This should be called when statusBubble_ is released, to
-// prevent attempts to call into the released object.
-- (void)invalidate;
+- (id)initWithCompletionHandler:(void (^)(void))completionHandler;
 
 // CAAnimation delegate method
 - (void)animationDidStop:(CAAnimation*)animation finished:(BOOL)finished;
 @end
 
 @implementation StatusBubbleAnimationDelegate
 
-- (id)initWithStatusBubble:(StatusBubbleMac*)statusBubble {
+- (id)initWithCompletionHandler:(void (^)(void))completionHandler {
   if ((self = [super init])) {
-    statusBubble_ = statusBubble;
+    completionHandler_.reset(completionHandler, base::scoped_policy::RETAIN);
   }
 
   return self;
 }
 
-- (void)invalidate {
-  statusBubble_ = NULL;
-}
-
 - (void)animationDidStop:(CAAnimation*)animation finished:(BOOL)finished {
-  if (statusBubble_)
-    statusBubble_->AnimationDidStop(animation, finished);
+  completionHandler_.get()();
 }
 
 @end
+
+@interface StatusBubbleWindow : NSWindow {
+ @private
+  void (^completionHandler_)(void);
+}
+
+- (id)animationForKey:(NSString *)key;
+- (void)runAnimationGroup:(void (^)(NSAnimationContext *context))changes
+        completionHandler:(void (^)(void))completionHandler;
+@end
+
+@implementation StatusBubbleWindow
+
+- (id)animationForKey:(NSString *)key {
+  CAAnimation* animation = [super animationForKey:key];
+  // If completionHandler_ isn't nil, then this is the first of (potentially)
+  // multiple animations in a grouping; give it the completion handler. If
+  // completionHandler_ is nil, then some other animation was tagged with the
+  // completion handler.
+  if (completionHandler_) {
+    DCHECK(![NSAnimationContext respondsToSelector:
+               @selector(runAnimationGroup:completionHandler:)]);
+    StatusBubbleAnimationDelegate* animation_delegate =
+        [[StatusBubbleAnimationDelegate alloc]
+             initWithCompletionHandler:completionHandler_];
+    [animation setDelegate:animation_delegate];
+    completionHandler_ = nil;
+  }
+  return animation;
+}
+
+- (void)runAnimationGroup:(void (^)(NSAnimationContext *context))changes
+        completionHandler:(void (^)(void))completionHandler {
+  if ([NSAnimationContext respondsToSelector:
+          @selector(runAnimationGroup:completionHandler:)]) {
+    [NSAnimationContext runAnimationGroup:changes
+                        completionHandler:completionHandler];
+  } else {
+    // Mac OS 10.6 does not have completion handler callbacks at the Cocoa
+    // level, only at the CoreAnimation level. So intercept calls made to
+    // -animationForKey: and tag one of the animations with a delegate that will
+    // execute the completion handler.
+    completionHandler_ = completionHandler;
+    [NSAnimationContext beginGrouping];
+    changes([NSAnimationContext currentContext]);
+    // At this point, -animationForKey should have been called by CoreAnimation
+    // to set up the animation to run. Verify this.
+    DCHECK(completionHandler_ == nil);
+    [NSAnimationContext endGrouping];
+  }
+}
+
+@end
 
 StatusBubbleMac::StatusBubbleMac(NSWindow* parent, id delegate)
     : timer_factory_(this),
       expand_timer_factory_(this),
+      completion_handler_factory_(this),
       parent_(parent),
       delegate_(delegate),
       window_(nil),
       status_text_(nil),
       url_text_(nil),
       state_(kBubbleHidden),
       immediate_(false),
       is_expanded_(false) {
   Create();
   Attach();
 }
 
 StatusBubbleMac::~StatusBubbleMac() {
   DCHECK(window_);
 
   Hide();
 
-  [[[window_ animationForKey:kFadeAnimationKey] delegate] invalidate];
+  completion_handler_factory_.InvalidateWeakPtrs();
   Detach();
   [window_ release];
   window_ = nil;
 }
 
 void StatusBubbleMac::SetStatus(const base::string16& status) {
   SetText(status, false);
 }
 
 void StatusBubbleMac::SetURL(const GURL& url, const std::string& languages) {
@@ skipping 96 matching lines @@
   is_expanded_ = false;
 
   bool fade_out = false;
   if (state_ == kBubbleHidingFadeOut || state_ == kBubbleShowingFadeIn) {
     SetState(kBubbleHidingFadeOut);
 
     if (!immediate_) {
       // An animation is in progress.  Cancel it by starting a new animation.
       // Use kMinimumTimeInterval to set the opacity as rapidly as possible.
       fade_out = true;
-      [NSAnimationContext beginGrouping];
-      [[NSAnimationContext currentContext] setDuration:kMinimumTimeInterval];
-      [[window_ animator] setAlphaValue:0.0];
-      [NSAnimationContext endGrouping];
+      AnimateWindowAlpha(0.0, kMinimumTimeInterval);
     }
   }
 
   if (!fade_out) {
     // No animation is in progress, so the opacity can be set directly.
     [window_ setAlphaValue:0.0];
     SetState(kBubbleHidden);
   }
 
   // Stop any width animation and reset the bubble size.
@@ skipping 103 matching lines @@
     SetFrameAvoidingMouse([window_ frame], location);
 }
 
 void StatusBubbleMac::UpdateDownloadShelfVisibility(bool visible) {
   UpdateSizeAndPosition();
 }
 
 void StatusBubbleMac::Create() {
   DCHECK(!window_);
 
-  window_ = [[NSWindow alloc] initWithContentRect:ui::kWindowSizeDeterminedLater
-                                        styleMask:NSBorderlessWindowMask
-                                          backing:NSBackingStoreBuffered
-                                            defer:YES];
+  window_ = [[StatusBubbleWindow alloc]
+      initWithContentRect:ui::kWindowSizeDeterminedLater
+                styleMask:NSBorderlessWindowMask
+                  backing:NSBackingStoreBuffered
+                    defer:YES];
   [window_ setMovableByWindowBackground:NO];
   [window_ setBackgroundColor:[NSColor clearColor]];
   [window_ setLevel:NSNormalWindowLevel];
   [window_ setOpaque:NO];
   [window_ setHasShadow:NO];
 
   // We do not need to worry about the bubble outliving |parent_| because our
   // teardown sequence in BWC guarantees that |parent_| outlives the status
   // bubble and that the StatusBubble is torn down completely prior to the
   // window going away.
   base::scoped_nsobject<BubbleView> view(
       [[BubbleView alloc] initWithFrame:NSZeroRect themeProvider:parent_]);
   [window_ setContentView:view];
 
   [window_ setAlphaValue:0.0];
 
   // TODO(dtseng): Ignore until we provide NSAccessibility support.
   [window_ accessibilitySetOverrideValue:NSAccessibilityUnknownRole
                             forAttribute:NSAccessibilityRoleAttribute];
 
-  // Set a delegate for the fade-in and fade-out transitions to be notified
-  // when fades are complete.  The ownership model is for window_ to own
-  // animation_dictionary, which owns animation, which owns
-  // animation_delegate.
-  CAAnimation* animation = [[window_ animationForKey:kFadeAnimationKey] copy];
-  [animation autorelease];
-  StatusBubbleAnimationDelegate* animation_delegate =
-      [[StatusBubbleAnimationDelegate alloc] initWithStatusBubble:this];
-  [animation_delegate autorelease];
-  [animation setDelegate:animation_delegate];
-  NSMutableDictionary* animation_dictionary =
-      [NSMutableDictionary dictionaryWithDictionary:[window_ animations]];
-  [animation_dictionary setObject:animation forKey:kFadeAnimationKey];
-  [window_ setAnimations:animation_dictionary];
-
   [view setCornerFlags:kRoundedTopRightCorner];
   MouseMoved(gfx::Point(), false);
 }
 
 void StatusBubbleMac::Attach() {
   DCHECK(!is_attached());
 
   [window_ orderFront:nil];
   [parent_ addChildWindow:window_ ordered:NSWindowAbove];
 
   [[window_ contentView] setThemeProvider:parent_];
 }
 
 void StatusBubbleMac::Detach() {
   DCHECK(is_attached());
 
   // Magic setFrame: See http://crbug.com/58506 and http://crrev.com/3564021 .
   [window_ setFrame:CalculateWindowFrame(/*expand=*/false) display:NO];
   [parent_ removeChildWindow:window_];  // See crbug.com/28107 ...
   [window_ orderOut:nil];               // ... and crbug.com/29054.
 
   [[window_ contentView] setThemeProvider:nil];
 }
 
-void StatusBubbleMac::AnimationDidStop(CAAnimation* animation, bool finished) {
+void StatusBubbleMac::AnimationDidStop() {
   DCHECK([NSThread isMainThread]);
   DCHECK(state_ == kBubbleShowingFadeIn || state_ == kBubbleHidingFadeOut);
   DCHECK(is_attached());
 
-  if (finished) {
-    // Because of the mechanism used to interrupt animations, this is never
-    // actually called with finished set to false.  If animations ever become
-    // directly interruptible, the check will ensure that state_ remains
-    // properly synchronized.
-    if (state_ == kBubbleShowingFadeIn) {
-      DCHECK_EQ([[window_ animator] alphaValue], kBubbleOpacity);
-      SetState(kBubbleShown);
-    } else {
-      DCHECK_EQ([[window_ animator] alphaValue], 0.0);
-      SetState(kBubbleHidden);
-    }
+  if (state_ == kBubbleShowingFadeIn) {
+    DCHECK_EQ([[window_ animator] alphaValue], kBubbleOpacity);
+    SetState(kBubbleShown);
+  } else {
+    DCHECK_EQ([[window_ animator] alphaValue], 0.0);
+    SetState(kBubbleHidden);
   }
 }
 
 void StatusBubbleMac::SetState(StatusBubbleState state) {
   if (state == state_)
     return;
 
   if (state == kBubbleHidden) {
     // When hidden (with alpha of 0), make the window have the minimum size,
     // while still keeping the same origin. It's important to not set the
@@ skipping 42 matching lines @@
   // If an incomplete transition has left the opacity somewhere between 0 and
   // kBubbleOpacity, the fade rate is kept constant by shortening the duration.
   NSTimeInterval duration =
       full_duration *
       fabs(opacity - [[window_ animator] alphaValue]) / kBubbleOpacity;
 
   // 0.0 will not cancel an in-progress animation.
   if (duration == 0.0)
     duration = kMinimumTimeInterval;
 
-  // This will cancel an in-progress transition and replace it with this fade.
-  [NSAnimationContext beginGrouping];
-  // Don't use the GTM additon for the "Steve" slowdown because this can happen
-  // async from user actions and the effects could be a surprise.
-  [[NSAnimationContext currentContext] setDuration:duration];
-  [[window_ animator] setAlphaValue:opacity];
-  [NSAnimationContext endGrouping];
+  // Cancel an in-progress transition and replace it with this fade.
+  AnimateWindowAlpha(opacity, duration);
+}
+
+void StatusBubbleMac::AnimateWindowAlpha(CGFloat alpha,
+                                         NSTimeInterval duration) {
+  completion_handler_factory_.InvalidateWeakPtrs();
+  base::WeakPtr<StatusBubbleMac> weak_ptr(
+      completion_handler_factory_.GetWeakPtr());
+  [window_
+      runAnimationGroup:^(NSAnimationContext* context) {
+          [context setDuration:duration];
+          [[window_ animator] setAlphaValue:alpha];
+      }
+      completionHandler:^{
+          if (weak_ptr)
+            weak_ptr->AnimationDidStop();
+      }];
 }
 
 void StatusBubbleMac::StartTimer(int64 delay_ms) {
   DCHECK([NSThread isMainThread]);
   DCHECK(state_ == kBubbleShowingTimer || state_ == kBubbleHidingTimer);
 
   if (immediate_) {
     TimerFired();
     return;
   }
@@ skipping 218 matching lines @@
     }
 
     // Round the top corners when the bubble is below the parent window.
     if (NSMinY(window_frame) < NSMinY(parent_frame)) {
       corner_flags |= kRoundedTopLeftCorner | kRoundedTopRightCorner;
     }
   }
 
   return corner_flags;
 }