(Mac) Make mashing the close tab button work.

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 "base/mac_util.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/app/chrome_dll_resource.h"
@@ skipping 19 matching lines @@
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "grit/generated_resources.h"
 #include "skia/ext/skia_utils_mac.h"
 
 NSString* const kTabStripNumberOfTabsChanged = @"kTabStripNumberOfTabsChanged";
 
 // A value to indicate tab layout should use the full available width of the
 // view.
 static const float kUseFullAvailableWidth = -1.0;
 
-// A simple view class that prevents the windowserver from dragging the
-// area behind tabs. Sometimes core animation confuses it.
-@interface TabStripControllerDragBlockingView : NSView
+// A simple view class that prevents the Window Server from dragging the area
+// behind tabs. Sometimes core animation confuses it. Unfortunately, it can also
+// falsely pick up clicks during rapid tab closure, so we have to account for
+// that.
+@interface TabStripControllerDragBlockingView : NSView {
+  TabStripController* controller_;  // weak; owns us
+}
+
+- (id)initWithFrame:(NSRect)frameRect
+         controller:(TabStripController*)controller;
 @end
 @implementation TabStripControllerDragBlockingView
 - (BOOL)mouseDownCanMoveWindow {return NO;}
 - (void)drawRect:(NSRect)rect {}
+
+- (id)initWithFrame:(NSRect)frameRect
+         controller:(TabStripController*)controller {
+  if ((self = [super initWithFrame:frameRect]))
+    controller_ = controller;
+  return self;
+}
+
+// In "rapid tab closure" mode (i.e., the user is clicking close tab buttons in
+// rapid succession), the animations confuse Cocoa's hit testing (which appears
+// to use cached results, among other tricks), so this view can somehow end up
+// getting a mouse down event. Thus we do an explicit hit test during rapid tab
+// closure, and if we find that we got a mouse down we shouldn't have, we send
+// it off to the appropriate view.
+- (void)mouseDown:(NSEvent*)event {
+  if ([controller_ inRapidClosureMode]) {
+    NSView* superview = [self superview];
+    NSPoint hitLocation =
+        [[superview superview] convertPoint:[event locationInWindow]
+                                   fromView:nil];
+    NSView* hitView = [superview hitTest:hitLocation];
+    if (hitView != self) {
+      [hitView mouseDown:event];
+      return;
+    }
+  }
+  [super mouseDown:event];
+}
 @end
 
 @interface TabStripController(Private)
-- (BOOL)useFullWidthForLayout;
+- (void)installTrackingArea;
 - (void)addSubviewToPermanentList:(NSView*)aView;
 - (void)regenerateSubviewList;
 - (NSInteger)indexForContentsView:(NSView*)view;
 - (void)updateFavIconForContents:(TabContents*)contents
                          atIndex:(NSInteger)index;
 @end
 
 @implementation TabStripController
 
 - (id)initWithView:(TabStripView*)view
@@ skipping 14 matching lines @@
     // some reason, if the view is present in the nib apriori, it draws
     // correctly. If we create it in code and add it to the tab view, it draws
     // with all sorts of crazy artifacts.
     newTabButton_ = [[tabView_ subviews] objectAtIndex:0];
     DCHECK([newTabButton_ isKindOfClass:[NSButton class]]);
     [self addSubviewToPermanentList:newTabButton_];
     [newTabButton_ setTarget:nil];
     [newTabButton_ setAction:@selector(commandDispatch:)];
     [newTabButton_ setTag:IDC_NEW_TAB];
     targetFrames_.reset([[NSMutableDictionary alloc] init]);
-    dragBlockingView_.reset([[TabStripControllerDragBlockingView alloc]
-                              initWithFrame:NSZeroRect]);
+    dragBlockingView_.reset(
+        [[TabStripControllerDragBlockingView alloc] initWithFrame:NSZeroRect
+                                                       controller:self]);
     [self addSubviewToPermanentList:dragBlockingView_];
     newTabTargetFrame_ = NSMakeRect(0, 0, 0, 0);
     availableResizeWidth_ = kUseFullAvailableWidth;
 
     // Install the permanent subviews.
     [self regenerateSubviewList];
 
     // Watch for notifications that the tab strip view has changed size so
     // we can tell it to layout for the new size.
     [[NSNotificationCenter defaultCenter]
@@ skipping 217 matching lines @@
   [[NSAnimationContext currentContext] setDuration:0.2];
 
   // Update the current subviews and their z-order if requested.
   if (doUpdate)
       [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 useFullWidthForLayout]) {
+  if ([self inRapidClosureMode]) {
+    availableWidth = availableResizeWidth_;
+  } else {
     availableWidth = NSWidth([tabView_ frame]);
     availableWidth -= NSWidth([newTabButton_ frame]) + kNewTabButtonOffset;
-  } else {
-    availableWidth = availableResizeWidth_;
   }
   availableWidth -= kIndentLeavingSpaceForControls;
 
   // Add back in the amount we "get back" from the tabs overlapping.
   availableWidth += ([tabContentsArray_ count] - 1) * kTabOverlap;
   const float baseTabWidth =
       MAX(MIN(availableWidth / [tabContentsArray_ count],
               kMaxTabWidth),
           kMinTabWidth);
 
@@ skipping 72 matching lines @@
     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.
   if (forceNewTabButtonHidden_) {
     [newTabButton_ setHidden:YES];
   } else {
     NSRect newTabNewFrame = [newTabButton_ frame];
-    if ([self useFullWidthForLayout])
+    if ([self inRapidClosureMode])
+      newTabNewFrame.origin = NSMakePoint(offset + kNewTabButtonOffset, 0);
+    else
       newTabNewFrame.origin =
           NSMakePoint(MIN(availableWidth, offset + kNewTabButtonOffset), 0);
-    else
-      newTabNewFrame.origin = NSMakePoint(offset + kNewTabButtonOffset, 0);
     newTabNewFrame.origin.x = MAX(newTabNewFrame.origin.x,
                                   NSMaxX(placeholderFrame_));
     if (i > 0 && [newTabButton_ isHidden]) {
       id target = animate ? [newTabButton_ animator] : newTabButton_;
       [target setHidden:NO];
     }
 
     if (!NSEqualRects(newTabTargetFrame_, newTabNewFrame)) {
       [newTabButton_ setFrame:newTabNewFrame];
       newTabTargetFrame_ = newTabNewFrame;
@@ skipping 333 matching lines @@
 
 // Called when the tab strip view changes size. As we only registered for
 // changes on our view, we know it's only for our view. Layout w/out
 // animations since they are blocked by the resize nested runloop. We need
 // the views to adjust immediately. Neither the tabs nor their z-order are
 // changed, so we don't need to update the subviews.
 - (void)tabViewFrameChanged:(NSNotification*)info {
   [self layoutTabsWithAnimation:NO regenerateSubviews:NO];
 }
 
-- (BOOL)useFullWidthForLayout {
-  return availableResizeWidth_ == kUseFullAvailableWidth;
+- (BOOL)inRapidClosureMode {
+  return availableResizeWidth_ != kUseFullAvailableWidth;
 }
 
 - (void)mouseMoved:(NSEvent *)event {
   // Use hit test to figure out what view we are hovering over.
   TabView* targetView = (TabView*)[tabView_ hitTest:[event locationInWindow]];
   if (![targetView isKindOfClass:[TabView class]]) {
     if ([[targetView superview] isKindOfClass:[TabView class]]) {
       targetView = (TabView*)[targetView superview];
     } else {
       targetView = nil;
@@ skipping 118 matching lines @@
   BrowserWindowController* controller =
       (BrowserWindowController*)[[switchView_ window] windowController];
   DCHECK(index >= 0);
   if (index >= 0) {
     [controller setTab:[self viewAtIndex:index] isDraggable:YES];
   }
 }
 
 
 @end