Material Hybrid mode for tabstrip.

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"
 
 #include <algorithm>
 #include <iterator>
 #include <string>
 #include <vector>
@@ skipping 99 matching lines @@
 
 // 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 kPinnedToNonPinnedOffset = 2;
 #else
 const int kPinnedToNonPinnedOffset = 3;
 #endif
 
-// The vertical offset of the tab strip button.
-const int kNewTabButtonVerticalOffset = 7;
+// Returns the offset from the top of the tabstrip at which the new tab button's
+// visible region begins.
+int GetNewTabButtonTopOffset() {
+  // The vertical distance between the bottom of the new tab button and the
+  // bottom of the tabstrip.
+  const int kNewTabButtonBottomOffset = 4;
+  return Tab::GetMinimumInactiveSize().height() - kNewTabButtonBottomOffset -
+      GetLayoutSize(NEW_TAB_BUTTON).height();
+}
 
 // Returns the width needed for the new tab button (and padding).
 int GetNewTabButtonWidth() {
   return GetLayoutSize(NEW_TAB_BUTTON).width() -
       GetLayoutConstant(TABSTRIP_NEW_TAB_BUTTON_OVERLAP);
 }
 
 skia::RefPtr<SkDrawLooper> CreateShadowDrawLooper(SkAlpha alpha) {
   SkLayerDrawLooper::Builder looper_builder;
   looper_builder.addLayer();
@@ skipping 237 matching lines @@
   const bool pressed = state() == views::CustomButton::STATE_PRESSED;
   double hover_value =
       (state() == views::CustomButton::STATE_HOVERED) ? 1 : 0;
   if (hover_animation_->is_animating())
     hover_value = hover_animation_->GetCurrentValue();
   const float scale = canvas->image_scale();
 
   SkPath fill;
   if (ui::MaterialDesignController::IsModeMaterial()) {
     // Fill.
-    fill.moveTo(9.75 * scale, 16 * scale);
+    const float fill_bottom = (visible_height - 2) * scale;
+    const float diag_height = fill_bottom - 3.5 * scale;
+    const float diag_width = diag_height * Tab::GetInverseDiagonalSlope();
+    fill.moveTo(diag_width + 4 * scale, fill_bottom);
     fill.rCubicTo(-0.75 * scale, 0, -1.625 * scale, -0.5 * scale, -2 * scale,
                   -1.5 * scale);
-    fill.rLineTo(-5.75 * scale, -12.5 * scale);
+    fill.rLineTo(-diag_width, -diag_height);
     fill.rCubicTo(0, -0.5 * scale, 0.25 * scale, -scale, scale, -scale);
-    fill.rLineTo(23.25 * scale, 0);
+    fill.lineTo((width() - 4) * scale - diag_width, scale);
     fill.rCubicTo(0.75 * scale, 0, 1.625 * scale, 0.5 * scale, 2 * scale,
                   1.5 * scale);
-    fill.rLineTo(5.75 * scale, 12.5 * scale);
+    fill.rLineTo(diag_width, diag_height);
     fill.rCubicTo(0, 0.5 * scale, -0.25 * scale, scale, -scale, scale);
     fill.close();
     PaintFill(pressed, hover_value, scale, fill, canvas);
 
     // Stroke.
     gfx::ScopedCanvas scoped_canvas(canvas);
     canvas->UndoDeviceScaleFactor();
     SkPath stroke;
     GetBorderPath(0, scale, false, &stroke);
     // We want to draw a drop shadow either inside or outside the stroke,
@@ skipping 36 matching lines @@
                          0, alpha);
   }
 }
 
 bool NewTabButton::GetHitTestMask(gfx::Path* mask) const {
   DCHECK(mask);
 
   if (ui::MaterialDesignController::IsModeMaterial()) {
     SkPath border;
     const float scale = GetWidget()->GetCompositor()->device_scale_factor();
-    GetBorderPath(kNewTabButtonVerticalOffset * scale, scale,
+    GetBorderPath(GetNewTabButtonTopOffset() * scale, scale,
                   tab_strip_->SizeTabButtonToTopOfTabStrip(), &border);
     mask->addPath(border, SkMatrix::MakeScale(1 / scale));
   } else if (tab_strip_->SizeTabButtonToTopOfTabStrip()) {
     // When the button is sized to the top of the tab strip, we want the hit
     // test mask to be defined as the complete (rectangular) bounds of the
     // button.
     gfx::Rect button_bounds(GetContentsBounds());
     button_bounds.set_x(GetMirroredXForRect(button_bounds));
     mask->addRect(RectToSkRect(button_bounds));
   } else {
     SkScalar w = SkIntToScalar(width());
-    SkScalar v_offset = SkIntToScalar(kNewTabButtonVerticalOffset);
+    SkScalar v_offset = SkIntToScalar(GetNewTabButtonTopOffset());
 
     // 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.
     mask->moveTo(0, v_offset + 1);
     mask->lineTo(w - 7, v_offset + 1);
     mask->lineTo(w - 4, v_offset + 4);
     mask->lineTo(w, v_offset + 16);
     mask->lineTo(w - 1, v_offset + 17);
     mask->lineTo(7, v_offset + 17);
     mask->lineTo(4, v_offset + 13);
     mask->lineTo(0, v_offset + 1);
     mask->close();
   }
 
   return true;
 }
 
 void NewTabButton::GetBorderPath(float button_y,
                                  float scale,
                                  bool extend_to_top,
                                  SkPath* path) const {
-  path->moveTo(9.75 * scale - 1, button_y + 16 * scale + 1);
+  const float inverse_slope = Tab::GetInverseDiagonalSlope();
+  const float fill_bottom =
+      (GetLayoutSize(NEW_TAB_BUTTON).height() - 2) * scale;
+  const float stroke_bottom = button_y + fill_bottom + 1;
+  const float diag_height = fill_bottom - 3.5 * scale;
+  const float diag_width = diag_height * inverse_slope;
+  path->moveTo(diag_width + 4 * scale - 1, stroke_bottom);
   path->rCubicTo(-0.75 * scale, 0, -1.625 * scale, -0.5 * scale, -2 * scale,
                  -1.5 * scale);
-  path->rLineTo(-5.75 * scale, -12.5 * scale);
+  path->rLineTo(-diag_width, -diag_height);
   if (extend_to_top) {
     // Create the vertical extension by extending the side diagonals at the
     // upper left and lower right corners until they reach the top and bottom of
     // the border, respectively (in other words, "un-round-off" those corners
     // and turn them into sharp points).  Then extend upward from the corner
     // points to the top of the bounds.
     const float dy = scale + 2;
-    const float dx = 11.5 / 25 * dy;
+    const float dx = inverse_slope * dy;
     path->rLineTo(-dx, -dy);
     path->rLineTo(0, -button_y - scale + 1);
-    path->lineTo(34 * scale + 1 + dx, 0);
-    path->rLineTo(0, button_y + 16 * scale + 1);
+    path->lineTo((width() - 2) * scale + 1 + dx, 0);
+    path->rLineTo(0, stroke_bottom);
   } else {
     path->rCubicTo(-0.5 * scale, -1.125 * scale, 0.5 * scale, -scale - 2, scale,
                    -scale - 2);
-    path->rLineTo(23.25 * scale + 2, 0);
+    path->lineTo((width() - 4) * scale - diag_width + 1, scale - 1);
     path->rCubicTo(0.75 * scale, 0, 1.625 * scale, 0.5 * scale, 2 * scale,
                    1.5 * scale);
-    path->rLineTo(5.75 * scale, 12.5 * scale);
+    path->rLineTo(diag_width, diag_height);
     path->rCubicTo(0.5 * scale, 1.125 * scale, -0.5 * scale, scale + 2, -scale,
                    scale + 2);
   }
   path->close();
 }
 
 void NewTabButton::PaintFill(bool pressed,
                              double hover_value,
                              float scale,
                              const SkPath& fill,
@@ skipping 44 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 += size.width();
     }
-    canvas->TileImageInt(*background, x, kNewTabButtonVerticalOffset + offset_y,
+    canvas->TileImageInt(*background, x, GetNewTabButtonTopOffset() + offset_y,
                          x_scale, 1.0f, 0, 0, size.width(), size.height());
 
     // For non-MD, adjust the alpha of the fill to match that of inactive tabs
     // (except for pressed buttons, which get a different value).  For MD, we do
     // this with an opacity recorder in TabStrip::PaintChildren() so the fill
     // and stroke are both affected, to better match how tabs are handled, but
     // in non-MD, the button stroke is already lighter than the tab stroke, and
     // using the opacity recorder washes it out too much.
     static const SkAlpha kPressedAlpha = 145;
     const SkAlpha alpha =
@@ skipping 1077 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_.set_size(GetLayoutSize(NEW_TAB_BUTTON));
-  newtab_button_bounds_.Inset(0, 0, 0, -kNewTabButtonVerticalOffset);
+  newtab_button_bounds_.Inset(0, 0, 0, -GetNewTabButtonTopOffset());
   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_)));
   AddChildView(newtab_button_);
@@ skipping 1168 matching lines @@
           ConvertPointToViewAndGetEventHandler(this, newtab_button_, point);
       if (view)
         return view;
     }
     Tab* tab = FindTabForEvent(point);
     if (tab)
       return ConvertPointToViewAndGetEventHandler(this, tab, point);
   }
   return this;
 }