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/11 15:31:11]

First off, this has to be 'const sk_sp<const SkImage>&' or it won't work with
rvalues (for example canvas->drawImage(CreateImage(...)) won't work).


Even with this change, I don't think this works well with the common case of

sk_sp<SkImage> foo = ...;
canvas->drawImage(foo, ...);

The issue is that sk_sp<SkImage> and sk_sp<const SkImage> are distinct types, so
a conversion is required. Since foo is an lvalue, the compiler uses the
'is_convertible' copy-like constructor to create a temporary sk_sp<const
SkImage>. This means at the call site there will be a ref-unref pair around
making this call.

[bungeman-skia, 2016/03/11 16:03:39]

Writing this declaration as

template <typename T> skstd::enable_if_t<std::is_convertible<T, sk_sp<const
SkImage>>::value, void> drawImage(...)

does work around the whole making a copy thing, though I'm not sure that's the
kind of solution you want. This essentially says that if you could have created
a temporary sk_sp from what you had, just pass me what you had instead.



I was just thinking that with generics like in Java this concept would be
written something like

drawImage(const sk_sp<? extends const SkImage>&, ...)

but that only works in Java because they don't have templates or template
specialization.

+                   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