add bench for sprite-like drawing w/ imagefilters

bench/ImageBench.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Benchmark.h"
 #include "SkCanvas.h"
 #include "SkImage.h"
@@ skipping 43 matching lines @@
         }
     }
 
 private:
     SkString                fName;
     SkAutoTUnref<SkImage>   fImage;
     SkAutoTUnref<SkSurface> fRasterSurface;
 
     typedef Benchmark INHERITED;
 };
+DEF_BENCH( return new Image2RasterBench; )
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
 
-DEF_BENCH( return new Image2RasterBench; )
+#include "SkBlurImageFilter.h"
+#include "SkGrPixelRef.h"
+
+enum MyDrawType {
+    kSprite_Type,
+    kBitmap_Type,
+    kImage_Type,
+};
+
+/*
+ *  Want to time drawing images/bitmaps via drawSprite, and via drawBitmap/drawImage but with
+ *  a non-scaling matrix and a clip that is tight to the image bounds. In this scenario, we
+ *  should be able to match the speed of drawSprite.
+ *
+ *  An optimal result should be that all three types: sprite/bitmap/image draw at the same speed.
+ */
+class ImageFilterSpriteBench : public Benchmark {

[robertphillips, 2015/12/03 19:30:56]

Why do we keep the SkSurface around - can't it be transient ?

[reed1, 2015/12/03 19:37:16]

Done.

+    SkAutoTUnref<SkSurface>     fSurface;
+    SkAutoTUnref<SkImage>       fImage;
+    SkBitmap                    fBitmap;

[robertphillips, 2015/12/03 19:30:56]

fFilter doesn't seem to be really used ?

[reed1, 2015/12/03 19:37:15]

Done.

+    SkAutoTUnref<SkImageFilter> fFilter;
+    SkString                    fName;
+    MyDrawType                  fType;
+
+public:
+    ImageFilterSpriteBench(MyDrawType dt, const char suffix[]) : fType(dt) {
+        fName.printf("image-filter-sprite-draw-%s", suffix);
+

[robertphillips, 2015/12/03 19:30:56]

kSigma ?

[reed1, 2015/12/03 19:37:16]

Done.

+        const SkScalar sigma = 10;
+        fFilter.reset(SkBlurImageFilter::Create(sigma, sigma));
+    }
+
+    bool isSuitableFor(Backend backend) override {
+        return kGPU_Backend == backend || kRaster_Backend == backend;
+    }
+
+protected:
+    bool isVisual() override {
+        return true;
+    }
+
+    const char* onGetName() override {
+        return fName.c_str();
+    }
+
+    void onPerCanvasPreDraw(SkCanvas* canvas) override {
+        const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
+        fSurface.reset(canvas->newSurface(info));
+
+        fSurface->getCanvas()->drawColor(SK_ColorRED);
+        fImage.reset(fSurface->newImageSnapshot());
+
+        fBitmap.setInfo(info);
+        if (fImage->getTexture()) {
+            fBitmap.setPixelRef(new SkGrPixelRef(info, fImage->getTexture()))->unref();
+        } else {
+            SkPixmap pmap;
+            if (!fImage->peekPixels(&pmap)) {
+                sk_throw();
+            }
+            fBitmap.installPixels(pmap.info(), pmap.writable_addr(), pmap.rowBytes());
+        }
+    }
+
+    void onPerCanvasPostDraw(SkCanvas*) override {
+        // Release the image and raster surface here to prevent out of order destruction
+        // between these and the gpu interface.
+        fSurface.reset(nullptr);
+        fImage.reset(nullptr);
+        fBitmap.reset();
+    }
+
+    void onDraw(int loops, SkCanvas* canvas) override {
+        // This clip is important; it allows the drawImage/drawBitmap code to fall into the
+        // fast (sprite) case, since the imagefilter's output should match.
+        //
+        // When we address skbug.com/4526 we should be able to remove the need for this clip.
+        //
+        canvas->clipRect(SkRect::MakeIWH(fImage->width(), fImage->height()));
+

[robertphillips, 2015/12/03 19:30:56]

kSigma ?

[reed1, 2015/12/03 19:37:16]

Done.

+        const SkScalar sigma = 10;
+        SkPaint paint;
+        for (int i = 0; i < loops; i++) {
+            for (int inner = 0; inner < 10; ++inner) {
+                // build the filter everytime, so we don't accidentally draw a cached version,
+                // since the point of this bench is to time the actual blurring/drawing process.
+                SkAutoTUnref<SkImageFilter> filter(SkBlurImageFilter::Create(sigma, sigma));
+                paint.setImageFilter(filter);
+
+                switch (fType) {
+                    case kSprite_Type:
+                        canvas->drawSprite(fBitmap, 0, 0, &paint);
+                        break;
+                    case kBitmap_Type:
+                        canvas->drawBitmap(fBitmap, 0, 0, &paint);
+                        break;
+                    case kImage_Type:
+                        canvas->drawImage(fImage, 0, 0, &paint);
+                        break;
+                }
+            }
+        }
+    }
+
+private:
+    typedef Benchmark INHERITED;
+};
+DEF_BENCH( return new ImageFilterSpriteBench(kSprite_Type, "sprite"); )
+DEF_BENCH( return new ImageFilterSpriteBench(kBitmap_Type, "bitmap"); )
+DEF_BENCH( return new ImageFilterSpriteBench(kImage_Type,  "image"); )
+