Revert of guard to remove DrawBitmapRectFlags

gm/drawbitmaprect.cpp

 /*
  * Copyright 2011 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"
@@ skipping 61 matching lines @@
         canvas.drawRect(rect, paint);
         rect.inset(wScalar / 8, hScalar / 8);
         mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4);
     }
     // Let backends know we won't change this, so they don't have to deep copy it defensively.
     bm->setImmutable();
 
     return image_from_bitmap(*bm);
 }
 
-static void canvasproc(SkCanvas* canvas, SkImage*, const SkBitmap& bm, const SkIRect& srcR,
+static void canvasproc(SkCanvas* canvas, SkImage*, const SkBitmap& bm, const SkIRect* srcR,
                        const SkRect& dstR) {
-    canvas->drawBitmapRect(bm, srcR, dstR, NULL);
+    canvas->drawBitmapRect(bm, srcR, dstR);
 }
 
-static void imageproc(SkCanvas* canvas, SkImage* image, const SkBitmap&, const SkIRect& srcR,
+static void imageproc(SkCanvas* canvas, SkImage* image, const SkBitmap&, const SkIRect* srcIR,
                       const SkRect& dstR) {
-    canvas->drawImageRect(image, srcR, dstR, NULL);
+    SkRect storage, *srcR = NULL;
+    if (srcIR) {
+        storage.set(*srcIR);
+        srcR = &storage;
+    }
+    canvas->drawImageRect(image, srcR, dstR);
 }
 
-static void imagescaleproc(SkCanvas* canvas, SkImage* image, const SkBitmap&, const SkIRect& srcIR,
+static void imagescaleproc(SkCanvas* canvas, SkImage* image, const SkBitmap&, const SkIRect* srcIR,
                            const SkRect& dstR) {
     const int newW = SkScalarRoundToInt(dstR.width());
     const int newH = SkScalarRoundToInt(dstR.height());
-    SkAutoTUnref<SkImage> newImage(image->newImage(newW, newH, &srcIR));
+    SkAutoTUnref<SkImage> newImage(image->newImage(newW, newH, srcIR));
 
 #ifdef SK_DEBUG
     const SkIRect baseR = SkIRect::MakeWH(image->width(), image->height());
-    const bool containsSubset = baseR.contains(srcIR);
+    const bool containsSubset = !srcIR || baseR.contains(*srcIR);
 #endif
 
     if (newImage) {
         SkASSERT(containsSubset);
         canvas->drawImage(newImage, dstR.x(), dstR.y());
     } else {
         // newImage() does not support subsets that are not contained by the original
         // but drawImageRect does, so we just draw an X in its place to indicate that we are
         // deliberately not drawing here.
         SkASSERT(!containsSubset);
         SkPaint paint;
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(4);
         canvas->drawLine(4, 4, newW - 4.0f, newH - 4.0f, paint);
         canvas->drawLine(4, newH - 4.0f, newW - 4.0f, 4, paint);
     }
 }
 
-typedef void DrawRectRectProc(SkCanvas*, SkImage*, const SkBitmap&, const SkIRect&, const SkRect&);
+typedef void DrawRectRectProc(SkCanvas*, SkImage*, const SkBitmap&, const SkIRect*, const SkRect&);
 
 static const int gSize = 1024;
 static const int gBmpSize = 2048;
 
 class DrawBitmapRectGM : public skiagm::GM {
 public:
     DrawBitmapRectGM(DrawRectRectProc proc, const char suffix[]) : fProc(proc) {
         fName.set("drawbitmaprect");
         if (suffix) {
             fName.append(suffix);
@@ skipping 39 matching lines @@
         canvas->drawText(title.c_str(), title.size(), 0,
                          titleHeight, blackPaint);
 
         canvas->translate(0, SK_Scalar1 * kPadY / 2  + titleHeight);
         int rowCount = 0;
         canvas->save();
         for (int w = 1; w <= kMaxSrcRectSize; w *= 4) {
             for (int h = 1; h <= kMaxSrcRectSize; h *= 4) {
 
                 SkIRect srcRect = SkIRect::MakeXYWH((gBmpSize - w) / 2, (gBmpSize - h) / 2, w, h);
-                fProc(canvas, fImage, fLargeBitmap, srcRect, dstRect);
+                fProc(canvas, fImage, fLargeBitmap, &srcRect, dstRect);
 
                 SkString label;
                 label.appendf("%d x %d", w, h);
                 blackPaint.setAntiAlias(true);
                 blackPaint.setStyle(SkPaint::kFill_Style);
                 blackPaint.setTextSize(SK_Scalar1 * 10);
                 SkScalar baseline = dstRect.height() +
                                     blackPaint.getTextSize() + SK_Scalar1 * 3;
                 canvas->drawText(label.c_str(), label.size(),
                                     0, baseline,
@@ skipping 24 matching lines @@
             bm = make_chessbm(5, 5);
             paint.setFilterQuality(kLow_SkFilterQuality);
 
             srcRect.setXYWH(1, 1, 3, 3);
             SkMaskFilter* mf = SkBlurMaskFilter::Create(
                 kNormal_SkBlurStyle,
                 SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5)),
                 SkBlurMaskFilter::kHighQuality_BlurFlag |
                 SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
             paint.setMaskFilter(mf)->unref();
-            canvas->drawBitmapRect(bm, srcRect, dstRect, &paint);
+            canvas->drawBitmapRect(bm, &srcRect, dstRect, &paint);
         }
     }
 
 private:
     typedef skiagm::GM INHERITED;
 };
 
 DEF_GM( return new DrawBitmapRectGM(canvasproc, NULL); )
 DEF_GM( return new DrawBitmapRectGM(imageproc, "-imagerect"); )
 DEF_GM( return new DrawBitmapRectGM(imagescaleproc, "-imagescale"); )