[Mac][Material Design] Fix TabStripController test that fails under MD.

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

 // Copyright (c) 2012 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>
@@ skipping 66 matching lines @@
 using content::OpenURLParams;
 using content::Referrer;
 using content::WebContents;
 
 namespace {
 
 // A value to indicate tab layout should use the full available width of the
 // view.
 const CGFloat kUseFullAvailableWidth = -1.0;
 
-// The amount by which tabs overlap.
-// Needs to be <= the x position of the favicon within a tab. Else, every time
-// the throbber is painted, the throbber's invalidation will also invalidate
-// parts of the tab to the left, and two tabs's backgrounds need to be painted
-// on each throbber frame instead of one.
-const CGFloat kTabOverlap = 18.0;
-const CGFloat kTabOverlapNonMD = 19.0;
-
 // The amount by which pinned tabs are separated from normal tabs.
 const CGFloat kLastPinnedTabSpacing = 2.0;
 
 // The amount by which the new tab button is offset (from the tabs).
 const CGFloat kNewTabButtonOffset = 10.0;
 const CGFloat kNewTabButtonOffsetNonMD = 8.0;
 
 // Time (in seconds) in which tabs animate to their final position.
 const NSTimeInterval kAnimationDuration = 0.125;
 
@@ skipping 447 matching lines @@
 + (CGFloat)defaultTabHeight {
   return [TabController defaultTabHeight];
 }
 
 + (CGFloat)defaultLeftIndentForControls {
   // Default indentation leaves enough room so tabs don't overlap with the
   // window controls.
   return 70.0;
 }
 
++ (CGFloat)tabOverlap {
+  // The overlap value needs to be <= the x position of the favicon within a
+  // tab. Else, every time the throbber is painted, the throbber's invalidation
+  // will also invalidate parts of the tab to the left, and two tabs's
+  // backgrounds need to be painted on each throbber frame instead of one.
+  const CGFloat kTabOverlap = 18.0;
+  const CGFloat kTabOverlapNonMD = 19.0;
+
+  if (!ui::MaterialDesignController::IsModeMaterial()) {
+    return kTabOverlapNonMD;
+  }
+  return kTabOverlap;
+}
+
 // Finds the TabContentsController associated with the given index into the tab
 // model and swaps out the sole child of the contentArea to display its
 // contents.
 - (void)swapInTabAtIndex:(NSInteger)modelIndex {
   DCHECK(modelIndex >= 0 && modelIndex < tabStripModel_->count());
   NSInteger index = [self indexFromModelIndex:modelIndex];
   TabContentsController* controller = [tabContentsArray_ objectAtIndex:index];
 
   // Make sure we do not draw any transient arrangements of views.
   gfx::ScopedCocoaDisableScreenUpdates cocoa_disabler;
@@ skipping 333 matching lines @@
 - (void)layoutTabsWithAnimation:(BOOL)animate
              regenerateSubviews:(BOOL)doUpdate {
   DCHECK([NSThread isMainThread]);
   if (![tabArray_ count])
     return;
 
   const CGFloat kMaxTabWidth = [TabController maxTabWidth];
   const CGFloat kMinTabWidth = [TabController minTabWidth];
   const CGFloat kMinActiveTabWidth = [TabController minActiveTabWidth];
   const CGFloat kPinnedTabWidth = [TabController pinnedTabWidth];
+  const CGFloat kTabOverlap = [TabStripController tabOverlap];
 
   NSRect enclosingRect = NSZeroRect;
   ScopedNSAnimationContextGroup mainAnimationGroup(animate);
   mainAnimationGroup.SetCurrentContextDuration(kAnimationDuration);
 
   // 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. 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 availableSpace = 0;
   if ([self inRapidClosureMode]) {
     availableSpace = availableResizeWidth_;
   } else {
     availableSpace = NSWidth([tabStripView_ frame]);
 
     // Account for the width of the new tab button.
     if (!ui::MaterialDesignController::IsModeMaterial()) {
       availableSpace -=
           NSWidth([newTabButton_ frame]) + kNewTabButtonOffsetNonMD -
-              kTabOverlapNonMD;
+              kTabOverlap;
     } else {
       availableSpace -=
           NSWidth([newTabButton_ frame]) + kNewTabButtonOffset - kTabOverlap;
     }
     // Account for the right-side controls if not in rapid closure mode.
     // (In rapid closure mode, the available width is set based on the
     // position of the rightmost tab, not based on the width of the tab strip,
     // so the right controls have already been accounted for.)
     availableSpace -= [self rightIndentForControls];
   }
@@ skipping 10 matching lines @@
         [self numberOfOpenPinnedTabs] * (kPinnedTabWidth - kTabOverlap);
     availableSpaceForNonPinned -= kLastPinnedTabSpacing;
   }
 
   // Initialize |nonPinnedTabWidth| in case there aren't any non-pinned tabs;
   // this value shouldn't actually be used.
   CGFloat nonPinnedTabWidth = kMaxTabWidth;
   CGFloat nonPinnedTabWidthFraction = 0;
   NSInteger numberOfNonPinnedTabs = MIN(
       [self numberOfOpenNonPinnedTabs],
-      (availableSpaceForNonPinned - kTabOverlap) / (kMinTabWidth -
-          kTabOverlap));
+      (availableSpaceForNonPinned - kTabOverlap) /
+          (kMinTabWidth - kTabOverlap));
 
   if (numberOfNonPinnedTabs) {
     // Find the width of a non-pinned tab. This only applies to horizontal
     // mode. Add in the amount we "get back" from the tabs overlapping.
     nonPinnedTabWidth =
         ((availableSpaceForNonPinned - kTabOverlap) / numberOfNonPinnedTabs) +
         kTabOverlap;
 
     // Clamp the width between the max and min.
     nonPinnedTabWidth = MAX(MIN(nonPinnedTabWidth, kMaxTabWidth), kMinTabWidth);
 
     // When there are multiple tabs, we'll have one active and some inactive
     // tabs.  If the desired width was between the minimum sizes of these types,
     // try to shrink the tabs with the smaller minimum.  For example, if we have
     // a strip of width 10 with 4 tabs, the desired width per tab will be 2.5.
     // If selected tabs have a minimum width of 4 and unselected tabs have
     // minimum width of 1, the above code would set *unselected_width = 2.5,
     // *selected_width = 4, which results in a total width of 11.5.  Instead, we
     // want to set *unselected_width = 2, *selected_width = 4, for a total width
     // of 10.
     if (numberOfNonPinnedTabs > 1 && nonPinnedTabWidth < kMinActiveTabWidth) {
       nonPinnedTabWidth = (availableSpaceForNonPinned - kMinActiveTabWidth) /
-                            (numberOfNonPinnedTabs - 1) +
-                        kTabOverlap;
+                            (numberOfNonPinnedTabs - 1) + kTabOverlap;
       if (nonPinnedTabWidth < kMinTabWidth) {
         // The above adjustment caused the tabs to not fit, show 1 less tab.
         --numberOfNonPinnedTabs;
         nonPinnedTabWidth = ((availableSpaceForNonPinned - kTabOverlap) /
-                                numberOfNonPinnedTabs) +
-                            kTabOverlap;
+                                numberOfNonPinnedTabs) + kTabOverlap;
       }
     }
 
     // Separate integral and fractional parts.
     CGFloat integralPart = std::floor(nonPinnedTabWidth);
     nonPinnedTabWidthFraction = nonPinnedTabWidth - integralPart;
     nonPinnedTabWidth = integralPart;
   }
 
   BOOL visible = [[tabStripView_ window] isVisible];
@@ skipping 961 matching lines @@
 // the |TabStripView|'s coordinates). It considers only the x-coordinate of the
 // given point. If it's in the "middle" of a tab, it drops on that tab. If it's
 // to the left, it inserts to the left, and similarly for the right.
 - (void)droppingURLsAt:(NSPoint)point
             givesIndex:(NSInteger*)index
            disposition:(WindowOpenDisposition*)disposition {
   // Proportion of the tab which is considered the "middle" (and causes things
   // to drop on that tab).
   const double kMiddleProportion = 0.5;
   const double kLRProportion = (1.0 - kMiddleProportion) / 2.0;
+  const CGFloat kTabOverlap = [TabStripController tabOverlap];
 
   DCHECK(index && disposition);
   NSInteger i = 0;
   for (TabController* tab in tabArray_.get()) {
     NSView* view = [tab view];
     DCHECK([view isKindOfClass:[TabView class]]);
 
     // Recall that |-[NSView frame]| is in its superview's coordinates, so a
     // |TabView|'s frame is in the coordinates of the |TabStripView| (which
     // matches the coordinate system of |point|).
@@ skipping 101 matching lines @@
 
   [self openURL:&url inView:view at:point];
 }
 
 // (URLDropTargetController protocol)
 - (void)indicateDropURLsInView:(NSView*)view at:(NSPoint)point {
   DCHECK_EQ(view, tabStripView_.get());
 
   // The minimum y-coordinate at which one should consider place the arrow.
   const CGFloat arrowBaseY = 25;
+  const CGFloat kTabOverlap = [TabStripController tabOverlap];
 
   NSInteger index;
   WindowOpenDisposition disposition;
   [self droppingURLsAt:point
             givesIndex:&index
            disposition:&disposition];
 
   NSPoint arrowPos = NSMakePoint(0, arrowBaseY);
   if (index == -1) {
     // Append a tab at the end.
@@ skipping 176 matching lines @@
 
 - (TabAlertState)alertStateForContents:(content::WebContents*)contents {
   return chrome::GetTabAlertStateForContents(contents);
 }
 
 - (void)themeDidChangeNotification:(NSNotification*)notification {
   [newTabButton_ setImages];
 }
 
 @end