Set toolbar padding to something appropriate for Metro icons.

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/utf_string_conversions.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/tabs/tab_resources.h"
 #include "chrome/browser/ui/views/tabs/tab_controller.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/theme_resources_standard.h"
 #include "grit/ui_resources.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "ui/base/animation/multi_animation.h"
 #include "ui/base/animation/throb_animation.h"
+#include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/widget/tooltip_manager.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/window/non_client_view.h"
 
+namespace {
+
 // Padding around the "content" of a tab, occupied by the tab border graphics.
-#if defined(USE_ASH)
-static const int kLeftPadding = 21;
-static const int kTopPadding = 8;
-static const int kRightPadding = 20;
-static const int kBottomPadding = 5;
-#else
-static const int kLeftPadding = 16;
-static const int kTopPadding = 6;
-static const int kRightPadding = 15;
-static const int kBottomPadding = 5;
-#endif
+
+const int GetLeftPadding() {
+  static int value = -1;
+  if (value == -1) {
+    switch (ui::GetDisplayLayout()) {
+      case ui::LAYOUT_ASH:
+        value = 21;
+        break;
+      case ui::LAYOUT_TOUCH:
+        value = 20;
+        break;
+      default:
+        value = 16;
+    }
+  }
+  return value;
+}
+
+const int GetTopPadding() {
+  static int value = -1;
+  if (value == -1) {
+    switch (ui::GetDisplayLayout()) {
+      case ui::LAYOUT_ASH:
+        value = 8;
+        break;
+      case ui::LAYOUT_TOUCH:
+        value = 12;
+        break;
+      default:
+        value = 6;
+    }
+  }
+  return value;
+}
+
+const int GetRightPadding() {
+  static int value = -1;
+  if (value == -1) {
+    switch (ui::GetDisplayLayout()) {
+      case ui::LAYOUT_ASH:
+        value = 20;
+        break;
+      case ui::LAYOUT_TOUCH:
+        value = 21;
+        break;
+      default:
+        value = 15;
+    }
+  }
+  return value;
+}
+
+const int GetBottomPadding() {
+  static int value = -1;
+  if (value == -1) {
+    switch (ui::GetDisplayLayout()) {
+      case ui::LAYOUT_TOUCH:
+        value = 7;
+        break;
+      case ui::LAYOUT_ASH:
+      default:
+        value = 5;
+    }
+  }
+  return value;
+}
 
 // Height of the shadow at the top of the tab image assets.
 #if defined(USE_ASH)
 static const int kDropShadowHeight = 4;
 #else
 static const int kDropShadowHeight = 2;
 #endif
 static const int kToolbarOverlap = 1;
 static const int kFaviconTitleSpacing = 4;
 // Additional vertical offset for title text relative to top of tab.
@@ skipping 27 matching lines @@
 
 // How opaque to make the hover state (out of 1).
 static const double kHoverOpacity = 0.33;
 
 // Opacity for non-active selected tabs.
 static const double kSelectedTabOpacity = .45;
 
 // Selected (but not active) tabs have their throb value scaled down by this.
 static const double kSelectedTabThrobScale = .5;
 
-Tab::TabImage Tab::tab_alpha_ = {0};
-Tab::TabImage Tab::tab_active_ = {0};
-Tab::TabImage Tab::tab_inactive_ = {0};
-
 // Durations for the various parts of the mini tab title animation.
 static const int kMiniTitleChangeAnimationDuration1MS = 1600;
 static const int kMiniTitleChangeAnimationStart1MS = 0;
 static const int kMiniTitleChangeAnimationEnd1MS = 1900;
 static const int kMiniTitleChangeAnimationDuration2MS = 0;
 static const int kMiniTitleChangeAnimationDuration3MS = 550;
 static const int kMiniTitleChangeAnimationStart3MS = 150;
 static const int kMiniTitleChangeAnimationEnd3MS = 800;
 
 // Offset from the right edge for the start of the mini title change animation.
 static const int kMiniTitleChangeInitialXOffset = 6;
 
 // Radius of the radial gradient used for mini title change animation.
 static const int kMiniTitleChangeGradientRadius = 20;
 
 // Colors of the gradient used during the mini title change animation.
 static const SkColor kMiniTitleChangeGradientColor1 = SK_ColorWHITE;
 static const SkColor kMiniTitleChangeGradientColor2 =
     SkColorSetARGB(0, 255, 255, 255);
 
+}  // namespace
+
+Tab::TabImage Tab::tab_alpha_ = {0};
+Tab::TabImage Tab::tab_active_ = {0};
+Tab::TabImage Tab::tab_inactive_ = {0};
+
 // static
 const char Tab::kViewClassName[] = "browser/tabs/Tab";
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, public:
 
 Tab::Tab(TabController* controller)
     : BaseTab(controller),
       showing_icon_(false),
       showing_close_button_(false),
@@ skipping 30 matching lines @@
 void Tab::StopMiniTabTitleAnimation() {
   if (mini_title_animation_.get())
     mini_title_animation_->Stop();
 }
 
 // static
 gfx::Size Tab::GetBasicMinimumUnselectedSize() {
   InitTabResources();
 
   gfx::Size minimum_size;
-  minimum_size.set_width(kLeftPadding + kRightPadding);
+  minimum_size.set_width(GetLeftPadding() + GetRightPadding());
   // Since we use bitmap 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(kLeftPadding + gfx::kFaviconSize + kRightPadding);
+  minimum_size.set_width(
+      GetLeftPadding() + gfx::kFaviconSize + GetRightPadding());
   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 59 matching lines @@
     close_button()->SetBackground(close_button_color_,
         rb.GetBitmapNamed(IDR_TAB_CLOSE),
         rb.GetBitmapNamed(IDR_TAB_CLOSE_MASK));
   }
 }
 
 void Tab::Layout() {
   gfx::Rect lb = GetContentsBounds();
   if (lb.IsEmpty())
     return;
-  lb.Inset(kLeftPadding, kTopPadding, kRightPadding, kBottomPadding);
+  lb.Inset(
+      GetLeftPadding(), GetTopPadding(), GetRightPadding(), GetBottomPadding());
 
   // 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(kTabIconSize, font_height());
   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 = kTopPadding + content_height / 2 - kTabIconSize / 2;
+    int favicon_top = GetTopPadding() + content_height / 2 - kTabIconSize / 2;
     int favicon_left = lb.x();
     favicon_bounds_.SetRect(favicon_left, favicon_top,
                             kTabIconSize, kTabIconSize);
     if (data().mini && width() < kMiniTabRendererAsNormalTabWidth) {
       // Adjust the location of the favicon when transitioning from a normal
       // tab to a mini-tab.
       int mini_delta = kMiniTabRendererAsNormalTabWidth - GetMiniWidth();
       int ideal_delta = width() - GetMiniWidth();
       if (ideal_delta < mini_delta) {
         int ideal_x = (GetMiniWidth() - kTabIconSize) / 2;
         int x = favicon_bounds_.x() + static_cast<int>(
             (1 - static_cast<float>(ideal_delta) /
              static_cast<float>(mini_delta)) *
             (ideal_x - favicon_bounds_.x()));
         favicon_bounds_.set_x(x);
       }
     }
   } else {
     favicon_bounds_.SetRect(lb.x(), lb.y(), 0, 0);
   }
 
   // Size the Close button.
   showing_close_button_ = ShouldShowCloseBox();
   if (showing_close_button_) {
-    int close_button_top = kTopPadding + kCloseButtonVertFuzz +
+    int close_button_top = GetTopPadding() + kCloseButtonVertFuzz +
         (content_height - close_button_size.height()) / 2;
     // If the ratio of the close button size to tab width exceeds the maximum.
     close_button()->SetBounds(lb.width() + kCloseButtonHorzFuzz,
                               close_button_top, close_button_size.width(),
                               close_button_size.height());
     close_button()->SetVisible(true);
   } else {
     close_button()->SetBounds(0, 0, 0, 0);
     close_button()->SetVisible(false);
   }
 
   int title_left = favicon_bounds_.right() + kFaviconTitleSpacing;
-  int title_top =
-      kTopPadding + kTitleTextOffsetY + (content_height - font_height()) / 2;
+  int title_top = GetTopPadding() + kTitleTextOffsetY +
+      (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() + kBottomPadding;
+    int text_height = title_top + font_height() + GetBottomPadding();
     if (text_height > minimum_size.height())
       title_top -= (text_height - minimum_size.height()) / 2;
 
     int title_width;
     if (close_button()->visible()) {
       title_width = std::max(close_button()->x() -
                              kTitleCloseButtonSpacing - title_left, 0);
     } else {
       title_width = std::max(lb.width() - title_left, 0);
     }
@@ skipping 230 matching lines @@
   // Now draw the highlights/shadows around the tab edge.
   canvas->DrawBitmapInt(*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->DrawBitmapInt(*tab_image->image_r, width() - tab_image->r_width, 0);
 }
 
 int Tab::IconCapacity() const {
   if (height() < GetMinimumUnselectedSize().height())
     return 0;
-  return (width() - kLeftPadding - kRightPadding) / kTabIconSize;
+  return (width() - GetLeftPadding() - GetRightPadding()) / kTabIconSize;
 }
 
 bool Tab::ShouldShowIcon() const {
   if (data().mini && height() >= GetMinimumUnselectedSize().height())
     return true;
   if (!data().show_icon) {
     return false;
   } else if (IsActive()) {
     // The active tab clips favicon before close button.
     return IconCapacity() >= 2;
@@ skipping 51 matching lines @@
   tab_active_.image_r = rb.GetBitmapNamed(IDR_TAB_ACTIVE_RIGHT);
   tab_active_.l_width = tab_active_.image_l->width();
   tab_active_.r_width = tab_active_.image_r->width();
 
   tab_inactive_.image_l = rb.GetBitmapNamed(IDR_TAB_INACTIVE_LEFT);
   tab_inactive_.image_c = rb.GetBitmapNamed(IDR_TAB_INACTIVE_CENTER);
   tab_inactive_.image_r = rb.GetBitmapNamed(IDR_TAB_INACTIVE_RIGHT);
   tab_inactive_.l_width = tab_inactive_.image_l->width();
   tab_inactive_.r_width = tab_inactive_.image_r->width();
 }