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 "gm.h"
@@ skipping 85 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",
+                    fprintf(stderr, GM_PREAMBLE "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",
+                    fprintf(stderr, GM_PREAMBLE "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",
+                            fprintf(stderr, GM_PREAMBLE "found non-integer checksum"
+                                    " in json element '%s'\n",
                                     jsonElement.toStyledString().c_str());
                             DEBUGFAIL_SEE_STDERR;
                         } else {
                             fAllowedChecksums.push_back() = asChecksum(checksumElement);
                         }
                     }
                 }
             }
         }
 
@@ skipping 88 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());
+                    fprintf(stderr, GM_PREAMBLE "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);
+                fprintf(stderr, GM_PREAMBLE "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);
+                fprintf(stderr, GM_PREAMBLE "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);
+                fprintf(stderr, GM_PREAMBLE "error parsing JSON file %s\n", jsonPath);
                 DEBUGFAIL_SEE_STDERR;
                 return false;
             }
             return true;
         }
 
         Json::Value fJsonRoot;
         Json::Value fJsonExpectedResults;
     };
 
 }
 #endif