Parametrize a variety of constants in preparation for changing them 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
 
 #include <algorithm>
 #include <iterator>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/view_ids.h"
+#include "chrome/browser/ui/views/layout_constants.h"
 #include "chrome/browser/ui/views/tabs/stacked_tab_strip_layout.h"
 #include "chrome/browser/ui/views/tabs/tab.h"
 #include "chrome/browser/ui/views/tabs/tab_drag_controller.h"
 #include "chrome/browser/ui/views/tabs/tab_strip_controller.h"
 #include "chrome/browser/ui/views/tabs/tab_strip_observer.h"
 #include "chrome/browser/ui/views/touch_uma/touch_uma.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/grit/generated_resources.h"
 #include "content/public/browser/user_metrics.h"
 #include "grit/theme_resources.h"
@@ skipping 71 matching lines @@
 
 // See UpdateLayoutTypeFromMouseEvent() for a description of these.
 #if !defined(USE_ASH)
 const int kMouseMoveTimeMS = 200;
 const int kMouseMoveCountBeforeConsiderReal = 3;
 #endif
 
 // Amount of time we delay before resizing after a close from a touch.
 const int kTouchResizeLayoutTimeMS = 2000;
 
-// Amount of overlap between two adjacent tabs.
-#if defined(OS_MACOSX)
-const int kTabOverlap = 19;
-#else
-const int kTabOverlap = 26;
-#endif
-
 // 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;
 
 base::string16 GetClipboardText() {
   if (!ui::Clipboard::IsSupportedClipboardType(ui::CLIPBOARD_TYPE_SELECTION))
     return base::string16();
   ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
@@ skipping 670 matching lines @@
 
   int model_count = GetModelCount();
   if (model_count > 1 && model_index != model_count - 1) {
     // The user is about to close a tab other than the last tab. Set
     // available_width_for_tabs_ so that if we do a layout we don't position a
     // tab past the end of the second to last tab. We do this so that as the
     // user closes tabs with the mouse a tab continues to fall under the mouse.
     Tab* last_tab = tab_at(model_count - 1);
     Tab* tab_being_removed = tab_at(model_index);
     available_width_for_tabs_ = last_tab->x() + last_tab->width() -
-        tab_being_removed->width() + GetTabOverlap();
+        tab_being_removed->width() + GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
     if (model_index == 0 && tab_being_removed->data().pinned &&
         !tab_at(1)->data().pinned) {
       available_width_for_tabs_ -= kPinnedToNonPinnedGap;
     }
   }
 
   in_tab_close_ = true;
   resize_layout_timer_.Stop();
   if (source == CLOSE_TAB_FROM_TOUCH) {
     StartResizeLayoutTabsFromTouchTimer();
@@ skipping 383 matching lines @@
         tab_at(index)->height());
   } else if (index > active_index && index > 0) {
     const gfx::Rect& tab_bounds(tab_at(index)->bounds());
     const gfx::Rect& previous_tab_bounds(tab_at(index - 1)->bounds());
     if (tab_bounds.x() == previous_tab_bounds.x())
       return false;
 
     if (tab_bounds.x() < previous_tab_bounds.x())
       return true;  // Can happen during dragging.
 
-    if (previous_tab_bounds.right() - GetTabOverlap() != tab_bounds.x()) {
+    if (previous_tab_bounds.right() - GetLayoutConstant(TABSTRIP_TAB_OVERLAP) !=
+        tab_bounds.x()) {
       int x = previous_tab_bounds.right() - tab_bounds.x() -
           kStackedTabRightClip;
       clip->SetRect(x, 0, tab_bounds.width() - x, tab_bounds.height());
     }
   }
   return true;
 }
 
 bool TabStrip::IsImmersiveStyle() const {
   return immersive_style_;
@@ skipping 95 matching lines @@
     SkPaint paint;
     // If there are multiple tabs selected, fade non-selected tabs more to make
     // the selected tabs more noticable.
     uint8_t alpha = selected_tab_count > 1
                         ? kGlassFrameInactiveTabAlphaMultiSelection
                         : kGlassFrameInactiveTabAlpha;
     paint.setColor(SkColorSetARGB(alpha, 255, 255, 255));
     paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
     paint.setStyle(SkPaint::kFill_Style);
 
-    // The tab graphics include some shadows at the top, so the actual
-    // tabstrip top is 4 px. above the apparent top of the tab, to provide room
-    // to draw these. Exclude this region when trying to make tabs transparent
-    // as it's transparent enough already, and drawing in this region can
-    // overlap the avatar button, leading to visual artifacts.
-    const int kTopOffset = 4;
-    // The tabstrip area overlaps the toolbar area by 2 px.
-    recorder.canvas()->DrawRect(
-        gfx::Rect(0, kTopOffset, width(), height() - kTopOffset - 2), paint);
+    gfx::Rect bounds(GetLocalBounds());
+    // The tab graphics include some shadows at the top, plus a 1 pixel top
+    // stroke.  Exclude this region when trying to make tabs transparent as it's
+    // transparent enough already, and drawing in this region can overlap the
+    // avatar button, leading to visual artifacts.  Also exclude the toolbar
+    // overlap region at the bottom.
+    bounds.Inset(0, GetLayoutConstant(TABSTRIP_TOP_SHADOW_HEIGHT) + 1, 0,
+                 GetLayoutConstant(TABSTRIP_TOOLBAR_OVERLAP));
+    recorder.canvas()->DrawRect(bounds, paint);
   }
 
   // Now selected but not active. We don't want these dimmed if using native
   // frame, so they're painted after initial pass.
   for (size_t i = 0; i < selected_tabs.size(); ++i)
     selected_tabs[i]->Paint(context);
 
   // Next comes the active tab.
   if (active_tab && !is_dragging)
     active_tab->Paint(context);
@@ skipping 28 matching lines @@
     // Otherwise the minimum width is based on the actual number of tabs.
     const int pinned_tab_count = GetPinnedTabCount();
     needed_tab_width = pinned_tab_count * Tab::GetPinnedWidth();
     const int remaining_tab_count = tab_count() - pinned_tab_count;
     const int min_selected_width = Tab::GetMinimumSelectedSize().width();
     const int min_unselected_width = Tab::GetMinimumUnselectedSize().width();
     if (remaining_tab_count > 0) {
       needed_tab_width += kPinnedToNonPinnedGap + min_selected_width +
           ((remaining_tab_count - 1) * min_unselected_width);
     }
-    const int tab_overlap = GetTabOverlap();
+    const int tab_overlap = GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
     if (tab_count() > 1)
       needed_tab_width -= (tab_count() - 1) * tab_overlap;
 
     // Don't let the tabstrip shrink smaller than is necessary to show one tab,
     // and don't force it to be larger than is necessary to show 20 tabs.
     const int largest_min_tab_width =
         min_selected_width + 19 * (min_unselected_width - tab_overlap);
     needed_tab_width = std::min(
         std::max(needed_tab_width, min_selected_width), largest_min_tab_width);
   }
@@ skipping 147 matching lines @@
   available_width_for_tabs_ = -1;
 
   GenerateIdealBounds();
 
   Tab* tab = tab_at(model_index);
   if (model_index == 0) {
     tab->SetBounds(0, ideal_bounds(model_index).y(), 0,
                    ideal_bounds(model_index).height());
   } else {
     Tab* last_tab = tab_at(model_index - 1);
-    tab->SetBounds(last_tab->bounds().right() - GetTabOverlap(),
-                   ideal_bounds(model_index).y(), 0,
-                   ideal_bounds(model_index).height());
+    tab->SetBounds(
+        last_tab->bounds().right() - GetLayoutConstant(TABSTRIP_TAB_OVERLAP),
+        ideal_bounds(model_index).y(), 0, ideal_bounds(model_index).height());
   }
 
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMoveTabAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
@@ skipping 228 matching lines @@
 void TabStrip::CalculateBoundsForDraggedTabs(const Tabs& tabs,
                                              std::vector<gfx::Rect>* bounds) {
   int x = 0;
   for (size_t i = 0; i < tabs.size(); ++i) {
     Tab* tab = tabs[i];
     if (i > 0 && tab->data().pinned != tabs[i - 1]->data().pinned)
       x += kPinnedToNonPinnedGap;
     gfx::Rect new_bounds = tab->bounds();
     new_bounds.set_origin(gfx::Point(x, 0));
     bounds->push_back(new_bounds);
-    x += tab->width() - GetTabOverlap();
+    x += tab->width() - GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
   }
 }
 
 int TabStrip::GetSizeNeededForTabs(const Tabs& tabs) {
   int width = 0;
   for (size_t i = 0; i < tabs.size(); ++i) {
     Tab* tab = tabs[i];
     width += tab->width();
     if (i > 0 && tab->data().pinned != tabs[i - 1]->data().pinned)
       width += kPinnedToNonPinnedGap;
   }
-  if (tabs.size() > 0)
-    width -= GetTabOverlap() * static_cast<int>(tabs.size() - 1);
+  if (!tabs.empty())
+    width -= GetLayoutConstant(TABSTRIP_TAB_OVERLAP) * (tabs.size() - 1);
   return width;
 }
 
-int TabStrip::GetTabOverlap() const {
-  return kTabOverlap;
-}
-
 int TabStrip::GetPinnedTabCount() const {
   int pinned_count = 0;
   while (pinned_count < tab_count() && tab_at(pinned_count)->data().pinned)
     pinned_count++;
   return pinned_count;
 }
 
 const Tab* TabStrip::GetLastVisibleTab() const {
   for (int i = tab_count() - 1; i >= 0; --i) {
     const Tab* tab = tab_at(i);
@@ skipping 266 matching lines @@
   *selected_width = min_selected_width;
 
   if (tab_count == 0) {
     // Return immediately to avoid divide-by-zero below.
     return;
   }
 
   // Determine how much space we can actually allocate to tabs.
   int available_width = (available_width_for_tabs_ < 0) ?
       tab_area_width() : available_width_for_tabs_;
-  const int tab_overlap = GetTabOverlap();
+  const int tab_overlap = GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
   if (pinned_tab_count > 0) {
     available_width -=
         pinned_tab_count * (Tab::GetPinnedWidth() - tab_overlap);
     tab_count -= pinned_tab_count;
     if (tab_count == 0) {
       *selected_width = *unselected_width = Tab::GetStandardSize().width();
       return;
     }
     // Account for gap between the last pinned tab and first non-pinned tab.
     available_width -= kPinnedToNonPinnedGap;
@@ skipping 92 matching lines @@
 
 void TabStrip::RemoveMessageLoopObserver() {
   mouse_watcher_.reset(NULL);
 }
 
 gfx::Rect TabStrip::GetDropBounds(int drop_index,
                                   bool drop_before,
                                   bool* is_beneath) {
   DCHECK_NE(drop_index, -1);
   int center_x;
-  const int tab_overlap = GetTabOverlap();
+  const int tab_overlap = GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
   if (drop_index < tab_count()) {
     Tab* tab = tab_at(drop_index);
     center_x = tab->x() + ((drop_before ? tab_overlap : tab->width()) / 2);
   } else {
     Tab* last_tab = tab_at(drop_index - 1);
     center_x = last_tab->x() + last_tab->width() - (tab_overlap / 2);
   }
 
   // Mirror the center point if necessary.
   center_x = GetMirroredXInView(center_x);
@@ skipping 145 matching lines @@
   }
 
   GetDesiredTabWidths(tab_count(), GetPinnedTabCount(),
                       &current_unselected_width_, &current_selected_width_);
 
   // NOTE: This currently assumes a tab's height doesn't differ based on
   // selected state or the number of tabs in the strip!
   int tab_height = Tab::GetStandardSize().height();
   int first_non_pinned_index = 0;
   double tab_x = GenerateIdealBoundsForPinnedTabs(&first_non_pinned_index);
-  const int tab_overlap = GetTabOverlap();
+  const int tab_overlap = GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
   for (int i = first_non_pinned_index; i < tab_count(); ++i) {
     Tab* tab = tab_at(i);
     DCHECK(!tab->data().pinned);
     double tab_width =
         tab->IsActive() ? current_selected_width_ : current_unselected_width_;
     double end_of_tab = tab_x + tab_width;
     int rounded_tab_x = Round(tab_x);
     tabs_.set_ideal_bounds(
         i,
         gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
@@ skipping 17 matching lines @@
 }
 
 int TabStrip::GenerateIdealBoundsForPinnedTabs(int* first_non_pinned_index) {
   int next_x = 0;
   int pinned_width = Tab::GetPinnedWidth();
   int tab_height = Tab::GetStandardSize().height();
   int index = 0;
   for (; index < tab_count() && tab_at(index)->data().pinned; ++index) {
     tabs_.set_ideal_bounds(index,
                            gfx::Rect(next_x, 0, pinned_width, tab_height));
-    next_x += pinned_width - GetTabOverlap();
+    next_x += pinned_width - GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
   }
   if (index > 0 && index < tab_count())
     next_x += kPinnedToNonPinnedGap;
   if (first_non_pinned_index)
     *first_non_pinned_index = index;
   return next_x;
 }
 
 void TabStrip::StartResizeLayoutAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartPinnedTabAnimation() {
   in_tab_close_ = false;
   available_width_for_tabs_ = -1;
 
   PrepareForAnimation();
 
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMouseInitiatedRemoveTabAnimation(int model_index) {
   // The user initiated the close. We want to persist the bounds of all the
   // existing tabs, so we manually shift ideal_bounds then animate.
   Tab* tab_closing = tab_at(model_index);
-  int delta = tab_closing->width() - GetTabOverlap();
+  int delta = tab_closing->width() - GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
   // If the tab being closed is a pinned tab next to a non-pinned tab, be sure
   // to add the extra padding.
   DCHECK_LT(model_index, tab_count() - 1);
   if (tab_closing->data().pinned && !tab_at(model_index + 1)->data().pinned)
     delta += kPinnedToNonPinnedGap;
 
   for (int i = model_index + 1; i < tab_count(); ++i) {
     gfx::Rect bounds = ideal_bounds(i);
     bounds.set_x(bounds.x() - delta);
     tabs_.set_ideal_bounds(i, bounds);
@@ skipping 32 matching lines @@
                             const gfx::Point& point_in_tabstrip_coords) {
   gfx::Point point_in_tab_coords(point_in_tabstrip_coords);
   View::ConvertPointToTarget(this, tab, &point_in_tab_coords);
   return tab->HitTestPoint(point_in_tab_coords);
 }
 
 int TabStrip::GetStartXForNormalTabs() const {
   int pinned_tab_count = GetPinnedTabCount();
   if (pinned_tab_count == 0)
     return 0;
-  return pinned_tab_count * (Tab::GetPinnedWidth() - GetTabOverlap()) +
+  const int overlap = GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
+  return pinned_tab_count * (Tab::GetPinnedWidth() - overlap) +
       kPinnedToNonPinnedGap;
 }
 
 Tab* TabStrip::FindTabForEvent(const gfx::Point& point) {
   if (touch_layout_) {
     int active_tab_index = touch_layout_->active_index();
     if (active_tab_index != -1) {
       Tab* tab = FindTabForEventFrom(point, active_tab_index, -1);
       if (!tab)
         tab = FindTabForEventFrom(point, active_tab_index + 1, 1);
@@ skipping 50 matching lines @@
   bool needs_touch = NeedsTouchLayout();
   bool using_touch = touch_layout_ != NULL;
   if (needs_touch == using_touch)
     return;
 
   if (needs_touch) {
     gfx::Size tab_size(Tab::GetMinimumSelectedSize());
     tab_size.set_width(Tab::GetTouchWidth());
     touch_layout_.reset(new StackedTabStripLayout(
                             tab_size,
-                            GetTabOverlap(),
+                            GetLayoutConstant(TABSTRIP_TAB_OVERLAP),
                             kStackedPadding,
                             kMaxStackedCount,
                             &tabs_));
     touch_layout_->SetWidth(tab_area_width());
     // This has to be after SetWidth() as SetWidth() is going to reset the
     // bounds of the pinned tabs (since StackedTabStripLayout doesn't yet know
     // how many pinned tabs there are).
     GenerateIdealBoundsForPinnedTabs(NULL);
     touch_layout_->SetXAndPinnedCount(GetStartXForNormalTabs(),
                                     GetPinnedTabCount());
@@ skipping 10 matching lines @@
 }
 
 bool TabStrip::NeedsTouchLayout() const {
   if (!stacked_layout_)
     return false;
 
   int pinned_tab_count = GetPinnedTabCount();
   int normal_count = tab_count() - pinned_tab_count;
   if (normal_count <= 1 || normal_count == pinned_tab_count)
     return false;
-  int x = GetStartXForNormalTabs();
-  int available_width = tab_area_width() - x;
-  return (Tab::GetTouchWidth() * normal_count -
-          GetTabOverlap() * (normal_count - 1)) > available_width;
+  const int overlap = GetLayoutConstant(TABSTRIP_TAB_OVERLAP);
+  return (Tab::GetTouchWidth() * normal_count - overlap * (normal_count - 1)) >
+      tab_area_width() - GetStartXForNormalTabs();
 }
 
 void TabStrip::SetResetToShrinkOnExit(bool value) {
   if (!adjust_layout_)
     return;
 
   if (value && !stacked_layout_)
     value = false;  // We're already using shrink (not stacked) layout.
 
   if (value == reset_to_shrink_on_exit_)
@@ skipping 148 matching lines @@
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }