Parametrize some more constants that will be changing in MD.

chrome/browser/ui/views/tabs/tab_strip.cc

 // 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.
 
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 
 #if defined(OS_WIN)
 #include <windowsx.h>
 #endif
 
@@ skipping 102 matching lines @@
 // Amount of time we delay before resizing after a close from a touch.
 const int kTouchResizeLayoutTimeMS = 2000;
 
 // Amount to adjust the clip by when the tab is stacked before the active index.
 const int kStackedTabLeftClip = 20;
 
 // Amount to adjust the clip by when the tab is stacked after the active index.
 const int kStackedTabRightClip = 20;
 
 #if defined(OS_MACOSX)
-const int kNewTabButtonHorizontalOffset = -8;
 const int kPinnedToNonPinnedOffset = 2;
 #else
-const int kNewTabButtonHorizontalOffset = -11;
 const int kPinnedToNonPinnedOffset = 3;
 #endif
 
 // Returns the width needed for the new tab button (and padding).
 int GetNewTabButtonWidth() {
-  return TabStrip::kNewTabButtonAssetWidth + kNewTabButtonHorizontalOffset;
+  return GetLayoutConstant(NEW_TAB_BUTTON_WIDTH) -
+      GetLayoutConstant(TABSTRIP_NEW_TAB_BUTTON_OVERLAP);
 }
 
 // Animation delegate used for any automatic tab movement.  Hides the tab if it
 // is not fully visible within the tabstrip area, to prevent overflow clipping.
 class TabAnimationDelegate : public gfx::AnimationDelegate {
  public:
   TabAnimationDelegate(TabStrip* tab_strip, Tab* tab);
   ~TabAnimationDelegate() override;
 
   void AnimationProgressed(const gfx::Animation* animation) override;
@@ skipping 386 matching lines @@
 void TabStrip::RemoveTabDelegate::AnimationCanceled(
     const gfx::Animation* animation) {
   AnimationEnded(animation);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, public:
 
 // static
 const int TabStrip::kNewTabButtonVerticalOffset = 7;
-const int TabStrip::kNewTabButtonAssetWidth = 34;
 
 TabStrip::TabStrip(TabStripController* controller)
     : controller_(controller),
       newtab_button_(NULL),
       current_inactive_width_(Tab::GetStandardSize().width()),
       current_active_width_(Tab::GetStandardSize().width()),
       available_width_for_tabs_(-1),
       in_tab_close_(false),
       animation_container_(new gfx::AnimationContainer()),
       bounds_animator_(this),
@@ skipping 956 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   set_id(VIEW_ID_TAB_STRIP);
   // So we get enter/exit on children to switch stacked layout on and off.
   set_notify_enter_exit_on_child(true);
   newtab_button_bounds_.SetRect(
-      0, 0, kNewTabButtonAssetWidth,
+      0, 0, GetLayoutConstant(NEW_TAB_BUTTON_WIDTH),
       kNewTabButtonHeight + kNewTabButtonVerticalOffset);
   newtab_button_ = new NewTabButton(this, this);
   newtab_button_->SetTooltipText(
       l10n_util::GetStringUTF16(IDS_TOOLTIP_NEW_TAB));
   newtab_button_->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_ACCNAME_NEWTAB));
   newtab_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
                                     views::ImageButton::ALIGN_BOTTOM);
   newtab_button_->SetEventTargeter(
       scoped_ptr<views::ViewTargeter>(new views::ViewTargeter(newtab_button_)));
@@ skipping 783 matching lines @@
     const std::vector<gfx::Rect> tabs_bounds =
         CalculateBounds(GetTabSizeInfo(), GetPinnedTabCount(), tab_count(),
                         controller_->GetActiveIndex(), available_width,
                         &current_active_width_, &current_inactive_width_);
     DCHECK_EQ(static_cast<size_t>(tab_count()), tabs_bounds.size());
 
     for (size_t i = 0; i < tabs_bounds.size(); ++i)
       tabs_.set_ideal_bounds(i, tabs_bounds[i]);
   }
 
-  const int new_tab_x = tabs_.ideal_bounds(tabs_.view_size() - 1).right() +
-                        kNewTabButtonHorizontalOffset;
+  const int new_tab_x = tabs_.ideal_bounds(tabs_.view_size() - 1).right() -
+                        GetLayoutConstant(TABSTRIP_NEW_TAB_BUTTON_OVERLAP);
   newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, 0));
 }
 
 int TabStrip::GenerateIdealBoundsForPinnedTabs(int* first_non_pinned_index) {
   const int num_pinned_tabs = GetPinnedTabCount();
 
   if (first_non_pinned_index)
     *first_non_pinned_index = num_pinned_tabs;
 
   if (num_pinned_tabs == 0)
@@ skipping 45 matching lines @@
     gfx::Rect bounds = ideal_bounds(i);
     bounds.set_x(bounds.x() - delta);
     tabs_.set_ideal_bounds(i, bounds);
   }
 
   // Don't just subtract |delta| from the New Tab x-coordinate, as we might have
   // overflow tabs that will be able to animate into the strip, in which case
   // the new tab button should stay where it is.
   newtab_button_bounds_.set_x(std::min(
       width() - newtab_button_bounds_.width(),
-      ideal_bounds(tab_count() - 1).right() + kNewTabButtonHorizontalOffset));
+      ideal_bounds(tab_count() - 1).right() -
+          GetLayoutConstant(TABSTRIP_NEW_TAB_BUTTON_OVERLAP)));
 
   PrepareForAnimation();
 
   tab_closing->set_closing(true);
 
   // We still need to paint the tab until we actually remove it. Put it in
   // tabs_closing_map_ so we can find it.
   RemoveTabFromViewModel(model_index);
 
   AnimateToIdealBounds();
@@ skipping 294 matching lines @@
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }