add a verbose flag to skdiff that shows the progress and status of

tools/skdiff_main.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.
  */
 #include "skdiff.h"
 #include "skdiff_html.h"
 #include "skdiff_utils.h"
 #include "SkBitmap.h"
@@ skipping 293 matching lines @@
             get_bitmap(fileBits, resource, SkImageDecoder::kDecodeBounds_Mode);
         }
     }
 }
 
 static void get_bounds(DiffRecord& drp) {
     get_bounds(drp.fBase, "base");
     get_bounds(drp.fComparison, "comparison");
 }
 
+#ifdef SK_OS_WIN
+#define ANSI_COLOR_RED     ""
+#define ANSI_COLOR_GREEN   ""
+#define ANSI_COLOR_YELLOW  ""
+#define ANSI_COLOR_RESET   ""
+#else
+#define ANSI_COLOR_RED     "\x1b[31m"
+#define ANSI_COLOR_GREEN   "\x1b[32m"
+#define ANSI_COLOR_YELLOW  "\x1b[33m"
+#define ANSI_COLOR_RESET   "\x1b[0m"
+#endif
+
+#define VERBOSE_STATUS(status,color,filename) if (verbose) printf( "[ " color " %10s " ANSI_COLOR_RESET " ] %s\n", status, filename->c_str())
+
 /// Creates difference images, returns the number that have a 0 metric.
 /// If outputDir.isEmpty(), don't write out diff files.
 static void create_diff_images (DiffMetricProc dmp,
                                 const int colorThreshold,
                                 RecordArray* differences,
                                 const SkString& baseDir,
                                 const SkString& comparisonDir,
                                 const SkString& outputDir,
                                 const StringArray& matchSubstrings,
                                 const StringArray& nomatchSubstrings,
                                 bool recurseIntoSubdirs,
                                 bool getBounds,
+                                bool verbose,
                                 DiffSummary* summary) {
     SkASSERT(!baseDir.isEmpty());
     SkASSERT(!comparisonDir.isEmpty());
 
     FileArray baseFiles;
     FileArray comparisonFiles;
 
     get_file_list(baseDir, matchSubstrings, nomatchSubstrings, recurseIntoSubdirs, &baseFiles);
     get_file_list(comparisonDir, matchSubstrings, nomatchSubstrings, recurseIntoSubdirs,
                   &comparisonFiles);
@@ skipping 27 matching lines @@
             comparisonPath.append(*baseFiles[i]);
 
             drp->fBase.fFilename = *baseFiles[i];
             drp->fBase.fFullPath = basePath;
             drp->fBase.fStatus = DiffResource::kExists_Status;
 
             drp->fComparison.fFilename = *baseFiles[i];
             drp->fComparison.fFullPath = comparisonPath;
             drp->fComparison.fStatus = DiffResource::kDoesNotExist_Status;
 
+            VERBOSE_STATUS("MISSING", ANSI_COLOR_YELLOW, baseFiles[i]);
+
             ++i;
         } else if (v > 0) {
             // in comparisonDir, but not in baseDir
             drp->fResult = DiffRecord::kCouldNotCompare_Result;
 
             basePath.append(*comparisonFiles[j]);
             comparisonPath.append(*comparisonFiles[j]);
 
             drp->fBase.fFilename = *comparisonFiles[j];
             drp->fBase.fFullPath = basePath;
             drp->fBase.fStatus = DiffResource::kDoesNotExist_Status;
 
             drp->fComparison.fFilename = *comparisonFiles[j];
             drp->fComparison.fFullPath = comparisonPath;
             drp->fComparison.fStatus = DiffResource::kExists_Status;
 
+            VERBOSE_STATUS("MISSING", ANSI_COLOR_YELLOW, comparisonFiles[j]);
+
             ++j;
         } else {
             // Found the same filename in both baseDir and comparisonDir.
             SkASSERT(DiffRecord::kUnknown_Result == drp->fResult);
 
             basePath.append(*baseFiles[i]);
             comparisonPath.append(*comparisonFiles[j]);
 
             drp->fBase.fFilename = *baseFiles[i];
             drp->fBase.fFullPath = basePath;
             drp->fBase.fStatus = DiffResource::kExists_Status;
 
             drp->fComparison.fFilename = *comparisonFiles[j];
             drp->fComparison.fFullPath = comparisonPath;
             drp->fComparison.fStatus = DiffResource::kExists_Status;
 
             SkAutoDataUnref baseFileBits(read_file(drp->fBase.fFullPath.c_str()));
             if (NULL != baseFileBits) {
                 drp->fBase.fStatus = DiffResource::kRead_Status;
             }
             SkAutoDataUnref comparisonFileBits(read_file(drp->fComparison.fFullPath.c_str()));
             if (NULL != comparisonFileBits) {
                 drp->fComparison.fStatus = DiffResource::kRead_Status;
             }
             if (NULL == baseFileBits || NULL == comparisonFileBits) {
                 if (NULL == baseFileBits) {
                     drp->fBase.fStatus = DiffResource::kCouldNotRead_Status;
+                    VERBOSE_STATUS("READ FAIL", ANSI_COLOR_RED, baseFiles[i]);
                 }
                 if (NULL == comparisonFileBits) {
                     drp->fComparison.fStatus = DiffResource::kCouldNotRead_Status;
+                    VERBOSE_STATUS("READ FAIL", ANSI_COLOR_RED, comparisonFiles[j]);
                 }
                 drp->fResult = DiffRecord::kCouldNotCompare_Result;
 
             } else if (are_buffers_equal(baseFileBits, comparisonFileBits)) {
                 drp->fResult = DiffRecord::kEqualBits_Result;
-
+                VERBOSE_STATUS("MATCH", ANSI_COLOR_GREEN, baseFiles[i]);
             } else {
                 AutoReleasePixels arp(drp);
                 get_bitmap(baseFileBits, drp->fBase, SkImageDecoder::kDecodePixels_Mode);
                 get_bitmap(comparisonFileBits, drp->fComparison,
                            SkImageDecoder::kDecodePixels_Mode);
+                VERBOSE_STATUS("DIFFERENT", ANSI_COLOR_RED, baseFiles[i]);
                 if (DiffResource::kDecoded_Status == drp->fBase.fStatus &&
                     DiffResource::kDecoded_Status == drp->fComparison.fStatus) {
                     create_and_write_diff_image(drp, dmp, colorThreshold,
                                                 outputDir, drp->fBase.fFilename);
                 } else {
                     drp->fResult = DiffRecord::kCouldNotCompare_Result;
                 }
             }
 
             ++i;
@@ skipping 111 matching lines @@
     SkString comparisonDir;
     SkString outputDir;
 
     StringArray matchSubstrings;
     StringArray nomatchSubstrings;
 
     bool generateDiffs = true;
     bool listFilenames = false;
     bool printDirNames = true;
     bool recurseIntoSubdirs = true;
+    bool verbose = false;
 
     RecordArray differences;
     DiffSummary summary;
 
     bool failOnResultType[DiffRecord::kResultCount];
     for (int i = 0; i < DiffRecord::kResultCount; i++) {
         failOnResultType[i] = false;
     }
 
     bool failOnStatusType[DiffResource::kStatusCount][DiffResource::kStatusCount];
@@ skipping 47 matching lines @@
             continue;
         }
         if (!strcmp(argv[i], "--help")) {
             usage(argv[0]);
             return kNoError;
         }
         if (!strcmp(argv[i], "--listfilenames")) {
             listFilenames = true;
             continue;
         }
+        if (!strcmp(argv[i], "--verbose")) {
+            verbose = true;
+            continue;
+        }
         if (!strcmp(argv[i], "--match")) {
             matchSubstrings.push(new SkString(argv[++i]));
             continue;
         }
         if (!strcmp(argv[i], "--nodiffs")) {
             generateDiffs = false;
             continue;
         }
         if (!strcmp(argv[i], "--nomatch")) {
             nomatchSubstrings.push(new SkString(argv[++i]));
@@ skipping 83 matching lines @@
 
     // If no matchSubstrings were specified, match ALL strings
     // (except for whatever nomatchSubstrings were specified, if any).
     if (matchSubstrings.isEmpty()) {
         matchSubstrings.push(new SkString(""));
     }
 
     create_diff_images(diffProc, colorThreshold, &differences,
                        baseDir, comparisonDir, outputDir,
                        matchSubstrings, nomatchSubstrings, recurseIntoSubdirs, generateDiffs,
-                       &summary);
+                       verbose, &summary);
     summary.print(listFilenames, failOnResultType, failOnStatusType);
 
     if (differences.count()) {
         qsort(differences.begin(), differences.count(),
               sizeof(DiffRecord*), sortProc);
     }
 
     if (generateDiffs) {
         print_diff_page(summary.fNumMatches, colorThreshold, differences,
                         baseDir, comparisonDir, outputDir);
@@ skipping 25 matching lines @@
     // range [0...255] are wrapped (mod 256).  Do the conversion ourselves, to
     // make sure that we only return 0 when there were no failures.
     return (num_failing_results > 255) ? 255 : num_failing_results;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif