Refactor how we handle resources path in Tests.

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_error.h"
 #include "gm_expectations.h"
 #include "system_preferences.h"
+#include "Resources.h"
+#include "SamplePipeControllers.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkCommandLineFlags.h"
 #include "SkData.h"
 #include "SkDeferredCanvas.h"
 #include "SkDevice.h"
 #include "SkDocument.h"
 #include "SkDrawFilter.h"
 #include "SkForceLinking.h"
 #include "SkGPipe.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkJSONCPP.h"
 #include "SkOSFile.h"
 #include "SkPDFRasterizer.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkRefCnt.h"
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkSurface.h"
 #include "SkTArray.h"
 #include "SkTDict.h"
-#include "SamplePipeControllers.h"
 
 #ifdef SK_DEBUG
 static const bool kDebugOnly = true;
 #define GR_DUMP_FONT_CACHE 0
 #else
 static const bool kDebugOnly = false;
 #endif
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
@@ skipping 1400 matching lines @@
 DEFINE_string(modulo, "", "[--modulo <remainder> <divisor>]: only run tests for which "
               "testIndex %% divisor == remainder.");
 DEFINE_bool(pipe, false, "Exercise the SkGPipe replay test pass.");
 DEFINE_bool(quadtree, false, "Exercise the QuadTree variant of SkPicture 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, false, "Exercise the SkPicture replay test pass.");
 #if SK_SUPPORT_GPU
 DEFINE_bool(resetGpuContext, false, "Reset the GrContext prior to running each GM.");
 #endif
-DEFINE_string2(resourcePath, i, "resources", "Directory that stores image resources.");
 DEFINE_bool(rtree, false, "Exercise the R-Tree variant of SkPicture test pass.");
 DEFINE_bool(serialize, false, "Exercise the SkPicture serialization & deserialization test pass.");
 DEFINE_bool(simulatePipePlaybackFailure, false, "Simulate a rendering failure in pipe mode only.");
 DEFINE_bool(tiledPipe, false, "Exercise tiled SkGPipe replay.");
 DEFINE_bool(tileGrid, false, "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_bool2(verbose, v, false, "Give more detail (e.g. list all GMs run, more info about "
              "each test).");
 DEFINE_bool(writeChecksumBasedFilenames, false, "When writing out actual images, use checksum-"
@@ skipping 728 matching lines @@
             if (FLAGS_verbose) {
                 SkDebugf("reading expectations from JSON summary file %s\n", readPath);
             }
             gmmain->fExpectationsSource.reset(SkNEW_ARGS(JsonExpectationsSource, (readPath)));
 #endif
         }
     }
     return true;
 }
 
-static bool parse_flags_resource_path() {
-    if (FLAGS_resourcePath.count() == 1) {
-        GM::SetResourcePath(FLAGS_resourcePath[0]);
-    }
-    return true;
-}
-
 static bool parse_flags_jpeg_quality() {
     if (FLAGS_pdfJpegQuality < -1 || FLAGS_pdfJpegQuality > 100) {
         SkDebugf("%s\n", "pdfJpegQuality must be in [-1 .. 100] range.");
         return false;
     }
     return true;
 }
 
 int tool_main(int argc, char** argv);
 int tool_main(int argc, char** argv) {
-
     SkString usage;
     usage.printf("Run the golden master tests.\n");
     SkCommandLineFlags::SetUsage(usage.c_str());
     SkCommandLineFlags::Parse(argc, argv);
 
 #if SK_ENABLE_INST_COUNT
     if (FLAGS_leaks) {
         gPrintInstCount = true;
     }
 #endif
@@ skipping 19 matching lines @@
         SkDebugf( "Doing a dry run; no tests will actually be executed.\n");
     }
 
     if (!parse_flags_modulo(&moduloRemainder, &moduloDivisor) ||
         !parse_flags_ignore_error_types(&gmmain.fIgnorableErrorTypes) ||
         !parse_flags_ignore_tests(gmmain.fIgnorableTestNames) ||
 #if SK_SUPPORT_GPU
         !parse_flags_gpu_cache(&gGpuCacheSizeBytes, &gGpuCacheSizeCount) ||
 #endif
         !parse_flags_tile_grid_replay_scales(&tileGridReplayScales) ||
-        !parse_flags_resource_path() ||
         !parse_flags_jpeg_quality() ||
         !parse_flags_configs(&configs, grFactory) ||
         !parse_flags_pdf_rasterizers(configs, &pdfRasterizers) ||
         !parse_flags_gmmain_paths(&gmmain)) {
         return -1;
     }
 
     if (FLAGS_verbose) {
         if (FLAGS_writePath.count() == 1) {
             SkDebugf("writing to %s\n", FLAGS_writePath[0]);
         }
         if (NULL != gmmain.fMismatchPath) {
             SkDebugf("writing mismatches to %s\n", gmmain.fMismatchPath);
         }
         if (NULL != gmmain.fMissingExpectationsPath) {
             SkDebugf("writing images without expectations to %s\n",
                      gmmain.fMissingExpectationsPath);
         }
         if (FLAGS_writePicturePath.count() == 1) {
             SkDebugf("writing pictures to %s\n", FLAGS_writePicturePath[0]);
         }
-        if (FLAGS_resourcePath.count() == 1) {
-            SkDebugf("reading resources from %s\n", FLAGS_resourcePath[0]);
+        if (!GetResourcePath().isEmpty()) {
+            SkDebugf("reading resources from %s\n", GetResourcePath().c_str());
         }
     }
 
     int gmsRun = 0;
     int gmIndex = -1;
     SkString moduloStr;
 
     if (!FLAGS_dryRun) {
         // If we will be writing out files, prepare subdirectories.
         if (FLAGS_writePath.count() == 1) {
@@ skipping 157 matching lines @@
     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