Revert "Make gm use SkFlags."

gm/gmmain.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*
  * Code for the "gm" (Golden Master) rendering comparison tool.
  *
  * If you make changes to this, re-run the self-tests at gm/tests/run.sh
  * to make sure they still pass... you may need to change the expected
  * results of the self-test.
  */
 
 #include "gm.h"
 #include "gm_expectations.h"
 #include "system_preferences.h"
 #include "SkBitmap.h"
 #include "SkBitmapChecksummer.h"
 #include "SkColorPriv.h"
 #include "SkData.h"
 #include "SkDeferredCanvas.h"
 #include "SkDevice.h"
 #include "SkDrawFilter.h"
-#include "SkFlags.h"
 #include "SkGPipe.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkRefCnt.h"
 #include "SkStream.h"
 #include "SkTArray.h"
 #include "SkTileGridPicture.h"
@@ skipping 14 matching lines @@
 #include "GrContextFactory.h"
 #include "GrRenderTarget.h"
 #include "SkGpuDevice.h"
 typedef GrContextFactory::GLContextType GLContextType;
 #else
 class GrContext;
 class GrRenderTarget;
 typedef int GLContextType;
 #endif
 
+static bool gForceBWtext;
+
 extern bool gSkSuppressFontCachePurgeSpew;
 
 #ifdef SK_SUPPORT_PDF
     #include "SkPDFDevice.h"
     #include "SkPDFDocument.h"
 #endif
 
 // Until we resolve http://code.google.com/p/skia/issues/detail?id=455 ,
 // stop writing out XPS-format image baselines in gm.
 #undef SK_SUPPORT_XPS
@@ skipping 284 matching lines @@
      *    CON: Math is hard.
      *
      * 4. Perform a "close enough" comparison of bitmaps (+/- 1 bit in each
      *    channel), rather than demanding absolute equality.
      *    CON: Can't do this with checksums.
      */
     static void complete_bitmap(SkBitmap* bitmap) {
         force_all_opaque(*bitmap);
     }
 
-    static void installFilter(SkCanvas* canvas);
+    static void installFilter(SkCanvas* canvas) {
+        if (gForceBWtext) {
+            canvas->setDrawFilter(new BWTextDrawFilter)->unref();
+        }
+    }
 
     static void invokeGM(GM* gm, SkCanvas* canvas, bool isPDF, bool isDeferred) {
         SkAutoCanvasRestore acr(canvas, true);
 
         if (!isPDF) {
             canvas->concat(gm->getInitialTransform());
         }
         installFilter(canvas);
         gm->setCanvasIsDeferred(isDeferred);
         gm->draw(canvas);
@@ skipping 513 matching lines @@
 
     ErrorBitfield test_pipe_playback(GM* gm,
                                      const ConfigData& gRec,
                                      const SkBitmap& referenceBitmap) {
         ErrorBitfield errors = kEmptyErrorBitfield;
         for (size_t i = 0; i < SK_ARRAY_COUNT(gPipeWritingFlagCombos); ++i) {
             SkBitmap bitmap;
             SkISize size = gm->getISize();
             setup_bitmap(gRec, size, &bitmap);
             SkCanvas canvas(bitmap);
+            installFilter(&canvas);
             PipeController pipeController(&canvas);
             SkGPipeWriter writer;
             SkCanvas* pipeCanvas = writer.startRecording(
               &pipeController, gPipeWritingFlagCombos[i].flags);
             invokeGM(gm, pipeCanvas, false, false);
             complete_bitmap(&bitmap);
             writer.endRecording();
             SkString string("-pipe");
             string.append(gPipeWritingFlagCombos[i].name);
             errors |= compare_test_results_to_reference_bitmap(
                 gm, gRec, string.c_str(), bitmap, &referenceBitmap);
             if (errors != kEmptyErrorBitfield) {
                 break;
             }
         }
         return errors;
     }
 
     ErrorBitfield test_tiled_pipe_playback(
       GM* gm, const ConfigData& gRec, const SkBitmap& referenceBitmap) {
         ErrorBitfield errors = kEmptyErrorBitfield;
         for (size_t i = 0; i < SK_ARRAY_COUNT(gPipeWritingFlagCombos); ++i) {
             SkBitmap bitmap;
             SkISize size = gm->getISize();
             setup_bitmap(gRec, size, &bitmap);
             SkCanvas canvas(bitmap);
+            installFilter(&canvas);
             TiledPipeController pipeController(bitmap);
             SkGPipeWriter writer;
             SkCanvas* pipeCanvas = writer.startRecording(
               &pipeController, gPipeWritingFlagCombos[i].flags);
             invokeGM(gm, pipeCanvas, false, false);
             complete_bitmap(&bitmap);
             writer.endRecording();
             SkString string("-tiled pipe");
             string.append(gPipeWritingFlagCombos[i].name);
             errors |= compare_test_results_to_reference_bitmap(
@@ skipping 65 matching lines @@
 #endif // defined(SK_SCALAR_IS_FLOAT) && SK_SUPPORT_GPU
 #ifdef SK_SUPPORT_XPS
     /* At present we have no way of comparing XPS files (either natively or by converting to PNG). */
     { SkBitmap::kARGB_8888_Config, kXPS_Backend,    kDontCare_GLContextType,                  0, kWrite_ConfigFlag, "xps" },
 #endif // SK_SUPPORT_XPS
 #ifdef SK_SUPPORT_PDF
     { SkBitmap::kARGB_8888_Config, kPDF_Backend,    kDontCare_GLContextType,                  0, kPDFConfigFlags,   "pdf" },
 #endif // SK_SUPPORT_PDF
 };
 
-static SkString configUsage() {
-    SkString result("Possible options for --config: [");
+static void usage(const char * argv0) {
+    fprintf(stderr, "%s\n", argv0);
+    fprintf(stderr, "    [--config ");
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
         if (i > 0) {
-            result.appendf("|");
+            fprintf(stderr, "|");
         }
-        result.appendf("%s", gRec[i].fName);
+        fprintf(stderr, "%s", gRec[i].fName);
     }
-    result.appendf("]");
-    return result;
+    fprintf(stderr, "]:\n        run these configurations\n");
+    fprintf(stderr,
+// Alphabetized ignoring "no" prefix ("readPath", "noreplay", "resourcePath").
+// It would probably be better if we allowed both yes-and-no settings for each
+// one, e.g.:
+// [--replay|--noreplay]: whether to exercise SkPicture replay; default is yes
+"    [--nodeferred]: skip the deferred rendering test pass\n"
+"    [--disable-missing-warning]: don't print a message to stderr if\n"
+"        unable to read a reference image for any tests (NOT default behavior)\n"
+"    [--enable-missing-warning]: print message to stderr (but don't fail) if\n"
+"        unable to read a reference image for any tests (default behavior)\n"
+"    [--exclude-config]: disable this config (may be used multiple times)\n"
+"    [--forceBWtext]: disable text anti-aliasing\n"
+#if SK_SUPPORT_GPU
+"    [--gpuCacheSize <bytes> <count>]: limits gpu cache to byte size or object count\n"
+"        -1 for either value means use the default. 0 for either disables the cache.\n"
+#endif
+"    [--help|-h]: show this help message\n"
+"    [--hierarchy|--nohierarchy]: whether to use multilevel directory structure\n"
+"        when reading/writing files; default is no\n"
+"    [--match <substring>]: only run tests whose name includes this substring\n"
+"    [--mismatchPath <path>]: write images for tests that failed due to\n"
+"        pixel mismatched into this directory"
+"    [--modulo <remainder> <divisor>]: only run tests for which \n"
+"        testIndex %% divisor == remainder\n"
+"    [--nopdf]: skip the pdf rendering test pass\n"
+"    [--nopipe]: Skip SkGPipe replay\n"
+"    [--readPath|-r <path>]: read reference images from this dir, and report\n"
+"        any differences between those and the newly generated ones\n"
+"    [--noreplay]: do not exercise SkPicture replay\n"
+"    [--resourcePath|-i <path>]: directory that stores image resources\n"
+"    [--nortree]: Do not exercise the R-Tree variant of SkPicture\n"
+"    [--noserialize]: do not exercise SkPicture serialization & deserialization\n"
+"    [--tiledPipe]: Exercise tiled SkGPipe replay\n"
+"    [--notileGrid]: Do not exercise the tile grid variant of SkPicture\n"
+"    [--tileGridReplayScales <scales>]: Comma separated list of floating-point scale\n"
+"        factors to be used for tileGrid playback testing. Default value: 1.0\n"
+"    [--writeJsonSummary <path>]: write a JSON-formatted result summary to this file\n"
+"    [--verbose] print diagnostics (e.g. list each config to be tested)\n"
+"    [--writePath|-w <path>]: write rendered images into this directory\n"
+"    [--writePicturePath|-wp <path>]: write .skp files into this directory\n"
+             );
 }
 
-// Alphabetized ignoring "no" prefix ("readPath", "noreplay", "resourcePath").
-DEFINE_string(config, "", "Space delimited list of which configs to run. "
-              "Possible configs listed above. If none are specified, "
-              "all will be run.");
-DEFINE_bool(deferred, true, "Exercise the deferred rendering test pass.");
-DEFINE_bool(enableMissingWarning, true, "Print message to stderr (but don't fail) if "
-            "unable to read a reference image for any tests.");
-DEFINE_string(excludeConfig, "", "Space delimited list of configs to skip.");
-DEFINE_bool(forceBWtext, false, "Disable text anti-aliasing.");
-DEFINE_string(gpuCacheSize, "", "<bytes> <count>: Limit the gpu cache to byte size or "
-              "object count. -1 for either value means use the default. 0 for either "
-              "disables the cache.");
-DEFINE_bool(hierarchy, false, "Whether to use multilevel directory structure "
-            "when reading/writing files.");
-DEFINE_string(match, "",  "Only run tests whose name includes this substring/these substrings "
-              "(more than one can be supplied, separated by spaces).");
-DEFINE_string(mismatchPath, "", "Write images for tests that failed due to "
-              "pixel mismatches into this directory.");
-DEFINE_string(modulo, "", "[--modulo <remainder> <divisor>]: only run tests for which "
-              "testIndex %% divisor == remainder.");
-DEFINE_bool(pdf, true, "Exercise the pdf rendering test pass.");
-DEFINE_bool(pipe, true, "Exercise the SkGPipe replay test pass.");
-DEFINE_string2(readPath, r, "", "Read reference images from this dir, and report "
-               "any differences between those and the newly generated ones.");
-DEFINE_bool(replay, true, "Exercise the SkPicture replay test pass.");
-DEFINE_string2(resourcePath, i, "", "Directory that stores image resources.");
-DEFINE_bool(rtree, true, "Exercise the R-Tree variant of SkPicture test pass.");
-DEFINE_bool(serialize, true, "Exercise the SkPicture serialization & deserialization test pass.");
-DEFINE_bool(tiledPipe, false, "Exercise tiled SkGPipe replay.");
-DEFINE_bool(tileGrid, true, "Exercise the tile grid variant of SkPicture.");
-DEFINE_string(tileGridReplayScales, "", "Space separated list of floating-point scale "
-              "factors to be used for tileGrid playback testing. Default value: 1.0");
-DEFINE_string(writeJsonSummaryPath, "", "Write a JSON-formatted result summary to this file.");
-DEFINE_bool2(verbose, v, false, "Print diagnostics (e.g. list each config to be tested).");
-DEFINE_string2(writePath, w, "",  "Write rendered images into this directory.");
-DEFINE_string2(writePicturePath, wp, "", "Write .skp files into this directory.");
-
 static int findConfig(const char config[]) {
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); i++) {
         if (!strcmp(config, gRec[i].fName)) {
             return i;
         }
     }
     return -1;
 }
 
 static bool skip_name(const SkTDArray<const char*> array, const char name[]) {
@@ skipping 65 matching lines @@
     gPrintInstCount = true;
 #endif
 
     SkGraphics::Init();
     // we don't need to see this during a run
     gSkSuppressFontCachePurgeSpew = true;
 
     setSystemPreferences();
     GMMain gmmain;
 
+    const char* writeJsonSummaryPath = NULL;// if non-null, where we write the JSON summary
+    const char* writePath = NULL;   // if non-null, where we write the originals
+    const char* writePicturePath = NULL;    // if non-null, where we write serialized pictures
+    const char* readPath = NULL;    // if non-null, were we read from to compare
+    const char* resourcePath = NULL;// if non-null, where we read from for image resources
+
+    // if true, emit a message when we can't find a reference image to compare
+    bool notifyMissingReadReference = true;
+
+    SkTDArray<const char*> fMatches;
+
+    bool doPDF = true;
+    bool doReplay = true;
+    bool doPipe = true;
+    bool doTiledPipe = false;
+    bool doSerialize = true;
+    bool doDeferred = true;
+    bool doRTree = true;
+    bool doTileGrid = true;
+    bool doVerbose = false;
+
     SkTDArray<size_t> configs;
     SkTDArray<size_t> excludeConfigs;
     SkTDArray<SkScalar> tileGridReplayScales;
     *tileGridReplayScales.append() = SK_Scalar1; // By default only test at scale 1.0
     bool userConfig = false;
 
-    SkString usage;
-    usage.printf("Run the golden master tests.\n\t%s", configUsage().c_str());
-    SkFlags::SetUsage(usage.c_str());
-    SkFlags::ParseCommandLine(argc, argv);
-
+    int moduloRemainder = -1;
+    int moduloDivisor = -1;
+
+#if SK_SUPPORT_GPU
     struct {
         int     fBytes;
         int     fCount;
     } gpuCacheSize = { -1, -1 }; // -1s mean use the default
-
-    if (FLAGS_gpuCacheSize.count() > 0) {
-        if (FLAGS_gpuCacheSize.count() != 2) {
-            gm_fprintf(stderr, "--gpuCacheSize requires two arguments\n");
+#endif
+
+    const char* const commandName = argv[0];
+    char* const* stop = argv + argc;
+    for (++argv; argv < stop; ++argv) {
+        if (strcmp(*argv, "--config") == 0) {
+            argv++;
+            if (argv < stop) {
+                int index = findConfig(*argv);
+                if (index >= 0) {
+                    appendUnique<size_t>(&configs, index);
+                    userConfig = true;
+                } else {
+                    gm_fprintf(stderr, "unrecognized config %s\n", *argv);
+                    usage(commandName);
+                    return -1;
+                }
+            } else {
+                gm_fprintf(stderr, "missing arg for --config\n");
+                usage(commandName);
+                return -1;
+            }
+        } else if (strcmp(*argv, "--exclude-config") == 0) {
+            argv++;
+            if (argv < stop) {
+                int index = findConfig(*argv);
+                if (index >= 0) {
+                    *excludeConfigs.append() = index;
+                } else {
+                    gm_fprintf(stderr, "unrecognized exclude-config %s\n", *argv);
+                    usage(commandName);
+                    return -1;
+                }
+            } else {
+                gm_fprintf(stderr, "missing arg for --exclude-config\n");
+                usage(commandName);
+                return -1;
+            }
+        } else if (strcmp(*argv, "--nodeferred") == 0) {
+            doDeferred = false;
+        } else if (strcmp(*argv, "--disable-missing-warning") == 0) {
+            notifyMissingReadReference = false;
+        } else if (strcmp(*argv, "--mismatchPath") == 0) {
+            argv++;
+            if (argv < stop && **argv) {
+                gmmain.fMismatchPath = *argv;
+            }
+        } else if (strcmp(*argv, "--nortree") == 0) {
+            doRTree = false;
+        } else if (strcmp(*argv, "--notileGrid") == 0) {
+            doTileGrid = false;
+        } else if (strcmp(*argv, "--tileGridReplayScales") == 0) {
+            tileGridReplayScales.reset();
+            ++argv;
+            if (argv < stop) {
+                char* token = strtok(*argv, ",");
+                while (NULL != token) {
+                    double val = atof(token);
+                    if (0 < val) {
+                        *tileGridReplayScales.append() = SkDoubleToScalar(val);
+                    }
+                    token = strtok(NULL, ",");
+                }
+            }
+            if (0 == tileGridReplayScales.count()) {
+                // Should have at least one scale
+                usage(commandName);
+                return -1;
+            }
+        } else if (strcmp(*argv, "--enable-missing-warning") == 0) {
+            notifyMissingReadReference = true;
+        } else if (strcmp(*argv, "--forceBWtext") == 0) {
+            gForceBWtext = true;
+#if SK_SUPPORT_GPU
+        } else if (strcmp(*argv, "--gpuCacheSize") == 0) {
+            if (stop - argv > 2) {
+                gpuCacheSize.fBytes = atoi(*++argv);
+                gpuCacheSize.fCount = atoi(*++argv);
+            } else {
+                gm_fprintf(stderr, "missing arg for --gpuCacheSize\n");
+                usage(commandName);
+                return -1;
+            }
+#endif
+        } else if (strcmp(*argv, "--help") == 0 || strcmp(*argv, "-h") == 0) {
+            usage(commandName);
             return -1;
-        }
-        gpuCacheSize.fBytes = atoi(FLAGS_gpuCacheSize[0]);
-        gpuCacheSize.fCount = atoi(FLAGS_gpuCacheSize[1]);
-    }
-
-    gmmain.fUseFileHierarchy = FLAGS_hierarchy;
-    if (FLAGS_mismatchPath.count() == 1) {
-        gmmain.fMismatchPath = FLAGS_mismatchPath[0];
-    }
-
-    for (int i = 0; i < FLAGS_config.count(); i++) {
-        int index = findConfig(FLAGS_config[i]);
-        if (index >= 0) {
-            appendUnique<size_t>(&configs, index);
-            userConfig = true;
+        } else if (strcmp(*argv, "--hierarchy") == 0) {
+            gmmain.fUseFileHierarchy = true;
+        } else if (strcmp(*argv, "--nohierarchy") == 0) {
+            gmmain.fUseFileHierarchy = false;
+        } else if (strcmp(*argv, "--match") == 0) {
+            ++argv;
+            if (argv < stop && **argv) {
+                // just record the ptr, no need for a deep copy
+                *fMatches.append() = *argv;
+            }
+        } else if (strcmp(*argv, "--modulo") == 0) {
+            ++argv;
+            if (argv >= stop) {
+                continue;
+            }
+            moduloRemainder = atoi(*argv);
+
+            ++argv;
+            if (argv >= stop) {
+                continue;
+            }
+            moduloDivisor = atoi(*argv);
+            if (moduloRemainder < 0 || moduloDivisor <= 0 || moduloRemainder >= moduloDivisor) {
+                gm_fprintf(stderr, "invalid modulo values.");
+                return -1;
+            }
+        } else if (strcmp(*argv, "--nopdf") == 0) {
+            doPDF = false;
+        } else if (strcmp(*argv, "--nopipe") == 0) {
+            doPipe = false;
+        } else if ((0 == strcmp(*argv, "--readPath")) ||
+                   (0 == strcmp(*argv, "-r"))) {
+            argv++;
+            if (argv < stop && **argv) {
+                readPath = *argv;
+            }
+        } else if (strcmp(*argv, "--noreplay") == 0) {
+            doReplay = false;
+        } else if ((0 == strcmp(*argv, "--resourcePath")) ||
+                   (0 == strcmp(*argv, "-i"))) {
+            argv++;
+            if (argv < stop && **argv) {
+                resourcePath = *argv;
+            }
+        } else if (strcmp(*argv, "--serialize") == 0) {
+            doSerialize = true;
+        } else if (strcmp(*argv, "--noserialize") == 0) {
+            doSerialize = false;
+        } else if (strcmp(*argv, "--tiledPipe") == 0) {
+            doTiledPipe = true;
+        } else if (!strcmp(*argv, "--verbose") || !strcmp(*argv, "-v")) {
+            doVerbose = true;
+        } else if ((0 == strcmp(*argv, "--writePath")) ||
+            (0 == strcmp(*argv, "-w"))) {
+            argv++;
+            if (argv < stop && **argv) {
+                writePath = *argv;
+            }
+        } else if (0 == strcmp(*argv, "--writeJsonSummary")) {
+            argv++;
+            if (argv < stop && **argv) {
+                writeJsonSummaryPath = *argv;
+            }
+        } else if ((0 == strcmp(*argv, "--writePicturePath")) ||
+                   (0 == strcmp(*argv, "-wp"))) {
+            argv++;
+            if (argv < stop && **argv) {
+                writePicturePath = *argv;
+            }
         } else {
-            gm_fprintf(stderr, "unrecognized config %s\n", FLAGS_config[i]);
+            usage(commandName);
             return -1;
         }
     }
-
-    for (int i = 0; i < FLAGS_excludeConfig.count(); i++) {
-        int index = findConfig(FLAGS_excludeConfig[i]);
-        if (index >= 0) {
-            *excludeConfigs.append() = index;
-        } else {
-            gm_fprintf(stderr, "unrecognized excludeConfig %s\n", FLAGS_excludeConfig[i]);
-            return -1;
-        }
+    if (argv != stop) {
+        usage(commandName);
+        return -1;
     }
 
-    if (FLAGS_tileGridReplayScales.count() > 0) {
-        tileGridReplayScales.reset();
-        for (int i = 0; i < FLAGS_tileGridReplayScales.count(); i++) {
-            double val = atof(FLAGS_tileGridReplayScales[i]);
-            if (0 < val) {
-                *tileGridReplayScales.append() = SkDoubleToScalar(val);
-            }
-        }
-        if (0 == tileGridReplayScales.count()) {
-            // Should have at least one scale
-            gm_fprintf(stderr, "--tileGridReplayScales requires at least one scale.\n");
-            return -1;
-        }
-    }
-
-    int moduloRemainder = -1;
-    int moduloDivisor = -1;
-
-    if (FLAGS_modulo.count() == 2) {
-        moduloRemainder = atoi(FLAGS_modulo[0]);
-        moduloDivisor = atoi(FLAGS_modulo[1]);
-        if (moduloRemainder < 0 || moduloDivisor <= 0 || moduloRemainder >= moduloDivisor) {
-            gm_fprintf(stderr, "invalid modulo values.");
-            return -1;
-        }
-    }
-
     if (!userConfig) {
         // if no config is specified by user, we add them all.
         for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
             *configs.append() = i;
         }
     }
     // now remove any explicitly excluded configs
     for (int i = 0; i < excludeConfigs.count(); ++i) {
         int index = configs.find(excludeConfigs[i]);
         if (index >= 0) {
             configs.remove(index);
             // now assert that there was only one copy in configs[]
             SkASSERT(configs.find(excludeConfigs[i]) < 0);
         }
     }
 
-    if (FLAGS_verbose) {
+    if (doVerbose) {
         SkString str;
         str.printf("%d configs:", configs.count());
         for (int i = 0; i < configs.count(); ++i) {
             str.appendf(" %s", gRec[configs[i]].fName);
         }
         gm_fprintf(stderr, "%s\n", str.c_str());
     }
 
-    if (FLAGS_resourcePath.count() == 1) {
-        GM::SetResourcePath(FLAGS_resourcePath[0]);
-    }
+    GM::SetResourcePath(resourcePath);
 
-    if (FLAGS_readPath.count() == 1) {
-        const char* readPath = FLAGS_readPath[0];
+    if (readPath) {
         if (!sk_exists(readPath)) {
             gm_fprintf(stderr, "readPath %s does not exist!\n", readPath);
             return -1;
         }
         if (sk_isdir(readPath)) {
             gm_fprintf(stdout, "reading from %s\n", readPath);
             gmmain.fExpectationsSource.reset(SkNEW_ARGS(
                 IndividualImageExpectationsSource,
-                (readPath, FLAGS_enableMissingWarning)));
+                (readPath, notifyMissingReadReference)));
         } else {
             gm_fprintf(stdout, "reading expectations from JSON summary file %s\n", readPath);
             gmmain.fExpectationsSource.reset(SkNEW_ARGS(
                 JsonExpectationsSource, (readPath)));
         }
     }
-    if (FLAGS_writePath.count() == 1) {
-        gm_fprintf(stderr, "writing to %s\n", FLAGS_writePath[0]);
+    if (writePath) {
+        gm_fprintf(stdout, "writing to %s\n", writePath);
     }
-    if (FLAGS_writePicturePath.count() == 1) {
-        gm_fprintf(stderr, "writing pictures to %s\n", FLAGS_writePicturePath[0]);
+    if (writePicturePath) {
+        gm_fprintf(stdout, "writing pictures to %s\n", writePicturePath);
     }
-    if (FLAGS_resourcePath.count() == 1) {
-        gm_fprintf(stderr, "reading resources from %s\n", FLAGS_resourcePath[0]);
+    if (resourcePath) {
+        gm_fprintf(stdout, "reading resources from %s\n", resourcePath);
     }
 
     if (moduloDivisor <= 0) {
         moduloRemainder = -1;
     }
     if (moduloRemainder < 0 || moduloRemainder >= moduloDivisor) {
         moduloRemainder = -1;
     }
 
     // Accumulate success of all tests.
     int testsRun = 0;
     int testsPassed = 0;
     int testsFailed = 0;
     int testsMissingReferenceImages = 0;
 
 #if SK_SUPPORT_GPU
     GrContextFactory* grFactory = new GrContextFactory;
 #endif
 
     int gmIndex = -1;
     SkString moduloStr;
 
     // If we will be writing out files, prepare subdirectories.
-    if (FLAGS_writePath.count() == 1) {
-        if (!sk_mkdir(FLAGS_writePath[0])) {
+    if (writePath) {
+        if (!sk_mkdir(writePath)) {
             return -1;
         }
         if (gmmain.fUseFileHierarchy) {
             for (int i = 0; i < configs.count(); i++) {
                 ConfigData config = gRec[configs[i]];
                 SkString subdir;
-                subdir.appendf("%s%c%s", FLAGS_writePath[0], SkPATH_SEPARATOR,
+                subdir.appendf("%s%c%s", writePath, SkPATH_SEPARATOR,
                                config.fName);
                 if (!sk_mkdir(subdir.c_str())) {
                     return -1;
                 }
             }
         }
     }
 
     Iter iter;
     GM* gm;
     while ((gm = iter.next()) != NULL) {
 
         ++gmIndex;
         if (moduloRemainder >= 0) {
             if ((gmIndex % moduloDivisor) != moduloRemainder) {
                 continue;
             }
             moduloStr.printf("[%d.%d] ", gmIndex, moduloDivisor);
         }
 
         const char* shortName = gm->shortName();
-        if (skip_name(FLAGS_match, shortName)) {
+        if (skip_name(fMatches, shortName)) {
             SkDELETE(gm);
             continue;
         }
 
         SkISize size = gm->getISize();
         gm_fprintf(stdout, "%sdrawing... %s [%d %d]\n", moduloStr.c_str(), shortName,
                    size.width(), size.height());
 
         ErrorBitfield testErrors = kEmptyErrorBitfield;
         uint32_t gmFlags = gm->getFlags();
 
         for (int i = 0; i < configs.count(); i++) {
             ConfigData config = gRec[configs[i]];
 
             // Skip any tests that we don't even need to try.
             if ((kPDF_Backend == config.fBackend) &&
-                (!FLAGS_pdf|| (gmFlags & GM::kSkipPDF_Flag)))
+                (!doPDF || (gmFlags & GM::kSkipPDF_Flag)))
                 {
                     continue;
                 }
             if ((gmFlags & GM::kSkip565_Flag) &&
                 (kRaster_Backend == config.fBackend) &&
                 (SkBitmap::kRGB_565_Config == config.fConfig)) {
                 continue;
             }
             if ((gmFlags & GM::kSkipGPU_Flag) &&
                 kGPU_Backend == config.fBackend) {
@@ skipping 41 matching lines @@
                     gr->setTextureCacheLimits(count, bytes);
                 }
                 if (!grSuccess) {
                     renderErrors |= kNoGpuContext_ErrorBitmask;
                 }
             }
 #endif
 
             SkBitmap comparisonBitmap;
 
-            const char* writePath;
-            if (FLAGS_writePath.count() == 1) {
-                writePath = FLAGS_writePath[0];
-            } else {
-                writePath = NULL;
-            }
             if (kEmptyErrorBitfield == renderErrors) {
                 renderErrors |= gmmain.test_drawing(gm, config, writePath,
                                                     GetGr(),
                                                     renderTarget,
                                                     &comparisonBitmap);
             }
 
-            if (FLAGS_deferred && !renderErrors &&
+            if (doDeferred && !renderErrors &&
                 (kGPU_Backend == config.fBackend ||
                  kRaster_Backend == config.fBackend)) {
                 renderErrors |= gmmain.test_deferred_drawing(gm, config,
                                                              comparisonBitmap,
                                                              GetGr(),
                                                              renderTarget);
             }
 
             testErrors |= renderErrors;
         }
 
         SkBitmap comparisonBitmap;
         const ConfigData compareConfig =
             { SkBitmap::kARGB_8888_Config, kRaster_Backend, kDontCare_GLContextType, 0, kRW_ConfigFlag, "comparison" };
         testErrors |= gmmain.generate_image(gm, compareConfig, NULL, NULL, &comparisonBitmap, false);
 
         // run the picture centric GM steps
         if (!(gmFlags & GM::kSkipPicture_Flag)) {
 
             ErrorBitfield pictErrors = kEmptyErrorBitfield;
 
             //SkAutoTUnref<SkPicture> pict(generate_new_picture(gm));
             SkPicture* pict = gmmain.generate_new_picture(gm, kNone_BbhType, 0);
             SkAutoUnref aur(pict);
 
-            if ((kEmptyErrorBitfield == testErrors) && FLAGS_replay) {
+            if ((kEmptyErrorBitfield == testErrors) && doReplay) {
                 SkBitmap bitmap;
                 gmmain.generate_image_from_picture(gm, compareConfig, pict,
                                                    &bitmap);
                 pictErrors |= gmmain.compare_test_results_to_reference_bitmap(
                     gm, compareConfig, "-replay", bitmap, &comparisonBitmap);
             }
 
             if ((kEmptyErrorBitfield == testErrors) &&
                 (kEmptyErrorBitfield == pictErrors) &&
-                FLAGS_serialize) {
+                doSerialize) {
                 SkPicture* repict = gmmain.stream_to_new_picture(*pict);
                 SkAutoUnref aurr(repict);
 
                 SkBitmap bitmap;
                 gmmain.generate_image_from_picture(gm, compareConfig, repict,
                                                    &bitmap);
                 pictErrors |= gmmain.compare_test_results_to_reference_bitmap(
                     gm, compareConfig, "-serialize", bitmap, &comparisonBitmap);
             }
 
-            if (FLAGS_writePicturePath.count() == 1) {
+            if (writePicturePath) {
                 const char* pictureSuffix = "skp";
-                SkString path = make_filename(FLAGS_writePicturePath[0], "",
+                SkString path = make_filename(writePicturePath, "",
                                               gm->shortName(),
                                               pictureSuffix);
                 SkFILEWStream stream(path.c_str());
                 pict->serialize(&stream);
             }
 
             testErrors |= pictErrors;
         }
 
         // TODO: add a test in which the RTree rendering results in a
         // different bitmap than the standard rendering.  It should
         // show up as failed in the JSON summary, and should be listed
         // in the stdout also.
-        if (!(gmFlags & GM::kSkipPicture_Flag) && FLAGS_rtree) {
+        if (!(gmFlags & GM::kSkipPicture_Flag) && doRTree) {
             SkPicture* pict = gmmain.generate_new_picture(
                 gm, kRTree_BbhType, SkPicture::kUsePathBoundsForClip_RecordingFlag);
             SkAutoUnref aur(pict);
             SkBitmap bitmap;
             gmmain.generate_image_from_picture(gm, compareConfig, pict,
                                                &bitmap);
             testErrors |= gmmain.compare_test_results_to_reference_bitmap(
                 gm, compareConfig, "-rtree", bitmap, &comparisonBitmap);
         }
 
-        if (!(gmFlags & GM::kSkipPicture_Flag) && FLAGS_tileGrid) {
+        if (!(gmFlags & GM::kSkipPicture_Flag) && doTileGrid) {
             for(int scaleIndex = 0; scaleIndex < tileGridReplayScales.count(); ++scaleIndex) {
                 SkScalar replayScale = tileGridReplayScales[scaleIndex];
                 if ((gmFlags & GM::kSkipScaledReplay_Flag) && replayScale != 1)
                     continue;
                 // We record with the reciprocal scale to obtain a replay
                 // result that can be validated against comparisonBitmap.
                 SkScalar recordScale = SkScalarInvert(replayScale);
                 SkPicture* pict = gmmain.generate_new_picture(
                     gm, kTileGrid_BbhType, SkPicture::kUsePathBoundsForClip_RecordingFlag,
                     recordScale);
@@ skipping 10 matching lines @@
                     gm, compareConfig, suffix.c_str(), bitmap,
                     &comparisonBitmap);
             }
         }
 
         // run the pipe centric GM steps
         if (!(gmFlags & GM::kSkipPipe_Flag)) {
 
             ErrorBitfield pipeErrors = kEmptyErrorBitfield;
 
-            if ((kEmptyErrorBitfield == testErrors) && FLAGS_pipe) {
+            if ((kEmptyErrorBitfield == testErrors) && doPipe) {
                 pipeErrors |= gmmain.test_pipe_playback(gm, compareConfig,
                                                         comparisonBitmap);
             }
 
             if ((kEmptyErrorBitfield == testErrors) &&
                 (kEmptyErrorBitfield == pipeErrors) &&
-                FLAGS_tiledPipe && !(gmFlags & GM::kSkipTiled_Flag)) {
+                doTiledPipe && !(gmFlags & GM::kSkipTiled_Flag)) {
                 pipeErrors |= gmmain.test_tiled_pipe_playback(gm, compareConfig,
                                                               comparisonBitmap);
             }
 
             testErrors |= pipeErrors;
         }
 
         // Update overall results.
         // We only tabulate the particular error types that we currently
         // care about (e.g., missing reference images). Later on, if we
         // want to also tabulate other error types, we can do so.
         testsRun++;
         if (!gmmain.fExpectationsSource.get() ||
             (kEmptyErrorBitfield != (kMissingExpectations_ErrorBitmask & testErrors))) {
             testsMissingReferenceImages++;
         }
         if (testErrors == (testErrors & kIgnorable_ErrorBitmask)) {
             testsPassed++;
         } else {
             testsFailed++;
         }
 
         SkDELETE(gm);
     }
     gm_fprintf(stdout, "Ran %d tests: %d passed, %d failed, %d missing reference images\n",
                testsRun, testsPassed, testsFailed, testsMissingReferenceImages);
     gmmain.ListErrors();
 
-    if (FLAGS_writeJsonSummaryPath.count() == 1) {
+    if (NULL != writeJsonSummaryPath) {
         Json::Value actualResults;
         actualResults[kJsonKey_ActualResults_Failed] =
             gmmain.fJsonActualResults_Failed;
         actualResults[kJsonKey_ActualResults_FailureIgnored] =
             gmmain.fJsonActualResults_FailureIgnored;
         actualResults[kJsonKey_ActualResults_NoComparison] =
             gmmain.fJsonActualResults_NoComparison;
         actualResults[kJsonKey_ActualResults_Succeeded] =
             gmmain.fJsonActualResults_Succeeded;
         Json::Value root;
         root[kJsonKey_ActualResults] = actualResults;
         root[kJsonKey_ExpectedResults] = gmmain.fJsonExpectedResults;
         std::string jsonStdString = root.toStyledString();
-        SkFILEWStream stream(FLAGS_writeJsonSummaryPath[0]);
+        SkFILEWStream stream(writeJsonSummaryPath);
         stream.write(jsonStdString.c_str(), jsonStdString.length());
     }
 
 #if SK_SUPPORT_GPU
 
 #if GR_CACHE_STATS
     for (int i = 0; i < configs.count(); i++) {
         ConfigData config = gRec[configs[i]];
 
         if (kGPU_Backend == config.fBackend) {
             GrContext* gr = grFactory->get(config.fGLContextType);
 
             gm_fprintf(stdout, "config: %s %x\n", config.fName, gr);
             gr->printCacheStats();
         }
     }
 #endif
 
     delete grFactory;
 #endif
     SkGraphics::Term();
 
     return (0 == testsFailed) ? 0 : -1;
 }
 
-void GMMain::installFilter(SkCanvas* canvas) {
-    if (FLAGS_forceBWtext) {
-        canvas->setDrawFilter(SkNEW(BWTextDrawFilter))->unref();
-    }
-}
-
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif