Remove Subset*Benches

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"
 
 #include "Benchmark.h"
 #include "BitmapRegionDecoderBench.h"
 #include "CodecBench.h"
 #include "CodecBenchPriv.h"
 #include "CrashHandler.h"
 #include "DecodingBench.h"
 #include "GMBench.h"
 #include "ProcStats.h"
 #include "ResultsWriter.h"
 #include "RecordingBench.h"
 #include "SKPAnimationBench.h"
 #include "SKPBench.h"
-#include "SubsetSingleBench.h"
-#include "SubsetTranslateBench.h"
-#include "SubsetZoomBench.h"
 #include "Stats.h"
 
 #include "SkBitmapRegionDecoder.h"
 #include "SkBBoxHierarchy.h"
 #include "SkCanvas.h"
 #include "SkCodec.h"
 #include "SkCommonFlags.h"
 #include "SkData.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
@@ skipping 462 matching lines @@
         break;
     }
 
     if (!target->init(info, bench)) {
         delete target;
         return nullptr;
     }
     return target;
 }
 
-/*
- * We only run our subset benches on files that are supported by BitmapRegionDecoder:
- * i.e. PNG, JPEG, and WEBP. We do *not* test WEBP, since we do not have a scanline
- * decoder for WEBP, which is necessary for running the subset bench. (Another bench
- * must be used to test WEBP, which decodes subsets natively.)
- */
-static bool run_subset_bench(const SkString& path) {
-    static const char* const exts[] = {
-        "jpg", "jpeg", "png",
-        "JPG", "JPEG", "PNG",
-    };
-
-    for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
-        if (path.endsWith(exts[i])) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/*
- * Returns true if set up for a subset decode succeeds, false otherwise
- * If the set-up succeeds, the width and height parameters will be set
- */
-static bool valid_subset_bench(const SkString& path, SkColorType colorType,
-        int* width, int* height) {
-    SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
-    SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(encoded));
-
-    // Check that we can create a codec.
-    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.detach()));
-    if (nullptr == codec) {
-        SkDebugf("Could not create codec for %s.  Skipping bench.\n", path.c_str());
-        return false;
-    }
-
-    // These will be initialized by SkCodec if the color type is kIndex8 and
-    // unused otherwise.
-    SkPMColor colors[256];
-    int colorCount;
-    const SkImageInfo info = codec->getInfo().makeColorType(colorType);
-    if (codec->startScanlineDecode(info, nullptr, colors, &colorCount) != SkCodec::kSuccess)
-    {
-        SkDebugf("Could not create scanline decoder for %s with color type %s.  "
-                "Skipping bench.\n", path.c_str(), color_type_to_str(colorType));
-        return false;
-    }
-    *width = info.width();
-    *height = info.height();
-
-    // Check if the image is large enough for a meaningful subset benchmark.
-    if (*width <= 512 && *height <= 512) {
-        // This should not print a message since it is not an error.
-        return false;
-    }
-
-    return true;
-}
-
 static bool valid_brd_bench(SkData* encoded, SkBitmapRegionDecoder::Strategy strategy,
         SkColorType colorType, uint32_t sampleSize, uint32_t minOutputSize, int* width,
         int* height) {
     SkAutoTDelete<SkBitmapRegionDecoder> brd(
             SkBitmapRegionDecoder::Create(encoded, strategy));
     if (nullptr == brd.get()) {
         // This is indicates that subset decoding is not supported for a particular image format.
         return false;
     }
 
@@ skipping 31 matching lines @@
 class BenchmarkStream {
 public:
     BenchmarkStream() : fBenches(BenchRegistry::Head())
                       , fGMs(skiagm::GMRegistry::Head())
                       , fCurrentRecording(0)
                       , fCurrentScale(0)
                       , fCurrentSKP(0)
                       , fCurrentUseMPD(0)
                       , fCurrentCodec(0)
                       , fCurrentImage(0)
-                      , fCurrentSubsetImage(0)
                       , fCurrentBRDImage(0)
                       , fCurrentColorType(0)
                       , fCurrentSubsetType(0)
                       , fCurrentBRDStrategy(0)
                       , fCurrentBRDSampleSize(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 {
@@ skipping 231 matching lines @@
                 if (SkImageDecoder::DecodeFile(path.c_str(), &bitmap,
                         colorType, SkImageDecoder::kDecodePixels_Mode)
                         && bitmap.colorType() == colorType) {
                     return new DecodingBench(path, colorType);
                 }
             }
             fCurrentColorType = 0;
             fCurrentImage++;
         }
 
-        // Run the SubsetBenches
-        while (fCurrentSubsetImage < fImages.count()) {
-            fSourceType = "image";
-            fBenchType = "skcodec";
-            const SkString& path = fImages[fCurrentSubsetImage];
-            if (!run_subset_bench(path)) {
-                fCurrentSubsetImage++;
-                continue;
-            }
-            while (fCurrentColorType < fColorTypes.count()) {
-                SkColorType colorType = fColorTypes[fCurrentColorType];
-                while (fCurrentSubsetType <= kLast_SubsetType) {
-                    int width = 0;
-                    int height = 0;
-                    int currentSubsetType = fCurrentSubsetType++;
-                    if (valid_subset_bench(path, colorType, &width, &height)) {
-                        switch (currentSubsetType) {
-                            case kTopLeft_SubsetType:
-                                return new SubsetSingleBench(path, colorType, width/3,
-                                        height/3, 0, 0);
-                            case kTopRight_SubsetType:
-                                return new SubsetSingleBench(path, colorType, width/3,
-                                        height/3, 2*width/3, 0);
-                            case kMiddle_SubsetType:
-                                return new SubsetSingleBench(path, colorType, width/3,
-                                        height/3, width/3, height/3);
-                            case kBottomLeft_SubsetType:
-                                return new SubsetSingleBench(path, colorType, width/3,
-                                        height/3, 0, 2*height/3);
-                            case kBottomRight_SubsetType:
-                                return new SubsetSingleBench(path, colorType, width/3,
-                                        height/3, 2*width/3, 2*height/3);
-                            case kTranslate_SubsetType:
-                                return new SubsetTranslateBench(path, colorType, 512, 512);
-                            case kZoom_SubsetType:
-                                return new SubsetZoomBench(path, colorType, 512, 512);
-                        }
-                    } else {
-                        break;
-                    }
-                }
-                fCurrentSubsetType = 0;
-                fCurrentColorType++;
-            }
-            fCurrentColorType = 0;
-            fCurrentSubsetImage++;
-        }
-
         // 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" },
         };
 
@@ skipping 137 matching lines @@
     double fSKPBytes, fSKPOps;
 
     const char* fSourceType;  // What we're benching: bench, GM, SKP, ...
     const char* fBenchType;   // How we bench it: micro, recording, playback, ...
     int fCurrentRecording;
     int fCurrentScale;
     int fCurrentSKP;
     int fCurrentUseMPD;
     int fCurrentCodec;
     int fCurrentImage;
-    int fCurrentSubsetImage;
     int fCurrentBRDImage;
     int fCurrentColorType;
     int fCurrentSubsetType;
     int fCurrentBRDStrategy;
     int fCurrentBRDSampleSize;
     int fCurrentAnimSKP;
 };
 
 int nanobench_main();
 int nanobench_main() {
@@ skipping 220 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif