flag to use const& instead of const* for src-rect

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 19 matching lines @@
 class SkMetaData;
 class SkPath;
 class SkPicture;
 class SkPixmap;
 class SkRRect;
 struct SkRSXform;
 class SkSurface;
 class SkSurface_Base;
 class SkTextBlob;
 
+//#define SK_SUPPORT_LEGACY_SIMPLE_DRAWIMAGERECT
+//#define SK_SUPPORT_LEGACY_SRCPTR_DRAWIMAGERECT
+
 /** \class SkCanvas
 
     A Canvas encapsulates all of the state about drawing into a device (bitmap).
     This includes a reference to the device itself, and a stack of matrix/clip
     values. For any given draw call (e.g. drawRect), the geometry of the object
     being drawn is transformed by the concatenation of all the matrices in the
     stack. The transformed geometry is clipped by the intersection of all of
     the clips in the stack.
 
     While the Canvas holds the state of the drawing device, the state (style)
@@ skipping 762 matching lines @@
      *  dst rect. If the src rect is non-null, only that subset of the image is transformed
      *  and drawn.
      *
      *  @param image      The image to be drawn
      *  @param src        Optional: specify the subset of the image to be drawn
      *  @param dst        The destination rectangle where the scaled/translated
      *                    image will be drawn
      *  @param paint      The paint used to draw the image, or NULL
      *  @param constraint Control the tradeoff between speed and exactness w.r.t. the src-rect.
      */
+    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
+#ifdef SK_SUPPORT_LEGACY_SIMPLE_DRAWIMAGERECT
+    void drawImageRect(const SkImage* image, const SkRect& dst, const SkPaint* paint = NULL);
+#else
+    void drawImageRect(const SkImage* image, const SkRect& dst, const SkPaint* paint,
+                       SrcRectConstraint = kStrict_SrcRectConstraint);
+#endif
+
+#ifdef SK_SUPPORT_LEGACY_SRCPTR_DRAWIMAGERECT
     void drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
                        const SkPaint* paint, SrcRectConstraint = kStrict_SrcRectConstraint);
 
     void drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst) {
         this->drawImageRect(image, src, dst, NULL, kStrict_SrcRectConstraint);
     }
-
-    void drawImageRect(const SkImage* image, const SkRect& dst, const SkPaint* paint = NULL) {
-        // With no src-rect, the constraint value is ignored, so we just use the default.
-        this->drawImageRect(image, NULL, dst, paint, kStrict_SrcRectConstraint);
-    }
-
-    void drawImageRect(const SkImage* image, const SkIRect& isrc, const SkRect& dst,
-                       const SkPaint* paint, SrcRectConstraint = kStrict_SrcRectConstraint);
+#endif
 
     /**
      *  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.
@@ skipping 28 matching lines @@
      *  dst rect. If the src rect is non-null, only that subset of the bitmap is transformed
      *  and drawn.
      *
      *  @param bitmap     The bitmap to be drawn
      *  @param src        Optional: specify the subset of the bitmap to be drawn
      *  @param dst        The destination rectangle where the scaled/translated
      *                    bitmap will be drawn
      *  @param paint      The paint used to draw the bitmap, or NULL
      *  @param constraint Control the tradeoff between speed and exactness w.r.t. the src-rect.
      */
+    void drawBitmapRect(const SkBitmap& bitmap, const SkRect& src, const SkRect& dst,
+                        const SkPaint* paint, SrcRectConstraint = kStrict_SrcRectConstraint);
+    // variant where src is SkIRect
+    void drawBitmapRect(const SkBitmap& bitmap, const SkIRect& isrc, const SkRect& dst,
+                        const SkPaint* paint, SrcRectConstraint = kStrict_SrcRectConstraint);
+#ifdef SK_SUPPORT_LEGACY_SIMPLE_DRAWIMAGERECT
+    void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst, const SkPaint* paint = NULL);
+#else
+    void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst, const SkPaint* paint,
+                       SrcRectConstraint = kStrict_SrcRectConstraint);
+#endif
+
+#ifdef SK_SUPPORT_LEGACY_SRCPTR_DRAWIMAGERECT
     void drawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst,
                         const SkPaint* paint, SrcRectConstraint = kStrict_SrcRectConstraint);
-
-    void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst, const SkPaint* paint = NULL) {
-        this->drawBitmapRect(bitmap, NULL, dst, paint, kStrict_SrcRectConstraint);
-    }
-
-    void drawBitmapRect(const SkBitmap& bitmap, const SkIRect& isrc, const SkRect& dst,
-                        const SkPaint* paint, SrcRectConstraint = kStrict_SrcRectConstraint);
+#endif
 
     /**
      *  Draw the bitmap stretched differentially to fit into dst.
      *  center is a rect within the bitmap, and logically divides the bitmap
      *  into 9 sections (3x3). For example, if the middle pixel of a [5x5]
      *  bitmap is the "center", then the center-rect should be [2, 2, 3, 3].
      *
      *  If the dst is >= the bitmap size, then...
      *  - The 4 corners are not stretched at all.
      *  - The sides are stretched in only one axis.
@@ skipping 299 matching lines @@
 
     // don't call
     GrRenderTarget* internal_private_accessTopLayerRenderTarget();
 
     // don't call
     static void Internal_Private_SetIgnoreSaveLayerBounds(bool);
     static bool Internal_Private_GetIgnoreSaveLayerBounds();
     static void Internal_Private_SetTreatSpriteAsBitmap(bool);
     static bool Internal_Private_GetTreatSpriteAsBitmap();
 
+    // TEMP helpers until we switch virtual over to const& for src-rect
+    void legacy_drawImageRect(const SkImage* image, const SkRect* src, const SkRect& dst,
+                              const SkPaint* paint,
+                              SrcRectConstraint constraint = kStrict_SrcRectConstraint);
+    void legacy_drawBitmapRect(const SkBitmap& bitmap, const SkRect* src, const SkRect& dst,
+                               const SkPaint* paint,
+                               SrcRectConstraint constraint = kStrict_SrcRectConstraint);
+
 protected:
     // default impl defers to getDevice()->newSurface(info)
     virtual SkSurface* onNewSurface(const SkImageInfo&, const SkSurfaceProps&);
 
     // default impl defers to its device
     virtual bool onPeekPixels(SkPixmap*);
     virtual bool onAccessTopLayerPixels(SkPixmap*);
 
     // Subclass save/restore notifiers.
     // Overriders should call the corresponding INHERITED method up the inheritance chain.
@@ skipping 339 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