Stop testing texture-backed bitmaps in drawbitmaprect GM

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"
 #include "SkColorPriv.h"
 #include "SkGradientShader.h"
 #include "SkImage.h"
 #include "SkImage_Base.h"
 #include "SkMathPriv.h"
 #include "SkShader.h"
 #include "SkSurface.h"
 
-#if SK_SUPPORT_GPU
-#include "SkGrPriv.h"
-#endif
 
 static SkBitmap make_chessbm(int w, int h) {
     SkBitmap bm;
     bm.allocN32Pixels(w, h);
 
     for (int y = 0; y < bm.height(); y++) {
         uint32_t* p = bm.getAddr32(0, y);
         for (int x = 0; x < bm.width(); x++) {
             p[x] = ((x + y) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
         }
     }
     bm.unlockPixels();
     return bm;
 }
 
+// Creates a bitmap and a matching image.
 static sk_sp<SkImage> makebm(SkCanvas* origCanvas, SkBitmap* resultBM, int w, int h) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
 
     auto surface(origCanvas->makeSurface(info));
     if (nullptr == surface) {
         // picture canvas will return null, so fall-back to raster
         surface = SkSurface::MakeRaster(info);
     }
 
     SkCanvas* canvas = surface->getCanvas();
@@ skipping 32 matching lines @@
                         0, &mat));
         canvas->drawRect(rect, paint);
         rect.inset(wScalar / 8, hScalar / 8);
         mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4);
     }
 
     auto image = surface->makeImageSnapshot();
 
     SkBitmap tempBM;
 
-#if SK_SUPPORT_GPU
-    if (GrTexture* texture = as_IB(image)->peekTexture()) {
-        GrWrapTextureInBitmap(texture, image->width(), image->height(), image->isOpaque(), &tempBM);
-    } else
-#endif
-    {
-        image->asLegacyBitmap(&tempBM, SkImage::kRO_LegacyBitmapMode);
-    }
+    image->asLegacyBitmap(&tempBM, SkImage::kRO_LegacyBitmapMode);
 
     // Let backends know we won't change this, so they don't have to deep copy it defensively.
     tempBM.setImmutable();
     *resultBM = tempBM;
 
     return image;
 }
 
 static void canvasproc(SkCanvas* canvas, SkImage*, const SkBitmap& bm, const SkIRect& srcR,
                        const SkRect& dstR) {
@@ skipping 38 matching lines @@
             this->setupImage(canvas);
         }
 
         SkRect dstRect = { 0, 0, SkIntToScalar(64), SkIntToScalar(64)};
         static const int kMaxSrcRectSize = 1 << (SkNextLog2(gBmpSize) + 2);
 
         static const int kPadX = 30;
         static const int kPadY = 40;
         SkPaint paint;
         paint.setAlpha(0x20);
-        canvas->drawBitmapRect(fLargeBitmap, SkRect::MakeIWH(gSize, gSize), &paint);

[bsalomon, 2016/07/13 21:13:08]

The GM was (arbitrarily) always using the bitmap rather than the image to draw
the background. Now that the bitmap is never texture-backed but the image still
is (for GPU configs). By switching this to choose the image I will only need to
rebaseline the drawbitmaprect gpu image and not the drawbitmaprect-imagerect. 

+        canvas->drawImageRect(fImage, SkRect::MakeIWH(gSize, gSize), &paint);
         canvas->translate(SK_Scalar1 * kPadX / 2,
                           SK_Scalar1 * kPadY / 2);
         SkPaint blackPaint;
         SkScalar titleHeight = SK_Scalar1 * 24;
         blackPaint.setColor(SK_ColorBLACK);
         blackPaint.setTextSize(titleHeight);
         blackPaint.setAntiAlias(true);
         sk_tool_utils::set_portable_typeface(&blackPaint);
         SkString title;
         title.printf("Bitmap size: %d x %d", gBmpSize, gBmpSize);
@@ skipping 54 matching lines @@
             canvas->drawBitmapRect(bm, srcRect, dstRect, &paint);
         }
     }
 
 private:
     typedef skiagm::GM INHERITED;
 };
 
 DEF_GM( return new DrawBitmapRectGM(canvasproc, nullptr); )
 DEF_GM( return new DrawBitmapRectGM(imageproc, "-imagerect"); )