Make drawbitmaprect GM use Ganesh-backed bitmaps and images

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 "SkShader.h"
-#include "SkImage.h"
+#include "SkSurface.h"
+
+#if SK_SUPPORT_GPU
+#include "SkGr.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;
 }
 
-static SkImage* image_from_bitmap(const SkBitmap& bm) {
-    SkBitmap b(bm);
-    b.lockPixels();
-    return SkImage::NewRasterCopy(b.info(), b.getPixels(), b.rowBytes());
-}
+static SkImage* makebm(SkCanvas* origCanvas, SkBitmap* resultBM, int w, int h) {
+    SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
+    
+    SkAutoTUnref<SkSurface> surface(origCanvas->newSurface(info));
+    if (nullptr == surface) {
+        // picture canvas will return null, so fall-back to raster
+        surface.reset(SkSurface::NewRaster(info));
+    }
 
-static SkImage* makebm(SkBitmap* bm, int w, int h) {
-    bm->allocN32Pixels(w, h);
-    bm->eraseColor(SK_ColorTRANSPARENT);
+    SkCanvas* canvas = surface->getCanvas();
 
-    SkCanvas    canvas(*bm);
+    canvas->clear(SK_ColorTRANSPARENT);
 
     SkScalar wScalar = SkIntToScalar(w);
     SkScalar hScalar = SkIntToScalar(h);
 
     SkPoint     pt = { wScalar / 2, hScalar / 2 };
 
     SkScalar    radius = 4 * SkMaxScalar(wScalar, hScalar);
 
     SkColor     colors[] = { SK_ColorRED, SK_ColorYELLOW,
                              SK_ColorGREEN, SK_ColorMAGENTA,
@@ skipping 11 matching lines @@
     SkPaint     paint;
     SkRect rect = SkRect::MakeWH(wScalar, hScalar);
     SkMatrix mat = SkMatrix::I();
     for (int i = 0; i < 4; ++i) {
         paint.setShader(SkGradientShader::CreateRadial(
                         pt, radius,
                         colors, pos,
                         SK_ARRAY_COUNT(colors),
                         SkShader::kRepeat_TileMode,
                         0, &mat))->unref();
-        canvas.drawRect(rect, paint);
+        canvas->drawRect(rect, paint);
         rect.inset(wScalar / 8, hScalar / 8);
         mat.postScale(SK_Scalar1 / 4, SK_Scalar1 / 4);
     }
+
+    SkImage* image = surface->newImageSnapshot();
+
+    SkBitmap tempBM;
+
+#if SK_SUPPORT_GPU
+    if (image->getTexture()) {
+        GrWrapTextureInBitmap(image->getTexture(),
+                              image->width(), image->height(), image->isOpaque(), &tempBM);
+    } else 
+#endif
+    {
+        image->asLegacyBitmap(&tempBM, SkImage::kRO_LegacyBitmapMode);
+    }
+
     // Let backends know we won't change this, so they don't have to deep copy it defensively.
-    bm->setImmutable();
+    tempBM.setImmutable();
+    *resultBM = tempBM;
 
-    return image_from_bitmap(*bm);
+    return image;
 }
 
 static void canvasproc(SkCanvas* canvas, SkImage*, const SkBitmap& bm, const SkIRect& srcR,
                        const SkRect& dstR) {
     canvas->drawBitmapRect(bm, srcR, dstR, nullptr);
 }
 
 static void imageproc(SkCanvas* canvas, SkImage* image, const SkBitmap&, const SkIRect& srcR,
                       const SkRect& dstR) {
     canvas->drawImageRect(image, srcR, dstR, nullptr);
@@ skipping 16 matching lines @@
     DrawRectRectProc*     fProc;
     SkBitmap              fLargeBitmap;
     SkAutoTUnref<SkImage> fImage;
     SkString              fName;
 
 protected:
     SkString onShortName() override { return fName; }
 
     SkISize onISize() override { return SkISize::Make(gSize, gSize); }
 
-    void onOnceBeforeDraw() override {
-        fImage.reset(makebm(&fLargeBitmap, gBmpSize, gBmpSize));
+    void setupImage(SkCanvas* canvas) {
+        fImage.reset(makebm(canvas, &fLargeBitmap, gBmpSize, gBmpSize));
     }
 
     void onDraw(SkCanvas* canvas) override {
+        if (!fImage) {
+            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);
         canvas->translate(SK_Scalar1 * kPadX / 2,
                           SK_Scalar1 * kPadY / 2);
@@ skipping 63 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"); )