replace gm_fprintf() calls with SkDebugf()

gm/gm_expectations.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "gm_expectations.h"
 #include "SkBitmapHasher.h"
 #include "SkImageDecoder.h"
 
 #define DEBUGFAIL_SEE_STDERR SkDEBUGFAIL("see stderr for message")
 
 // See gm_json.py for descriptions of each of these JSON keys.
 // These constants must be kept in sync with the ones in that Python file!
 const static char kJsonKey_ActualResults[]   = "actual-results";
 const static char kJsonKey_ActualResults_Failed[]        = "failed";
 const static char kJsonKey_ActualResults_FailureIgnored[]= "failure-ignored";
 const static char kJsonKey_ActualResults_NoComparison[]  = "no-comparison";
 const static char kJsonKey_ActualResults_Succeeded[]     = "succeeded";
 const static char kJsonKey_ExpectedResults[] = "expected-results";
 const static char kJsonKey_ExpectedResults_AllowedDigests[] = "allowed-digests";
 const static char kJsonKey_ExpectedResults_IgnoreFailure[]  = "ignore-failure";
 
 // Types of result hashes we support in the JSON file.
 const static char kJsonKey_Hashtype_Bitmap_64bitMD5[]  = "bitmap-64bitMD5";
 
 
 namespace skiagm {
-    void gm_fprintf(FILE *stream, const char format[], ...) {
-        va_list args;
-        va_start(args, format);
-        fprintf(stream, "GM: ");
-        vfprintf(stream, format, args);
-#ifdef SK_BUILD_FOR_WIN
-        if (stderr == stream || stdout == stream) {
-            fflush(stream);
-        }
-#endif
-        va_end(args);
-    }
 
     Json::Value CreateJsonTree(Json::Value expectedResults,
                                Json::Value actualResultsFailed,
                                Json::Value actualResultsFailureIgnored,
                                Json::Value actualResultsNoComparison,
                                Json::Value actualResultsSucceeded) {
         Json::Value actualResults;
         actualResults[kJsonKey_ActualResults_Failed] = actualResultsFailed;
         actualResults[kJsonKey_ActualResults_FailureIgnored] = actualResultsFailureIgnored;
         actualResults[kJsonKey_ActualResults_NoComparison] = actualResultsNoComparison;
         actualResults[kJsonKey_ActualResults_Succeeded] = actualResultsSucceeded;
         Json::Value root;
         root[kJsonKey_ActualResults] = actualResults;
         root[kJsonKey_ExpectedResults] = expectedResults;
         return root;
     }
 
 
     // GmResultDigest class...
 
     GmResultDigest::GmResultDigest(const SkBitmap &bitmap) {
         fIsValid = SkBitmapHasher::ComputeDigest(bitmap, &fHashDigest);
     }
 
     GmResultDigest::GmResultDigest(const Json::Value &jsonTypeValuePair) {
         fIsValid = false;
         if (!jsonTypeValuePair.isArray()) {
-            gm_fprintf(stderr, "found non-array json value when parsing GmResultDigest: %s\n",
-                       jsonTypeValuePair.toStyledString().c_str());
+            SkDebugf("found non-array json value when parsing GmResultDigest: %s\n",
+                     jsonTypeValuePair.toStyledString().c_str());
             DEBUGFAIL_SEE_STDERR;
         } else if (2 != jsonTypeValuePair.size()) {
-            gm_fprintf(stderr, "found json array with wrong size when parsing GmResultDigest: %s\n",
-                       jsonTypeValuePair.toStyledString().c_str());
+            SkDebugf("found json array with wrong size when parsing GmResultDigest: %s\n",
+                     jsonTypeValuePair.toStyledString().c_str());
             DEBUGFAIL_SEE_STDERR;
         } else {
             // TODO(epoger): The current implementation assumes that the
             // result digest is always of type kJsonKey_Hashtype_Bitmap_64bitMD5
             Json::Value jsonHashValue = jsonTypeValuePair[1];
             if (!jsonHashValue.isIntegral()) {
-                gm_fprintf(stderr,
-                           "found non-integer jsonHashValue when parsing GmResultDigest: %s\n",
-                           jsonTypeValuePair.toStyledString().c_str());
+                SkDebugf("found non-integer jsonHashValue when parsing GmResultDigest: %s\n",
+                         jsonTypeValuePair.toStyledString().c_str());
                 DEBUGFAIL_SEE_STDERR;
             } else {
                 fHashDigest = jsonHashValue.asUInt64();
                 fIsValid = true;
             }
         }
     }
 
     bool GmResultDigest::isValid() const {
         return fIsValid;
@@ skipping 52 matching lines @@
     }
 
     Expectations::Expectations(Json::Value jsonElement) {
         if (jsonElement.empty()) {
             fIgnoreFailure = kDefaultIgnoreFailure;
         } else {
             Json::Value ignoreFailure = jsonElement[kJsonKey_ExpectedResults_IgnoreFailure];
             if (ignoreFailure.isNull()) {
                 fIgnoreFailure = kDefaultIgnoreFailure;
             } else if (!ignoreFailure.isBool()) {
-                gm_fprintf(stderr, "found non-boolean json value"
-                           " for key '%s' in element '%s'\n",
-                           kJsonKey_ExpectedResults_IgnoreFailure,
-                           jsonElement.toStyledString().c_str());
+                SkDebugf("found non-boolean json value for key '%s' in element '%s'\n",
+                         kJsonKey_ExpectedResults_IgnoreFailure,
+                         jsonElement.toStyledString().c_str());
                 DEBUGFAIL_SEE_STDERR;
                 fIgnoreFailure = kDefaultIgnoreFailure;
             } else {
                 fIgnoreFailure = ignoreFailure.asBool();
             }
 
             Json::Value allowedDigests = jsonElement[kJsonKey_ExpectedResults_AllowedDigests];
             if (allowedDigests.isNull()) {
                 // ok, we'll just assume there aren't any AllowedDigests to compare against
             } else if (!allowedDigests.isArray()) {
-                gm_fprintf(stderr, "found non-array json value"
-                           " for key '%s' in element '%s'\n",
-                           kJsonKey_ExpectedResults_AllowedDigests,
-                           jsonElement.toStyledString().c_str());
+                SkDebugf("found non-array json value for key '%s' in element '%s'\n",
+                         kJsonKey_ExpectedResults_AllowedDigests,
+                         jsonElement.toStyledString().c_str());
                 DEBUGFAIL_SEE_STDERR;
             } else {
                 for (Json::ArrayIndex i=0; i<allowedDigests.size(); i++) {
                     fAllowedResultDigests.push_back(GmResultDigest(allowedDigests[i]));
                 }
             }
         }
     }
 
     bool Expectations::match(GmResultDigest actualGmResultDigest) const {
@@ skipping 64 matching lines @@
             }
             bytesRemaining -= bytesReadThisTime;
             bufPtr += bytesReadThisTime;
         }
         return SkData::NewFromMalloc(bufStart, maxBytes - bytesRemaining);
     }
 
     /*static*/ bool JsonExpectationsSource::Parse(const char *jsonPath, Json::Value *jsonRoot) {
         SkFILEStream inFile(jsonPath);
         if (!inFile.isValid()) {
-            gm_fprintf(stderr, "unable to read JSON file %s\n", jsonPath);
+            SkDebugf("unable to read JSON file %s\n", jsonPath);
             DEBUGFAIL_SEE_STDERR;
             return false;
         }
 
         SkAutoDataUnref dataRef(ReadFileIntoSkData(inFile));
         if (NULL == dataRef.get()) {
-            gm_fprintf(stderr, "error reading JSON file %s\n", jsonPath);
+            SkDebugf("error reading JSON file %s\n", jsonPath);
             DEBUGFAIL_SEE_STDERR;
             return false;
         }
 
         const char *bytes = reinterpret_cast<const char *>(dataRef.get()->data());
         size_t size = dataRef.get()->size();
         Json::Reader reader;
         if (!reader.parse(bytes, bytes+size, *jsonRoot)) {
-            gm_fprintf(stderr, "error parsing JSON file %s\n", jsonPath);
+            SkDebugf("error parsing JSON file %s\n", jsonPath);
             DEBUGFAIL_SEE_STDERR;
             return false;
         }
         return true;
     }
 
 }