Fix several issues with dragging tabs and quickly letting go, including crash...

chrome/browser/cocoa/tab_view.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_view.h"
 
 #include "base/logging.h"
 #include "chrome/browser/cocoa/nsimage_cache.h"
 #import "chrome/browser/cocoa/tab_controller.h"
 #import "chrome/browser/cocoa/tab_window_controller.h"
@@ skipping 31 matching lines @@
   closeTrackingArea_.reset(
       [[NSTrackingArea alloc] initWithRect:[closeButton_ bounds]
                                    options:NSTrackingMouseEnteredAndExited |
                                            NSTrackingActiveAlways
                                      owner:self
                                   userInfo:nil]);
   [closeButton_ addTrackingArea:closeTrackingArea_.get()];
 }
 
 - (void)dealloc {
+  // Cancel any delayed requests that may still be pending (drags or hover).
+  [NSObject cancelPreviousPerformRequestsWithTarget:self];
   // [self gtm_unregisterForThemeNotifications];
   [closeButton_ removeTrackingArea:closeTrackingArea_.get()];
   [super dealloc];
 }
 
 // Overridden so that mouse clicks come to this view (the parent of the
 // hierarchy) first. We want to handle clicks and drags in this class and
 // leave the background button for display purposes only.
 - (BOOL)acceptsFirstMouse:(NSEvent *)theEvent {
   return YES;
@@ skipping 95 matching lines @@
       TabWindowController* realController =
           static_cast<TabWindowController*>(controller);
       if ([realController canReceiveFrom:dragController]) {
         [targets addObject:controller];
       }
     }
   }
   return targets;
 }
 
+// Call to clear out transient weak references we hold during drags.
+- (void)resetDragControllers {
+  draggedController_ = nil;
+  dragWindow_ = nil;
+  dragOverlay_ = nil;
+  sourceController_ = nil;
+  sourceWindow_ = nil;
+  targetController_ = nil;
+}
+
 // Handle clicks and drags in this button. We get here because we have
 // overridden acceptsFirstMouse: and the click is within our bounds.
 // TODO(pinkerton/alcor): This routine needs *a lot* of work to marry Cole's
 // ideas of dragging cocoa views between windows and how the Browser and
 // TabStrip models want to manage tabs.
 
 static const CGFloat kTearDistance = 36.0;
 static const NSTimeInterval kTearDuration = 0.333;
 
 // This is used to judge whether the mouse has moved during rapid closure; if it
@@ skipping 14 matching lines @@
       [closeButton_ mouseDown:theEvent];
       return;
     }
   }
 
   // Fire the action to select the tab.
   if ([[controller_ target] respondsToSelector:[controller_ action]])
     [[controller_ target] performSelector:[controller_ action]
                                withObject:self];
 
+  [self resetDragControllers];
+
   // Resolve overlay back to original window.
   sourceWindow_ = [self window];
   if ([sourceWindow_ isKindOfClass:[NSPanel class]]) {
     sourceWindow_ = [sourceWindow_ parentWindow];
   }
 
   sourceWindowFrame_ = [sourceWindow_ frame];
   sourceTabFrame_ = [self frame];
   sourceController_ = [sourceWindow_ windowController];
-  draggedController_ = nil;
-  dragWindow_ = nil;
-  dragOverlay_ = nil;
-  targetController_ = nil;
   tabWasDragged_ = NO;
   tearTime_ = 0.0;
   draggingWithinTabStrip_ = YES;
 
   // If there's more than one potential window to be a drop target, we want to
   // treat a drag of a tab just like dragging around a tab that's already
   // detached. Note that unit tests might have |-numberOfTabs| reporting zero
   // since the model won't be fully hooked up. We need to be prepared for that
   // and not send them into the "magnetic" codepath.
   NSArray* targets = [self dropTargetsForController:sourceController_];
@@ skipping 147 matching lines @@
     [draggedController_ showOverlay];
     dragOverlay_ = [draggedController_ overlayWindow];
     // Force the new tab button to be hidden. We'll reset it on mouse up.
     [draggedController_ showNewTabButton:NO];
     //if (![targets count])
     //  [dragOverlay_ setHasShadow:NO];
     tearTime_ = [NSDate timeIntervalSinceReferenceDate];
     tearOrigin_ = sourceWindowFrame_.origin;
   }
 
+  DCHECK(draggedController_);
+  DCHECK(sourceController_);
+
+  // When the user first tears off the window, we want slide the window to
+  // the current mouse location (to reduce the jarring appearance). We do this
+  // by calling ourselves back with additional mouseDragged calls (not actual
+  // events). |tearProgress| is a normalized measure of how far through this
+  // tear "animation" (of length kTearDuration) we are and has values [0..1].
+  // We use sqrt() so the animation is non-linear (slow down near the end
+  // point).
   float tearProgress = [NSDate timeIntervalSinceReferenceDate] - tearTime_;
-  tearProgress /= kTearDuration;
+  tearProgress /= kTearDuration;  // Normalize.
   tearProgress = sqrtf(MAX(MIN(tearProgress, 1.0), 0.0));
 
   // Move the dragged window to the right place on the screen.
   NSPoint origin = sourceWindowFrame_.origin;
   origin.x += (thisPoint.x - dragOrigin_.x);
   origin.y += (thisPoint.y - dragOrigin_.y);
 
   if (tearProgress < 1) {
     // If the tear animation is not complete, call back to ourself with the
-    // same event to animate even if the mouse isn't moving.
+    // same event to animate even if the mouse isn't moving. We need to make
+    // sure these get cancelled in mouseUp:.
     [NSObject cancelPreviousPerformRequestsWithTarget:self];
     [self performSelector:@selector(mouseDragged:)
                withObject:theEvent
                afterDelay:1.0f/30.0f];
 
-    origin.x = (1 - tearProgress) *  tearOrigin_.x + tearProgress * origin.x;
+    // Set the current window origin based on how far we've progressed through
+    // the tear animation.
+    origin.x = (1 - tearProgress) * tearOrigin_.x + tearProgress * origin.x;
     origin.y = (1 - tearProgress) * tearOrigin_.y + tearProgress * origin.y;
   }
 
   if (targetController_) {
     // In order to "snap" two windows of different sizes together at their
     // toolbar, we can't just use the origin of the target frame. We also have
     // to take into consideration the difference in height.
     NSRect targetFrame = [[targetController_ window] frame];
     NSRect sourceFrame = [dragWindow_ frame];
     origin.y = NSMinY(targetFrame) +
@@ skipping 27 matching lines @@
     [targetController_ insertPlaceholderForTab:self
                                          frame:tabFrame
                                  yStretchiness:0];
     [targetController_ layoutTabs];
   } else {
     [dragWindow_ makeKeyAndOrderFront:nil];
   }
   BOOL chromeShouldBeVisible = targetController_ == nil;
 
   if (chromeIsVisible_ != chromeShouldBeVisible) {
+    // TODO(pinkerton): There appears to be a race-condition in CoreAnimation
+    // where if we use animators to set the alpha values, we can't guarantee
+    // that we cancel them. This has the side effect of sometimes leaving
+    // the dragged window translucent or invisible. We should re-visit this,
+    // but for now, don't animate the alpha change.
     [dragWindow_ setHasShadow:YES];
+    [[draggedController_ overlayWindow] setAlphaValue:1.0];
     if (targetController_) {
-      [NSAnimationContext beginGrouping];
-      [[NSAnimationContext currentContext] setDuration:0.00001];
-      [[dragWindow_ animator] setAlphaValue:0.0];
-      [NSAnimationContext endGrouping];
+      [dragWindow_ setAlphaValue:0.0];
       [[draggedController_ overlayWindow] setHasShadow:YES];
-      [[[draggedController_ overlayWindow] animator] setAlphaValue:1.0];
     } else {
-      [[draggedController_ overlayWindow] setAlphaValue:1.0];
+      [dragWindow_ setAlphaValue:0.5];
       [[draggedController_ overlayWindow] setHasShadow:NO];
-      [[dragWindow_ animator] setAlphaValue:0.5];
     }
     chromeIsVisible_ = chromeShouldBeVisible;
   }
 }
 
 - (void)mouseUp:(NSEvent *)theEvent {
   // The drag/click is done. If the user dragged the mouse, finalize the drag
   // and clean up.
 
   // Special-case this to keep the logic below simpler.
   if (moveWindowOnDrag_)
     return;
 
+  // Cancel any delayed -mouseDragged: requests that may still be pending.
+  [NSObject cancelPreviousPerformRequestsWithTarget:self];
+
   // We are now free to re-display the new tab button in the window we're
   // dragging. It will show when the next call to -layoutTabs (which happens
   // indrectly by several of the calls below, such as removing the placeholder).
   [draggedController_ showNewTabButton:YES];
 
   if (draggingWithinTabStrip_) {
     if (tabWasDragged_) {
       // Move tab to new location.
       DCHECK([sourceController_ numberOfTabs]);
       TabWindowController* dropController = sourceController_;
       [dropController moveTabView:[dropController selectedTabView]
                    fromController:nil];
     }
   } else if (targetController_) {
     // Move between windows. If |targetController_| is nil, we're not dropping
     // into any existing window.
     NSView* draggedTabView = [draggedController_ selectedTabView];
     [draggedController_ removeOverlay];
     [targetController_ moveTabView:draggedTabView
                     fromController:draggedController_];
     [targetController_ showWindow:nil];
   } else {
-    // Tab dragging did move window only.
+    // Only move the window around on screen. Make sure it's set back to
+    // normal state (fully opaque, has shadow, has key, etc).
     [draggedController_ removeOverlay];
     // Don't want to re-show the window if it was closed during the drag.
     if ([dragWindow_ isVisible]) {
       [dragWindow_ setAlphaValue:1.0];
       [dragOverlay_ setHasShadow:NO];
       [dragWindow_ setHasShadow:YES];
       [dragWindow_ makeKeyAndOrderFront:nil];
     }
     [[draggedController_ window] setLevel:NSNormalWindowLevel];
     [draggedController_ removePlaceholder];
   }
   [sourceController_ removePlaceholder];
   chromeIsVisible_ = YES;
+
+  [self resetDragControllers];
 }
 
 - (void)otherMouseUp:(NSEvent*)theEvent {
   // Support middle-click-to-close.
   if ([theEvent buttonNumber] == 2) {
     [controller_ closeTab:self];
   }
 }
 
 - (NSPoint)patternPhase {
@@ skipping 156 matching lines @@
   [[NSGraphicsContext currentContext] restoreGraphicsState];
 }
 
 // Called when the user hits the right mouse button (or control-clicks) to
 // show a context menu.
 - (void)rightMouseDown:(NSEvent*)theEvent {
   [NSMenu popUpContextMenu:[self menu] withEvent:theEvent forView:self];
 }
 
 @end