Lay out tabs to have integer widths.

chrome/browser/ui/cocoa/tabs/tab_strip_controller.mm

 // Copyright (c) 2011 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/ui/cocoa/tabs/tab_strip_controller.h"
 
 #import <QuartzCore/QuartzCore.h>
 
+#include <cmath>
 #include <limits>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/mac/mac_util.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
@@ skipping 825 matching lines @@
   // This may be negative, but that's okay (taken care of by |MAX()| when
   // calculating tab sizes). "mini" tabs in horizontal mode just get a special
   // section, they don't change size.
   CGFloat availableSpaceForNonMini = availableSpace;
   availableSpaceForNonMini -=
       [self numberOfOpenMiniTabs] * (kMiniTabWidth - kTabOverlap);
 
   // Initialize |nonMiniTabWidth| in case there aren't any non-mini-tabs; this
   // value shouldn't actually be used.
   CGFloat nonMiniTabWidth = kMaxTabWidth;
+  CGFloat nonMiniTabWidthFraction = 0;
   const NSInteger numberOfOpenNonMiniTabs = [self numberOfOpenNonMiniTabs];
   if (numberOfOpenNonMiniTabs) {
     // Find the width of a non-mini-tab. This only applies to horizontal
     // mode. Add in the amount we "get back" from the tabs overlapping.
     availableSpaceForNonMini += (numberOfOpenNonMiniTabs - 1) * kTabOverlap;
 
     // Divide up the space between the non-mini-tabs.
     nonMiniTabWidth = availableSpaceForNonMini / numberOfOpenNonMiniTabs;
 
     // Clamp the width between the max and min.
     nonMiniTabWidth = MAX(MIN(nonMiniTabWidth, kMaxTabWidth), kMinTabWidth);
+
+    // Separate integral and fractional parts.
+    CGFloat integralPart = std::floor(nonMiniTabWidth);
+    nonMiniTabWidthFraction = nonMiniTabWidth - integralPart;
+    nonMiniTabWidth = integralPart;
   }
 
   BOOL visible = [[tabStripView_ window] isVisible];
 
   CGFloat offset = [self leftIndentForControls];
   bool hasPlaceholderGap = false;
   // Whether or not the last tab processed by the loop was a mini tab.
   BOOL isLastTabMini = NO;
+  CGFloat tabWidthAccumulatedFraction = 0;
+  NSInteger laidOutNonMiniTabs = 0;
   for (TabController* tab in tabArray_.get()) {
     // Ignore a tab that is going through a close animation.
     if ([closingControllers_ containsObject:tab])
       continue;
 
     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;
@@ skipping 30 matching lines @@
         hasPlaceholderGap = true;
         offset += NSWidth(placeholderFrame_);
         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.
     BOOL isMini = [tab mini];
-    tabFrame.size.width = isMini ?
-        ([tab app] ? kAppTabWidth : kMiniTabWidth) : nonMiniTabWidth;
+    if (isMini) {
+      tabFrame.size.width = [tab app] ? kAppTabWidth : kMiniTabWidth;
+    } else {
+      tabFrame.size.width = nonMiniTabWidth;
+      tabWidthAccumulatedFraction += nonMiniTabWidthFraction;
+
+      if (tabWidthAccumulatedFraction >= 1.0) {

[Robert Sesek, 2011/12/13 18:46:38]

I'd maybe name and discuss the algorithm you're using.

+        ++tabFrame.size.width;
+        --tabWidthAccumulatedFraction;
+      }
+
+      // In case of rounding error, give any left over pixels to the last tab.

[Robert Sesek, 2011/12/13 18:46:38]

Why is this a "rounding error"?

[Avi (use Gerrit), 2011/12/13 19:15:01]

Assume that we have 181px to distribute across three tabs. Each tab will be
60.3333px.

First tab is 60px. Accumulate the .3333219 (or whatever the floating point
version of 1/3 is).
Second tab is 60px. Accumulate another .3333219.
By the third tab, we've accumulated .9999657. That's our missing pixel, but due
to rounding error it's not exactly 1. Since we're on our last tab, if we have
what's clearly "almost a pixel" we just treat it as it is.

[Robert Sesek, 2011/12/13 19:49:56]

Got to love floating point math.

+      if (laidOutNonMiniTabs == numberOfOpenNonMiniTabs - 1 &&
+          tabWidthAccumulatedFraction > 0.5) {
+        ++tabFrame.size.width;
+      }
+
+      ++laidOutNonMiniTabs;
+    }
+
     if ([tab selected])
       tabFrame.size.width = MAX(tabFrame.size.width, kMinSelectedTabWidth);
 
     // If this is the first non-mini tab, then add a bit of spacing between this
     // and the last mini tab.
     if (!isMini && isLastTabMini) {
       offset += kLastMiniTabSpacing;
       tabFrame.origin.x = offset;
     }
     isLastTabMini = isMini;
@@ skipping 1082 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