use Make instead of Create to return a shared shader

include/core/SkShader.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkShader_DEFINED
 #define SkShader_DEFINED
 
 #include "SkBitmap.h"
 #include "SkFlattenable.h"
 #include "SkImageInfo.h"
 #include "SkMask.h"
 #include "SkMatrix.h"
 #include "SkPaint.h"
 #include "../gpu/GrColor.h"
 
 class SkColorFilter;
 class SkPath;
 class SkPicture;
 class SkXfermode;
 class GrContext;
 class GrFragmentProcessor;
 
+//#define SK_SUPPORT_LEGACY_CREATESHADER_PTR
+
 /** \class SkShader
  *
  *  Shaders specify the source color(s) for what is being drawn. If a paint
  *  has no shader, then the paint's color is used. If the paint has a
  *  shader, then the shader's color(s) are use instead, but they are
  *  modulated by the paint's alpha. This makes it easy to create a shader
  *  once (e.g. bitmap tiling or gradient) and then change its transparency
  *  w/o having to modify the original shader... only the paint's alpha needs
  *  to be modified.
  */
@@ skipping 292 matching lines @@
      *  the colorfilter.
      */
     SkShader* newWithColorFilter(SkColorFilter*) const;
 
     //////////////////////////////////////////////////////////////////////////
     //  Factory methods for stock shaders
     
     /**
      *  Call this to create a new "empty" shader, that will not draw anything.
      */
-    static SkShader* CreateEmptyShader();
+    static sk_sp<SkShader> MakeEmptyShader();
 
     /**
      *  Call this to create a new shader that just draws the specified color. This should always
      *  draw the same as a paint with this color (and no shader).
      */
-    static SkShader* CreateColorShader(SkColor);
+    static sk_sp<SkShader> MakeColorShader(SkColor);
 
-    static SkShader* CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode::Mode);
+    static sk_sp<SkShader> MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
+                                             SkXfermode::Mode);
+
+#ifdef SK_SUPPORT_LEGACY_CREATESHADER_PTR

[mtklein, 2016/03/08 14:49:11]

Wanna make it one more step general to cover all Create methods?

SK_SUPPORT_LEGACY_CREATE_METHODS ?

[reed1, 2016/03/08 15:15:19]

Could. My thought had been that the effort was so large, we might like to have
manageable subpieces (e.g. shaders, xfermodes, images) we could complete
separately, so multiple build flags might be better. Just a thought.

+    static SkShader* CreateEmptyShader() { return MakeEmptyShader().release(); }
+    static SkShader* CreateColorShader(SkColor c) { return MakeColorShader(c).release(); }
+    static SkShader* CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode::Mode mode) {
+        return MakeComposeShader(dst, src, mode).release();
+    }
+    static SkShader* CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode* xfer) {
+        return MakeComposeShader(dst, src, xfer).release();
+    }
+    static SkShader* CreateBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy,
+                                        const SkMatrix* localMatrix = nullptr) {
+        return MakeBitmapShader(src, tmx, tmy, localMatrix).release();
+    }
+    static SkShader* CreatePictureShader(const SkPicture* src, TileMode tmx, TileMode tmy,
+                                         const SkMatrix* localMatrix, const SkRect* tile) {
+        return MakePictureShader(src, tmx, tmy, localMatrix, tile).release();
+    }
+#endif
 
     /**
      *  Create a new compose shader, given shaders dst, src, and a combining xfermode mode.
      *  The xfermode is called with the output of the two shaders, and its output is returned.
      *  If xfer is null, SkXfermode::kSrcOver_Mode is assumed.
      *
      *  Ownership of the shaders, and the xfermode if not null, is not transfered, so the caller

[f(malita), 2016/03/08 15:50:35]

Is the ownership comment still useful?

[reed1, 2016/03/08 20:17:15]

Nope. Will remove.

      *  is still responsible for managing its reference-count for those objects.
      */
-    static SkShader* CreateComposeShader(SkShader* dst, SkShader* src, SkXfermode* xfer);
+    static sk_sp<SkShader> MakeComposeShader(sk_sp<SkShader> dst, sk_sp<SkShader> src,
+                                             SkXfermode* xfer);
 
     /** Call this to create a new shader that will draw with the specified bitmap.
      *
      *  If the bitmap cannot be used (e.g. has no pixels, or its dimensions
      *  exceed implementation limits (currently at 64K - 1)) then SkEmptyShader
      *  may be returned.
      *
      *  If the src is kA8_Config then that mask will be colorized using the color on
      *  the paint.
      *
      *  @param src  The bitmap to use inside the shader
      *  @param tmx  The tiling mode to use when sampling the bitmap in the x-direction.
      *  @param tmy  The tiling mode to use when sampling the bitmap in the y-direction.
      *  @return     Returns a new shader object. Note: this function never returns null.
     */
-    static SkShader* CreateBitmapShader(const SkBitmap& src,
-                                        TileMode tmx, TileMode tmy,
-                                        const SkMatrix* localMatrix = NULL);
+    static sk_sp<SkShader> MakeBitmapShader(const SkBitmap& src, TileMode tmx, TileMode tmy,
+                                            const SkMatrix* localMatrix = nullptr);
 
     // NOTE: You can create an SkImage Shader with SkImage::newShader().
 
     /** Call this to create a new shader that will draw with the specified picture.
      *
      *  @param src  The picture to use inside the shader (if not NULL, its ref count
      *              is incremented). The SkPicture must not be changed after
      *              successfully creating a picture shader.
      *  @param tmx  The tiling mode to use when sampling the bitmap in the x-direction.
      *  @param tmy  The tiling mode to use when sampling the bitmap in the y-direction.
      *  @param tile The tile rectangle in picture coordinates: this represents the subset
      *              (or superset) of the picture used when building a tile. It is not
      *              affected by localMatrix and does not imply scaling (only translation
      *              and cropping). If null, the tile rect is considered equal to the picture
      *              bounds.
      *  @return     Returns a new shader object. Note: this function never returns null.
     */
-    static SkShader* CreatePictureShader(const SkPicture* src,
-                                         TileMode tmx, TileMode tmy,
-                                         const SkMatrix* localMatrix,
-                                         const SkRect* tile);
+    static sk_sp<SkShader> MakePictureShader(const SkPicture* src, TileMode tmx, TileMode tmy,
+                                             const SkMatrix* localMatrix, const SkRect* tile);
 
     /**
      *  If this shader can be represented by another shader + a localMatrix, return that shader
      *  and, if not NULL, the localMatrix. If not, return NULL and ignore the localMatrix parameter.
      *
      *  Note: the returned shader (if not NULL) will have been ref'd, and it is the responsibility
      *  of the caller to balance that with unref() when they are done.
      */
     virtual SkShader* refAsALocalMatrixShader(SkMatrix* localMatrix) const;
 
@@ skipping 31 matching lines @@
     SkMatrix fLocalMatrix;
 
     // So the SkLocalMatrixShader can whack fLocalMatrix in its SkReadBuffer constructor.
     friend class SkLocalMatrixShader;
     friend class SkBitmapProcShader;    // for computeTotalInverse()
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif