[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 541 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 {
+  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 tabOverlap = [TabStripController tabOverlap];

[Avi (use Gerrit), 2016/05/04 20:57:20]

kTabOverlap is taken, but having this be not a k... where all the other
constants are k... is weird.

[shrike, 2016/05/04 21:15:20]

Yeah, it needs to (sorry, still locking all of our coding conventions into my
head). I moved the others out of the global scope which allows me create it
again as needed. Once we remove the old UI code the tabOverlap method can
probably just return a number instead of declare it first.

 
   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;
+              tabOverlap;
     } else {
       availableSpace -=
-          NSWidth([newTabButton_ frame]) + kNewTabButtonOffset - kTabOverlap;
+          NSWidth([newTabButton_ frame]) + kNewTabButtonOffset - tabOverlap;
     }
     // 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];
   }
 
   // Need to leave room for the left-side controls even in rapid closure mode.
   availableSpace -= [self leftIndentForControls];
 
   // This may be negative, but that's okay (taken care of by |MAX()| when
   // calculating tab sizes). "pinned" tabs in horizontal mode just get a special
   // section, they don't change size.
   CGFloat availableSpaceForNonPinned = availableSpace;
   if ([self numberOfOpenPinnedTabs]) {
     availableSpaceForNonPinned -=
-        [self numberOfOpenPinnedTabs] * (kPinnedTabWidth - kTabOverlap);
+        [self numberOfOpenPinnedTabs] * (kPinnedTabWidth - tabOverlap);
     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 - tabOverlap) / (kMinTabWidth - tabOverlap));
 
   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;
+        ((availableSpaceForNonPinned - tabOverlap) / numberOfNonPinnedTabs) +
+        tabOverlap;
 
     // 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) + tabOverlap;
       if (nonPinnedTabWidth < kMinTabWidth) {
         // The above adjustment caused the tabs to not fit, show 1 less tab.
         --numberOfNonPinnedTabs;
-        nonPinnedTabWidth = ((availableSpaceForNonPinned - kTabOverlap) /
-                                numberOfNonPinnedTabs) +
-                            kTabOverlap;
+        nonPinnedTabWidth = ((availableSpaceForNonPinned - tabOverlap) /
+                                numberOfNonPinnedTabs) + tabOverlap;
       }
     }
 
     // Separate integral and fractional parts.
     CGFloat integralPart = std::floor(nonPinnedTabWidth);
     nonPinnedTabWidthFraction = nonPinnedTabWidth - integralPart;
     nonPinnedTabWidth = integralPart;
   }
 
   BOOL visible = [[tabStripView_ window] isVisible];
@@ skipping 38 matching lines @@
       continue;
     }
 
     if (placeholderTab_ && !hasPlaceholderGap) {
       const CGFloat placeholderMin = NSMinX(placeholderFrame_);
       // If the left edge is to the left of the placeholder's left, but the
       // mid is to the right of it slide over to make space for it.
       if (NSMidX(tabFrame) > placeholderMin) {
         hasPlaceholderGap = true;
         offset += NSWidth(placeholderFrame_);
-        offset -= kTabOverlap;
+        offset -= tabOverlap;
         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 isPinned = [tab pinned];
     if (isPinned) {
       tabFrame.size.width = kPinnedTabWidth;
     } else {
@@ skipping 67 matching lines @@
       }];
 
       [frameTarget setFrame:tabFrame];
       [targetFrames_ setObject:[NSValue valueWithRect:tabFrame]
                         forKey:identifier];
     }
 
     enclosingRect = NSUnionRect(tabFrame, enclosingRect);
 
     offset += NSWidth(tabFrame);
-    offset -= kTabOverlap;
+    offset -= tabOverlap;
   }
 
   // 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
     // so we don't have to check it against the available space. We do need
     // to make sure we put it after any placeholder.
-    CGFloat maxTabX = MAX(offset, NSMaxX(placeholderFrame_) - kTabOverlap);
+    CGFloat maxTabX = MAX(offset, NSMaxX(placeholderFrame_) - tabOverlap);
     newTabNewFrame.origin = NSMakePoint(maxTabX + kNewTabButtonOffset, 0);
     if ([tabContentsArray_ count])
       [newTabButton_ setHidden:NO];
 
     if (!NSEqualRects(newTabTargetFrame_, newTabNewFrame)) {
       // Set the new tab button image correctly based on where the cursor is.
       NSWindow* window = [tabStripView_ window];
       NSPoint currentMouse = [window mouseLocationOutsideOfEventStream];
       currentMouse = [tabStripView_ convertPoint:currentMouse fromView:nil];
 
@@ skipping 801 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 tabOverlap = [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|).
     NSRect frame = [view frame];
 
     // Modify the frame to make it "unoverlapped".
-    frame.origin.x += kTabOverlap / 2.0;
-    frame.size.width -= kTabOverlap;
+    frame.origin.x += tabOverlap / 2.0;
+    frame.size.width -= tabOverlap;
     if (frame.size.width < 1.0)
       frame.size.width = 1.0;  // try to avoid complete failure
 
     // Drop in a new tab to the left of tab |i|?
     if (point.x < (frame.origin.x + kLRProportion * frame.size.width)) {
       *index = i;
       *disposition = NEW_FOREGROUND_TAB;
       return;
     }
 
@@ skipping 86 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 tabOverlap = [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.
     DCHECK(disposition == NEW_FOREGROUND_TAB);
     NSInteger lastIndex = [tabArray_ count] - 1;
     NSRect overRect = [[[tabArray_ objectAtIndex:lastIndex] view] frame];
-    arrowPos.x = overRect.origin.x + overRect.size.width - kTabOverlap / 2.0;
+    arrowPos.x = overRect.origin.x + overRect.size.width - tabOverlap / 2.0;
   } else {
     NSRect overRect = [[[tabArray_ objectAtIndex:index] view] frame];
     switch (disposition) {
       case NEW_FOREGROUND_TAB:
         // Insert tab (to the left of the given tab).
-        arrowPos.x = overRect.origin.x + kTabOverlap / 2.0;
+        arrowPos.x = overRect.origin.x + tabOverlap / 2.0;
         break;
       case CURRENT_TAB:
         // Overwrite the given tab.
         arrowPos.x = overRect.origin.x + overRect.size.width / 2.0;
         break;
       default:
         NOTREACHED();
     }
   }
 
@@ skipping 156 matching lines @@
 
 - (TabAlertState)alertStateForContents:(content::WebContents*)contents {
   return chrome::GetTabAlertStateForContents(contents);
 }
 
 - (void)themeDidChangeNotification:(NSNotification*)notification {
   [newTabButton_ setImages];
 }
 
 @end