cc: Move SkShader construction to a single spot in PaintShader

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

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, 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.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 209 matching lines @@
   } else {
     DrawPattern(ctxt, src_rect, tile_scale_factor, pattern_phase, op, dst_rect,
                 spacing);
   }
 
   StartAnimation();
 }
 
 namespace {
 
-sk_sp<PaintShader> CreatePatternShader(const PaintImage& image,
-                                       const SkMatrix& shader_matrix,
-                                       const PaintFlags& paint,
-                                       const FloatSize& spacing,
-                                       SkShader::TileMode tmx,
-                                       SkShader::TileMode tmy) {
-  if (spacing.IsZero())
-    return MakePaintShaderImage(image.sk_image(), tmx, tmy, &shader_matrix);
+std::unique_ptr<PaintShader> CreatePatternShader(const PaintImage& image,
+                                                 const SkMatrix& shader_matrix,
+                                                 const PaintFlags& paint,
+                                                 const FloatSize& spacing,
+                                                 SkShader::TileMode tmx,
+                                                 SkShader::TileMode tmy) {
+  if (spacing.IsZero()) {
+    return WTF::MakeUnique<PaintShader>(image.sk_image(), tmx, tmy,
+                                        &shader_matrix);
+  }
 
   // Arbitrary tiling is currently only supported for SkPictureShader, so we use
   // that instead of a plain bitmap shader to implement spacing.
   const SkRect tile_rect =
       SkRect::MakeWH(image.sk_image()->width() + spacing.Width(),
                      image.sk_image()->height() + spacing.Height());
 
   PaintRecorder recorder;
   PaintCanvas* canvas = recorder.beginRecording(tile_rect);
   canvas->drawImage(image, 0, 0, &paint);
 
-  return MakePaintShaderRecord(recorder.finishRecordingAsPicture(), tmx, tmy,
-                               &shader_matrix, nullptr);
+  return WTF::MakeUnique<PaintShader>(recorder.finishRecordingAsPicture(), tmx,
+                                      tmy, &shader_matrix, nullptr);
 }
 
 SkShader::TileMode ComputeTileMode(float left,
                                    float right,
                                    float min,
                                    float max) {
   DCHECK(left < right);
   return left >= min && right <= max ? SkShader::kClamp_TileMode
                                      : SkShader::kRepeat_TileMode;
 }
@@ skipping 59 matching lines @@
       context.ComputeFilterQuality(this, dest_rect, norm_src_rect));
   flags.setAntiAlias(context.ShouldAntialias());
   flags.setShader(
       CreatePatternShader(image, local_matrix, flags,
                           FloatSize(repeat_spacing.Width() / scale.Width(),
                                     repeat_spacing.Height() / scale.Height()),
                           tmx, tmy));
   // If the shader could not be instantiated (e.g. non-invertible matrix),
   // draw transparent.
   // Note: we can't simply bail, because of arbitrary blend mode.
-  if (!flags.getShader())
+  if (!flags.HasShader())
     flags.setColor(SK_ColorTRANSPARENT);
 
   context.DrawRect(dest_rect, flags);
 
   if (CurrentFrameIsLazyDecoded())
     PlatformInstrumentation::DidDrawLazyPixelRef(image_id);
 }
 
 PassRefPtr<Image> Image::ImageForDefaultFrame() {
   RefPtr<Image> image(this);
@@ skipping 11 matching lines @@
                     completion_state);
 }
 
 bool Image::ApplyShader(PaintFlags& flags, const SkMatrix& local_matrix) {
   // Default shader impl: attempt to build a shader based on the current frame
   // SkImage.
   sk_sp<SkImage> image = ImageForCurrentFrame();
   if (!image)
     return false;
 
-  flags.setShader(image->makeShader(SkShader::kRepeat_TileMode,
-                                    SkShader::kRepeat_TileMode, &local_matrix));
-  if (!flags.getShader())
+  flags.setShader(
+      WTF::MakeUnique<PaintShader>(std::move(image), SkShader::kRepeat_TileMode,
+                                   SkShader::kRepeat_TileMode, &local_matrix));
+  if (!flags.HasShader())
     return false;
 
   // Animation is normally refreshed in draw() impls, which we don't call when
   // painting via shaders.
   StartAnimation();
 
   return true;
 }
 
 FloatRect Image::ComputeTileContaining(const FloatPoint& point,
@@ skipping 23 matching lines @@
   FloatRect subset = dest;
   subset.SetX((dest.X() - tile.X()) / scale.Width());
   subset.SetY((dest.Y() - tile.Y()) / scale.Height());
   subset.SetWidth(dest.Width() / scale.Width());
   subset.SetHeight(dest.Height() / scale.Height());
 
   return subset;
 }
 
 }  // namespace blink