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 {
+      // Tabs have non-integer widths. Assign the integer part to the tab, and
+      // keep an accumulation of the fractional parts. When the fractional
+      // accumulation gets to be more than one pixel, assign that to the current
+      // tab being laid out. This is vaguely inspired by Bresenham's line
+      // algorithm.
+      tabFrame.size.width = nonMiniTabWidth;
+      tabWidthAccumulatedFraction += nonMiniTabWidthFraction;
+
+      if (tabWidthAccumulatedFraction >= 1.0) {
+        ++tabFrame.size.width;
+        --tabWidthAccumulatedFraction;
+      }
+
+      // In case of rounding error, give any left over pixels to the last tab.
+      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