cc: Move SkShader construction to a single spot in PaintShader

third_party/WebKit/Source/platform/graphics/Gradient.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 103 matching lines @@
 
   // Copy the last stop to 1.0 if needed. See comment above about this float
   // comparison.
   DCHECK(!pos.IsEmpty());
   if (pos.back() < 1) {
     pos.push_back(WebCoreFloatToSkScalar(1));
     colors.push_back(colors.back());
   }
 }
 
-sk_sp<PaintShader> Gradient::CreateShaderInternal(
+std::unique_ptr<PaintShader> Gradient::CreateShaderInternal(
     const SkMatrix& local_matrix) {
   SortStopsIfNecessary();
   DCHECK(stops_sorted_);
 
   ColorBuffer colors;
   colors.ReserveCapacity(stops_.size());
   OffsetBuffer pos;
   pos.ReserveCapacity(stops_.size());
 
   FillSkiaStops(colors, pos);
   DCHECK_GE(colors.size(), 2ul);
   DCHECK_EQ(pos.size(), colors.size());
 
   SkShader::TileMode tile = SkShader::kClamp_TileMode;
   switch (spread_method_) {
     case kSpreadMethodReflect:
       tile = SkShader::kMirror_TileMode;
       break;
     case kSpreadMethodRepeat:
       tile = SkShader::kRepeat_TileMode;
       break;
     case kSpreadMethodPad:
       tile = SkShader::kClamp_TileMode;
       break;
   }
 
   uint32_t flags = color_interpolation_ == ColorInterpolation::kPremultiplied
                        ? SkGradientShader::kInterpolateColorsInPremul_Flag
                        : 0;
-  sk_sp<SkShader> shader = CreateShader(colors, pos, tile, flags, local_matrix);
-  if (!shader) {
+  std::unique_ptr<PaintShader> shader =
+      CreateShader(colors, pos, tile, flags, local_matrix);
+  if (!shader || !shader->is_valid()) {
     // use last color, since our "geometry" was degenerate (e.g. radius==0)
-    shader = SkShader::MakeColorShader(colors.back());
+    shader = WTF::MakeUnique<PaintShader>(colors.back());
   }
 
-  return WrapSkShader(std::move(shader));
+  return shader;
 }
 
 void Gradient::ApplyToFlags(PaintFlags& flags, const SkMatrix& local_matrix) {
-  if (!cached_shader_ || local_matrix != cached_shader_->getLocalMatrix())
+  if (!cached_shader_ ||
+      local_matrix != cached_shader_->sk_shader()->getLocalMatrix()) {
     cached_shader_ = CreateShaderInternal(local_matrix);
+  }
 
-  flags.setShader(cached_shader_);
+  flags.setShader(WTF::MakeUnique<PaintShader>(*cached_shader_));

[enne (OOO), 2017/05/23 18:55:02]

This line is probably the one that's most concerning to me, largely because I'm
not sure I understand what this code will do in the future.  In the future there
won't be an underlying sk_shader and so every shader type will just construct a
copy of itself?

I guess I'm not sure I understand what the goal of caching these shaders will
be, other than avoiding SkShader creation.

 
   // Legacy behavior: gradients are always dithered.
   flags.setDither(true);
 }
 
 namespace {
 
 class LinearGradient final : public Gradient {
  public:
   LinearGradient(const FloatPoint& p0,
                  const FloatPoint& p1,
                  GradientSpreadMethod spread_method,
                  ColorInterpolation interpolation)
       : Gradient(Type::kLinear, spread_method, interpolation),
         p0_(p0),
         p1_(p1) {}
 
  protected:
-  sk_sp<SkShader> CreateShader(const ColorBuffer& colors,
-                               const OffsetBuffer& pos,
-                               SkShader::TileMode tile_mode,
-                               uint32_t flags,
-                               const SkMatrix& local_matrix) const override {
+  std::unique_ptr<PaintShader> CreateShader(
+      const ColorBuffer& colors,
+      const OffsetBuffer& pos,
+      SkShader::TileMode tile_mode,
+      uint32_t flags,
+      const SkMatrix& local_matrix) const override {
     SkPoint pts[2] = {p0_.Data(), p1_.Data()};
-    return SkGradientShader::MakeLinear(pts, colors.data(), pos.data(),
+    return WTF::MakeUnique<PaintShader>(pts, colors.data(), pos.data(),
                                         static_cast<int>(colors.size()),
                                         tile_mode, flags, &local_matrix);
   }
 
  private:
   const FloatPoint p0_;
   const FloatPoint p1_;
 };
 
 class RadialGradient final : public Gradient {
  public:
   RadialGradient(const FloatPoint& p0,
                  float r0,
                  const FloatPoint& p1,
                  float r1,
                  float aspect_ratio,
                  GradientSpreadMethod spread_method,
                  ColorInterpolation interpolation)
       : Gradient(Type::kRadial, spread_method, interpolation),
         p0_(p0),
         p1_(p1),
         r0_(r0),
         r1_(r1),
         aspect_ratio_(aspect_ratio) {}
 
  protected:
-  sk_sp<SkShader> CreateShader(const ColorBuffer& colors,
-                               const OffsetBuffer& pos,
-                               SkShader::TileMode tile_mode,
-                               uint32_t flags,
-                               const SkMatrix& local_matrix) const override {
+  std::unique_ptr<PaintShader> CreateShader(
+      const ColorBuffer& colors,
+      const OffsetBuffer& pos,
+      SkShader::TileMode tile_mode,
+      uint32_t flags,
+      const SkMatrix& local_matrix) const override {
     SkTCopyOnFirstWrite<SkMatrix> adjusted_local_matrix(local_matrix);
     if (aspect_ratio_ != 1) {
       // CSS3 elliptical gradients: apply the elliptical scaling at the
       // gradient center point.
       DCHECK(p0_ == p1_);
       adjusted_local_matrix.writable()->preScale(1, 1 / aspect_ratio_, p0_.X(),
                                                  p0_.Y());
     }
 
     // Since the two-point radial gradient is slower than the plain radial,
     // only use it if we have to.
     if (p0_ == p1_ && r0_ <= 0.0f) {
-      return SkGradientShader::MakeRadial(
+      return WTF::MakeUnique<PaintShader>(
           p1_.Data(), r1_, colors.data(), pos.data(),
           static_cast<int>(colors.size()), tile_mode, flags,
           adjusted_local_matrix);
     }
 
     // The radii we give to Skia must be positive. If we're given a
     // negative radius, ask for zero instead.
     const SkScalar radius0 = std::max(WebCoreFloatToSkScalar(r0_), 0.0f);
     const SkScalar radius1 = std::max(WebCoreFloatToSkScalar(r1_), 0.0f);
-    return SkGradientShader::MakeTwoPointConical(
+    return WTF::MakeUnique<PaintShader>(
         p0_.Data(), radius0, p1_.Data(), radius1, colors.data(), pos.data(),
         static_cast<int>(colors.size()), tile_mode, flags,
         adjusted_local_matrix);
   }
 
  private:
   const FloatPoint p0_;
   const FloatPoint p1_;
   const float r0_;
   const float r1_;
   const float aspect_ratio_;  // For elliptical gradient, width / height.
 };
 
 class ConicGradient final : public Gradient {
  public:
   ConicGradient(const FloatPoint& position,
                 float angle,
                 ColorInterpolation interpolation)
       : Gradient(Type::kConic, kSpreadMethodPad, interpolation),
         position_(position),
         angle_(angle) {}
 
  protected:
-  sk_sp<SkShader> CreateShader(const ColorBuffer& colors,
-                               const OffsetBuffer& pos,
-                               SkShader::TileMode tile_mode,
-                               uint32_t flags,
-                               const SkMatrix& local_matrix) const override {
+  std::unique_ptr<PaintShader> CreateShader(
+      const ColorBuffer& colors,
+      const OffsetBuffer& pos,
+      SkShader::TileMode tile_mode,
+      uint32_t flags,
+      const SkMatrix& local_matrix) const override {
     DCHECK_NE(tile_mode, SkShader::kMirror_TileMode);
 
     // Skia's sweep gradient angles are relative to the x-axis, not the y-axis.
     const float skia_angle = angle_ - 90;
     SkTCopyOnFirstWrite<SkMatrix> adjusted_local_matrix(local_matrix);
     if (skia_angle) {
       adjusted_local_matrix.writable()->preRotate(skia_angle, position_.X(),
                                                   position_.Y());
     }
 
-    return SkGradientShader::MakeSweep(
+    return WTF::MakeUnique<PaintShader>(
         position_.X(), position_.Y(), colors.data(), pos.data(),
         static_cast<int>(colors.size()), flags, adjusted_local_matrix);
   }
 
  private:
   const FloatPoint position_;
   const float angle_;
 };
 
 }  // anonymous ns
@@ skipping 16 matching lines @@
                                      spread_method, interpolation));
 }
 
 PassRefPtr<Gradient> Gradient::CreateConic(const FloatPoint& position,
                                            float angle,
                                            ColorInterpolation interpolation) {
   return AdoptRef(new ConicGradient(position, angle, interpolation));
 }
 
 }  // namespace blink