Test SkCodec to kIndex8 in nanobench.

bench/DecodingBench.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 "DecodingBench.h"
+#include "SkBitmap.h"
 #include "SkData.h"
 #include "SkImageDecoder.h"
 #include "SkMallocPixelRef.h"
 #include "SkOSFile.h"
-#include "SkPixelRef.h"
 #include "SkStream.h"
 
 /*
  *
  * This benchmark is designed to test the performance of image decoding.
  * It is invoked from the nanobench.cpp file.
  *
  */
 DecodingBench::DecodingBench(SkString path, SkColorType colorType)
     : fColorType(colorType)
@@ skipping 30 matching lines @@
 }
 
 bool DecodingBench::isSuitableFor(Backend backend) {
     return kNonRendering_Backend == backend;
 }
 
 void DecodingBench::onPreDraw() {
     // Allocate the pixels now, to remove it from the loop.
     SkAutoTDelete<SkStreamRewindable> stream(new SkMemoryStream(fData));
     SkAutoTDelete<SkImageDecoder> decoder(SkImageDecoder::Factory(stream));
+    SkBitmap bm;
 #ifdef SK_DEBUG
     SkImageDecoder::Result result =
 #endif
-    decoder->decode(stream, &fBitmap, fColorType,
-                    SkImageDecoder::kDecodeBounds_Mode);
+    decoder->decode(stream, &bm, fColorType, SkImageDecoder::kDecodeBounds_Mode);
     SkASSERT(SkImageDecoder::kFailure != result);
-    fBitmap.allocPixels(fBitmap.info());
+
+    const size_t rowBytes = bm.info().minRowBytes();
+    fStorage.reset(bm.info().getSafeSize(rowBytes));
 }
 
-// Allocator which just reuses the pixels from an existing SkPixelRef.
-class UseExistingAllocator : public SkBitmap::Allocator {
+// Allocator which just uses an existing block of memory.
+class TargetAllocator : public SkBitmap::Allocator {
 public:
-    explicit UseExistingAllocator(SkPixelRef* pr)
-        : fPixelRef(SkRef(pr)) {}
+    explicit TargetAllocator(void* storage)
+        : fStorage(storage) {}
 
     bool allocPixelRef(SkBitmap* bm, SkColorTable* ct) override {
-        // We depend on the fact that fPixelRef is an SkMallocPixelRef, which
-        // is always locked, and the fact that this will only ever be used to
-        // decode to a bitmap with the same settings used to create the
-        // original pixel ref.
+        // We depend on the fact that this will only ever be used to
+        // decode to a bitmap with the same settings used to create
+        // fStorage.
         bm->setPixelRef(SkMallocPixelRef::NewDirect(bm->info(),
-                fPixelRef->pixels(), bm->rowBytes(), ct))->unref();
+                fStorage, bm->rowBytes(), ct))->unref();
         return true;
     }
 
 private:
-    SkAutoTUnref<SkPixelRef> fPixelRef;
+    void* fStorage; // Unowned. DecodingBench owns this.
 };
 
 void DecodingBench::onDraw(const int n, SkCanvas* canvas) {
     SkBitmap bitmap;
     // Declare the allocator before the decoder, so it will outlive the
     // decoder, which will unref it.
-    UseExistingAllocator allocator(fBitmap.pixelRef());
+    TargetAllocator allocator(fStorage.get());
     SkAutoTDelete<SkImageDecoder> decoder;
     SkAutoTDelete<SkStreamRewindable> stream;
     for (int i = 0; i < n; i++) {
         // create a new stream and a new decoder to mimic the behavior of
         // CodecBench.
         stream.reset(new SkMemoryStream(fData));
         decoder.reset(SkImageDecoder::Factory(stream));
         decoder->setAllocator(&allocator);
         decoder->decode(stream, &bitmap, fColorType,
                         SkImageDecoder::kDecodePixels_Mode);
     }
 }