replace gm_fprintf() calls with SkDebugf()

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.
  *
@@ skipping 256 matching lines @@
     static void force_all_opaque(const SkBitmap& bitmap) {
         SkColorType colorType = bitmap.colorType();
         switch (colorType) {
         case kPMColor_SkColorType:
             force_all_opaque_8888(bitmap);
             break;
         case kRGB_565_SkColorType:
             // nothing to do here; 565 bitmaps are inherently opaque
             break;
         default:
-            gm_fprintf(stderr, "unsupported bitmap colorType %d\n", colorType);
+            SkDebugf("unsupported bitmap colorType %d\n", colorType);
             DEBUGFAIL_SEE_STDERR;
         }
     }
 
     static void force_all_opaque_8888(const SkBitmap& bitmap) {
         SkAutoLockPixels lock(bitmap);
         for (int y = 0; y < bitmap.height(); y++) {
             for (int x = 0; x < bitmap.width(); x++) {
                 *bitmap.getAddr32(x, y) |= (SK_A32_MASK << SK_A32_SHIFT);
             }
         }
     }
 
     static ErrorCombination write_bitmap(const SkString& path, const SkBitmap& bitmap) {
         // TODO(epoger): Now that we have removed force_all_opaque()
         // from this method, we should be able to get rid of the
         // transformation to 8888 format also.
         SkBitmap copy;
         bitmap.copyTo(&copy, kPMColor_SkColorType);
         if (!SkImageEncoder::EncodeFile(path.c_str(), copy,
                                         SkImageEncoder::kPNG_Type,
                                         100)) {
-            gm_fprintf(stderr, "FAILED to write bitmap: %s\n", path.c_str());
+            SkDebugf("FAILED to write bitmap: %s\n", path.c_str());
             return ErrorCombination(kWritingReferenceImage_ErrorType);
         }
         return kEmpty_ErrorCombination;
     }
 
     /**
      * Add all render modes encountered thus far to the "modes" array.
      */
     void GetRenderModesEncountered(SkTArray<SkString> &modes) {
         SkTDict<int>::Iter iter(this->fRenderModesEncountered);
@@ skipping 111 matching lines @@
         SkTArray<SkString> *failedTestsOfThisType = &fFailedTests[type];
         int count = failedTestsOfThisType->count();
         line.appendf("%d %s", count, getErrorTypeName(type));
         if (!isIgnorableType || verbose) {
             line.append(":");
             for (int i = 0; i < count; ++i) {
                 line.append(" ");
                 line.append((*failedTestsOfThisType)[i]);
             }
         }
-        gm_fprintf(stdout, "%s\n", line.c_str());
+        SkDebugf("%s\n", line.c_str());
     }
 
     /**
      * List contents of fFailedTests to stdout.
      *
      * @param verbose whether to be all verbose about it
      */
     void ListErrors(bool verbose) {
         // First, print a single summary line.
         SkString summary;
         summary.appendf("Ran %d tests:", fTestsRun);
         for (int typeInt = 0; typeInt <= kLast_ErrorType; typeInt++) {
             ErrorType type = static_cast<ErrorType>(typeInt);
             summary.appendf(" %s=%d", getErrorTypeName(type), fFailedTests[type].count());
         }
-        gm_fprintf(stdout, "%s\n", summary.c_str());
+        SkDebugf("%s\n", summary.c_str());
 
         // Now, for each failure type, list the tests that failed that way.
         for (int typeInt = 0; typeInt <= kLast_ErrorType; typeInt++) {
             this->DisplayResultTypeSummary(static_cast<ErrorType>(typeInt), verbose);
         }
-        gm_fprintf(stdout, "(results marked with [*] will cause nonzero return value)\n");
+        SkDebugf("(results marked with [*] will cause nonzero return value)\n");
     }
 
     static ErrorCombination write_document(const SkString& path, SkStreamAsset* asset) {
         SkFILEWStream stream(path.c_str());
         if (!stream.writeStream(asset, asset->getLength())) {
-            gm_fprintf(stderr, "FAILED to write document: %s\n", path.c_str());
+            SkDebugf("FAILED to write document: %s\n", path.c_str());
             return ErrorCombination(kWritingReferenceImage_ErrorType);
         }
         return kEmpty_ErrorCombination;
     }
 
     /**
      * Prepare an SkBitmap to render a GM into.
      *
      * After you've rendered the GM into the SkBitmap, you must call
      * complete_bitmap()!
@@ skipping 256 matching lines @@
      * Log more detail about the mistmatch between expectedBitmap and
      * actualBitmap.
      */
     void report_bitmap_diffs(const SkBitmap& expectedBitmap, const SkBitmap& actualBitmap,
                              const char *testName) {
         const int expectedWidth = expectedBitmap.width();
         const int expectedHeight = expectedBitmap.height();
         const int width = actualBitmap.width();
         const int height = actualBitmap.height();
         if ((expectedWidth != width) || (expectedHeight != height)) {
-            gm_fprintf(stderr, "---- %s: dimension mismatch --"
-                       " expected [%d %d], actual [%d %d]\n",
-                       testName, expectedWidth, expectedHeight, width, height);
+            SkDebugf("---- %s: dimension mismatch -- expected [%d %d], actual [%d %d]\n",
+                     testName, expectedWidth, expectedHeight, width, height);
             return;
         }
 
         if ((kPMColor_SkColorType != expectedBitmap.colorType()) ||
             (kPMColor_SkColorType != actualBitmap.colorType())) {
-            gm_fprintf(stderr, "---- %s: not computing max per-channel"
-                       " pixel mismatch because non-8888\n", testName);
+            SkDebugf("---- %s: not computing max per-channel pixel mismatch because non-8888\n",
+                     testName);
             return;
         }
 
         SkAutoLockPixels alp0(expectedBitmap);
         SkAutoLockPixels alp1(actualBitmap);
         int errR = 0;
         int errG = 0;
         int errB = 0;
         int errA = 0;
         int differingPixels = 0;
@@ skipping 10 matching lines @@
                                                  (int)SkGetPackedR32(actualPixel)));
                     errG = SkMax32(errG, SkAbs32((int)SkGetPackedG32(expectedPixel) -
                                                  (int)SkGetPackedG32(actualPixel)));
                     errB = SkMax32(errB, SkAbs32((int)SkGetPackedB32(expectedPixel) -
                                                  (int)SkGetPackedB32(actualPixel)));
                     errA = SkMax32(errA, SkAbs32((int)SkGetPackedA32(expectedPixel) -
                                                  (int)SkGetPackedA32(actualPixel)));
                 }
             }
         }
-        gm_fprintf(stderr, "---- %s: %d (of %d) differing pixels,"
-                   " max per-channel mismatch R=%d G=%d B=%d A=%d\n",
-                   testName, differingPixels, width*height, errR, errG, errB, errA);
+        SkDebugf("---- %s: %d (of %d) differing pixels, "
+                 "max per-channel mismatch R=%d G=%d B=%d A=%d\n",
+                 testName, differingPixels, width*height, errR, errG, errB, errA);
     }
 
     /**
      * Compares actual hash digest to expectations, returning the set of errors
      * (if any) that we saw along the way.
      *
      * If fMismatchPath has been set, and there are pixel diffs, then the
      * actual bitmap will be written out to a file within fMismatchPath.
      * And similarly for fMissingExpectationsPath...
      *
@@ skipping 293 matching lines @@
                     errors.add(write_document(path, documentStream));
                 }
 
                 if (!(gm->getFlags() & GM::kSkipPDFRasterization_Flag)) {
                     for (int i = 0; i < pdfRasterizers.count(); i++) {
                         SkBitmap pdfBitmap;
                         documentStream->rewind();
                         bool success = (*pdfRasterizers[i]->fRasterizerFunction)(
                                 documentStream.get(), &pdfBitmap);
                         if (!success) {
-                            gm_fprintf(stderr, "FAILED to render PDF for %s using renderer %s\n",
-                                       gm->getName(),
-                                       pdfRasterizers[i]->fName);
+                            SkDebugf("FAILED to render PDF for %s using renderer %s\n",
+                                     gm->getName(),
+                                     pdfRasterizers[i]->fName);
                             continue;
                         }
 
                         SkString configName(gRec.fName);
                         configName.append("-");
                         configName.append(pdfRasterizers[i]->fName);
 
                         BitmapAndDigest bitmapAndDigest(pdfBitmap);
                         errors.add(compare_test_results_to_stored_expectations(
                                    gm, gRec, configName.c_str(), &bitmapAndDigest));
@@ skipping 706 matching lines @@
  * Read individual lines from a file, pushing them into the given array.
  *
  * @param filename path to the file to read
  * @param lines array of strings to add the lines to
  * @returns true if able to read lines from the file
  */
 static bool read_lines_from_file(const char* filename, SkTArray<SkString> &lines) {
     SkAutoTUnref<SkStream> streamWrapper(SkStream::NewFromFile(filename));
     SkStream *stream = streamWrapper.get();
     if (!stream) {
-        gm_fprintf(stderr, "unable to read file '%s'\n", filename);
+        SkDebugf("unable to read file '%s'\n", filename);
         return false;
     }
 
     char c;
     SkString line;
     while (1 == stream->read(&c, 1)) {
         // If we hit either CR or LF, we've completed a line.
         //
         // TODO: If the file uses both CR and LF, this will return an extra blank
         // line for each line of the file.  Which is OK for current purposes...
@@ skipping 92 matching lines @@
         }
         int index = findConfig(config);
         if (index >= 0) {
             if (exclude) {
                 *excludeConfigs.append() = index;
             } else {
                 appendUnique<size_t>(outConfigs, index);
             }
         } else if (0 == strcmp(kDefaultsConfigStr, config)) {
             if (exclude) {
-                gm_fprintf(stderr, "%c%s is not allowed.\n",
-                           kExcludeConfigChar, kDefaultsConfigStr);
+                SkDebugf("%c%s is not allowed.\n",
+                         kExcludeConfigChar, kDefaultsConfigStr);
                 return false;
             }
             for (size_t c = 0; c < SK_ARRAY_COUNT(gRec); ++c) {
                 if (gRec[c].fRunByDefault) {
                     appendUnique<size_t>(outConfigs, c);
                 }
             }
         } else {
-            gm_fprintf(stderr, "unrecognized config %s\n", config);
+            SkDebugf("unrecognized config %s\n", config);
             return false;
         }
     }
 
     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]);
+            SkDebugf("unrecognized excludeConfig %s\n", FLAGS_excludeConfig[i]);
             return false;
         }
     }
 
     if (outConfigs->count() == 0) {
         // if no config is specified by user, add the defaults
         for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
             if (gRec[i].fRunByDefault) {
                 *outConfigs->append() = i;
             }
         }
     }
     // now remove any explicitly excluded configs
     for (int i = 0; i < excludeConfigs.count(); ++i) {
         int index = outConfigs->find(excludeConfigs[i]);
         if (index >= 0) {
             outConfigs->remove(index);
             // now assert that there was only one copy in configs[]
             SkASSERT(outConfigs->find(excludeConfigs[i]) < 0);
         }
     }
 
 #if SK_SUPPORT_GPU
     SkASSERT(grFactory != NULL);
     for (int i = 0; i < outConfigs->count(); ++i) {
         size_t index = (*outConfigs)[i];
         if (kGPU_Backend == gRec[index].fBackend) {
             GrContext* ctx = grFactory->get(gRec[index].fGLContextType);
             if (NULL == ctx) {
-                gm_fprintf(stderr, "GrContext could not be created for config %s."
-                           " Config will be skipped.\n", gRec[index].fName);
+                SkDebugf("GrContext could not be created for config %s. Config will be skipped.\n",
+                         gRec[index].fName);
                 outConfigs->remove(i);
                 --i;
                 continue;
             }
             if (gRec[index].fSampleCnt > ctx->getMaxSampleCount()) {
-                gm_fprintf(stderr, "Sample count (%d) of config %s is not supported."
-                           " Config will be skipped.\n",
-                           gRec[index].fSampleCnt, gRec[index].fName);
+                SkDebugf("Sample count (%d) of config %s is not supported."
+                         " Config will be skipped.\n",
+                         gRec[index].fSampleCnt, gRec[index].fName);
                 outConfigs->remove(i);
                 --i;
             }
         }
     }
 #endif
 
     if (outConfigs->isEmpty()) {
-        gm_fprintf(stderr, "No configs to run.");
+        SkDebugf("No configs to run.");
         return false;
     }
 
     // now show the user the set of configs that will be run.
     SkString configStr("These configs will be run:");
     // show the user the config that will run.
     for (int i = 0; i < outConfigs->count(); ++i) {
         configStr.appendf(" %s", gRec[(*outConfigs)[i]].fName);
     }
-    gm_fprintf(stdout, "%s\n", configStr.c_str());
+    SkDebugf("%s\n", configStr.c_str());
 
     return true;
 }
 
 static bool parse_flags_pdf_rasterizers(const SkTDArray<size_t>& configs,
                                         SkTDArray<const PDFRasterizerData*>* outRasterizers) {
     // No need to run this check (and display the PDF rasterizers message)
     // if no PDF backends are in the configs.
     bool configHasPDF = false;
     for (int i = 0; i < configs.count(); i++) {
@@ skipping 12 matching lines @@
             if (kPDFRasterizers[i].fRunByDefault) {
                 *outRasterizers->append() = &kPDFRasterizers[i];
             }
         }
     } else {
         for (int i = 0; i < FLAGS_pdfRasterizers.count(); i++) {
             const char* rasterizer = FLAGS_pdfRasterizers[i];
             const PDFRasterizerData* rasterizerPtr =
                     findPDFRasterizer(rasterizer);
             if (rasterizerPtr == NULL) {
-                gm_fprintf(stderr, "unrecognized rasterizer %s\n", rasterizer);
+                SkDebugf("unrecognized rasterizer %s\n", rasterizer);
                 return false;
             }
             appendUnique<const PDFRasterizerData*>(outRasterizers,
                                                    rasterizerPtr);
         }
     }
 
     // now show the user the set of configs that will be run.
     SkString configStr("These PDF rasterizers will be run:");
     // show the user the config that will run.
     for (int i = 0; i < outRasterizers->count(); ++i) {
         configStr.appendf(" %s", (*outRasterizers)[i]->fName);
     }
-    gm_fprintf(stdout, "%s\n", configStr.c_str());
+    SkDebugf("%s\n", configStr.c_str());
 
     return true;
 }
 
 static bool parse_flags_ignore_error_types(ErrorCombination* outErrorTypes) {
     if (FLAGS_ignoreErrorTypes.count() > 0) {
         *outErrorTypes = ErrorCombination();
         for (int i = 0; i < FLAGS_ignoreErrorTypes.count(); i++) {
             ErrorType type;
             const char *name = FLAGS_ignoreErrorTypes[i];
             if (!getErrorTypeByName(name, &type)) {
-                gm_fprintf(stderr, "cannot find ErrorType with name '%s'\n", name);
+                SkDebugf("cannot find ErrorType with name '%s'\n", name);
                 return false;
             } else {
                 outErrorTypes->add(type);
             }
         }
     }
     return true;
 }
 
 /**
@@ skipping 22 matching lines @@
 
     return true;
 }
 
 static bool parse_flags_modulo(int* moduloRemainder, int* moduloDivisor) {
     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.");
+            SkDebugf("invalid modulo values.");
             return false;
         }
     }
     return true;
 }
 
 #if SK_SUPPORT_GPU
 static bool parse_flags_gpu_cache(int* sizeBytes, int* sizeCount) {
     if (FLAGS_gpuCacheSize.count() > 0) {
         if (FLAGS_gpuCacheSize.count() != 2) {
-            gm_fprintf(stderr, "--gpuCacheSize requires two arguments\n");
+            SkDebugf("--gpuCacheSize requires two arguments\n");
             return false;
         }
         *sizeBytes = atoi(FLAGS_gpuCacheSize[0]);
         *sizeCount = atoi(FLAGS_gpuCacheSize[1]);
     } else {
         *sizeBytes = DEFAULT_CACHE_VALUE;
         *sizeCount = DEFAULT_CACHE_VALUE;
     }
     return true;
 }
 #endif
 
 static bool parse_flags_tile_grid_replay_scales(SkTDArray<SkScalar>* outScales) {
     *outScales->append() = SK_Scalar1; // By default only test at scale 1.0
     if (FLAGS_tileGridReplayScales.count() > 0) {
         outScales->reset();
         for (int i = 0; i < FLAGS_tileGridReplayScales.count(); i++) {
             double val = atof(FLAGS_tileGridReplayScales[i]);
             if (0 < val) {
                 *outScales->append() = SkDoubleToScalar(val);
             }
         }
         if (0 == outScales->count()) {
             // Should have at least one scale
-            gm_fprintf(stderr, "--tileGridReplayScales requires at least one scale.\n");
+            SkDebugf("--tileGridReplayScales requires at least one scale.\n");
             return false;
         }
     }
     return true;
 }
 
 static bool parse_flags_gmmain_paths(GMMain* gmmain) {
     gmmain->fUseFileHierarchy = FLAGS_hierarchy;
     gmmain->fWriteChecksumBasedFilenames = FLAGS_writeChecksumBasedFilenames;
 
     if (FLAGS_mismatchPath.count() == 1) {
         gmmain->fMismatchPath = FLAGS_mismatchPath[0];
     }
 
     if (FLAGS_missingExpectationsPath.count() == 1) {
         gmmain->fMissingExpectationsPath = FLAGS_missingExpectationsPath[0];
     }
 
     if (FLAGS_readPath.count() == 1) {
         const char* readPath = FLAGS_readPath[0];
         if (!sk_exists(readPath)) {
-            gm_fprintf(stderr, "readPath %s does not exist!\n", readPath);
+            SkDebugf("readPath %s does not exist!\n", readPath);
             return false;
         }
         if (sk_isdir(readPath)) {
             if (FLAGS_verbose) {
-                gm_fprintf(stdout, "reading from %s\n", readPath);
+                SkDebugf("reading from %s\n", readPath);
             }
             gmmain->fExpectationsSource.reset(SkNEW_ARGS(
                 IndividualImageExpectationsSource, (readPath)));
         } else {
             if (FLAGS_verbose) {
-                gm_fprintf(stdout, "reading expectations from JSON summary file %s\n", readPath);
+                SkDebugf("reading expectations from JSON summary file %s\n", readPath);
             }
             gmmain->fExpectationsSource.reset(SkNEW_ARGS(JsonExpectationsSource, (readPath)));
         }
     }
     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) {
-        gm_fprintf(stderr, "%s\n", "pdfJpegQuality must be in [-1 .. 100] range.");
+        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");
@@ skipping 35 matching lines @@
         !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) {
-            gm_fprintf(stdout, "writing to %s\n", FLAGS_writePath[0]);
+            SkDebugf("writing to %s\n", FLAGS_writePath[0]);
         }
         if (NULL != gmmain.fMismatchPath) {
-            gm_fprintf(stdout, "writing mismatches to %s\n", gmmain.fMismatchPath);
+            SkDebugf("writing mismatches to %s\n", gmmain.fMismatchPath);
         }
         if (NULL != gmmain.fMissingExpectationsPath) {
-            gm_fprintf(stdout, "writing images without expectations to %s\n",
-                       gmmain.fMissingExpectationsPath);
+            SkDebugf("writing images without expectations to %s\n",
+                     gmmain.fMissingExpectationsPath);
         }
         if (FLAGS_writePicturePath.count() == 1) {
-            gm_fprintf(stdout, "writing pictures to %s\n", FLAGS_writePicturePath[0]);
+            SkDebugf("writing pictures to %s\n", FLAGS_writePicturePath[0]);
         }
         if (FLAGS_resourcePath.count() == 1) {
-            gm_fprintf(stdout, "reading resources from %s\n", FLAGS_resourcePath[0]);
+            SkDebugf("reading resources from %s\n", FLAGS_resourcePath[0]);
         }
     }
 
     int gmsRun = 0;
     int gmIndex = -1;
     SkString moduloStr;
 
     // If we will be writing out files, prepare subdirectories.
     if (FLAGS_writePath.count() == 1) {
         if (!prepare_subdirectories(FLAGS_writePath[0], gmmain.fUseFileHierarchy,
@@ skipping 36 matching lines @@
         }
 
         const char* shortName = gm->getName();
 
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, shortName)) {
             continue;
         }
 
         gmsRun++;
         SkISize size = gm->getISize();
-        gm_fprintf(stdout, "%sdrawing... %s [%d %d]\n", moduloStr.c_str(), shortName,
-                   size.width(), size.height());
+        SkDebugf("%sdrawing... %s [%d %d]\n", moduloStr.c_str(), shortName,
+                 size.width(), size.height());
 
         run_multiple_configs(gmmain, gm, configs, pdfRasterizers, tileGridReplayScales, grFactory);
     }
 
     SkTArray<SkString> modes;
     gmmain.GetRenderModesEncountered(modes);
     int modeCount = modes.count();
 
     // Now that we have run all the tests and thus know the full set of renderModes that we
     // tried to run, we can call RecordTestResults() to record the cases in which we skipped
@@ skipping 19 matching lines @@
         if (gRec[configs[i]].fBackend == kRaster_Backend) {
             rasterConfigs++;
         }
     }
     // For raster configs, we run all renderModes; for non-raster configs, just default renderMode
     const int expectedNumberOfTests = rasterConfigs * gmsRun * modeCount
                                     + (configs.count() - rasterConfigs) * gmsRun;
 
     // Output summary to stdout.
     if (FLAGS_verbose) {
-        gm_fprintf(stdout, "Ran %d GMs\n", gmsRun);
-        gm_fprintf(stdout, "... over %2d configs [%s]\n", configs.count(),
-                   list_all_config_names(configs).c_str());
-        gm_fprintf(stdout, "...  and %2d modes   [%s]\n", modeCount, list_all(modes).c_str());
-        gm_fprintf(stdout, "... so there should be a total of %d tests.\n", expectedNumberOfTests);
+        SkDebugf("Ran %d GMs\n", gmsRun);
+        SkDebugf("... over %2d configs [%s]\n", configs.count(),
+                 list_all_config_names(configs).c_str());
+        SkDebugf("...  and %2d modes   [%s]\n", modeCount, list_all(modes).c_str());
+        SkDebugf("... so there should be a total of %d tests.\n", expectedNumberOfTests);
     }
     gmmain.ListErrors(FLAGS_verbose);
 
     // TODO(epoger): Enable this check for Android, too, once we resolve
     // https://code.google.com/p/skia/issues/detail?id=1222
     // ('GM is unexpectedly skipping tests on Android')
 #ifndef SK_BUILD_FOR_ANDROID
     if (expectedNumberOfTests != gmmain.fTestsRun) {
-        gm_fprintf(stderr, "expected %d tests, but ran or skipped %d tests\n",
-                   expectedNumberOfTests, gmmain.fTestsRun);
+        SkDebugf("expected %d tests, but ran or skipped %d tests\n",
+                 expectedNumberOfTests, gmmain.fTestsRun);
         reportError = true;
     }
 #endif
 
     if (FLAGS_writeJsonSummaryPath.count() == 1) {
         Json::Value root = CreateJsonTree(
             gmmain.fJsonExpectedResults,
             gmmain.fJsonActualResults_Failed, gmmain.fJsonActualResults_FailureIgnored,
             gmmain.fJsonActualResults_NoComparison, gmmain.fJsonActualResults_Succeeded);
         std::string jsonStdString = root.toStyledString();
         SkFILEWStream stream(FLAGS_writeJsonSummaryPath[0]);
         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 (FLAGS_verbose && (kGPU_Backend == config.fBackend)) {
             GrContext* gr = grFactory->get(config.fGLContextType);
 
-            gm_fprintf(stdout, "config: %s %x\n", config.fName, gr);
+            SkDebugf("config: %s %x\n", config.fName, gr);
             gr->printCacheStats();
         }
     }
 #endif
 
     delete grFactory;
 #endif
     SkGraphics::Term();
 
     return (reportError) ? -1 : 0;
 }
 
 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