Total guess fix for the bug....

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"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include <limits>
 
@@ skipping 33 matching lines @@
 // view.
 static const float kUseFullAvailableWidth = -1.0;
 
 // Left-side indent for tab layout so tabs don't overlap with the window
 // controls.
 static const float kIndentLeavingSpaceForControls = 64.0;
 
 // Time (in seconds) in which tabs animate to their final position.
 static const NSTimeInterval kAnimationDuration = 0.2;
 
+namespace {
+
+// Helper class for doing NSAnimationContext calls that takes a bool to disable
+// all the work.  Useful for code that wants to conditionally animate.
+class ScopedNSAnimationContextGroup {
+ public:
+  explicit ScopedNSAnimationContextGroup(bool animate)
+      : animate_(animate) {
+    if (animate_) {
+      [NSAnimationContext beginGrouping];
+    }
+  }
+
+  ~ScopedNSAnimationContextGroup() {
+    if (animate_) {
+      [NSAnimationContext endGrouping];
+    }
+  }
+
+  void SetCurrentContextDuration(NSTimeInterval duration) {
+    if (animate_) {
+      [[NSAnimationContext currentContext] gtm_setDuration:duration];
+    }
+  }
+
+  void SetCurrentContextShortestDuration() {
+    if (animate_) {
+      // The minimum representable time interval.  This used to stop an
+      // in-progress animation as quickly as possible.
+      const NSTimeInterval kMinimumTimeInterval =
+          std::numeric_limits<NSTimeInterval>::min();
+      // Directly set the duration to be short, avoiding the Steve slowmotion
+      // ettect the gtm_setDuration: provides.
+      [[NSAnimationContext currentContext] setDuration:kMinimumTimeInterval];
+    }
+  }
+ private:
+  bool animate_;
+  DISALLOW_COPY_AND_ASSIGN(ScopedNSAnimationContextGroup);
+};
+
+}  // namespace
+
 @interface TabStripController(Private)
 - (void)installTrackingArea;
 - (void)addSubviewToPermanentList:(NSView*)aView;
 - (void)regenerateSubviewList;
 - (NSInteger)indexForContentsView:(NSView*)view;
 - (void)updateFavIconForContents:(TabContents*)contents
                          atIndex:(NSInteger)index;
 - (void)layoutTabsWithAnimation:(BOOL)animate
              regenerateSubviews:(BOOL)doUpdate;
 - (void)animationDidStopForController:(TabController*)controller
@@ skipping 460 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 {
+  DCHECK([NSThread isMainThread]);
   if (![tabArray_ count])
     return;
 
-  // 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();
   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] gtm_setDuration:kAnimationDuration];
+  ScopedNSAnimationContextGroup mainAnimationGroup(animate);
+  mainAnimationGroup.SetCurrentContextDuration(kAnimationDuration);
 
   // Update the current subviews and their z-order if requested.
   if (doUpdate)
-      [self regenerateSubviewList];
+    [self regenerateSubviewList];
 
   // Compute the base width of tabs given how much room we're allowed. We
   // may not be able to use the entire width if the user is quickly closing
   // tabs.
   float availableWidth = 0;
   if ([self inRapidClosureMode]) {
     availableWidth = availableResizeWidth_;
   } else {
     availableWidth = NSWidth([tabView_ frame]);
     availableWidth -= NSWidth([newTabButton_ frame]) + kNewTabButtonOffset;
@@ skipping 31 matching lines @@
     // If the tab is hidden, we consider it a new tab. We make it visible
     // 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:kMinimumTimeInterval];
+      ScopedNSAnimationContextGroup localAnimationGroup(animate);
+      localAnimationGroup.SetCurrentContextShortestDuration();
       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_ && !hasPlaceholderGap && NSMidX(tabFrame) > minX) {
@@ skipping 68 matching lines @@
         imageName = @"newtab";
       }
       [newTabButton_ setImage:nsimage_cache::ImageNamed(imageName)];
 
       // 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.
       if (visible && animate) {
-        [NSAnimationContext beginGrouping];
+        ScopedNSAnimationContextGroup localAnimationGroup(true);
         BOOL movingLeft = NSMinX(newTabNewFrame) < NSMinX(newTabTargetFrame_);
         if (!movingLeft) {
-          [[NSAnimationContext currentContext]
-              setDuration:kMinimumTimeInterval];
+          localAnimationGroup.SetCurrentContextShortestDuration();
         }
         [[newTabButton_ animator] setFrame:newTabNewFrame];
         newTabTargetFrame_ = newTabNewFrame;
-        [NSAnimationContext endGrouping];
       } else {
         [newTabButton_ setFrame:newTabNewFrame];
         newTabTargetFrame_ = newTabNewFrame;
       }
     }
   }
 
-  [NSAnimationContext endGrouping];
   [dragBlockingView_ setFrame:enclosingRect];
 
   // Mark that we've successfully completed layout of at least one tab.
   initialLayoutComplete_ = YES;
 }
 
 // When we're told to layout from the public API we usually want to animate,
 // except when it's the first time.
 - (void)layoutTabs {
   [self layoutTabsWithAnimation:initialLayoutComplete_ regenerateSubviews:YES];
@@ skipping 151 matching lines @@
 - (void)animationDidStopForController:(TabController*)controller
                              finished:(BOOL)finished {
   [closingControllers_ removeObject:controller];
   [self removeTab:controller];
 }
 
 // Save off which TabController is closing and tell its view's animator
 // where to move the tab to. Registers a delegate to call back when the
 // animation is complete in order to remove the tab from the model.
 - (void)startClosingTabWithAnimation:(TabController*)closingTab {
+  DCHECK([NSThread isMainThread]);
   // Save off the controller into the set of animating tabs. This alerts
   // the layout method to not do anything with it and allows us to correctly
   // calculate offsets when working with indices into the model.
   [closingControllers_ addObject:closingTab];
 
   // Mark the tab as closing. This prevents it from generating any drags or
   // selections while it's animating closed.
   [(TabView*)[closingTab view] setIsClosing:YES];
 
   // Register delegate (owned by the animation system).
   NSView* tabView = [closingTab view];
   CAAnimation* animation = [[tabView animationForKey:@"frameOrigin"] copy];
   [animation autorelease];
   scoped_nsobject<TabCloseAnimationDelegate> delegate(
     [[TabCloseAnimationDelegate alloc] initWithTabStrip:self
                                           tabController:closingTab]);
   [animation setDelegate:delegate.get()];  // Retains delegate.
   NSMutableDictionary* animationDictionary =
       [NSMutableDictionary dictionaryWithDictionary:[tabView animations]];
   [animationDictionary setObject:animation forKey:@"frameOrigin"];
   [tabView setAnimations:animationDictionary];
 
   // Periscope down! Animate the tab.
   NSRect newFrame = [tabView frame];
   newFrame = NSOffsetRect(newFrame, 0, -newFrame.size.height);
-  [NSAnimationContext beginGrouping];
-  [[NSAnimationContext currentContext] gtm_setDuration:kAnimationDuration];
+  ScopedNSAnimationContextGroup animationGroup(true);
+  animationGroup.SetCurrentContextDuration(kAnimationDuration);
   [[tabView animator] setFrame:newFrame];
-  [NSAnimationContext endGrouping];
 }
 
 // Called when a notification is received from the model that the given tab
 // has gone away. Start an animation then force a layout to put everything
 // in motion.
 - (void)tabDetachedWithContents:(TabContents*)contents
                         atIndex:(NSInteger)modelIndex {
   // Take closing tabs into account.
   NSInteger index = [self indexFromModelIndex:modelIndex];
 
@@ skipping 367 matching lines @@
   NSInteger index = [self indexFromModelIndex:modelIndex];
   BrowserWindowController* controller =
       (BrowserWindowController*)[[switchView_ window] windowController];
   DCHECK(index >= 0);
   if (index >= 0) {
     [controller setTab:[self viewAtIndex:index] isDraggable:YES];
   }
 }
 
 @end