Delete SkBitmapRegionCanvas

bench/nanobench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "nanobench.h"
@@ skipping 495 matching lines @@
         break;
     }
 
     if (!target->init(info, bench)) {
         delete target;
         return nullptr;
     }
     return target;
 }
 
-static bool valid_brd_bench(SkData* encoded, SkBitmapRegionDecoder::Strategy strategy,
-        SkColorType colorType, uint32_t sampleSize, uint32_t minOutputSize, int* width,
-        int* height) {
+static bool valid_brd_bench(SkData* encoded, SkColorType colorType, uint32_t sampleSize,
+        uint32_t minOutputSize, int* width, int* height) {
     SkAutoTDelete<SkBitmapRegionDecoder> brd(
-            SkBitmapRegionDecoder::Create(encoded, strategy));
+            SkBitmapRegionDecoder::Create(encoded, SkBitmapRegionDecoder::kAndroidCodec_Strategy));
     if (nullptr == brd.get()) {
         // This is indicates that subset decoding is not supported for a particular image format.
         return false;
     }
 
-    SkBitmap bitmap;
-    if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(0, 0, brd->width(), brd->height()),
-            1, colorType, false)) {
-        return false;
-    }
-
     if (sampleSize * minOutputSize > (uint32_t) brd->width() || sampleSize * minOutputSize >
             (uint32_t) brd->height()) {
         // This indicates that the image is not large enough to decode a
         // minOutputSize x minOutputSize subset at the given sampleSize.
         return false;
     }
 
     // Set the image width and height.  The calling code will use this to choose subsets to decode.
     *width = brd->width();
     *height = brd->height();
@@ skipping 19 matching lines @@
                       , fCurrentRecording(0)
                       , fCurrentScale(0)
                       , fCurrentSKP(0)
                       , fCurrentUseMPD(0)
                       , fCurrentCodec(0)
                       , fCurrentAndroidCodec(0)
                       , fCurrentBRDImage(0)
                       , fCurrentColorType(0)
                       , fCurrentAlphaType(0)
                       , fCurrentSubsetType(0)
-                      , fCurrentBRDStrategy(0)
                       , fCurrentSampleSize(0)
                       , fCurrentAnimSKP(0) {
         for (int i = 0; i < FLAGS_skps.count(); i++) {
             if (SkStrEndsWith(FLAGS_skps[i], ".skp")) {
                 fSKPs.push_back() = FLAGS_skps[i];
             } else {
                 SkOSFile::Iter it(FLAGS_skps[i], ".skp");
                 SkString path;
                 while (it.next(&path)) {
                     fSKPs.push_back() = SkOSPath::Join(FLAGS_skps[0], path.c_str());
@@ skipping 253 matching lines @@
                     // Avoid benchmarking scaled decodes of already small images.
                     break;
                 }
 
                 return new AndroidCodecBench(SkOSPath::Basename(path.c_str()), encoded, sampleSize);
             }
             fCurrentSampleSize = 0;
         }
 
         // Run the BRDBenches
-        // We will benchmark multiple BRD strategies.
-        static const struct {
-            SkBitmapRegionDecoder::Strategy    fStrategy;
-            const char*                        fName;
-        } strategies[] = {
-            { SkBitmapRegionDecoder::kCanvas_Strategy,       "BRD_canvas" },
-            { SkBitmapRegionDecoder::kAndroidCodec_Strategy, "BRD_android_codec" },
-        };
-
         // We intend to create benchmarks that model the use cases in
         // android/libraries/social/tiledimage.  In this library, an image is decoded in 512x512
         // tiles.  The image can be translated freely, so the location of a tile may be anywhere in
         // the image.  For that reason, we will benchmark decodes in five representative locations
         // in the image.  Additionally, this use case utilizes power of two scaling, so we will
         // test on power of two sample sizes.  The output tile is always 512x512, so, when a
         // sampleSize is used, the size of the subset that is decoded is always
         // (sampleSize*512)x(sampleSize*512).
         // There are a few good reasons to only test on power of two sample sizes at this time:
         //     All use cases we are aware of only scale by powers of two.
         //     PNG decodes use the indicated sampling strategy regardless of the sample size, so
         //         these tests are sufficient to provide good coverage of our scaling options.
         const uint32_t brdSampleSizes[] = { 1, 2, 4, 8, 16 };
         const uint32_t minOutputSize = 512;
         for (; fCurrentBRDImage < fImages.count(); fCurrentBRDImage++) {
+            fSourceType = "image";
+            fBenchType = "BRD";
+
             const SkString& path = fImages[fCurrentBRDImage];
             if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
                 continue;
             }
-            while (fCurrentBRDStrategy < (int) SK_ARRAY_COUNT(strategies)) {
-                fSourceType = "image";
-                fBenchType = strategies[fCurrentBRDStrategy].fName;
 
-                const SkBitmapRegionDecoder::Strategy strategy =
-                        strategies[fCurrentBRDStrategy].fStrategy;
+            while (fCurrentColorType < fColorTypes.count()) {
+                while (fCurrentSampleSize < (int) SK_ARRAY_COUNT(brdSampleSizes)) {
+                    while (fCurrentSubsetType <= kLastSingle_SubsetType) {
 
-                while (fCurrentColorType < fColorTypes.count()) {
-                    while (fCurrentSampleSize < (int) SK_ARRAY_COUNT(brdSampleSizes)) {
-                        while (fCurrentSubsetType <= kLastSingle_SubsetType) {
+                        SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
+                        const SkColorType colorType = fColorTypes[fCurrentColorType];
+                        uint32_t sampleSize = brdSampleSizes[fCurrentSampleSize];
+                        int currentSubsetType = fCurrentSubsetType++;
 
-                            SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
-                            const SkColorType colorType = fColorTypes[fCurrentColorType];
-                            uint32_t sampleSize = brdSampleSizes[fCurrentSampleSize];
-                            int currentSubsetType = fCurrentSubsetType++;
+                        int width = 0;
+                        int height = 0;
+                        if (!valid_brd_bench(encoded.get(), colorType, sampleSize, minOutputSize,
+                                &width, &height)) {
+                            break;
+                        }
 
-                            int width = 0;
-                            int height = 0;
-                            if (!valid_brd_bench(encoded.get(), strategy, colorType, sampleSize,
-                                    minOutputSize, &width, &height)) {
+                        SkString basename = SkOSPath::Basename(path.c_str());
+                        SkIRect subset;
+                        const uint32_t subsetSize = sampleSize * minOutputSize;
+                        switch (currentSubsetType) {
+                            case kTopLeft_SubsetType:
+                                basename.append("_TopLeft");
+                                subset = SkIRect::MakeXYWH(0, 0, subsetSize, subsetSize);
                                 break;
-                            }
+                            case kTopRight_SubsetType:
+                                basename.append("_TopRight");
+                                subset = SkIRect::MakeXYWH(width - subsetSize, 0, subsetSize,
+                                        subsetSize);
+                                break;
+                            case kMiddle_SubsetType:
+                                basename.append("_Middle");
+                                subset = SkIRect::MakeXYWH((width - subsetSize) / 2,
+                                        (height - subsetSize) / 2, subsetSize, subsetSize);
+                                break;
+                            case kBottomLeft_SubsetType:
+                                basename.append("_BottomLeft");
+                                subset = SkIRect::MakeXYWH(0, height - subsetSize, subsetSize,
+                                        subsetSize);
+                                break;
+                            case kBottomRight_SubsetType:
+                                basename.append("_BottomRight");
+                                subset = SkIRect::MakeXYWH(width - subsetSize,
+                                        height - subsetSize, subsetSize, subsetSize);
+                                break;
+                            default:
+                                SkASSERT(false);
+                        }
 
-                            SkString basename = SkOSPath::Basename(path.c_str());
-                            SkIRect subset;
-                            const uint32_t subsetSize = sampleSize * minOutputSize;
-                            switch (currentSubsetType) {
-                                case kTopLeft_SubsetType:
-                                    basename.append("_TopLeft");
-                                    subset = SkIRect::MakeXYWH(0, 0, subsetSize, subsetSize);
-                                    break;
-                                case kTopRight_SubsetType:
-                                    basename.append("_TopRight");
-                                    subset = SkIRect::MakeXYWH(width - subsetSize, 0, subsetSize,
-                                            subsetSize);
-                                    break;
-                                case kMiddle_SubsetType:
-                                    basename.append("_Middle");
-                                    subset = SkIRect::MakeXYWH((width - subsetSize) / 2,
-                                            (height - subsetSize) / 2, subsetSize, subsetSize);
-                                    break;
-                                case kBottomLeft_SubsetType:
-                                    basename.append("_BottomLeft");
-                                    subset = SkIRect::MakeXYWH(0, height - subsetSize, subsetSize,
-                                            subsetSize);
-                                    break;
-                                case kBottomRight_SubsetType:
-                                    basename.append("_BottomRight");
-                                    subset = SkIRect::MakeXYWH(width - subsetSize,
-                                            height - subsetSize, subsetSize, subsetSize);
-                                    break;
-                                default:
-                                    SkASSERT(false);
-                            }
-
-                            return new BitmapRegionDecoderBench(basename.c_str(), encoded.get(),
-                                    strategy, colorType, sampleSize, subset);
-                        }
-                        fCurrentSubsetType = 0;
-                        fCurrentSampleSize++;
+                        return new BitmapRegionDecoderBench(basename.c_str(), encoded.get(),
+                                colorType, sampleSize, subset);
                     }
-                    fCurrentSampleSize = 0;
-                    fCurrentColorType++;
+                    fCurrentSubsetType = 0;
+                    fCurrentSampleSize++;
                 }
-                fCurrentColorType = 0;
-                fCurrentBRDStrategy++;
+                fCurrentSampleSize = 0;
+                fCurrentColorType++;
             }
-            fCurrentBRDStrategy = 0;
+            fCurrentColorType = 0;
         }
 
         return nullptr;
     }
 
     void fillCurrentOptions(ResultsWriter* log) const {
         log->configOption("source_type", fSourceType);
         log->configOption("bench_type",  fBenchType);
         if (0 == strcmp(fSourceType, "skp")) {
             log->configOption("clip",
@@ skipping 43 matching lines @@
     int fCurrentRecording;
     int fCurrentScale;
     int fCurrentSKP;
     int fCurrentUseMPD;
     int fCurrentCodec;
     int fCurrentAndroidCodec;
     int fCurrentBRDImage;
     int fCurrentColorType;
     int fCurrentAlphaType;
     int fCurrentSubsetType;
-    int fCurrentBRDStrategy;
     int fCurrentSampleSize;
     int fCurrentAnimSKP;
 };
 
 // Some runs (mostly, Valgrind) are so slow that the bot framework thinks we've hung.
 // This prints something every once in a while so that it knows we're still working.
 static void start_keepalive() {
     struct Loop {
         static void forever(void*) {
             for (;;) {
@@ skipping 268 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif