P2.1a.

chrome/browser/cocoa/tab_strip_controller.mm

 // Copyright (c) 2010 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>
 #include <string>
@@ skipping 558 matching lines @@
 
   TabContents* contents = tabStripModel_->GetTabContentsAt(index);
   if (contents)
     UserMetrics::RecordAction("CloseTab_Mouse", contents->profile());
   const NSInteger numberOfOpenTabs = [self numberOfOpenTabs];
   if (numberOfOpenTabs > 1) {
     bool isClosingLastTab = index == numberOfOpenTabs - 1;
     if (!isClosingLastTab) {
       // Limit the width available for laying out tabs so that tabs are not
       // resized until a later time (when the mouse leaves the tab strip).
-      // TODO(pinkerton): re-visit when handling tab overflow.
-      // http://crbug.com/188
       NSView* penultimateTab = [self viewAtIndex:numberOfOpenTabs - 2];
       availableResizeWidth_ = NSMaxX([penultimateTab frame]);
     } else {
       // If the rightmost tab is closed, change the available width so that
       // another tab's close button lands below the cursor (assuming the tabs
-      // are currently below their maximum width and can grow).
+      // are currently below their maximum width and can grow) if possible.
       NSView* lastTab = [self viewAtIndex:numberOfOpenTabs - 1];
       availableResizeWidth_ = NSMaxX([lastTab frame]);
+
+      // Since close buttons are on the left, this is a bit tricky. To make this
+      // at all possible, the rightmost tab keeps its narrow pre-close width
+      // and the other tabs expand to push it over.
+      // Only do this if the other tabs can be pushed far enough, though.
+      lastClosedTabWidth_.reset();
+      const CGFloat kPinnedTabWidth = [TabController pinnedTabWidth];
+      const CGFloat pinnedWidth =
+          [self numberOfOpenPinnedTabs] * (kPinnedTabWidth - kTabOverlap);
+      const CGFloat kMaxTabWidth = [TabController maxTabWidth];
+      const CGFloat unpinnedWidth =  // 1 tab is candidate for being shorter
+          ([self numberOfOpenUnpinnedTabs] - 1) * (kMaxTabWidth - kTabOverlap);
+      CGFloat candidateWidth = NSWidth([lastTab frame]);
+      // Technically, it should be
+      // |pinnedWidth + unpinnedWidth + widthOfPartOfLastTabThatContainsClose|,
+      // but that's complicated _and_ makes the last tab look very thin.
+      if (pinnedWidth + unpinnedWidth >= availableResizeWidth_)
+        lastClosedTabWidth_.reset(new CGFloat(candidateWidth));
     }
     tabStripModel_->CloseTabContentsAt(index);
   } else {
     // Use the standard window close if this is the last tab
     // this prevents the tab from being removed from the model until after
     // the window dissapears
     [[tabStripView_ window] performClose:nil];
   }
 }
 
@@ skipping 61 matching lines @@
   if (doUpdate)
     [self regenerateSubviewList];
 
   // Compute the base width of tabs given how much room we're allowed. Note that
   // pinned tabs have a fixed width. We may not be able to use the entire width
   // if the user is quickly closing tabs. This may be negative, but that's okay
   // (taken care of by |MAX()| when calculating tab sizes).
   CGFloat availableWidth = 0;
   if ([self inRapidClosureMode]) {
     availableWidth = availableResizeWidth_;
+    if (lastClosedTabWidth_.get())
+      availableWidth -= *lastClosedTabWidth_.get();
   } else {
     availableWidth = NSWidth([tabStripView_ frame]);
     availableWidth -= NSWidth([newTabButton_ frame]) + kNewTabButtonOffset;
   }
   availableWidth -= [self indentForControls];
 
   // This may be negative, but that's okay (taken care of by |MAX()| when
   // calculating tab sizes).
   CGFloat availableWidthForUnpinned = availableWidth -
       [self numberOfOpenPinnedTabs] * (kPinnedTabWidth - kTabOverlap);
 
   // Initialize |unpinnedTabWidth| in case there aren't any unpinned tabs; this
   // value shouldn't actually be used.
   CGFloat unpinnedTabWidth = kMaxTabWidth;
-  const NSInteger numberOfOpenUnpinnedTabs = [self numberOfOpenUnpinnedTabs];
+  const NSInteger numberOfOpenUnpinnedTabs = [self numberOfOpenUnpinnedTabs]
+      - (lastClosedTabWidth_.get() ? 1 : 0);
   if (numberOfOpenUnpinnedTabs) {  // Find the width of an unpinned tab.
     // Add in the amount we "get back" from the tabs overlapping.
     availableWidthForUnpinned += (numberOfOpenUnpinnedTabs - 1) * kTabOverlap;
+    if (lastClosedTabWidth_.get())
+      availableWidthForUnpinned += kTabOverlap;
 
     // Divide up the space between the unpinned tabs.
     unpinnedTabWidth = availableWidthForUnpinned / numberOfOpenUnpinnedTabs;
 
     // Clamp the width between the max and min.
     unpinnedTabWidth = MAX(MIN(unpinnedTabWidth, kMaxTabWidth), kMinTabWidth);
   }
 
   const CGFloat minX = NSMinX(placeholderFrame_);
   BOOL visible = [[tabStripView_ window] isVisible];
 
   CGFloat offset = [self indentForControls];
-  NSUInteger i = 0;
   bool hasPlaceholderGap = false;
+  int openTabCount = 0;
   for (TabController* tab in tabArray_.get()) {
     // Ignore a tab that is going through a close animation.
     if ([closingControllers_ containsObject:tab])
       continue;
 
+    ++openTabCount;
     BOOL isPlaceholder = [[tab view] isEqual:placeholderTab_];
     NSRect tabFrame = [[tab view] frame];
     tabFrame.size.height = [[self class] defaultTabHeight] + 1;
     tabFrame.origin.y = 0;
     tabFrame.origin.x = offset;
 
     // 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) {
@@ skipping 26 matching lines @@
       offset -= kTabOverlap;
       tabFrame.origin.x = offset;
     }
 
     // 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 pinned] ? kPinnedTabWidth : unpinnedTabWidth;
     if ([tab selected])
       tabFrame.size.width = MAX(tabFrame.size.width, kMinSelectedTabWidth);
 
+    // When in rapid-closure mode, treat the width of the last tab in a way
+    // that its close button ends up below the cursor.
+    BOOL isLastOpenTab = tabStripModel_->count() == openTabCount;
+    if (isLastOpenTab && lastClosedTabWidth_.get())
+      tabFrame.size.width = *lastClosedTabWidth_.get();
+
     // Animate a new tab in by putting it below the horizon unless told to put
     // it in a specific location (i.e., from a drop).
     if (newTab && visible && animate) {
       if (NSEqualRects(droppedTabFrame_, NSZeroRect)) {
         [[tab view] setFrame:NSOffsetRect(tabFrame, 0, -NSHeight(tabFrame))];
       } else {
         [[tab view] setFrame:droppedTabFrame_];
         droppedTabFrame_ = NSZeroRect;
       }
     }
 
     // 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
@@ skipping 94 matching lines @@
   // upwards as it's being initially layed out. Oddly, this works while doing
   // something similar in |-layoutTabs| confuses the window server.
   [newView setFrame:NSOffsetRect([newView frame],
                                  0, -[[self class] defaultTabHeight])];
 
   [self setTabTitle:newController withContents:contents];
 
   // If a tab is being inserted, we can again use the entire tab strip width
   // for layout.
   availableResizeWidth_ = kUseFullAvailableWidth;
+  lastClosedTabWidth_.reset();
 
   // We don't need to call |-layoutTabs| if the tab will be in the foreground
   // because it will get called when the new tab is selected by the tab model.
   // Whenever |-layoutTabs| is called, it'll also add the new subview.
   if (!inForeground) {
     [self layoutTabs];
   }
 
   // During normal loading, we won't yet have a favicon and we'll get
   // subsequent state change notifications to show the throbber, but when we're
@@ skipping 498 matching lines @@
 
 // Called when the tracking area is in effect which means we're tracking to
 // see if the user leaves the tab strip with their mouse. When they do,
 // reset layout to use all available width.
 - (void)mouseExited:(NSEvent*)event {
   NSTrackingArea* area = [event trackingArea];
   if ([area isEqual:trackingArea_]) {
     mouseInside_ = NO;
     [self setTabTrackingAreasEnabled:NO];
     availableResizeWidth_ = kUseFullAvailableWidth;
+    lastClosedTabWidth_.reset();
     [hoveredTab_ mouseExited:event];
     hoveredTab_ = nil;
     [self layoutTabs];
   } else if ([area isEqual:newTabTrackingArea_]) {
     [newTabButton_ setImage:nsimage_cache::ImageNamed(kNewTabImage)];
   }
 }
 
 // Enable/Disable the tracking areas for the tabs. They are only enabled
 // when the mouse is in the tabstrip.
@@ skipping 301 matching lines @@
     return;
 
   TabContentsController* tabController =
       [tabContentsArray_ objectAtIndex:index];
   TabContents* devtoolsContents = contents ?
       DevToolsWindow::GetDevToolsContents(contents) : NULL;
   [tabController showDevToolsContents:devtoolsContents];
 }
 
 @end