Add nanobench tests for BitmapRegionDecoder

bench/BitmapRegionDecoderBench.cpp

Index: bench/BitmapRegionDecoderBench.cpp
diff --git a/bench/BitmapRegionDecoderBench.cpp b/bench/BitmapRegionDecoderBench.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7df20eb6c8ef37f88b63b1faac3756e51f73f648
--- /dev/null
+++ b/bench/BitmapRegionDecoderBench.cpp
@@ -0,0 +1,85 @@
+/*
+ * 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 "BitmapRegionDecoderBench.h"
+#include "SkBitmap.h"
+#include "SkOSFile.h"
+
+// FIXME (msarett): How can we share this code with DM?
+static float get_scale_from_sample_size(uint32_t sampleSize) {
+    return 1.0f / (float) sampleSize;
+}
+
+BitmapRegionDecoderBench::BitmapRegionDecoderBench(SkString baseName, SkData* encoded,
+        SkBitmapRegionDecoderInterface::Strategy strategy, SkColorType colorType,
+        uint32_t sampleSize, const SkIRect& subset)
+    : fData(SkRef(encoded))
+    , fStrategy(strategy)
+    , fColorType(colorType)
+    , fSampleSize(sampleSize)
+    , fSubset(subset)
+{
+    // Choose a useful name for the region decoding strategy
+    const char* strategyName;
+    switch (strategy) {
+        case SkBitmapRegionDecoderInterface::kOriginal_Strategy:
+            strategyName = "Original";
+            break;
+        case SkBitmapRegionDecoderInterface::kCanvas_Strategy:
+            strategyName = "Canvas";
+            break;
+        default:
+            SkASSERT(false);
+            strategyName = "";
+            break;
+    }
+
+    // Choose a useful name for the color type
+    const char* colorName;
+    switch (colorType) {
+        case kN32_SkColorType:

[scroggo, 2015/09/17 20:05:38]

This switch statement shows up a lot. Maybe we can unify on something in tools/?

[msarett, 2015/09/18 13:22:30]

I moved something into tools, but, on second look, this code doesn't show up
anywhere but nanobench.  In DM, we case on DstColorType and only change the name
for AlwaysGray8 and AlwaysIndex8.

I'm adding SkCodecBenchPriv.h to the bench folder to share this code.

On the other hand, we have come across cases where being able to share code
between some combination of dm, nanobench, codec, tools would be useful. 
get_scaled_dimension() and get_scale_from_sample_size() are two examples, and
there are probably more.

I tried this again when I added the header file to tools - but the compiler
always complains.  Any solution that includes the header file must use all of
the functions defined in the header.  Do you know a way around this?

[mtklein, 2015/09/18 13:26:51]

If the function's defined in the header, you'll want to mark it inline.

static int foo(float) { ... }  in .cpp ---> inline int foo(float) { ... } in .h

If you leave it as static, the compiler will include it from the .h into your
.cpp file, then say, hey this static function isn't used inside this .cpp, and
isn't visible outside this .cpp (that's what static means), so why did you
define it in the first place?

Alternatively, declare the function like int foo(float); in the header and
define it in another .cpp file.

[msarett, 2015/09/18 17:41:17]

Thanks for your explanation!

+            colorName = "N32";
+            break;
+        case kRGB_565_SkColorType:
+            colorName = "565";
+            break;
+        case kGray_8_SkColorType:
+            colorName = "Gray8";
+            break;
+        case kIndex_8_SkColorType:
+            colorName = "Index8";
+            break;
+        default:
+            colorName = "Unknown";
+    }
+    if (1 == sampleSize) {
+        fName.printf("BRD_%s_%s_%s", baseName.c_str(), strategyName, colorName);
+    } else {
+        fName.printf("BRD_%s_%s_%s_%.3f", baseName.c_str(), strategyName, colorName,
+                get_scale_from_sample_size(sampleSize));
+    }
+}
+
+const char* BitmapRegionDecoderBench::onGetName() {
+    return fName.c_str();
+}
+
+bool BitmapRegionDecoderBench::isSuitableFor(Backend backend) {
+    return kNonRendering_Backend == backend;
+}
+
+void BitmapRegionDecoderBench::onDraw(const int n, SkCanvas* canvas) {
+    SkAutoTDelete<SkBitmapRegionDecoderInterface> brd;
+    SkAutoTDelete<SkBitmap> bitmap;
+    for (int i = 0; i < n; i++) {
+        SkStreamRewindable* stream = new SkMemoryStream(fData);
+        brd.reset(SkBitmapRegionDecoderInterface::CreateBitmapRegionDecoder(stream, fStrategy));
+        bitmap.reset(brd->decodeRegion(fSubset.left(), fSubset.top(), fSubset.width(),
+                fSubset.height(), fSampleSize, fColorType));
+        SkASSERT(nullptr != bitmap.get());
+    }
+}