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

gm/bleed.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm.h"
 #include "SkBlurMask.h"
 #include "SkBlurMaskFilter.h"
 #include "SkCanvas.h"
 #include "SkImage.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrContextOptions.h"
 #endif
 
 static void draw_bitmap_rect(SkCanvas* canvas, const SkBitmap& bitmap, const SkImage*,
-                             const SkRect* src, const SkRect& dst,
+                             const SkRect& src, const SkRect& dst,
                              const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
     canvas->drawBitmapRect(bitmap, src, dst, paint, constraint);
 }
 
 static void draw_image_rect(SkCanvas* canvas, const SkBitmap&, const SkImage* image,
-                            const SkRect* src, const SkRect& dst,
+                            const SkRect& src, const SkRect& dst,
                             const SkPaint* paint, SkCanvas::SrcRectConstraint constraint) {
     canvas->drawImageRect(image, src, dst, paint, constraint);
 }
 
 enum BleedTest {
     kUseBitmap_BleedTest,
     kUseImage_BleedTest,
 };
 
 const struct {
     const char* fName;
-    void (*fDraw)(SkCanvas*, const SkBitmap&, const SkImage*, const SkRect*, const SkRect&,
+    void (*fDraw)(SkCanvas*, const SkBitmap&, const SkImage*, const SkRect&, const SkRect&,
                   const SkPaint*, SkCanvas::SrcRectConstraint);
 } gBleedRec[] = {
     { "bleed",          draw_bitmap_rect },
     { "bleed_image",    draw_image_rect },
 };
 
 // Create a black&white checked texture with 2 1-pixel rings
 // around the outside edge. The inner ring is red and the outer ring is blue.
 static void make_ringed_bitmap(SkBitmap* result, int width, int height) {
     SkASSERT(0 == width % 2 && 0 == height % 2);
@@ skipping 88 matching lines @@
                    SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
         SkRect src = SkRect::MakeXYWH(2, 2,
                                       SkIntToScalar(kSmallTextureSize-4),
                                       SkIntToScalar(kSmallTextureSize-4));
         SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
                                       SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
         SkPaint paint;
         paint.setFilterQuality(filter);
 
-        gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, &src, dst, &paint, constraint);
+        gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, src, dst, &paint, constraint);
     }
 
     // Draw almost all of the large bitmap
     void drawCase2(SkCanvas* canvas, int transX, int transY,
                    SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
         SkRect src = SkRect::MakeXYWH(2, 2,
                                       SkIntToScalar(fBitmapBig.width()-4),
                                       SkIntToScalar(fBitmapBig.height()-4));
         SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
                                       SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
         SkPaint paint;
         paint.setFilterQuality(filter);
 
-        gBleedRec[fBT].fDraw(canvas, fBitmapBig, fImageBig, &src, dst, &paint, constraint);
+        gBleedRec[fBT].fDraw(canvas, fBitmapBig, fImageBig, src, dst, &paint, constraint);
     }
 
     // Draw ~1/4 of the large bitmap
     void drawCase3(SkCanvas* canvas, int transX, int transY,
                    SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
         SkRect src = SkRect::MakeXYWH(2, 2,
                                       SkIntToScalar(fBitmapBig.width()/2-2),
                                       SkIntToScalar(fBitmapBig.height()/2-2));
         SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
                                       SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
         SkPaint paint;
         paint.setFilterQuality(filter);
 
-        gBleedRec[fBT].fDraw(canvas, fBitmapBig, fImageBig, &src, dst, &paint, constraint);
+        gBleedRec[fBT].fDraw(canvas, fBitmapBig, fImageBig, src, dst, &paint, constraint);
     }
 
     // Draw the center of the small bitmap with a mask filter
     void drawCase4(SkCanvas* canvas, int transX, int transY,
                    SkCanvas::SrcRectConstraint constraint, SkFilterQuality filter) {
         SkRect src = SkRect::MakeXYWH(2, 2,
                                       SkIntToScalar(kSmallTextureSize-4),
                                       SkIntToScalar(kSmallTextureSize-4));
         SkRect dst = SkRect::MakeXYWH(SkIntToScalar(transX), SkIntToScalar(transY),
                                       SkIntToScalar(kBlockSize), SkIntToScalar(kBlockSize));
 
         SkPaint paint;
         paint.setFilterQuality(filter);
         SkMaskFilter* mf = SkBlurMaskFilter::Create(kNormal_SkBlurStyle,
                                          SkBlurMask::ConvertRadiusToSigma(3));
         paint.setMaskFilter(mf)->unref();
 
-        gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, &src, dst, &paint, constraint);
+        gBleedRec[fBT].fDraw(canvas, fBitmapSmall, fImageSmall, src, dst, &paint, constraint);
     }
 
     void onDraw(SkCanvas* canvas) override {
 
         canvas->clear(SK_ColorGRAY);
 
         for (int m = 0; m < 2; ++m) {
             canvas->save();
             if (m) {
                 static const SkScalar kBottom = SkIntToScalar(kRow3Y + kBlockSize + kBlockSpacing);
@@ skipping 74 matching lines @@
     SkBitmap fBitmapBig;
     SkAutoTUnref<SkImage> fImageSmall;
     SkAutoTUnref<SkImage> fImageBig;
     const BleedTest fBT;
 
     typedef GM INHERITED;
 };
 
 DEF_GM( return new BleedGM(kUseBitmap_BleedTest); )
 DEF_GM( return new BleedGM(kUseImage_BleedTest); )