gm: write all messages to stdout/stderr with "GM:" preamble to distinguish from various debug messa…

gm/gm_expectations.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef gm_expectations_DEFINED
 #define gm_expectations_DEFINED
 
+#include <stdarg.h>
 #include "gm.h"
 #include "SkBitmap.h"
 #include "SkBitmapChecksummer.h"
 #include "SkData.h"
 #include "SkImageDecoder.h"
 #include "SkOSFile.h"
 #include "SkRefCnt.h"
 #include "SkStream.h"
 #include "SkTArray.h"
 
@@ skipping 26 matching lines @@
 
     // The actual type we use to represent a checksum is hidden in here.
     typedef Json::UInt64 Checksum;
     static inline Json::Value asJsonValue(Checksum checksum) {
         return checksum;
     }
     static inline Checksum asChecksum(Json::Value jsonValue) {
         return jsonValue.asUInt64();
     }
 
+    static void gm_fprintf(FILE *stream, const char format[], ...) {

[epoger, 2013/03/13 01:21:40]

I originally tried to declare this in gm.h, but then I got warnings about the
function being declared but not used in lots of .cpp files.

+        va_list args;
+        va_start(args, format);
+        fprintf(stream, "GM: ");
+        vfprintf(stream, format, args);
+        va_end(args);
+    }
+
     static SkString make_filename(const char path[],
                                   const char renderModeDescriptor[],
                                   const char *name,
                                   const char suffix[]) {
         SkString filename(path);
         if (filename.endsWith(SkPATH_SEPARATOR)) {
             filename.remove(filename.size() - 1, 1);
         }
         filename.appendf("%c%s%s.%s", SkPATH_SEPARATOR,
                          name, renderModeDescriptor, suffix);
@@ skipping 30 matching lines @@
          * don't have any 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()) {
-                    fprintf(stderr, "found non-boolean json value for key '%s' in element '%s'\n",
-                            kJsonKey_ExpectedResults_IgnoreFailure,
-                            jsonElement.toStyledString().c_str());
+                    gm_fprintf(stderr, "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 allowedChecksums = jsonElement[kJsonKey_ExpectedResults_Checksums];
                 if (allowedChecksums.isNull()) {
                     // ok, we'll just assume there aren't any expected checksums to compare against
                 } else if (!allowedChecksums.isArray()) {
-                    fprintf(stderr, "found non-array json value for key '%s' in element '%s'\n",
-                            kJsonKey_ExpectedResults_Checksums,
-                            jsonElement.toStyledString().c_str());
+                    gm_fprintf(stderr, "found non-array json value"
+                               " for key '%s' in element '%s'\n",
+                               kJsonKey_ExpectedResults_Checksums,
+                               jsonElement.toStyledString().c_str());
                     DEBUGFAIL_SEE_STDERR;
                 } else {
                     for (Json::ArrayIndex i=0; i<allowedChecksums.size(); i++) {
                         Json::Value checksumElement = allowedChecksums[i];
                         if (!checksumElement.isIntegral()) {
-                            fprintf(stderr, "found non-integer checksum in json element '%s'\n",
-                                    jsonElement.toStyledString().c_str());
+                            gm_fprintf(stderr, "found non-integer checksum"
+                                       " in json element '%s'\n",
+                                       jsonElement.toStyledString().c_str());
                             DEBUGFAIL_SEE_STDERR;
                         } else {
                             fAllowedChecksums.push_back() = asChecksum(checksumElement);
                         }
                     }
                 }
             }
         }
 
         /**
@@ skipping 87 matching lines @@
             SkBitmap referenceBitmap;
             bool decodedReferenceBitmap =
                 SkImageDecoder::DecodeFile(path.c_str(), &referenceBitmap,
                                            SkBitmap::kARGB_8888_Config,
                                            SkImageDecoder::kDecodePixels_Mode,
                                            NULL);
             if (decodedReferenceBitmap) {
                 return Expectations(referenceBitmap);
             } else {
                 if (fNotifyOfMissingFiles) {
-                    fprintf(stderr, "FAILED to read %s\n", path.c_str());
+                    gm_fprintf(stderr, "FAILED to read %s\n", path.c_str());
                 }
                 return Expectations();
             }
         }
 
     private:
         const SkString fRootDir;
         const bool fNotifyOfMissingFiles;
     };
 
@@ skipping 77 matching lines @@
         }
 
         /**
          * Read the file contents from jsonPath and parse them into jsonRoot.
          *
          * Returns true if successful.
          */
         static bool parse(const char *jsonPath, Json::Value *jsonRoot) {
             SkFILEStream inFile(jsonPath);
             if (!inFile.isValid()) {
-                fprintf(stderr, "unable to read JSON file %s\n", jsonPath);
+                gm_fprintf(stderr, "unable to read JSON file %s\n", jsonPath);
                 DEBUGFAIL_SEE_STDERR;
                 return false;
             }
 
             SkAutoDataUnref dataRef(readFileIntoSkData(inFile));
             if (NULL == dataRef.get()) {
-                fprintf(stderr, "error reading JSON file %s\n", jsonPath);
+                gm_fprintf(stderr, "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)) {
-                fprintf(stderr, "error parsing JSON file %s\n", jsonPath);
+                gm_fprintf(stderr, "error parsing JSON file %s\n", jsonPath);
                 DEBUGFAIL_SEE_STDERR;
                 return false;
             }
             return true;
         }
 
         Json::Value fJsonRoot;
         Json::Value fJsonExpectedResults;
     };
 
 }
 #endif