Fix pixelation of tab borders when device scale changes (abandoned)

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 26 matching lines @@
 #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/canvas_image_source.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/paint_vector_icon.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/vector_icons_public.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/views/border.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/label.h"
@@ skipping 354 matching lines @@
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab::ImageCacheEntryMetadata
 
 struct Tab::ImageCacheEntryMetadata {
   ImageCacheEntryMetadata(int resource_id,
                           SkColor fill_color,
                           SkColor stroke_color,
-                          ui::ScaleFactor scale_factor,
                           const gfx::Size& size);
 
   ~ImageCacheEntryMetadata();
 
   // Making this a non-member would require a friend declaration in Tab.  Bleh.
   bool operator==(const ImageCacheEntryMetadata& rhs) const;
 
   int resource_id;     // Only needed by pre-MD
   SkColor fill_color;  // Both colors only needed by MD
   SkColor stroke_color;

[Greg Levin, 2016/07/12 23:23:45]

I've removed cache as a differentiator of cache entries.  Am I correct that one
CanvasImageSource will handle all relevant scales?

-  ui::ScaleFactor scale_factor;
   gfx::Size size;
 };
 
 Tab::ImageCacheEntryMetadata::ImageCacheEntryMetadata(
     int resource_id,
     SkColor fill_color,
     SkColor stroke_color,
-    ui::ScaleFactor scale_factor,
     const gfx::Size& size)
     : resource_id(resource_id),
       fill_color(fill_color),
       stroke_color(stroke_color),
-      scale_factor(scale_factor),
       size(size) {
-  DCHECK_NE(ui::SCALE_FACTOR_NONE, scale_factor);
-
   // 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;
 }
 
 Tab::ImageCacheEntryMetadata::~ImageCacheEntryMetadata() {}
 
 bool Tab::ImageCacheEntryMetadata::operator==(
     const ImageCacheEntryMetadata& rhs) const {
   return resource_id == rhs.resource_id && fill_color == rhs.fill_color &&
-      stroke_color == rhs.stroke_color && scale_factor == rhs.scale_factor &&
-      size == rhs.size;
+         stroke_color == rhs.stroke_color && size == rhs.size;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// Tab::TabImageSource
+//
+// This subclass of CanvasImageSource allows the inactive tab image to be cached
+// once and rendered correctly for all scale factors.
+class Tab::TabImageSource : public gfx::CanvasImageSource {
+ public:
+  TabImageSource(Tab* tab, int fill_id, int y_offset);
+  ~TabImageSource() override {}
+
+  // gfx::CanvasImageSource override.
+  void Draw(gfx::Canvas* canvas) override;
+
+ private:
+  PaintBackgroundParams params_;
+
+  DISALLOW_COPY_AND_ASSIGN(TabImageSource);
+};
+
+Tab::TabImageSource::TabImageSource(Tab* tab, int fill_id, int y_offset)
+    : gfx::CanvasImageSource(tab->size(), true) {
+  params_.tp = tab->GetThemeProvider();
+  params_.hc = nullptr;
+  params_.is_active = false;
+  params_.fill_id = fill_id;
+  params_.has_custom_image = false;
+  params_.x_offset = 0;
+  params_.y_offset = y_offset;
+  params_.size = tab->size();
+  params_.stroke_color = tab->controller()->GetToolbarTopSeparatorColor();
+}
+
+void Tab::TabImageSource::Draw(gfx::Canvas* canvas) {
+  PaintTabBackgroundUsingFillId(canvas, params_);
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // Tab::ImageCacheEntry
 
 struct Tab::ImageCacheEntry {
   ImageCacheEntry(const ImageCacheEntryMetadata& metadata,
-                  const gfx::ImageSkia& image);
+                  Tab* tab,
+                  int fill_id,
+                  int y_offset);
   ~ImageCacheEntry();
 
   ImageCacheEntryMetadata metadata;
   gfx::ImageSkia image;
 };
 
 Tab::ImageCacheEntry::ImageCacheEntry(const ImageCacheEntryMetadata& metadata,
-                                      const gfx::ImageSkia& image)
-    : metadata(metadata), image(image) {}
+                                      Tab* tab,
+                                      int fill_id,
+                                      int y_offset)
+    : metadata(metadata),
+      image(new TabImageSource(tab, fill_id, y_offset), tab->size()) {}
 
 Tab::ImageCacheEntry::~ImageCacheEntry() {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // Tab, statics:
 
 // static
 const char Tab::kViewClassName[] = "Tab";
 Tab::TabImages Tab::active_images_ = {0};
 Tab::TabImages Tab::inactive_images_ = {0};
@@ skipping 311 matching lines @@
   // When the window is maximized we don't want to shave off the edges or top
   // shadow of the tab, such that the user can click anywhere along the top
   // edge of the screen to select a tab. Ditto for immersive fullscreen.
   const views::Widget* widget = GetWidget();
   const bool extend_to_top =
       widget && (widget->IsMaximized() || widget->IsFullscreen());
 
   if (ui::MaterialDesignController::IsModeMaterial()) {
     SkPath border;
     const float scale = GetWidget()->GetCompositor()->device_scale_factor();
-    GetBorderPath(scale, extend_to_top, &border);
+    GetBorderPath(scale, size(), extend_to_top, &border);
     mask->addPath(border, SkMatrix::MakeScale(1 / 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)
@@ skipping 458 matching lines @@
   // We only cache the image when it's the default image and we're not hovered,
   // to avoid caching a background image that isn't the same for all tabs.
   if (has_custom_image || hover_controller_.ShouldDraw()) {
     PaintTabBackgroundUsingFillId(canvas, false, fill_id, has_custom_image,
                                   y_offset);
     return;
   }
 
   const ImageCacheEntryMetadata metadata(
       fill_id, tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB),
-      controller_->GetToolbarTopSeparatorColor(),
-      ui::GetSupportedScaleFactor(canvas->image_scale()), size());
+      controller_->GetToolbarTopSeparatorColor(), size());
   auto it = std::find_if(
       image_cache_->begin(), image_cache_->end(),
       [&metadata](const ImageCacheEntry& e) { return e.metadata == metadata; });
   if (it == image_cache_->end()) {
-    gfx::Canvas tmp_canvas(size(), canvas->image_scale(), false);
-    PaintTabBackgroundUsingFillId(&tmp_canvas, false, fill_id, false, y_offset);
-    image_cache_->emplace_front(metadata,
-                                gfx::ImageSkia(tmp_canvas.ExtractImageRep()));
+    image_cache_->emplace_front(metadata, this, fill_id, y_offset);

[Greg Levin, 2016/07/12 23:23:45]

Previously, the image would be rendered here, then passed to the cache.  Now, we
only give the cache the needed parameters to construct a TabImageSource; the
rendering will be done on demand by TabImageSource::Draw.

     if (image_cache_->size() > kMaxImageCacheSize)
       image_cache_->pop_back();
     it = image_cache_->begin();
   }
   canvas->DrawImageInt(it->image, 0, 0);
 }
 
 void Tab::PaintTabBackgroundUsingFillId(gfx::Canvas* 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);
+  PaintBackgroundParams params;
+  params.tp = GetThemeProvider();
+  params.hc = &hover_controller_;
+  params.is_active = is_active;
+  params.fill_id = fill_id;
+  params.has_custom_image = has_custom_image;
   // 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();
+  params.x_offset = GetMirroredX() + background_offset_.x();
+  params.y_offset = y_offset;
+  params.size = size();
+  params.stroke_color = controller_->GetToolbarTopSeparatorColor();
+
+  PaintTabBackgroundUsingFillId(canvas, params);
+}
+
+// static
+// For use by Tab and TabImageSource
+void Tab::PaintTabBackgroundUsingFillId(gfx::Canvas* canvas,
+                                        const PaintBackgroundParams& params) {
+  const SkColor toolbar_color =
+      params.tp->GetColor(ThemeProperties::COLOR_TOOLBAR);
+  gfx::ImageSkia* fill_image = params.tp->GetImageSkiaNamed(params.fill_id);

[oshima, 2016/07/13 20:55:28]

instead of passing tp/fill_id etc, can you just pass

fill_image, tab_color, and hover_color?

[Greg Levin, 2016/07/15 22:24:48]

I'm still constructing TabImageSource with tab and fill_id, but I'm converting
those into fill_image, toolbar_color, and background_color in the TabImageSource
constructor, so that ThemeProvider* isn't stored in the struct.

 
   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(PointToSkPoint(hover_controller_.location()));
+      std::max(SkFloatToScalar(params.size.width() / 4.f), kMinHoverRadius);
+  const bool draw_hover =
+      !params.is_active && params.hc && params.hc->ShouldDraw();

[oshima, 2016/07/13 20:55:28]

you can also just pas nullptr if !ShouldDraw()

[Greg Levin, 2016/07/15 22:24:48]

Done.

+  SkPoint hover_location(
+      PointToSkPoint(draw_hover ? params.hc->location() : gfx::Point()));
   const SkColor hover_color =
-      SkColorSetA(toolbar_color, hover_controller_.GetAlpha());
+      SkColorSetA(toolbar_color, draw_hover ? params.hc->GetAlpha() : 255);
 
   if (ui::MaterialDesignController::IsModeMaterial()) {
     gfx::ScopedCanvas scoped_canvas(canvas);
     const float scale = canvas->UndoDeviceScaleFactor();
 
     // Draw the fill.
     SkPath fill;
-    GetFillPath(scale, &fill);
+    GetFillPath(scale, params.size, &fill);
     SkPaint paint;
     paint.setAntiAlias(true);
     {
       gfx::ScopedCanvas clip_scoper(canvas);
       canvas->ClipPath(fill, true);
-      if (has_custom_image) {
+      if (params.has_custom_image) {
         gfx::ScopedCanvas scale_scoper(canvas);
         canvas->sk_canvas()->scale(scale, scale);
-        canvas->TileImageInt(*fill_image, x_offset, y_offset, 0, 0, width(),
-                             height());
+        canvas->TileImageInt(*fill_image, params.x_offset, params.y_offset, 0,
+                             0, params.size.width(), params.size.height());
       } else {
         paint.setColor(
-            is_active ? toolbar_color
-                      : tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB));
-        canvas->DrawRect(gfx::ScaleToEnclosingRect(GetLocalBounds(), scale),
-                         paint);
+            params.is_active
+                ? toolbar_color
+                : params.tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB));
+        canvas->DrawRect(
+            gfx::ScaleToEnclosingRect(gfx::Rect(params.size), scale), paint);
       }
       if (draw_hover) {
         hover_location.scale(SkFloatToScalar(scale));
         DrawHighlight(canvas, hover_location, radius * scale, hover_color);
       }
     }
 
     // Draw the stroke.
     SkPath stroke;
-    GetBorderPath(scale, false, &stroke);
+    GetBorderPath(scale, params.size, false, &stroke);
     Op(stroke, fill, kDifference_SkPathOp, &stroke);
-    if (!is_active) {
+    if (!params.is_active) {
       // Clip out the bottom line; this will be drawn for us by
       // TabStrip::PaintChildren().
-      canvas->sk_canvas()->clipRect(
-          SkRect::MakeWH(width() * scale, height() * scale - 1));
+      canvas->sk_canvas()->clipRect(SkRect::MakeWH(
+          params.size.width() * scale, params.size.height() * scale - 1));
     }
-    paint.setColor(controller_->GetToolbarTopSeparatorColor());
+    paint.setColor(params.stroke_color);
     canvas->DrawPath(stroke, paint);
   } else {
     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, x_offset, y_offset,
-                   is_active);
+      gfx::Canvas background_canvas(params.size, canvas->image_scale(), false);
+      PaintTabFill(&background_canvas, fill_image, params.x_offset,
+                   params.y_offset, params.size, params.is_active);
       gfx::ImageSkia background_image(background_canvas.ExtractImageRep());
       canvas->DrawImageInt(background_image, 0, 0);
 
-      gfx::Canvas hover_canvas(size(), canvas->image_scale(), false);
+      gfx::Canvas hover_canvas(params.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, x_offset, y_offset, is_active);
+      PaintTabFill(canvas, fill_image, params.x_offset, params.y_offset,

[Greg Levin, 2016/07/12 23:23:45]

I'm a little concerned about this use of x_offset.  As I understand the code,
this block is triggered for non-MD, inactive, unhovered tabs.  In that case,
this function is being called by TabImageSource::Draw, where x_offset = 0, not a
tab-specific value.  On the other hand, it kinda looks like the image painted
and cached here by the old version of the code was using an x_offset specific to
the originating tab, so maybe it's fine.

+                   params.size, params.is_active);
     }
 
     // Now draw the stroke, highlights, and shadows around the tab edge.
-    TabImages* stroke_images = is_active ? &active_images_ : &inactive_images_;
+    TabImages* stroke_images =
+        params.is_active ? &active_images_ : &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());
+        params.size.width() - stroke_images->l_width - stroke_images->r_width,
+        params.size.height());
     canvas->DrawImageInt(*stroke_images->image_r,
-                         width() - stroke_images->r_width, 0);
+                         params.size.width() - stroke_images->r_width, 0);
   }
 }
 
+// static
 void Tab::PaintTabFill(gfx::Canvas* canvas,
                        gfx::ImageSkia* fill_image,
                        int x_offset,
                        int y_offset,
+                       const gfx::Size& size,
                        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, x_offset, y_offset, mask_images_.l_width, height());
+      *fill_image, x_offset, y_offset, mask_images_.l_width, size.height());
   gfx::ImageSkia theme_l =
       gfx::ImageSkiaOperations::CreateMaskedImage(tab_l, *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, x_offset + width() - mask_images_.r_width, y_offset,
-      mask_images_.r_width, height());
+      *fill_image, x_offset + size.width() - mask_images_.r_width, y_offset,
+      mask_images_.r_width, size.height());
   gfx::ImageSkia theme_r =
       gfx::ImageSkiaOperations::CreateMaskedImage(tab_r, *mask_images_.image_r);
   canvas->DrawImageInt(theme_r, 0, 0, theme_r.width(),
                        theme_r.height() - toolbar_overlap,
-                       width() - theme_r.width(), 0, theme_r.width(),
+                       size.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.
-  canvas->TileImageInt(*fill_image, x_offset + mask_images_.l_width,
-                       y_offset + tab_insets.top(), mask_images_.l_width,
-                       tab_insets.top(),
-                       width() - mask_images_.l_width - mask_images_.r_width,
-                       height() - tab_insets.top() - toolbar_overlap);
+  canvas->TileImageInt(
+      *fill_image, x_offset + mask_images_.l_width, y_offset + tab_insets.top(),
+      mask_images_.l_width, tab_insets.top(),
+      size.width() - mask_images_.l_width - mask_images_.r_width,
+      size.height() - tab_insets.top() - toolbar_overlap);
 }
 
 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.
   // . a circle in the bottom right (or left in rtl) of the favicon.
@@ skipping 218 matching lines @@
   if (bounds.IsEmpty())
     return;
 
   // 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);
 }
 
-void Tab::GetFillPath(float scale, SkPath* fill) const {
-  const float right = width() * scale;
+// static
+void Tab::GetFillPath(float scale, const gfx::Size& size, SkPath* fill) {
+  const float right = size.width() * scale;
   // The bottom of the tab needs to be pixel-aligned or else when we call
   // ClipPath with anti-aliasing enabled it can cause artifacts.
-  const float bottom = std::ceil(height() * scale);
+  const float bottom = std::ceil(size.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 - (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 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(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 {
+// static
+void Tab::GetBorderPath(float scale,
+                        const gfx::Size& size,
+                        bool extend_to_top,
+                        SkPath* path) {
   const float top = scale - 1;
-  const float right = width() * scale;
-  const float bottom = height() * scale;
+  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.
@@ skipping 60 matching lines @@
   inactive_images_.image_c = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_CENTER);
   inactive_images_.image_r = rb.GetImageSkiaNamed(IDR_TAB_INACTIVE_RIGHT);
   inactive_images_.l_width = inactive_images_.image_l->width();
   inactive_images_.r_width = inactive_images_.image_r->width();
 
   mask_images_.image_l = rb.GetImageSkiaNamed(IDR_TAB_ALPHA_LEFT);
   mask_images_.image_r = rb.GetImageSkiaNamed(IDR_TAB_ALPHA_RIGHT);
   mask_images_.l_width = mask_images_.image_l->width();
   mask_images_.r_width = mask_images_.image_r->width();
 }