Remove pre-MD code from browser/ui/views/tabs/tab.cc

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 <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 16 matching lines @@
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/theme_resources.h"
 #include "components/grit/components_scaled_resources.h"
 #include "components/strings/grit/components_strings.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/url_constants.h"
 #include "third_party/skia/include/effects/SkGradientShader.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/models/list_selection_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/animation/animation_container.h"
 #include "ui/gfx/animation/throb_animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_analysis.h"
 #include "ui/gfx/favicon_size.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/image/image_skia_operations.h"
@@ skipping 66 matching lines @@
 // Number of steps in the immersive mode loading animation.
 const int kImmersiveLoadingStepCount = 32;
 
 const char kTabCloseButtonName[] = "TabCloseButton";
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageCacheEntryMetadata
 //
 // All metadata necessary to uniquely identify a cached image.
 struct ImageCacheEntryMetadata {
-  ImageCacheEntryMetadata(int resource_id,
-                          SkColor fill_color,
+  ImageCacheEntryMetadata(SkColor fill_color,
                           SkColor stroke_color,
                           bool use_fill_and_stroke_images,
                           float scale_factor,
                           const gfx::Size& size);
 
   ~ImageCacheEntryMetadata();
 
   bool operator==(const ImageCacheEntryMetadata& rhs) const;
 
-  int resource_id;     // Only needed by pre-MD
-  SkColor fill_color;  // Both colors only needed by MD
+  SkColor fill_color;
   SkColor stroke_color;
   bool use_fill_and_stroke_images;
   float scale_factor;
   gfx::Size size;
 };
 
 ImageCacheEntryMetadata::ImageCacheEntryMetadata(
-    int resource_id,
     SkColor fill_color,
     SkColor stroke_color,
     bool use_fill_and_stroke_images,
     float scale_factor,
     const gfx::Size& size)
-    : resource_id(resource_id),
-      fill_color(fill_color),
+    : fill_color(fill_color),
       stroke_color(stroke_color),
       use_fill_and_stroke_images(use_fill_and_stroke_images),
       scale_factor(scale_factor),
-      size(size) {
-  // Some fields are only relevant for pre-MD vs. MD.  Erase the irrelevant ones
-  // so they don't cause incorrect cache misses.
-  // TODO(pkasting): Remove |resource_id| field when non-MD code is deleted.
-  if (ui::MaterialDesignController::IsModeMaterial())
-    resource_id = 0;
-  else
-    fill_color = stroke_color = SK_ColorTRANSPARENT;
-}
+      size(size) {}
 
 ImageCacheEntryMetadata::~ImageCacheEntryMetadata() {}
 
 bool ImageCacheEntryMetadata::operator==(
     const ImageCacheEntryMetadata& rhs) const {
-  return resource_id == rhs.resource_id && fill_color == rhs.fill_color &&
-         stroke_color == rhs.stroke_color &&
+  return fill_color == rhs.fill_color && stroke_color == rhs.stroke_color &&
          use_fill_and_stroke_images == rhs.use_fill_and_stroke_images &&
          scale_factor == rhs.scale_factor && size == rhs.size;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageCacheEntry and cache management
 //
 // A cached image and the metadata used to generate it.
 struct ImageCacheEntry {
   ImageCacheEntry(const ImageCacheEntryMetadata& metadata,
@@ skipping 12 matching lines @@
     : metadata(metadata), fill_image(fill_image), stroke_image(stroke_image) {}
 
 ImageCacheEntry::~ImageCacheEntry() {}
 
 typedef std::list<ImageCacheEntry> ImageCache;
 
 // As the majority of the tabs are inactive, and painting tabs is slowish,
 // we cache a handful of the inactive tab backgrounds here.
 static ImageCache* g_image_cache = nullptr;
 
-struct TabImages {
-  gfx::ImageSkia* image_l;
-  gfx::ImageSkia* image_c;
-  gfx::ImageSkia* image_r;
-  int l_width;
-  int r_width;
-};
-static TabImages g_active_images = {0};
-static TabImages g_inactive_images = {0};
-static TabImages g_mask_images = {0};
-
-// Loads the images to be used for the tab background.
-void LoadTabImages() {
-  g_image_cache->clear();
-
-  // We're not letting people override tab images just yet.
-  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-
-  g_active_images.image_l = rb.GetImageSkiaNamed(IDR_TAB_ACTIVE_LEFT);
-  g_active_images.image_c = rb.GetImageSkiaNamed(IDR_TAB_ACTIVE_CENTER);
-  g_active_images.image_r = rb.GetImageSkiaNamed(IDR_TAB_ACTIVE_RIGHT);
-  g_active_images.l_width = g_active_images.image_l->width();
-  g_active_images.r_width = g_active_images.image_r->width();
-
-  g_inactive_images.image_l = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_LEFT);
-  g_inactive_images.image_c = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_CENTER);
-  g_inactive_images.image_r = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_RIGHT);
-  g_inactive_images.l_width = g_inactive_images.image_l->width();
-  g_inactive_images.r_width = g_inactive_images.image_r->width();
-
-  g_mask_images.image_l = rb.GetImageSkiaNamed(IDR_TAB_ALPHA_LEFT);
-  g_mask_images.image_r = rb.GetImageSkiaNamed(IDR_TAB_ALPHA_RIGHT);
-  g_mask_images.l_width = g_mask_images.image_l->width();
-  g_mask_images.r_width = g_mask_images.image_r->width();
-}
-
 // Performs a one-time initialization of static resources such as tab images.
 void InitTabResources() {
   static bool initialized = false;
   if (initialized)
     return;
 
   initialized = true;
   g_image_cache = new ImageCache();
-
-  // Load the tab images once now, and maybe again later if the theme changes.
-  LoadTabImages();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Drawing and utility functions
 
 // 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.
@@ skipping 61 matching lines @@
 
 // Returns a path corresponding to the tab's outer border for a given tab |size|
 // and |scale|.  If |unscale_at_end| is true, this path will be normalized to a
 // 1x scale by scaling by 1/scale before returning.  If |extend_to_top| is true,
 // the path is extended vertically to the top of the tab bounds.  The caller
 // uses this for Fitts' Law purposes in maximized/fullscreen mode.
 gfx::Path GetBorderPath(float scale,
                         bool unscale_at_end,
                         bool extend_to_top,
                         const gfx::Size& size) {
+  const float top = scale - 1;
+  const float right = size.width() * scale;
+  const float bottom = size.height() * scale;
+  const float unscaled_endcap_width = GetUnscaledEndcapWidth();
+
   gfx::Path path;
-  if (ui::MaterialDesignController::IsModeMaterial()) {
-    const float top = scale - 1;
-    const float right = size.width() * scale;
-    const float bottom = size.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((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 = Tab::GetInverseDiagonalSlope() * dy;
+    path.rLineTo(dx, -dy);
+    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 - 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();
 
-    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((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 = Tab::GetInverseDiagonalSlope() * dy;
-      path.rLineTo(dx, -dy);
-      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 - 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();
-
-    if (unscale_at_end && (scale != 1))
-      path.transform(SkMatrix::MakeScale(1.f / scale));
-  } else {
-    // Hit mask constants.
-    const SkScalar kTabCapWidth = 15;
-    const SkScalar kTabTopCurveWidth = 4;
-    const SkScalar kTabBottomCurveWidth = 3;
-#if defined(OS_MACOSX)
-    // Mac's Cocoa UI doesn't have shadows.
-    const SkScalar kTabInset = 0;
-#elif defined(TOOLKIT_VIEWS)
-    // The views browser UI has shadows in the left, right and top parts of the
-    // tab.
-    const SkScalar kTabInset = 6;
-#endif
-
-    SkScalar left = kTabInset;
-    SkScalar top = SkIntToScalar(0);
-    SkScalar right = SkIntToScalar(size.width()) - kTabInset;
-    SkScalar bottom = SkIntToScalar(size.height());
-
-    // Start in the lower-left corner.
-    path.moveTo(left, bottom);
-
-    // Left end cap.
-    path.lineTo(left + kTabBottomCurveWidth, bottom - kTabBottomCurveWidth);
-    path.lineTo(left + kTabCapWidth - kTabTopCurveWidth,
-                top + kTabTopCurveWidth);
-    path.lineTo(left + kTabCapWidth, top);
-
-    // Connect to the right cap.
-    path.lineTo(right - kTabCapWidth, top);
-
-    // Right end cap.
-    path.lineTo(right - kTabCapWidth + kTabTopCurveWidth,
-                top + kTabTopCurveWidth);
-    path.lineTo(right - kTabBottomCurveWidth, bottom - kTabBottomCurveWidth);
-    path.lineTo(right, bottom);
-
-    // Close out the path.
-    path.lineTo(left, bottom);
-    path.close();
-
-    // Unscaling is not necessary since we never scaled up to begin with.
-  }
+  if (unscale_at_end && (scale != 1))
+    path.transform(SkMatrix::MakeScale(1.f / scale));
 
   return path;
 }
 
-void PaintTabFill(gfx::Canvas* canvas,
-                  const gfx::ImageSkia& fill_image,
-                  gfx::Rect rect,
-                  bool is_active) {
-  const gfx::Insets tab_insets(GetLayoutInsets(TAB));
-  // If this isn't the foreground tab, don't draw over the toolbar, but do
-  // include the 1 px divider stroke at the bottom.
-  const int toolbar_overlap = is_active ? 0 : (tab_insets.bottom() - 1);
-
-  // Draw left edge.
-  gfx::ImageSkia tab_l = gfx::ImageSkiaOperations::CreateTiledImage(
-      fill_image, rect.x(), rect.y(), g_mask_images.l_width, rect.height());
-  gfx::ImageSkia theme_l = gfx::ImageSkiaOperations::CreateMaskedImage(
-      tab_l, *g_mask_images.image_l);
-  canvas->DrawImageInt(
-      theme_l, 0, 0, theme_l.width(), theme_l.height() - toolbar_overlap, 0, 0,
-      theme_l.width(), theme_l.height() - toolbar_overlap, false);
-
-  // Draw right edge.
-  gfx::ImageSkia tab_r = gfx::ImageSkiaOperations::CreateTiledImage(
-      fill_image, rect.right() - g_mask_images.r_width, rect.y(),
-      g_mask_images.r_width, rect.height());
-  gfx::ImageSkia theme_r = gfx::ImageSkiaOperations::CreateMaskedImage(
-      tab_r, *g_mask_images.image_r);
-  canvas->DrawImageInt(theme_r, 0, 0, theme_r.width(),
-                       theme_r.height() - toolbar_overlap,
-                       rect.width() - theme_r.width(), 0, theme_r.width(),
-                       theme_r.height() - toolbar_overlap, false);
-
-  // Draw center.  Instead of masking out the top portion we simply skip over it
-  // by incrementing by the top padding, since it's a simple rectangle.
-  rect.Inset(g_mask_images.l_width, tab_insets.top(), g_mask_images.r_width,
-             toolbar_overlap);
-  canvas->TileImageInt(fill_image, rect.x(), rect.y(), g_mask_images.l_width,
-                       tab_insets.top(), rect.width(), rect.height());
-}
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // FaviconCrashAnimation
 //
 //  A custom animation subclass to manage the favicon crash animation.
 class Tab::FaviconCrashAnimation : public gfx::LinearAnimation,
                                    public gfx::AnimationDelegate {
  public:
   explicit FaviconCrashAnimation(Tab* target)
@@ skipping 607 matching lines @@
     }
     // The Label will automatically center the font's cap height within the
     // provided vertical space.
     title_->SetBoundsRect(
         gfx::Rect(title_left, lb.y(), std::max(title_width, 0), lb.height()));
   }
   title_->SetVisible(show_title);
 }
 
 void Tab::OnThemeChanged() {
-  LoadTabImages();
   OnButtonColorMaybeChanged();
   favicon_ = gfx::ImageSkia();
 }
 
 const char* Tab::GetClassName() const {
   return kViewClassName;
 }
 
 bool Tab::GetTooltipText(const gfx::Point& p, base::string16* tooltip) const {
   // Note: Anything that affects the tooltip text should be accounted for when
@@ skipping 276 matching lines @@
   if (has_custom_image || hover_controller_.ShouldDraw()) {
     PaintTabBackgroundUsingFillId(canvas, canvas, false, fill_id,
                                   has_custom_image, y_offset);
     return;
   }
 
   // For efficiency, we don't use separate fill and stroke images unless we
   // really need to clip the stroke and not the fill (for stacked tabs).  This
   // saves memory and avoids an extra image draw at the cost of recalculating
   // the images when MaySetClip() toggles.
-  const bool use_fill_and_stroke_images =
-      controller_->MaySetClip() &&
-      ui::MaterialDesignController::IsModeMaterial();
+  const bool use_fill_and_stroke_images = controller_->MaySetClip();
 
   const ImageCacheEntryMetadata metadata(
-      fill_id, tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB),
+      tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB),
       controller_->GetToolbarTopSeparatorColor(), use_fill_and_stroke_images,
       canvas->image_scale(), size());
   auto it = std::find_if(
       g_image_cache->begin(), g_image_cache->end(),
       [&metadata](const ImageCacheEntry& e) { return e.metadata == metadata; });
   if (it == g_image_cache->end()) {
     gfx::Canvas tmp_canvas(size(), canvas->image_scale(), false);
     if (use_fill_and_stroke_images) {
       gfx::Canvas tmp_fill_canvas(size(), canvas->image_scale(), false);
       PaintTabBackgroundUsingFillId(&tmp_fill_canvas, &tmp_canvas, false,
@@ skipping 21 matching lines @@
   }
   canvas->DrawImageInt(it->stroke_image, 0, 0);
 }
 
 void Tab::PaintTabBackgroundUsingFillId(gfx::Canvas* fill_canvas,
                                         gfx::Canvas* stroke_canvas,
                                         bool is_active,
                                         int fill_id,
                                         bool has_custom_image,
                                         int y_offset) {
-  const ui::ThemeProvider* tp = GetThemeProvider();
-  const SkColor toolbar_color = tp->GetColor(ThemeProperties::COLOR_TOOLBAR);
-  gfx::ImageSkia* fill_image = tp->GetImageSkiaNamed(fill_id);
-  // The tab image needs to be lined up with the background image
-  // so that it feels partially transparent.  These offsets represent the tab
-  // position within the frame background image.
-  const int x_offset = GetMirroredX() + background_offset_.x();
+  gfx::Path fill;
+  SkPaint paint;
+  paint.setAntiAlias(true);
 
-  const SkScalar kMinHoverRadius = 16;
-  const SkScalar radius =
-      std::max(SkFloatToScalar(width() / 4.f), kMinHoverRadius);
-  const bool draw_hover = !is_active && hover_controller_.ShouldDraw();
-  SkPoint hover_location(gfx::PointToSkPoint(hover_controller_.location()));
-  const SkColor hover_color =
-      SkColorSetA(toolbar_color, hover_controller_.GetAlpha());
+  // Draw the fill.
+  {
+    gfx::ScopedCanvas scoped_canvas(fill_canvas);
+    const float scale = fill_canvas->UndoDeviceScaleFactor();
+    const ui::ThemeProvider* tp = GetThemeProvider();
+    const SkColor toolbar_color = tp->GetColor(ThemeProperties::COLOR_TOOLBAR);
 
-  if (ui::MaterialDesignController::IsModeMaterial()) {
-    gfx::Path fill;
-    SkPaint paint;
-    paint.setAntiAlias(true);
+    fill = GetFillPath(scale, size());
+    {
+      gfx::ScopedCanvas clip_scoper(fill_canvas);
+      fill_canvas->ClipPath(fill, true);
+      if (has_custom_image) {
+        gfx::ScopedCanvas scale_scoper(fill_canvas);
+        fill_canvas->sk_canvas()->scale(scale, scale);
+        fill_canvas->TileImageInt(*tp->GetImageSkiaNamed(fill_id),
+                                  GetMirroredX() + background_offset_.x(),
+                                  y_offset, 0, 0, width(), height());
+      } else {
+        paint.setColor(
+            is_active ? toolbar_color
+                      : tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB));
+        fill_canvas->DrawRect(
+            gfx::ScaleToEnclosingRect(GetLocalBounds(), scale), paint);
+      }
 
-    // Draw the fill.
-    {
-      gfx::ScopedCanvas scoped_canvas(fill_canvas);
-      const float scale = fill_canvas->UndoDeviceScaleFactor();
-
-      fill = GetFillPath(scale, size());
-      {
-        gfx::ScopedCanvas clip_scoper(fill_canvas);
-        fill_canvas->ClipPath(fill, true);
-        if (has_custom_image) {
-          gfx::ScopedCanvas scale_scoper(fill_canvas);
-          fill_canvas->sk_canvas()->scale(scale, scale);
-          fill_canvas->TileImageInt(*fill_image, x_offset, y_offset, 0, 0,
-                                    width(), height());
-        } else {
-          paint.setColor(
-              is_active ? toolbar_color
-                        : tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB));
-          fill_canvas->DrawRect(
-              gfx::ScaleToEnclosingRect(GetLocalBounds(), scale), paint);
-        }
-        if (draw_hover) {
-          hover_location.scale(SkFloatToScalar(scale));
-          DrawHighlight(fill_canvas, hover_location, radius * scale,
-                        hover_color);
-        }
+      if (!is_active && hover_controller_.ShouldDraw()) {
+        SkPoint hover_location(
+            gfx::PointToSkPoint(hover_controller_.location()));
+        hover_location.scale(SkFloatToScalar(scale));
+        const SkScalar kMinHoverRadius = 16;
+        const SkScalar radius =
+            std::max(SkFloatToScalar(width() / 4.f), kMinHoverRadius);
+        DrawHighlight(fill_canvas, hover_location, radius * scale,
+                      SkColorSetA(toolbar_color, hover_controller_.GetAlpha()));
       }
     }
+  }
 
-    // Draw the stroke.
-    {
-      gfx::ScopedCanvas scoped_canvas(stroke_canvas);
-      const float scale = stroke_canvas->UndoDeviceScaleFactor();
+  // Draw the stroke.
+  {
+    gfx::ScopedCanvas scoped_canvas(stroke_canvas);
+    const float scale = stroke_canvas->UndoDeviceScaleFactor();
 
-      gfx::Path stroke = GetBorderPath(scale, false, false, size());
-      Op(stroke, fill, kDifference_SkPathOp, &stroke);
-      if (!is_active) {
-        // Clip out the bottom line; this will be drawn for us by
-        // TabStrip::PaintChildren().
-        stroke_canvas->ClipRect(
-            gfx::RectF(width() * scale, height() * scale - 1));
-      }
-      paint.setColor(controller_->GetToolbarTopSeparatorColor());
-      stroke_canvas->DrawPath(stroke, paint);
+    gfx::Path stroke = GetBorderPath(scale, false, false, size());
+    Op(stroke, fill, kDifference_SkPathOp, &stroke);
+    if (!is_active) {
+      // Clip out the bottom line; this will be drawn for us by
+      // TabStrip::PaintChildren().
+      stroke_canvas->ClipRect(
+          gfx::RectF(width() * scale, height() * scale - 1));
     }
-  } else {
-    gfx::Canvas* canvas = stroke_canvas;
-    gfx::Rect rect(gfx::Point(x_offset, y_offset), size());
-    if (draw_hover) {
-      // Draw everything to a temporary canvas so we can extract an image for
-      // use in masking the hover glow.
-      gfx::Canvas background_canvas(size(), canvas->image_scale(), false);
-      PaintTabFill(&background_canvas, *fill_image, rect, is_active);
-      gfx::ImageSkia background_image(background_canvas.ExtractImageRep());
-      canvas->DrawImageInt(background_image, 0, 0);
-
-      gfx::Canvas hover_canvas(size(), canvas->image_scale(), false);
-      DrawHighlight(&hover_canvas, hover_location, radius, hover_color);
-      gfx::ImageSkia result = gfx::ImageSkiaOperations::CreateMaskedImage(
-          gfx::ImageSkia(hover_canvas.ExtractImageRep()), background_image);
-      canvas->DrawImageInt(result, 0, 0);
-    } else {
-      PaintTabFill(canvas, *fill_image, rect, is_active);
-    }
-
-    // Now draw the stroke, highlights, and shadows around the tab edge.
-    TabImages* stroke_images =
-        is_active ? &g_active_images : &g_inactive_images;
-    canvas->DrawImageInt(*stroke_images->image_l, 0, 0);
-    canvas->TileImageInt(
-        *stroke_images->image_c, stroke_images->l_width, 0,
-        width() - stroke_images->l_width - stroke_images->r_width, height());
-    canvas->DrawImageInt(*stroke_images->image_r,
-                         width() - stroke_images->r_width, 0);
+    paint.setColor(controller_->GetToolbarTopSeparatorColor());
+    stroke_canvas->DrawPath(stroke, paint);
   }
 }
 
 void Tab::PaintPinnedTabTitleChangedIndicatorAndIcon(
     gfx::Canvas* canvas,
     const gfx::Rect& favicon_draw_bounds) {
   // The pinned tab title changed indicator consists of two parts:
   // . a clear (totally transparent) part over the bottom right (or left in rtl)
   //   of the favicon. This is done by drawing the favicon to a canvas, then
   //   drawing the clear part on top of the favicon.
@@ skipping 221 matching lines @@
 
   // Extends the area to the bottom when the crash animation is in progress.
   if (crash_icon_animation_->is_animating())
     bounds.set_height(height() - bounds.y());
   bounds.set_x(GetMirroredXForRect(bounds));
   SchedulePaintInRect(bounds);
 }
 
 gfx::Rect Tab::GetImmersiveBarRect() const {
   // The main bar is as wide as the normal tab's horizontal top line.
-  // This top line of the tab extends a few pixels left and right of the
-  // center image due to pixels in the rounded corner images.
-  const int kBarPadding = 1;
-  int main_bar_left = g_active_images.l_width - kBarPadding;
-  int main_bar_right = width() - g_active_images.r_width + kBarPadding;
-  return gfx::Rect(
-      main_bar_left, 0, main_bar_right - main_bar_left, kImmersiveBarHeight);
+  gfx::Rect contents = GetContentsBounds();

[Peter Kasting, 2016/09/26 21:05:29]

This seems to be a behavior change?  The old code, as the comment describes,
used the width of the top of the tab.  The new code uses the width of the whole
tab rect (i.e. the width of the bottom of the tab), so the comment is no longer
correct.  I'm worried that the behavior change isn't right either?

[Evan Stade, 2016/09/26 21:57:34]

I don't think so --- the tab's border is set here:
https://cs.chromium.org/chromium/src/chrome/browser/ui/views/tabs/tab.cc?rcl=...

GetLayoutInsets(TAB) to my understanding describes the insets for the portion of
the tab where we put the icon, text, etc., i.e. the width matches the tab's top
stroke.

[Peter Kasting, 2016/09/26 22:02:41]

Oh, I was thinking GetLocalBounds(), not GetContentsBounds().

Hmm.  We might be off by a little bit (roughly, the kBarPadding amount in the
old code).  But this is at least approximately correct.

I seem to recall being told by Scott not to worry about getting immersive mode
behavior perfect in MD anyway, so this seems OK.

+  contents.set_y(0);
+  contents.set_height(kImmersiveBarHeight);
+  return contents;
 }