Cancel previous new tab "submarine" animations when starting the animation fo...

chrome/browser/cocoa/tab_strip_controller.mm

 // Copyright (c) 2009 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/cocoa/tab_strip_controller.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/mac_util.h"
 #include "base/nsimage_cache_mac.h"
@@ skipping 342 matching lines @@
 // the ordering in the TabStripModel. This call isn't that expensive, though
 // it is O(n) in the number of tabs. Tabs will animate to their new position
 // if the window is visible and |animate| is YES.
 // TODO(pinkerton): Handle drag placeholders via proxy objects, perhaps a
 // subclass of TabContentsController with everything stubbed out or by
 // abstracting a base class interface.
 // TODO(pinkerton): Note this doesn't do too well when the number of min-sized
 // tabs would cause an overflow.
 - (void)layoutTabsWithAnimation:(BOOL)animate
              regenerateSubviews:(BOOL)doUpdate {
+  // A very short duration used to cancel in-progress animations by making the
+  // new animation happen "instantly".
+  const float kInstantly = 0.000001;

[Mark Mentovai, 2009/10/13 17:30:23]

Can you #include <limits> and use the std::numeric_limits<NSTimeInterval>::min()
trick that I used in status_bubble_mac.mm?  Also, this should be an
NSTimeInterval, not a float.

   const float kTabOverlap = 20.0;
   const float kNewTabButtonOffset = 8.0;
   const float kMaxTabWidth = [TabController maxTabWidth];
   const float kMinTabWidth = [TabController minTabWidth];
   const float kMinSelectedTabWidth = [TabController minSelectedTabWidth];
 
   NSRect enclosingRect = NSZeroRect;
   [NSAnimationContext beginGrouping];
   [[NSAnimationContext currentContext] setDuration:0.2];
 
@@ skipping 37 matching lines @@
     // and animate it in.
     BOOL newTab = [[tab view] isHidden];
     if (newTab) {
       [[tab view] setHidden:NO];
     }
 
     if (isPlaceholder) {
       // Move the current tab to the correct location instantly.
       // We need a duration or else it doesn't cancel an inflight animation.
       [NSAnimationContext beginGrouping];
-      [[NSAnimationContext currentContext] setDuration:0.000001];
+      [[NSAnimationContext currentContext] setDuration:kInstantly];

[Mark Mentovai, 2009/10/13 17:30:23]

Seems kind of funny to say "set duration to instantly" - since the only thing we
use the constant for is "set duration," we might as well make it grammatically
correct.

       tabFrame.origin.x = placeholderFrame_.origin.x;
       // TODO(alcor): reenable this
       //tabFrame.size.height += 10.0 * placeholderStretchiness_;
       id target = animate ? [[tab view] animator] : [tab view];
       [target setFrame:tabFrame];
       [NSAnimationContext endGrouping];
 
       // Store the frame by identifier to aviod redundant calls to animator.
       NSValue* identifier = [NSValue valueWithPointer:[tab view]];
       [targetFrames_ setObject:[NSValue valueWithRect:tabFrame]
                         forKey:identifier];
       continue;
     } else {
       // If our left edge is to the left of the placeholder's left, but our mid
       // is to the right of it we should slide over to make space for it.
       if (placeholderTab_ && gap < 0 && NSMidX(tabFrame) > minX) {
         gap = i;
         offset += NSWidth(tabFrame);
         offset -= kTabOverlap;
         tabFrame.origin.x = offset;
       }
 
-      // Animate the tab in by putting it below the horizon, but don't bother
-      // if we only have 1 tab.
-      BOOL shouldAnimate = animate && [tabContentsArray_ count] > 1;
-      if (newTab && visible && shouldAnimate) {
-        [[tab view] setFrame:NSOffsetRect(tabFrame, 0, -NSHeight(tabFrame))];
-      }
-
       // Set the width. Selected tabs are slightly wider when things get
       // really small and thus we enforce a different minimum width.
       tabFrame.size.width =
           [tab selected] ? MAX(baseTabWidth, kMinSelectedTabWidth) :
                            baseTabWidth;
 
+      // Animate a new tab in by putting it below the horizon, but don't bother
+      // if we only have 1 tab.
+      BOOL shouldAnimate = animate && [tabContentsArray_ count] > 1;
+      if (newTab && visible && shouldAnimate) {
+        [[tab view] setFrame:NSOffsetRect(tabFrame, 0, -NSHeight(tabFrame))];
+      }
+
       // Check the frame by identifier to avoid redundant calls to animator.
       id frameTarget = visible && animate ? [[tab view] animator] : [tab view];
       NSValue* identifier = [NSValue valueWithPointer:[tab view]];
       NSValue* oldTargetValue = [targetFrames_ objectForKey:identifier];
       if (!oldTargetValue ||
           !NSEqualRects([oldTargetValue rectValue], tabFrame)) {
         [frameTarget setFrame:tabFrame];
         [targetFrames_ setObject:[NSValue valueWithRect:tabFrame]
                           forKey:identifier];
       }
+
       enclosingRect = NSUnionRect(tabFrame, enclosingRect);
     }
 
     offset += NSWidth(tabFrame);
     offset -= kTabOverlap;
     i++;
   }
 
   // Hide the new tab button if we're explicitly told to. It may already
   // be hidden, doing it again doesn't hurt. Otherwise position it
   // appropriately, showing it if necessary.
   if (forceNewTabButtonHidden_) {
     [newTabButton_ setHidden:YES];
   } else {
     NSRect newTabNewFrame = [newTabButton_ frame];
     // We've already ensured there's enough space for the new tab button
     // so we don't have to check it against the available width. We do need
     // to make sure we put it after any placeholder.
     newTabNewFrame.origin = NSMakePoint(offset, 0);
     newTabNewFrame.origin.x = MAX(newTabNewFrame.origin.x,
                                   NSMaxX(placeholderFrame_)) +
                                       kNewTabButtonOffset;
     if ([tabContentsArray_ count])
       [newTabButton_ setHidden:NO];
 
     if (!NSEqualRects(newTabTargetFrame_, newTabNewFrame)) {
-      [newTabButton_ setFrame:newTabNewFrame];
+      // Move the new tab button into place. We want to animate the new tab
+      // button if it's moving to the left (closing a tab), but not when it's
+      // moving to the right (inserting a new tab). If moving right, we need
+      // to use a very small duration to make sure we cancel any in-flight
+      // animation to the left.
+      BOOL movingLeft = NSMinX(newTabNewFrame) < NSMinX(newTabTargetFrame_);
+      id target = animate ? [newTabButton_ animator] : newTabButton_;
+      [NSAnimationContext beginGrouping];

[Mark Mentovai, 2009/10/13 17:30:23]

Adding this is what fixed the bug I was seeing earlier with the disappearing new
tab button.

+      if (!movingLeft)
+        [[NSAnimationContext currentContext] setDuration:kInstantly];
+      [target setFrame:newTabNewFrame];
+      [NSAnimationContext endGrouping];
       newTabTargetFrame_ = newTabNewFrame;
-      // Move the new tab button into place.
     }
   }
 
   [NSAnimationContext endGrouping];
   [dragBlockingView_ setFrame:enclosingRect];
 }
 
 // When we're told to layout from the public API we always want to animate.
 - (void)layoutTabs {
   [self layoutTabsWithAnimation:YES regenerateSubviews:YES];
@@ skipping 474 matching lines @@
   BrowserWindowController* controller =
       (BrowserWindowController*)[[switchView_ window] windowController];
   DCHECK(index >= 0);
   if (index >= 0) {
     [controller setTab:[self viewAtIndex:index] isDraggable:YES];
   }
 }
 
 
 @end