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 53 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";
 
 ////////////////////////////////////////////////////////////////////////////////
+// PaintBackgroundParams
+
+struct PaintBackgroundParams {
+  bool is_active;
+  gfx::ImageSkia fill_image;
+  bool has_custom_image;
+  gfx::Point offset;
+  gfx::Size size;
+  SkColor stroke_color;
+  SkColor toolbar_color;
+  SkColor background_color;
+};
+
+void PaintTabBackgroundUsingFillId(gfx::Canvas* canvas,
+                                   views::GlowHoverController* hc,
+                                   const PaintBackgroundParams& params);
+
+////////////////////////////////////////////////////////////////////////////////
+// TabImageSource
+//
+// This subclass of CanvasImageSource allows the inactive tab image to be cached
+// once and rendered correctly for all scale factors.
+class 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);
+};
+
+TabImageSource::TabImageSource(Tab* tab, int fill_id, int y_offset)
+    : gfx::CanvasImageSource(tab->size(), true) {
+  params_.is_active = false;
+  if (!ui::MaterialDesignController::IsModeMaterial())
+    params_.fill_image = *tab->GetThemeProvider()->GetImageSkiaNamed(fill_id);
+  params_.has_custom_image = false;
+  params_.offset.SetPoint(0, y_offset);
+  params_.size = tab->size();
+  params_.stroke_color = tab->controller()->GetToolbarTopSeparatorColor();
+  params_.toolbar_color =
+      tab->GetThemeProvider()->GetColor(ThemeProperties::COLOR_TOOLBAR);
+  params_.background_color =
+      tab->GetThemeProvider()->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB);
+}
+
+void TabImageSource::Draw(gfx::Canvas* canvas) {
+  PaintTabBackgroundUsingFillId(canvas, nullptr, params_);
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // ImageCacheEntryMetadata
 //
 // All metadata necessary to uniquely identify a cached image.
 struct ImageCacheEntryMetadata {
   ImageCacheEntryMetadata(int resource_id,
                           SkColor fill_color,
                           SkColor stroke_color,
-                          ui::ScaleFactor 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 stroke_color;
-  ui::ScaleFactor scale_factor;
   gfx::Size size;
 };
 
 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;
 }
 
 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 && scale_factor == rhs.scale_factor &&
-         size == rhs.size;
+         stroke_color == rhs.stroke_color && size == rhs.size;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageCacheEntry and cache management
 //
 // A cached image and the metadata used to generate it.
 struct ImageCacheEntry {
   ImageCacheEntry(const ImageCacheEntryMetadata& metadata,
-                  const gfx::ImageSkia& image);
+                  Tab* tab,
+                  int fill_id,
+                  int y_offset);
   ~ImageCacheEntry();
 
   ImageCacheEntryMetadata metadata;
   gfx::ImageSkia image;
 };
 
 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()) {}
 
 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 {
@@ skipping 69 matching lines @@
   canvas->sk_canvas()->drawRect(
       SkRect::MakeXYWH(p.x() - radius, p.y() - radius, radius * 2, radius * 2),
       paint);
 }
 
 // Returns whether the favicon for the given URL should be colored according to
 // the browser theme.
 bool ShouldThemifyFaviconForUrl(const GURL& url) {
   return url.SchemeIs(content::kChromeUIScheme) &&
          url.host() != chrome::kChromeUIHelpHost &&
-         url.host() != chrome::kChromeUIUberHost &&
-         url.host() != chrome::kChromeUIAppLauncherPageHost;
+         url.host() != chrome::kChromeUIUberHost;
 }
 
 // Computes a path corresponding to the tab's content region inside the outer
 // stroke.
 void 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(size.height() * scale);
   const float unscaled_endcap_width = GetUnscaledEndcapWidth();
@@ skipping 56 matching lines @@
                    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();
 }
 
 void PaintTabFill(gfx::Canvas* canvas,
-                  gfx::ImageSkia* fill_image,
+                  const 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, g_mask_images.l_width, size.height());
+      fill_image, x_offset, y_offset, g_mask_images.l_width, size.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, x_offset + size.width() - g_mask_images.r_width, y_offset,
+      fill_image, x_offset + size.width() - g_mask_images.r_width, y_offset,
       g_mask_images.r_width, size.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,
                        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 + g_mask_images.l_width,
-      y_offset + tab_insets.top(), g_mask_images.l_width, tab_insets.top(),
+      fill_image, x_offset + g_mask_images.l_width, y_offset + tab_insets.top(),
+      g_mask_images.l_width, tab_insets.top(),
       size.width() - g_mask_images.l_width - g_mask_images.r_width,
       size.height() - tab_insets.top() - toolbar_overlap);
 }
 
+// For use by Tab and TabImageSource
+void PaintTabBackgroundUsingFillId(gfx::Canvas* canvas,
+                                   views::GlowHoverController* hc,
+                                   const PaintBackgroundParams& params) {
+  const SkScalar kMinHoverRadius = 16;
+  const SkScalar radius =
+      std::max(SkFloatToScalar(params.size.width() / 4.f), kMinHoverRadius);
+  const bool draw_hover = !params.is_active && hc;
+  SkPoint hover_location(
+      PointToSkPoint(draw_hover ? hc->location() : gfx::Point()));
+  const SkColor hover_color =
+      SkColorSetA(params.toolbar_color, draw_hover ? hc->GetAlpha() : 255);
+
+  if (ui::MaterialDesignController::IsModeMaterial()) {
+    gfx::ScopedCanvas scoped_canvas(canvas);
+    const float scale = canvas->UndoDeviceScaleFactor();
+
+    // Draw the fill.
+    SkPath fill;
+    GetFillPath(scale, params.size, &fill);
+    SkPaint paint;
+    paint.setAntiAlias(true);
+    {
+      gfx::ScopedCanvas clip_scoper(canvas);
+      canvas->ClipPath(fill, true);
+      if (params.has_custom_image) {
+        gfx::ScopedCanvas scale_scoper(canvas);
+        canvas->sk_canvas()->scale(scale, scale);
+        canvas->TileImageInt(params.fill_image, params.offset.x(),
+                             params.offset.y(), 0, 0, params.size.width(),
+                             params.size.height());
+      } else {
+        paint.setColor(params.is_active ? params.toolbar_color
+                                        : params.background_color);
+        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, params.size, false, &stroke);
+    Op(stroke, fill, kDifference_SkPathOp, &stroke);
+    if (!params.is_active) {
+      // Clip out the bottom line; this will be drawn for us by
+      // TabStrip::PaintChildren().
+      canvas->sk_canvas()->clipRect(SkRect::MakeWH(
+          params.size.width() * scale, params.size.height() * scale - 1));
+    }
+    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(params.size, canvas->image_scale(), false);
+      PaintTabFill(&background_canvas, params.fill_image, params.offset.x(),
+                   params.offset.y(), params.size, params.is_active);
+      gfx::ImageSkia background_image(background_canvas.ExtractImageRep());
+      canvas->DrawImageInt(background_image, 0, 0);
+
+      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, params.fill_image, params.offset.x(),
+                   params.offset.y(), params.size, params.is_active);
+    }
+
+    // Now draw the stroke, highlights, and shadows around the tab edge.
+    TabImages* stroke_images =
+        params.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,
+        params.size.width() - stroke_images->l_width - stroke_images->r_width,
+        params.size.height());
+    canvas->DrawImageInt(*stroke_images->image_r,
+                         params.size.width() - stroke_images->r_width, 0);
+  }
+}
+
 }  // 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 1044 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(
       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);
-    PaintTabBackgroundUsingFillId(&tmp_canvas, false, fill_id, false, y_offset);
-    g_image_cache->emplace_front(metadata,
-                                 gfx::ImageSkia(tmp_canvas.ExtractImageRep()));
+    g_image_cache->emplace_front(metadata, this, fill_id, y_offset);
     if (g_image_cache->size() > kMaxImageCacheSize)
       g_image_cache->pop_back();
     it = g_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);
+  views::GlowHoverController* hc =
+      hover_controller_.ShouldDraw() ? &hover_controller_ : nullptr;
+  PaintBackgroundParams params;
+  params.is_active = is_active;
+  if (has_custom_image || !ui::MaterialDesignController::IsModeMaterial())
+    params.fill_image = *GetThemeProvider()->GetImageSkiaNamed(fill_id);
+  params.has_custom_image = has_custom_image;

[oshima, 2016/07/28 20:45:48]

you should be able to use fill_image.isNull() to check if it should be drawn.

[Greg Levin, 2016/08/10 20:03:10]

Done.

   // 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.offset.SetPoint(GetMirroredX() + background_offset_.x(), y_offset);
+  params.size = size();
+  params.stroke_color = controller_->GetToolbarTopSeparatorColor();
+  params.toolbar_color =
+      GetThemeProvider()->GetColor(ThemeProperties::COLOR_TOOLBAR);
+  params.background_color =
+      GetThemeProvider()->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB);
 
-  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()));
-  const SkColor hover_color =
-      SkColorSetA(toolbar_color, hover_controller_.GetAlpha());
-
-  if (ui::MaterialDesignController::IsModeMaterial()) {
-    gfx::ScopedCanvas scoped_canvas(canvas);
-    const float scale = canvas->UndoDeviceScaleFactor();
-
-    // Draw the fill.
-    SkPath fill;
-    GetFillPath(scale, size(), &fill);
-    SkPaint paint;
-    paint.setAntiAlias(true);
-    {
-      gfx::ScopedCanvas clip_scoper(canvas);
-      canvas->ClipPath(fill, true);
-      if (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());
-      } else {
-        paint.setColor(
-            is_active ? toolbar_color
-                      : tp->GetColor(ThemeProperties::COLOR_BACKGROUND_TAB));
-        canvas->DrawRect(gfx::ScaleToEnclosingRect(GetLocalBounds(), 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, size(), false, &stroke);
-    Op(stroke, fill, kDifference_SkPathOp, &stroke);
-    if (!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));
-    }
-    paint.setColor(controller_->GetToolbarTopSeparatorColor());
-    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, size(),
-                   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, x_offset, y_offset, size(), 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);
-  }
+  ::PaintTabBackgroundUsingFillId(canvas, hc, params);
 }
 
 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 228 matching lines @@
 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);
 }