Remove touch layout

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 90 matching lines @@
 #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;
 
 // Horizontal offset for the new tab button to bring it closer to the
 // rightmost tab.
-int newtab_button_h_offset() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = -11;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = -13;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
+const int kNewTabButtonHorizontalOffset = -11;
 
 // Vertical offset for the new tab button to bring it closer to the
 // rightmost tab.
-int newtab_button_v_offset() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = 7;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 8;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
+const int kNewTabButtonVerticalOffset = 7;
 
 // Amount the left edge of a tab is offset from the rectangle of the tab's
 // favicon/title/close box.  Related to the width of IDR_TAB_ACTIVE_LEFT.
 // Affects the size of the "V" between adjacent tabs.
-int tab_h_offset() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = -26;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = -34;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
+const int kTabHorizontalOffset = -26;
 
 // The size of the new tab button must be hardcoded because we need to be
 // able to lay it out before we are able to get its image from the
 // ui::ThemeProvider.  It also makes sense to do this, because the size of the
 // new tab button should not need to be calculated dynamically.
-int newtab_button_asset_width() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = 34;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 46;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
-
-int newtab_button_asset_height() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = 18;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 24;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
+const int kNewTabButtonAssetWidth = 34;
+const int kNewTabButtonAssetHeight = 18;
 
 // Amount to adjust the clip by when the tab is stacked before the active index.
-int stacked_tab_left_clip() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = 20;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 26;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
+const int kStackedTabLeftClip = 20;
 
 // Amount to adjust the clip by when the tab is stacked after the active index.
-int stacked_tab_right_clip() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = 20;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 26;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
+const int kStackedTabRightClip = 20;
 
 base::string16 GetClipboardText() {
   if (!ui::Clipboard::IsSupportedClipboardType(ui::CLIPBOARD_TYPE_SELECTION))
     return base::string16();
   ui::Clipboard* clipboard = ui::Clipboard::GetForCurrentThread();
   CHECK(clipboard);
   base::string16 clipboard_text;
   clipboard->ReadText(ui::CLIPBOARD_TYPE_SELECTION, &clipboard_text);
   return clipboard_text;
 }
@@ skipping 120 matching lines @@
   // When the button is sized to the top of the tab strip we want the user to
   // be able to click on complete bounds, and so don't return a custom hit
   // mask.
   return !tab_strip_->SizeTabButtonToTopOfTabStrip();
 }
 
 void NewTabButton::GetHitTestMask(HitTestSource source, gfx::Path* path) const {
   DCHECK(path);
 
   SkScalar w = SkIntToScalar(width());
-  SkScalar v_offset = SkIntToScalar(newtab_button_v_offset());
+  SkScalar v_offset = SkIntToScalar(kNewTabButtonVerticalOffset);
 
   // These values are defined by the shape of the new tab image. Should that
   // image ever change, these values will need to be updated. They're so
   // custom it's not really worth defining constants for.
   // These values are correct for regular and USE_ASH versions of the image.
   path->moveTo(0, v_offset + 1);
   path->lineTo(w - 7, v_offset + 1);
   path->lineTo(w - 4, v_offset + 4);
   path->lineTo(w, v_offset + 16);
   path->lineTo(w - 1, v_offset + 17);
@@ skipping 88 matching lines @@
   // The new tab background is mirrored in RTL mode, but the theme background
   // should never be mirrored. Mirror it here to compensate.
   float x_scale = 1.0f;
   int x = GetMirroredX() + background_offset_.x();
   if (base::i18n::IsRTL()) {
     x_scale = -1.0f;
     // Offset by |width| such that the same region is painted as if there was no
     // flip.
     x += width;
   }
-  canvas.TileImageInt(*background, x, newtab_button_v_offset() + offset_y,
+  canvas.TileImageInt(*background, x, kNewTabButtonVerticalOffset + offset_y,
                       x_scale, 1.0f, 0, 0, width, height);
 
   if (alpha != 255) {
     SkPaint paint;
     paint.setColor(SkColorSetARGB(alpha, 255, 255, 255));
     paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
     paint.setStyle(SkPaint::kFill_Style);
     canvas.DrawRect(gfx::Rect(0, 0, width, height), paint);
   }
 
@@ skipping 320 matching lines @@
 
   int model_count = GetModelCount();
   if (model_index + 1 != model_count && 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() - tab_h_offset();
+        tab_being_removed->width() - kTabHorizontalOffset;
     if (model_index == 0 && tab_being_removed->data().mini &&
         !tab_at(1)->data().mini) {
       available_width_for_tabs_ -= kMiniToNonMiniGap;
     }
   }
 
   in_tab_close_ = true;
   resize_layout_timer_.Stop();
   if (source == CLOSE_TAB_FROM_TOUCH) {
     StartResizeLayoutTabsFromTouchTimer();
@@ skipping 353 matching lines @@
     active_index--;
 
   if (index < active_index) {
     if (tab_at(index)->x() == tab_at(index + 1)->x())
       return false;
 
     if (tab_at(index)->x() > tab_at(index + 1)->x())
       return true;  // Can happen during dragging.
 
     clip->SetRect(0, 0, tab_at(index + 1)->x() - tab_at(index)->x() +
-                      stacked_tab_left_clip(),
+                      kStackedTabLeftClip,
                   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() + tab_h_offset() != tab_bounds.x()) {
+    if (previous_tab_bounds.right() + kTabHorizontalOffset != tab_bounds.x()) {
       int x = previous_tab_bounds.right() - tab_bounds.x() -
-          stacked_tab_right_clip();
+          kStackedTabRightClip;
       clip->SetRect(x, 0, tab_bounds.width() - x, tab_bounds.height());
     }
   }
   return true;
 }
 
 bool TabStrip::IsImmersiveStyle() const {
   return immersive_style_;
 }
 
@@ skipping 415 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   set_id(VIEW_ID_TAB_STRIP);
   // So we get enter/exit on children to switch layout type.
   set_notify_enter_exit_on_child(true);
   newtab_button_bounds_.SetRect(0,
                                 0,
-                                newtab_button_asset_width(),
-                                newtab_button_asset_height() +
-                                    newtab_button_v_offset());
+                                kNewTabButtonAssetWidth,
+                                kNewTabButtonAssetHeight +
+                                    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);
   AddChildView(newtab_button_);
   if (drop_indicator_width == 0) {
     // Direction doesn't matter, both images are the same size.
@@ skipping 17 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() + tab_h_offset(),
+    tab->SetBounds(last_tab->bounds().right() + kTabHorizontalOffset,
                    ideal_bounds(model_index).y(), 0,
                    ideal_bounds(model_index).height());
   }
 
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMoveTabAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
@@ skipping 205 matching lines @@
 void TabStrip::CalculateBoundsForDraggedTabs(const std::vector<Tab*>& 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().mini != tabs[i - 1]->data().mini)
       x += kMiniToNonMiniGap;
     gfx::Rect new_bounds = tab->bounds();
     new_bounds.set_origin(gfx::Point(x, 0));
     bounds->push_back(new_bounds);
-    x += tab->width() + tab_h_offset();
+    x += tab->width() + kTabHorizontalOffset;
   }
 }
 
 int TabStrip::GetSizeNeededForTabs(const std::vector<Tab*>& 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().mini != tabs[i - 1]->data().mini)
       width += kMiniToNonMiniGap;
   }
   if (tabs.size() > 0)
-    width += tab_h_offset() * static_cast<int>(tabs.size() - 1);
+    width += kTabHorizontalOffset * static_cast<int>(tabs.size() - 1);
   return width;
 }
 
 void TabStrip::RemoveTabFromViewModel(int index) {
   // We still need to paint the tab until we actually remove it. Put it
   // in tabs_closing_map_ so we can find it.
   tabs_closing_map_[index].push_back(tab_at(index));
   UpdateTabsClosingMap(index + 1, -1);
   tabs_.Remove(index);
 }
@@ skipping 261 matching lines @@
     // width here; the first preserves the consistent "leave the last tab under
     // the user's mouse so they can close many tabs" behavior at the cost of
     // prolonging the glitchy appearance of the overflow state, while the second
     // gets us out of overflow as soon as possible but forces the user to move
     // their mouse for a few tabs' worth of closing.  We choose visual
     // imperfection over behavioral imperfection and select the first option.
     available_width = available_width_for_tabs_;
   }
 
   if (mini_tab_count > 0) {
-    available_width -= mini_tab_count * (Tab::GetMiniWidth() + tab_h_offset());
+    available_width -=
+        mini_tab_count * (Tab::GetMiniWidth() + kTabHorizontalOffset);
     tab_count -= mini_tab_count;
     if (tab_count == 0) {
       *selected_width = *unselected_width = Tab::GetStandardSize().width();
       return;
     }
     // Account for gap between the last mini-tab and first non-mini-tab.
     available_width -= kMiniToNonMiniGap;
   }
 
   // Calculate the desired tab widths by dividing the available space into equal
   // portions.  Don't let tabs get larger than the "standard width" or smaller
   // than the minimum width for each type, respectively.
-  const int total_offset = tab_h_offset() * (tab_count - 1);
+  const int total_offset = kTabHorizontalOffset * (tab_count - 1);
   const double desired_tab_width = std::min((static_cast<double>(
       available_width - total_offset) / static_cast<double>(tab_count)),
       static_cast<double>(Tab::GetStandardSize().width()));
   *unselected_width = std::max(desired_tab_width, min_unselected_width);
   *selected_width = std::max(desired_tab_width, min_selected_width);
 
   // When there are multiple tabs, we'll have one selected and some unselected
   // 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
@@ skipping 85 matching lines @@
 }
 
 gfx::Rect TabStrip::GetDropBounds(int drop_index,
                                   bool drop_before,
                                   bool* is_beneath) {
   DCHECK_NE(drop_index, -1);
   int center_x;
   if (drop_index < tab_count()) {
     Tab* tab = tab_at(drop_index);
     if (drop_before)
-      center_x = tab->x() - (tab_h_offset() / 2);
+      center_x = tab->x() - (kTabHorizontalOffset / 2);
     else
       center_x = tab->x() + (tab->width() / 2);
   } else {
     Tab* last_tab = tab_at(drop_index - 1);
-    center_x = last_tab->x() + last_tab->width() + (tab_h_offset() / 2);
+    center_x = last_tab->x() + last_tab->width() + (kTabHorizontalOffset / 2);
   }
 
   // Mirror the center point if necessary.
   center_x = GetMirroredXInView(center_x);
 
   // Determine the screen bounds.
   gfx::Point drop_loc(center_x - drop_indicator_width / 2,
                       -drop_indicator_height);
   ConvertPointToScreen(this, &drop_loc);
   gfx::Rect drop_bounds(drop_loc.x(), drop_loc.y(), drop_indicator_width,
@@ skipping 127 matching lines @@
 }
 
 void TabStrip::GenerateIdealBounds() {
   int new_tab_y = 0;
 
   if (touch_layout_.get()) {
     if (tabs_.view_size() == 0)
       return;
 
     int new_tab_x = tabs_.ideal_bounds(tabs_.view_size() - 1).right() +
-        newtab_button_h_offset();
+        kNewTabButtonHorizontalOffset;
     newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
     return;
   }
 
   double unselected, selected;
   GetDesiredTabWidths(tab_count(), GetMiniTabCount(), &unselected, &selected);
   current_unselected_width_ = unselected;
   current_selected_width_ = selected;
 
   // 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_mini_index = 0;
   double tab_x = GenerateIdealBoundsForMiniTabs(&first_non_mini_index);
   for (int i = first_non_mini_index; i < tab_count(); ++i) {
     Tab* tab = tab_at(i);
     DCHECK(!tab->data().mini);
     double tab_width = tab->IsActive() ? selected : unselected;
     double end_of_tab = tab_x + tab_width;
     int rounded_tab_x = Round(tab_x);
     set_ideal_bounds(
         i,
         gfx::Rect(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                   tab_height));
-    tab_x = end_of_tab + tab_h_offset();
+    tab_x = end_of_tab + kTabHorizontalOffset;
   }
 
   // Update bounds of new tab button.
   int new_tab_x;
   if (abs(Round(unselected) - Tab::GetStandardSize().width()) > 1 &&
       !in_tab_close_) {
     // We're shrinking tabs, so we need to anchor the New Tab button to the
     // right edge of the TabStrip's bounds, rather than the right edge of the
     // right-most Tab, otherwise it'll bounce when animating.
     new_tab_x = width() - newtab_button_bounds_.width();
   } else {
-    new_tab_x = Round(tab_x - tab_h_offset()) + newtab_button_h_offset();
+    new_tab_x = Round(tab_x - kTabHorizontalOffset) +
+        kNewTabButtonHorizontalOffset;
   }
   newtab_button_bounds_.set_origin(gfx::Point(new_tab_x, new_tab_y));
 }
 
 int TabStrip::GenerateIdealBoundsForMiniTabs(int* first_non_mini_index) {
   int next_x = 0;
   int mini_width = Tab::GetMiniWidth();
   int tab_height = Tab::GetStandardSize().height();
   int index = 0;
   for (; index < tab_count() && tab_at(index)->data().mini; ++index) {
     set_ideal_bounds(index,
                      gfx::Rect(next_x, 0, mini_width, tab_height));
-    next_x += mini_width + tab_h_offset();
+    next_x += mini_width + kTabHorizontalOffset;
   }
   if (index > 0 && index < tab_count())
     next_x += kMiniToNonMiniGap;
   if (first_non_mini_index)
     *first_non_mini_index = index;
   return next_x;
 }
 
 // static
 int TabStrip::new_tab_button_width() {
-  return newtab_button_asset_width() + newtab_button_h_offset();
+  return kNewTabButtonAssetWidth + kNewTabButtonHorizontalOffset;
 }
 
 // static
 int TabStrip::button_v_offset() {
-  return newtab_button_v_offset();
+  return kNewTabButtonVerticalOffset;
 }
 
 int TabStrip::tab_area_width() const {
   return width() - new_tab_button_width();
 }
 
 void TabStrip::StartResizeLayoutAnimation() {
   PrepareForAnimation();
   GenerateIdealBounds();
   AnimateToIdealBounds();
 }
 
 void TabStrip::StartMiniTabAnimation() {
   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() + tab_h_offset();
+  int delta = tab_closing->width() + kTabHorizontalOffset;
   // If the tab being closed is a mini-tab next to a non-mini-tab, be sure to
   // add the extra padding.
   DCHECK_NE(model_index + 1, tab_count());
   if (tab_closing->data().mini && model_index + 1 < tab_count() &&
       !tab_at(model_index + 1)->data().mini) {
     delta += kMiniToNonMiniGap;
   }
 
   for (int i = model_index + 1; i < tab_count(); ++i) {
     gfx::Rect bounds = ideal_bounds(i);
@@ skipping 29 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 mini_tab_count = GetMiniTabCount();
   if (mini_tab_count == 0)
     return 0;
-  return mini_tab_count * (Tab::GetMiniWidth() + tab_h_offset()) +
+  return mini_tab_count * (Tab::GetMiniWidth() + kTabHorizontalOffset) +
       kMiniToNonMiniGap;
 }
 
 Tab* TabStrip::FindTabForEvent(const gfx::Point& point) {
   if (touch_layout_.get()) {
     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_.get() != 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,
-                            tab_h_offset(),
+                            kTabHorizontalOffset,
                             kStackedPadding,
                             kMaxStackedCount,
                             &tabs_));
     touch_layout_->SetWidth(width() - new_tab_button_width());
     // This has to be after SetWidth() as SetWidth() is going to reset the
     // bounds of the mini-tabs (since StackedTabStripLayout doesn't yet know how
     // many mini-tabs there are).
     GenerateIdealBoundsForMiniTabs(NULL);
     touch_layout_->SetXAndMiniCount(GetStartXForNormalTabs(),
                                     GetMiniTabCount());
@@ skipping 10 matching lines @@
   if (layout_type_ == TAB_STRIP_LAYOUT_SHRINK)
     return false;
 
   int mini_tab_count = GetMiniTabCount();
   int normal_count = tab_count() - mini_tab_count;
   if (normal_count <= 1 || normal_count == mini_tab_count)
     return false;
   int x = GetStartXForNormalTabs();
   int available_width = width() - x - new_tab_button_width();
   return (Tab::GetTouchWidth() * normal_count +
-          tab_h_offset() * (normal_count - 1)) > available_width;
+          kTabHorizontalOffset * (normal_count - 1)) > available_width;
 }
 
 void TabStrip::SetResetToShrinkOnExit(bool value) {
   if (!GetAdjustLayout())
     return;
 
   if (value && layout_type_ == TAB_STRIP_LAYOUT_SHRINK)
     value = false;  // We're already at TAB_STRIP_LAYOUT_SHRINK.
 
   if (value == reset_to_shrink_on_exit_)
     return;
 
   reset_to_shrink_on_exit_ = value;
   // Add an observer so we know when the mouse moves out of the tabstrip.
   if (reset_to_shrink_on_exit_)
     AddMessageLoopObserver();
   else
     RemoveMessageLoopObserver();
 }
 
 bool TabStrip::GetAdjustLayout() const {
   if (!adjust_layout_)
     return false;
-
-#if defined(USE_AURA)
   return chrome::GetHostDesktopTypeForNativeView(
       GetWidget()->GetNativeView()) == chrome::HOST_DESKTOP_TYPE_ASH;
-#else
-  return ui::GetDisplayLayout() == ui::LAYOUT_TOUCH;
-#endif
 }