apply --match to image file names too, like we do for .skps

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 725 matching lines @@
                     SKPAnimationBench::CreateZoomAnimation(fZoomMax, fZoomPeriodMs));
                 return new SKPAnimationBench(name.c_str(), pic.get(), fClip, animation,
                                              FLAGS_loopSKP);
             }
         }
 
         for (; fCurrentCodec < fImages.count(); fCurrentCodec++) {
             fSourceType = "image";
             fBenchType = "skcodec";
             const SkString& path = fImages[fCurrentCodec];
+            if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {

[msarett, 2016/01/11 19:55:49]

I should have noticed this on my review, but this actually causes a problem for
my most common use case.

out/Release/nanobench --match Codec --images pngs/

"Codec" won't match the image name, so all of the tests will be skipped.  On the
other hand, if this is how everything else works, I'm still fine with it.  There
are tons of workarounds for me.

[scroggo, 2016/02/03 15:30:00]

Proposed fix in crrev.com/1663103002

+                continue;
+            }
             SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
             SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
             if (!codec) {
                 // Nothing to time.
                 SkDebugf("Cannot find codec for %s\n", path.c_str());
                 continue;
             }
 
             while (fCurrentColorType < fColorTypes.count()) {
                 const SkColorType colorType = fColorTypes[fCurrentColorType];
@@ skipping 47 matching lines @@
                     default:
                         // This represents some sort of failure.
                         SkASSERT(false);
                         break;
                 }
             }
             fCurrentColorType = 0;
         }
 
         // Run the DecodingBenches
-        while (fCurrentImage < fImages.count()) {
+        for (; fCurrentImage < fImages.count(); fCurrentImage++) {
             fSourceType = "image";
             fBenchType = "skimagedecoder";
+            const SkString& path = fImages[fCurrentImage];
+            if (SkCommandLineFlags::ShouldSkip(FLAGS_match, path.c_str())) {
+                continue;
+            }
             while (fCurrentColorType < fColorTypes.count()) {
-                const SkString& path = fImages[fCurrentImage];
                 SkColorType colorType = fColorTypes[fCurrentColorType];
                 fCurrentColorType++;
                 // Check if the image decodes to the right color type
                 // before creating the benchmark
                 SkBitmap bitmap;
                 if (SkImageDecoder::DecodeFile(path.c_str(), &bitmap,
                         colorType, SkImageDecoder::kDecodePixels_Mode)
                         && bitmap.colorType() == colorType) {
                     return new DecodingBench(path, colorType);
                 }
             }
             fCurrentColorType = 0;
-            fCurrentImage++;
         }
 
         // 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:
         //     JPEG decodes using kOriginal_Strategy are broken for non-powers of two.
         //         https://bug.skia.org/4319
         //     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 sampleSizes[] = { 1, 2, 4, 8, 16, 32, 64 };
         const uint32_t minOutputSize = 512;
-        while (fCurrentBRDImage < fImages.count()) {
+        for (; fCurrentBRDImage < fImages.count(); fCurrentBRDImage++) {
+            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 SkString& path = fImages[fCurrentBRDImage];
                 const SkBitmapRegionDecoder::Strategy strategy =
                         strategies[fCurrentBRDStrategy].fStrategy;
 
                 while (fCurrentColorType < fColorTypes.count()) {
                     while (fCurrentBRDSampleSize < (int) SK_ARRAY_COUNT(sampleSizes)) {
                         while (fCurrentSubsetType <= kLastSingle_SubsetType) {
 
 
                             SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
                             const SkColorType colorType = fColorTypes[fCurrentColorType];
@@ skipping 45 matching lines @@
                         fCurrentSubsetType = 0;
                         fCurrentBRDSampleSize++;
                     }
                     fCurrentBRDSampleSize = 0;
                     fCurrentColorType++;
                 }
                 fCurrentColorType = 0;
                 fCurrentBRDStrategy++;
             }
             fCurrentBRDStrategy = 0;
-            fCurrentBRDImage++;
         }
 
         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 304 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif