Material Hybrid mode for tabstrip.

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 111 matching lines @@
 // The minimum opacity (out of 1) when a tab (either active or inactive) is
 // throbbing in the immersive mode light strip.
 const double kImmersiveTabMinThrobOpacity = 0.66;
 
 // Number of steps in the immersive mode loading animation.
 const int kImmersiveLoadingStepCount = 32;
 
 const char kTabCloseButtonName[] = "TabCloseButton";
 const int kTabCloseButtonSize = 16;
 
+// Returns the width of the tab endcap at scale 1.  More precisely, this is the
+// width of the curve making up either the outer or inner edge of the stroke;
+// since these two curves are horizontally offset by 1 px (regardless of scale),
+// the total width of the endcap from tab outer edge to the inside end of the
+// stroke inner edge is (GetUnscaledEndcapWidth() * scale) + 1.
+float GetUnscaledEndcapWidth() {
+  return GetLayoutInsets(TAB).left() - 0.5f;
+}
+
 chrome::HostDesktopType GetHostDesktopType(views::View* view) {
   // Widget is NULL when tabs are detached.
   views::Widget* widget = view->GetWidget();
   return chrome::GetHostDesktopTypeForNativeView(
       widget ? widget->GetNativeView() : NULL);
 }
 
 // Stop()s |animation| and then deletes it. We do this rather than just deleting
 // so that the delegate is notified before the destruction.
 void StopAndDeleteAnimation(scoped_ptr<gfx::Animation> animation) {
@@ skipping 548 matching lines @@
 int Tab::GetYInsetForActiveTabBackground() {
   // The computed value here is strangely less than the height of the area atop
   // the tab that doesn't get a background painted; otherwise, we could compute
   // the value by simply using GetLayoutInsets(TAB).top().  My suspicion is that
   // originally there was some sort of off-by-one error in how this background
   // was painted, and theme authors compensated; now we're stuck perpetuating it
   // as a result.
   return GetLayoutConstant(TAB_TOP_EXCLUSION_HEIGHT) + 1;
 }
 
+// static
+float Tab::GetInverseDiagonalSlope() {
+  // This is computed from the border path as follows:
+  // * The unscaled endcap width is enough for the whole stroke outer curve,
+  //   i.e. the side diagonal plus the curves on both its ends.
+  // * The bottom and top curve are each (2 * scale) px wide, so the diagonal is
+  //   (unscaled endcap width - 2 - 2) * scale px wide.
+  // * The bottom and top curve are each 1.5 px high.  Additionally, there is an
+  //   extra 1 px below the bottom curve and (scale - 1) px above the top curve,
+  //   so the diagonal is ((height - 1.5 - 1.5) * scale - 1 - (scale - 1)) px
+  //   high.
+  // Simplifying these gives the expression below.
+  return (GetUnscaledEndcapWidth() - 4) /
+      (GetMinimumInactiveSize().height() - 4);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, AnimationDelegate overrides:
 
 void Tab::AnimationProgressed(const gfx::Animation* animation) {
   // Ignore if the pulse animation is being performed on active tab because
   // it repaints the same image. See |Tab::PaintTabBackground()|.
   if (animation == pulse_animation_.get() && IsActive())
     return;
   SchedulePaint();
 }
@@ skipping 890 matching lines @@
   // Extends the area to the bottom when the crash animation is in progress.
   if (crash_icon_animation_)
     bounds.set_height(height() - bounds.y());
   bounds.set_x(GetMirroredXForRect(bounds));
   SchedulePaintInRect(bounds);
 }
 
 void Tab::GetFillPath(float scale, SkPath* fill) const {
   const float right = width() * scale;
   const float bottom = height() * scale;
+  const float unscaled_endcap_width = GetUnscaledEndcapWidth();
 
   fill->moveTo(right - 1, bottom);
   fill->rCubicTo(-0.75 * scale, 0, -1.625 * scale, -0.5 * scale, -2 * scale,
                  -1.5 * scale);
-  fill->lineTo(right - 1 - 13.5 * scale, 2.5 * scale);
+  fill->lineTo(right - 1 - (unscaled_endcap_width - 2) * scale, 2.5 * scale);
   // Prevent overdraw in the center near minimum width (only happens if
   // scale < 2).  We could instead avoid this by increasing the tab inset
   // values, but that would shift all the content inward as well, unless we
   // then overlapped the content on the endcaps, by which point we'd have a
   // huge mess.
-  const float total_endcap_width = 31 * scale + 2;
-  const float overlap = total_endcap_width - right;
+  const float scaled_endcap_width = 1 + unscaled_endcap_width * scale;
+  const float overlap = scaled_endcap_width * 2 - right;
   const float offset = (overlap > 0) ? (overlap / 2) : 0;
   fill->rCubicTo(-0.375 * scale, -1 * scale, -1.25 * scale + offset,
                  -1.5 * scale, -2 * scale + offset, -1.5 * scale);
   if (overlap < 0)
-    fill->lineTo(1 + 15.5 * scale, scale);
+    fill->lineTo(scaled_endcap_width, scale);
   fill->rCubicTo(-0.75 * scale, 0, -1.625 * scale - offset, 0.5 * scale,
                  -2 * scale - offset, 1.5 * scale);
   fill->lineTo(1 + 2 * scale, bottom - 1.5 * scale);
   fill->rCubicTo(-0.375 * scale, scale, -1.25 * scale, 1.5 * scale, -2 * scale,
                  1.5 * scale);
   fill->close();
 }
 
 void Tab::GetBorderPath(float scale, bool extend_to_top, SkPath* path) const {
   const float top = scale - 1;
   const float right = width() * scale;
   const float bottom = height() * scale;
+  const float unscaled_endcap_width = GetUnscaledEndcapWidth();
 
   path->moveTo(0, bottom);
   path->rLineTo(0, -1);
   path->rCubicTo(0.75 * scale, 0, 1.625 * scale, -0.5 * scale, 2 * scale,
                  -1.5 * scale);
-  path->lineTo(13.5 * scale, top + 1.5 * scale);
+  path->lineTo((unscaled_endcap_width - 2) * scale, top + 1.5 * scale);
   if (extend_to_top) {
     // Create the vertical extension by extending the side diagonals until they
     // reach the top of the bounds.
     const float dy = 2.5 * scale - 1;
-    const float dx = 11.5 / 25 * dy;
+    const float dx = GetInverseDiagonalSlope() * dy;
     path->rLineTo(dx, -dy);
-    path->lineTo(right - 13.5 * scale - dx, 0);
+    path->lineTo(right - (unscaled_endcap_width - 2) * scale - dx, 0);
     path->rLineTo(dx, dy);
   } else {
     path->rCubicTo(0.375 * scale, -scale, 1.25 * scale, -1.5 * scale, 2 * scale,
                    -1.5 * scale);
-    path->lineTo(right - 15.5 * scale, top);
+    path->lineTo(right - unscaled_endcap_width * scale, top);
     path->rCubicTo(0.75 * scale, 0, 1.625 * scale, 0.5 * scale, 2 * scale,
                    1.5 * scale);
   }
   path->lineTo(right - 2 * scale, bottom - 1 - 1.5 * scale);
   path->rCubicTo(0.375 * scale, scale, 1.25 * scale, 1.5 * scale, 2 * scale,
                  1.5 * scale);
   path->rLineTo(0, 1);
   path->close();
 }
 
@@ skipping 67 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();
 }