add setter on SkPaint that takes sk_sp

include/core/SkPaint.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 SkPaint_DEFINED
 #define SkPaint_DEFINED
 
@@ skipping 458 matching lines @@
 
     bool getFillPath(const SkPath& src, SkPath* dst) const {
         return this->getFillPath(src, dst, NULL, 1);
     }
 
     /** Get the paint's shader object.
         <p />
       The shader's reference count is not affected.
         @return the paint's shader (or NULL)
     */
-    SkShader* getShader() const { return fShader; }
+    SkShader* getShader() const { return fShader.get(); }
 
     /** Set or clear the shader object.
      *  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.
      *
      *  There is an exception to this only-respect-paint's-alpha rule: If the shader only generates
      *  alpha (e.g. SkShader::CreateBitmapShader(bitmap, ...) where bitmap's colortype is kAlpha_8)
      *  then the shader will use the paint's entire color to "colorize" its output (modulating the
      *  bitmap's alpha with the paint's color+alpha).
      *
      *  Pass NULL to clear any previous shader.
      *  As a convenience, the parameter passed is also returned.
      *  If a previous shader exists, its reference count is decremented.
      *  If shader is not NULL, its reference count is incremented.
      *  @param shader   May be NULL. The shader to be installed in the paint
      *  @return         shader
      */
     SkShader* setShader(SkShader* shader);
+    void setShader(sk_sp<SkShader>);
 
     /** Get the paint's colorfilter. If there is a colorfilter, its reference
         count is not changed.
         @return the paint's colorfilter (or NULL)
     */
-    SkColorFilter* getColorFilter() const { return fColorFilter; }
+    SkColorFilter* getColorFilter() const { return fColorFilter.get(); }
 
     /** Set or clear the paint's colorfilter, returning the parameter.
         <p />
         If the paint already has a filter, its reference count is decremented.
         If filter is not NULL, its reference count is incremented.
         @param filter   May be NULL. The filter to be installed in the paint
         @return         filter
     */
     SkColorFilter* setColorFilter(SkColorFilter* filter);
+    void setColorFilter(sk_sp<SkColorFilter>);
 
     /** Get the paint's xfermode object.
         <p />
       The xfermode's reference count is not affected.
         @return the paint's xfermode (or NULL)
     */
-    SkXfermode* getXfermode() const { return fXfermode; }
+    SkXfermode* getXfermode() const { return fXfermode.get(); }
 
     /** Set or clear the xfermode object.
         <p />
         Pass NULL to clear any previous xfermode.
         As a convenience, the parameter passed is also returned.
         If a previous xfermode exists, its reference count is decremented.
         If xfermode is not NULL, its reference count is incremented.
         @param xfermode May be NULL. The new xfermode to be installed in the
                         paint
         @return         xfermode
     */
     SkXfermode* setXfermode(SkXfermode* xfermode);
+    void setXfermode(sk_sp<SkXfermode>);
 
     /** Create an xfermode based on the specified Mode, and assign it into the
         paint, returning the mode that was set. If the Mode is SrcOver, then
         the paint's xfermode is set to null.
      */
     SkXfermode* setXfermodeMode(SkXfermode::Mode);
 
     /** Get the paint's patheffect object.
         <p />
       The patheffect reference count is not affected.
         @return the paint's patheffect (or NULL)
     */
-    SkPathEffect* getPathEffect() const { return fPathEffect; }
+    SkPathEffect* getPathEffect() const { return fPathEffect.get(); }
 
     /** Set or clear the patheffect object.
         <p />
         Pass NULL to clear any previous patheffect.
         As a convenience, the parameter passed is also returned.
         If a previous patheffect exists, its reference count is decremented.
         If patheffect is not NULL, its reference count is incremented.
         @param effect   May be NULL. The new patheffect to be installed in the
                         paint
         @return         effect
     */
     SkPathEffect* setPathEffect(SkPathEffect* effect);
+    void setPathEffect(sk_sp<SkPathEffect>);
 
     /** Get the paint's maskfilter object.
         <p />
       The maskfilter reference count is not affected.
         @return the paint's maskfilter (or NULL)
     */
-    SkMaskFilter* getMaskFilter() const { return fMaskFilter; }
+    SkMaskFilter* getMaskFilter() const { return fMaskFilter.get(); }
 
     /** Set or clear the maskfilter object.
         <p />
         Pass NULL to clear any previous maskfilter.
         As a convenience, the parameter passed is also returned.
         If a previous maskfilter exists, its reference count is decremented.
         If maskfilter is not NULL, its reference count is incremented.
         @param maskfilter   May be NULL. The new maskfilter to be installed in
                             the paint
         @return             maskfilter
     */
     SkMaskFilter* setMaskFilter(SkMaskFilter* maskfilter);
+    void setMaskFilter(sk_sp<SkMaskFilter>);
 
     // These attributes are for text/fonts
 
     /** Get the paint's typeface object.
         <p />
         The typeface object identifies which font to use when drawing or
         measuring text. The typeface reference count is not affected.
         @return the paint's typeface (or NULL)
     */
-    SkTypeface* getTypeface() const { return fTypeface; }
+    SkTypeface* getTypeface() const { return fTypeface.get(); }
 
     /** Set or clear the typeface object.
         <p />
         Pass NULL to clear any previous typeface.
         As a convenience, the parameter passed is also returned.
         If a previous typeface exists, its reference count is decremented.
         If typeface is not NULL, its reference count is incremented.
         @param typeface May be NULL. The new typeface to be installed in the
                         paint
         @return         typeface
     */
     SkTypeface* setTypeface(SkTypeface* typeface);
+    void setTypeface(sk_sp<SkTypeface>);
 
     /** Get the paint's rasterizer (or NULL).
         <p />
         The raster controls how paths/text are turned into alpha masks.
         @return the paint's rasterizer (or NULL)
     */
-    SkRasterizer* getRasterizer() const { return fRasterizer; }
+    SkRasterizer* getRasterizer() const { return fRasterizer.get(); }
 
     /** Set or clear the rasterizer object.
         <p />
         Pass NULL to clear any previous rasterizer.
         As a convenience, the parameter passed is also returned.
         If a previous rasterizer exists in the paint, its reference count is
         decremented. If rasterizer is not NULL, its reference count is
         incremented.
         @param rasterizer May be NULL. The new rasterizer to be installed in
                           the paint.
         @return           rasterizer
     */
     SkRasterizer* setRasterizer(SkRasterizer* rasterizer);
+    void setRasterizer(sk_sp<SkRasterizer>);
 
-    SkImageFilter* getImageFilter() const { return fImageFilter; }
+    SkImageFilter* getImageFilter() const { return fImageFilter.get(); }
     SkImageFilter* setImageFilter(SkImageFilter*);
+    void setImageFilter(sk_sp<SkImageFilter>);
 
     /**
      *  Return the paint's SkDrawLooper (if any). Does not affect the looper's
      *  reference count.
      */
-    SkDrawLooper* getLooper() const { return fLooper; }
+    SkDrawLooper* getLooper() const { return fLooper.get(); }
 
     /**
      *  Set or clear the looper object.
      *  <p />
      *  Pass NULL to clear any previous looper.
      *  As a convenience, the parameter passed is also returned.
      *  If a previous looper exists in the paint, its reference count is
      *  decremented. If looper is not NULL, its reference count is
      *  incremented.
      *  @param looper May be NULL. The new looper to be installed in the paint.
      *  @return looper
      */
     SkDrawLooper* setLooper(SkDrawLooper* looper);
+    void setLooper(sk_sp<SkDrawLooper>);
 
     enum Align {
         kLeft_Align,
         kCenter_Align,
         kRight_Align,
     };
     enum {
         kAlignCount = 3
     };
 
@@ skipping 364 matching lines @@
 
     SkMatrix* setTextMatrix(SkMatrix* matrix) const {
         return SetTextMatrix(matrix, fTextSize, fTextScaleX, fTextSkewX);
     }
 
     typedef const SkGlyph& (*GlyphCacheProc)(SkGlyphCache*, const char**);
 
     SK_TO_STRING_NONVIRT()
 
 private:
-    SkTypeface*     fTypeface;
-    SkPathEffect*   fPathEffect;
-    SkShader*       fShader;
-    SkXfermode*     fXfermode;
-    SkMaskFilter*   fMaskFilter;
-    SkColorFilter*  fColorFilter;
-    SkRasterizer*   fRasterizer;
-    SkDrawLooper*   fLooper;
-    SkImageFilter*  fImageFilter;
+    sk_sp<SkTypeface>     fTypeface;
+    sk_sp<SkPathEffect>   fPathEffect;
+    sk_sp<SkShader>       fShader;
+    sk_sp<SkXfermode>     fXfermode;
+    sk_sp<SkMaskFilter>   fMaskFilter;
+    sk_sp<SkColorFilter>  fColorFilter;
+    sk_sp<SkRasterizer>   fRasterizer;
+    sk_sp<SkDrawLooper>   fLooper;
+    sk_sp<SkImageFilter>  fImageFilter;
 
     SkScalar        fTextSize;
     SkScalar        fTextScaleX;
     SkScalar        fTextSkewX;
     SkColor         fColor;
     SkScalar        fWidth;
     SkScalar        fMiterLimit;
     union {
         struct {
             // all of these bitfields should add up to 32
@@ skipping 89 matching lines @@
     friend class GrStencilAndCoverTextContext;
     friend class GrPathRendering;
     friend class GrTextUtils;
     friend class GrGLPathRendering;
     friend class SkScalerContext;
     friend class SkTextBaseIter;
     friend class SkCanonicalizePaint;
 };
 
 #endif