Allow const& for SkImages and SkPictures in draw methods.

include/core/SkCanvas.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 SkCanvas_DEFINED
 #define SkCanvas_DEFINED
 
@@ skipping 754 matching lines @@
 
     /** Draw the specified image, with its top/left corner at (x,y), using the
         specified paint, transformed by the current matrix.
 
         @param image    The image to be drawn
         @param left     The position of the left side of the image being drawn
         @param top      The position of the top side of the image being drawn
         @param paint    The paint used to draw the image, or NULL
      */
     void drawImage(const SkImage* image, SkScalar left, SkScalar top, const SkPaint* paint = NULL);
+    void drawImage(sk_sp<const SkImage> image, SkScalar left, SkScalar top,

[bungeman-skia, 2016/03/10 22:14:01]

Taking the sk_sp by value here means you're taking ownership (creating or moving
a ref). When the parameter goes out of scope then it will be released, causing
churn. I don't think that was intended. I think you want another signature that
takes one of these by reference? Maybe it's clearer to just pass the pointer
only to indicate that this doesn't take ownership?

[bsalomon, 2016/03/10 22:22:16]

Is there a downside to a const sk_sp<const>& param? Seems like life will get
annoying if we have to say drawImage(image.get()) all the time.

Until the transition is complete we will have methods that take a ptr and do
take ownership so I'm not sure it has an unambiguous meaning.

[bungeman-skia, 2016/03/10 23:06:14]

We would need two signatures, one for "const sk_sp<const>& param" and one for
"sk_sp<const>&& param". One could do this with templates and universal
references like

template <typename T> SK_WHEN(is_same<T, sk_sp<const SkImage>>::value, void)
drawImage(T&& image)

or something like that.

+                   const SkPaint* paint = NULL) {
+        this->drawImage(image.get(), left, top, paint);
+    }
 
     /**
      *  Controls the behavior at the edge of the src-rect, when specified in drawImageRect,
      *  trading off speed for exactness.
      *
      *  When filtering is enabled (in the Paint), skia may need to sample in a neighborhood around
      *  the pixels in the image. If there is a src-rect specified, it is intended to restrict the
      *  pixels that will be read. However, for performance reasons, some implementations may slow
      *  down if they cannot read 1-pixel past the src-rect boundary at times.
      *
@@ skipping 31 matching lines @@
     void drawImageRect(const SkImage* image, const SkRect& src, const SkRect& dst,
                        const SkPaint* paint,
                        SrcRectConstraint constraint = kStrict_SrcRectConstraint);
     // variant that takes src SkIRect
     void drawImageRect(const SkImage* image, const SkIRect& isrc, const SkRect& dst,
                        const SkPaint* paint, SrcRectConstraint = kStrict_SrcRectConstraint);
     // variant that assumes src == image-bounds
     void drawImageRect(const SkImage* image, const SkRect& dst, const SkPaint* paint,
                        SrcRectConstraint = kStrict_SrcRectConstraint);
 
+    void drawImageRect(sk_sp<const SkImage> image, const SkRect& src, const SkRect& dst,
+                       const SkPaint* paint,
+                       SrcRectConstraint constraint = kStrict_SrcRectConstraint) {
+        this->drawImageRect(image.get(), src, dst, paint, constraint);
+    }
+    void drawImageRect(sk_sp<const SkImage> image, const SkIRect& isrc, const SkRect& dst,
+                       const SkPaint* paint, SrcRectConstraint cons = kStrict_SrcRectConstraint) {
+        this->drawImageRect(image.get(), isrc, dst, paint, cons);
+    }
+    void drawImageRect(sk_sp<const SkImage> image, const SkRect& dst, const SkPaint* paint,
+                       SrcRectConstraint cons = kStrict_SrcRectConstraint) {
+        this->drawImageRect(image.get(), dst, paint, cons);
+    }
+
     /**
      *  Draw the image stretched differentially to fit into dst.
      *  center is a rect within the image, and logically divides the image
      *  into 9 sections (3x3). For example, if the middle pixel of a [5x5]
      *  image is the "center", then the center-rect should be [2, 2, 3, 3].
      *
      *  If the dst is >= the image size, then...
      *  - The 4 corners are not stretched at all.
      *  - The sides are stretched in only one axis.
      *  - The center is stretched in both axes.
      * Else, for each axis where dst < image,
      *  - The corners shrink proportionally
      *  - The sides (along the shrink axis) and center are not drawn
      */
     void drawImageNine(const SkImage*, const SkIRect& center, const SkRect& dst,
-                        const SkPaint* paint = NULL);
+                       const SkPaint* paint = nullptr);
+    void drawImageNine(sk_sp<const SkImage> image, const SkIRect& center, const SkRect& dst,
+                       const SkPaint* paint = nullptr) {
+        this->drawImageNine(image.get(), center, dst, paint);
+    }
 
     /** Draw the specified bitmap, with its top/left corner at (x,y), using the
         specified paint, transformed by the current matrix. Note: if the paint
         contains a maskfilter that generates a mask which extends beyond the
         bitmap's original width/height, then the bitmap will be drawn as if it
         were in a Shader with CLAMP mode. Thus the color outside of the original
         width/height will be the edge color replicated.
 
         If a shader is present on the paint it will be ignored, except in the
         case where the bitmap is kAlpha_8_SkColorType. In that case, the color is
@@ skipping 206 matching lines @@
      */
     void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
                    const SkColor colors[], int count, SkXfermode::Mode, const SkRect* cullRect,
                    const SkPaint* paint);
 
     void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], int count,
                    const SkRect* cullRect, const SkPaint* paint) {
         this->drawAtlas(atlas, xform, tex, NULL, count, SkXfermode::kDst_Mode, cullRect, paint);
     }
 
+    void drawAtlas(sk_sp<const SkImage> atlas, const SkRSXform xform[], const SkRect tex[],
+                   const SkColor colors[], int count, SkXfermode::Mode mode, const SkRect* cull,
+                   const SkPaint* paint) {
+        this->drawAtlas(atlas.get(), xform, tex, colors, count, mode, cull, paint);
+    }
+    void drawAtlas(sk_sp<const SkImage> atlas, const SkRSXform xform[], const SkRect tex[],
+                   int count, const SkRect* cullRect, const SkPaint* paint) {
+        this->drawAtlas(atlas.get(), xform, tex, nullptr, count, SkXfermode::kDst_Mode,
+                        cullRect, paint);
+    }
+
     /**
      *  Draw the contents of this drawable into the canvas. If the canvas is async
      *  (e.g. it is recording into a picture) then the drawable will be referenced instead,
      *  to have its draw() method called when the picture is finalized.
      *
      *  If the intent is to force the contents of the drawable into this canvas immediately,
      *  then drawable->draw(canvas) may be called.
      */
     void drawDrawable(SkDrawable* drawable, const SkMatrix* = NULL);
     void drawDrawable(SkDrawable*, SkScalar x, SkScalar y);
@@ skipping 434 matching lines @@
 
 class SkCanvasClipVisitor {
 public:
     virtual ~SkCanvasClipVisitor();
     virtual void clipRect(const SkRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipRRect(const SkRRect&, SkRegion::Op, bool antialias) = 0;
     virtual void clipPath(const SkPath&, SkRegion::Op, bool antialias) = 0;
 };
 
 #endif