Remove touch layout

chrome/browser/ui/views/tabs/tab.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.h"
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/debug/alias.h"
@@ skipping 38 matching lines @@
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/non_client_view.h"
 
 #if defined(USE_ASH)
 #include "ui/aura/env.h"
 #endif
 
 namespace {
 
 // Padding around the "content" of a tab, occupied by the tab border graphics.
-
-int left_padding() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = 22;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 30;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
-
-int top_padding() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = 7;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 10;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
-
-int right_padding() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = 17;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 21;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
-
-int bottom_padding() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = 5;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 7;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
+const int kLeftPadding = 22;
+const int kTopPadding = 7;
+const int kRightPadding = 17;
+const int kBottomPadding = 5;
 
 // Height of the shadow at the top of the tab image assets.
-int drop_shadow_height() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = 4;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 5;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
+const int kDropShadowHeight = 4;
 
 // Size of icon used for throbber and favicon next to tab title.
-int tab_icon_size() {
-  static int value = -1;
-  if (value == -1) {
-    switch (ui::GetDisplayLayout()) {
-      case ui::LAYOUT_DESKTOP:
-        value = gfx::kFaviconSize;
-        break;
-      case ui::LAYOUT_TOUCH:
-        value = 20;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-  return value;
-}
+const int kTabIconSize = gfx::kFaviconSize;
 
 // How long the pulse throb takes.
 const int kPulseDurationMs = 200;
 
 // Width of touch tabs.
 static const int kTouchWidth = 120;
 
 static const int kToolbarOverlap = 1;
 static const int kFaviconTitleSpacing = 4;
 // Additional vertical offset for title text relative to top of tab.
@@ skipping 480 matching lines @@
     return;
   tab_animation_->Stop();
   tab_animation_.reset(NULL);
 }
 
 // static
 gfx::Size Tab::GetBasicMinimumUnselectedSize() {
   InitTabResources();
 
   gfx::Size minimum_size;
-  minimum_size.set_width(left_padding() + right_padding());
+  minimum_size.set_width(kLeftPadding + kRightPadding);
   // Since we use image images, the real minimum height of the image is
   // defined most accurately by the height of the end cap images.
   minimum_size.set_height(tab_active_.image_l->height());
   return minimum_size;
 }
 
 gfx::Size Tab::GetMinimumUnselectedSize() {
   return GetBasicMinimumUnselectedSize();
 }
 
 // static
 gfx::Size Tab::GetMinimumSelectedSize() {
   gfx::Size minimum_size = GetBasicMinimumUnselectedSize();
   minimum_size.set_width(
-      left_padding() + gfx::kFaviconSize + right_padding());
+      kLeftPadding + gfx::kFaviconSize + kRightPadding);
   return minimum_size;
 }
 
 // static
 gfx::Size Tab::GetStandardSize() {
   gfx::Size standard_size = GetBasicMinimumUnselectedSize();
   standard_size.set_width(
       standard_size.width() + kFaviconTitleSpacing + kStandardTitleWidth);
   return standard_size;
 }
@@ skipping 84 matching lines @@
 
   if (!clip.IsEmpty())
     canvas->Restore();
 }
 
 void Tab::Layout() {
   gfx::Rect lb = GetContentsBounds();
   if (lb.IsEmpty())
     return;
   lb.Inset(
-      left_padding(), top_padding(), right_padding(), bottom_padding());
+      kLeftPadding, kTopPadding, kRightPadding, kBottomPadding);

[sky, 2014/04/24 03:29:02]

nit: I think you can fit this all on one line now.

[oshima, 2014/04/25 14:16:26]

Done.

 
   // The height of the content of the Tab is the largest of the favicon,
   // the title text and the close button graphic.
-  int content_height = std::max(tab_icon_size(), font_height_);
+  int content_height = std::max(kTabIconSize, font_height_);
   close_button_->SetBorder(views::Border::NullBorder());
   gfx::Size close_button_size(close_button_->GetPreferredSize());
   content_height = std::max(content_height, close_button_size.height());
 
   // Size the Favicon.
   showing_icon_ = ShouldShowIcon();
   if (showing_icon_) {
     // Use the size of the favicon as apps use a bigger favicon size.
-    int favicon_top = top_padding() + content_height / 2 - tab_icon_size() / 2;
+    int favicon_top = kTopPadding + content_height / 2 - kTabIconSize / 2;
     int favicon_left = lb.x();
     favicon_bounds_.SetRect(favicon_left, favicon_top,
-                            tab_icon_size(), tab_icon_size());
+                            kTabIconSize, kTabIconSize);
     MaybeAdjustLeftForMiniTab(&favicon_bounds_);
   } else {
     favicon_bounds_.SetRect(lb.x(), lb.y(), 0, 0);
   }
 
   // Size the Close button.
   showing_close_button_ = ShouldShowCloseBox();
   const bool is_host_desktop_type_ash =
       GetHostDesktopType(this) == chrome::HOST_DESKTOP_TYPE_ASH;
   if (showing_close_button_) {
     const int close_button_vert_fuzz = is_host_desktop_type_ash ?
         kCloseButtonVertFuzzAsh : kCloseButtonVertFuzz;
-    int close_button_top = top_padding() + close_button_vert_fuzz +
+    int close_button_top = kTopPadding + close_button_vert_fuzz +
         (content_height - close_button_size.height()) / 2;
     // If the ratio of the close button size to tab width exceeds the maximum.
     // The close button should be as large as possible so that there is a larger
     // hit-target for touch events. So the close button bounds extends to the
     // edges of the tab. However, the larger hit-target should be active only
     // for mouse events, and the close-image should show up in the right place.
     // So a border is added to the button with necessary padding. The close
     // button (BaseTab::TabCloseButton) makes sure the padding is a hit-target
     // only for touch events.
     int top_border = close_button_top;
@@ skipping 11 matching lines @@
     close_button_->SetVisible(false);
   }
 
   showing_media_indicator_ = ShouldShowMediaIndicator();
   if (showing_media_indicator_) {
     const gfx::Image& media_indicator_image =
         chrome::GetTabMediaIndicatorImage(animating_media_state_);
     media_indicator_bounds_.set_width(media_indicator_image.Width());
     media_indicator_bounds_.set_height(media_indicator_image.Height());
     media_indicator_bounds_.set_y(
-        top_padding() +
+        kTopPadding +
             (content_height - media_indicator_bounds_.height()) / 2);
     const int right = showing_close_button_ ?
         close_button_->x() + close_button_->GetInsets().left() : lb.right();
     media_indicator_bounds_.set_x(
         std::max(lb.x(), right - media_indicator_bounds_.width()));
     MaybeAdjustLeftForMiniTab(&media_indicator_bounds_);
   } else {
     media_indicator_bounds_.SetRect(lb.x(), lb.y(), 0, 0);
   }
 
   const int title_text_offset = is_host_desktop_type_ash ?
       kTitleTextOffsetYAsh : kTitleTextOffsetY;
   int title_left = favicon_bounds_.right() + kFaviconTitleSpacing;
-  int title_top = top_padding() + title_text_offset +
+  int title_top = kTopPadding + title_text_offset +
       (content_height - font_height_) / 2;
   // Size the Title text to fill the remaining space.
   if (!data().mini || width() >= kMiniTabRendererAsNormalTabWidth) {
     // If the user has big fonts, the title will appear rendered too far down
     // on the y-axis if we use the regular top padding, so we need to adjust it
     // so that the text appears centered.
     gfx::Size minimum_size = GetMinimumUnselectedSize();
-    int text_height = title_top + font_height_ + bottom_padding();
+    int text_height = title_top + font_height_ + kBottomPadding;
     if (text_height > minimum_size.height())
       title_top -= (text_height - minimum_size.height()) / 2;
 
     int title_width;
     if (showing_media_indicator_) {
       title_width = media_indicator_bounds_.x() - kTitleCloseButtonSpacing -
           title_left;
     } else if (close_button_->visible()) {
       // The close button has an empty border with some padding (see details
       // above where the close-button's bounds is set). Allow the title to
@@ skipping 478 matching lines @@
   background_canvas.DrawImageInt(theme_r,
       0, 0, theme_r.width(), theme_r.height() - kToolbarOverlap,
       width() - theme_r.width(), 0, theme_r.width(),
       theme_r.height() - kToolbarOverlap, false);
 
   // Draw center.  Instead of masking out the top portion we simply skip over
   // it by incrementing by GetDropShadowHeight(), since it's a simple
   // rectangle. And again, don't draw over the toolbar.
   background_canvas.TileImageInt(*tab_bg,
      offset + tab_image->l_width,
-     bg_offset_y + drop_shadow_height(),
+     bg_offset_y + kDropShadowHeight,
      tab_image->l_width,
-     drop_shadow_height(),
+     kDropShadowHeight,
      width() - tab_image->l_width - tab_image->r_width,
-     height() - drop_shadow_height() - kToolbarOverlap);
+     height() - kDropShadowHeight - kToolbarOverlap);
 
   canvas->DrawImageInt(
       gfx::ImageSkia(background_canvas.ExtractImageRep()), 0, 0);
 
   if (!GetThemeProvider()->HasCustomImage(tab_id) &&
       hover_controller_.ShouldDraw()) {
     hover_controller_.Draw(canvas, gfx::ImageSkia(
         background_canvas.ExtractImageRep()));
   }
 
@@ skipping 28 matching lines @@
       *tab_background,
       offset + width() - tab_image->r_width, 0, tab_image->r_width, height());
   gfx::ImageSkia theme_r =
       gfx::ImageSkiaOperations::CreateMaskedImage(tab_r, *alpha->image_r);
   canvas->DrawImageInt(theme_r, width() - tab_image->r_width, 0);
 
   // Draw center.  Instead of masking out the top portion we simply skip over it
   // by incrementing by GetDropShadowHeight(), since it's a simple rectangle.
   canvas->TileImageInt(*tab_background,
      offset + tab_image->l_width,
-     drop_shadow_height(),
+     kDropShadowHeight,
      tab_image->l_width,
-     drop_shadow_height(),
+     kDropShadowHeight,
      width() - tab_image->l_width - tab_image->r_width,
-     height() - drop_shadow_height());
+     height() - kDropShadowHeight);
 
   // Now draw the highlights/shadows around the tab edge.
   canvas->DrawImageInt(*tab_image->image_l, 0, 0);
   canvas->TileImageInt(*tab_image->image_c, tab_image->l_width, 0,
       width() - tab_image->l_width - tab_image->r_width, height());
   canvas->DrawImageInt(*tab_image->image_r, width() - tab_image->r_width, 0);
 }
 
 void Tab::PaintIcon(gfx::Canvas* canvas) {
   gfx::Rect bounds = GetIconBounds();
@@ skipping 125 matching lines @@
   if (controller_->IsImmersiveStyle())
     SchedulePaintInRect(GetImmersiveBarRect());
   else
     ScheduleIconPaint();
 }
 
 int Tab::IconCapacity() const {
   if (height() < GetMinimumUnselectedSize().height())
     return 0;
   const int available_width =
-      std::max(0, width() - left_padding() - right_padding());
-  const int width_per_icon = tab_icon_size();
+      std::max(0, width() - kLeftPadding - kRightPadding);
+  const int width_per_icon = kTabIconSize;
   const int kPaddingBetweenIcons = 2;
   if (available_width >= width_per_icon &&
       available_width < (width_per_icon + kPaddingBetweenIcons)) {
     return 1;
   }
   return available_width / (width_per_icon + kPaddingBetweenIcons);
 }
 
 bool Tab::ShouldShowIcon() const {
   return chrome::ShouldTabShowFavicon(
@@ skipping 165 matching lines @@
                          const gfx::ImageSkia& image) {
   DCHECK_NE(scale_factor, ui::SCALE_FACTOR_NONE);
   ImageCacheEntry entry;
   entry.resource_id = resource_id;
   entry.scale_factor = scale_factor;
   entry.image = image;
   image_cache_->push_front(entry);
   if (image_cache_->size() > kMaxImageCacheSize)
     image_cache_->pop_back();
 }