GM: Allow ignored-tests.txt to list configs as well as tests (and combinations too)

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 311 matching lines @@
             // compare_test_results_to_reference_bitmap() historically,
             // and changing that now may affect other parts of our code.
             if (modeAsString.startsWith("-")) {
                 modeAsString.remove(0, 1);
                 modes.push_back(modeAsString);
             }
         }
     }
 
     /**
+     * Returns true if failures on this test should be ignored.
+     */
+    bool ShouldIgnoreTest(const SkString &name) const {
+        for (int i = 0; i < fIgnorableTestSubstrings.count(); i++) {
+            if (name.contains(fIgnorableTestSubstrings[i].c_str())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
      * Records the results of this test in fTestsRun and fFailedTests.
      *
      * We even record successes, and errors that we regard as
      * "ignorable"; we can filter them out later.
      */
     void RecordTestResults(const ErrorCombination& errorCombination,
                            const SkString& shortNamePlusConfig,
                            const char renderModeDescriptor []) {
         // Things to do regardless of errorCombination.
         fTestsRun++;
@@ skipping 556 matching lines @@
                  *
                  * TODO(epoger): This relies on the fact that
                  * force_all_opaque() was called on the bitmap before it
                  * was written to disk as a PNG in the first place. If
                  * not, the hash digest returned here may not match the
                  * hash digest of actualBitmap, which *has* been run through
                  * force_all_opaque().
                  * See comments above complete_bitmap() for more detail.
                  */
                 Expectations expectations = expectationsSource->get(nameWithExtension.c_str());
-                if (gm->isIgnoringFailures()) {
+                if (this->ShouldIgnoreTest(shortNamePlusConfig)) {
                     expectations.setIgnoreFailure(true);
                 }
                 errors.add(compare_to_expectations(expectations, *actualBitmapAndDigest,
                                                    gm->shortName(), configName, "", true));
             } else {
                 // If we are running without expectations, we still want to
                 // record the actual results.
                 add_actual_results_to_json_summary(nameWithExtension.c_str(),
                                                    actualBitmapAndDigest->fDigest,
                                                    ErrorCombination(kMissingExpectations_ErrorType),
@@ skipping 286 matching lines @@
         return errors;
     }
 
     //
     // member variables.
     // They are public for now, to allow easier setting by tool_main().
     //
 
     bool fUseFileHierarchy, fWriteChecksumBasedFilenames;
     ErrorCombination fIgnorableErrorTypes;
+    SkTArray<SkString> fIgnorableTestSubstrings;
 
     const char* fMismatchPath;
     const char* fMissingExpectationsPath;
 
     // collection of tests that have failed with each ErrorType
     SkTArray<SkString> fFailedTests[kLast_ErrorType+1];
     int fTestsRun;
     SkTDict<int> fRenderModesEncountered;
 
     // Where to read expectations (expected image hash digests, etc.) from.
@@ skipping 747 matching lines @@
                 gm_fprintf(stderr, "cannot find ErrorType with name '%s'\n", name);
                 return false;
             } else {
                 outErrorTypes->add(type);
             }
         }
     }
     return true;
 }
 
+/**
+ * Replace contents of ignoreTestSubstrings with a list of testname/config substrings, indicating
+ * which tests' failures should be ignored.
+ */
+static bool parse_flags_ignore_tests(SkTArray<SkString> &ignoreTestSubstrings) {
+    ignoreTestSubstrings.reset();
+    for (int i = 0; i < FLAGS_ignoreTests.count(); i++) {
+        ignoreTestSubstrings.push_back(SkString(FLAGS_ignoreTests[i]));
+    }
+    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.");
             return false;
         }
     }
@@ skipping 111 matching lines @@
     SkTDArray<const PDFRasterizerData*> pdfRasterizers;
     SkTDArray<SkScalar> tileGridReplayScales;
 #if SK_SUPPORT_GPU
     GrContextFactory* grFactory = new GrContextFactory;
 #else
     GrContextFactory* grFactory = NULL;
 #endif
 
     if (!parse_flags_modulo(&moduloRemainder, &moduloDivisor) ||
         !parse_flags_ignore_error_types(&gmmain.fIgnorableErrorTypes) ||
+        !parse_flags_ignore_tests(gmmain.fIgnorableTestSubstrings) ||
 #if SK_SUPPORT_GPU
         !parse_flags_gpu_cache(&gGpuCacheSizeBytes, &gGpuCacheSizeCount) ||
 #endif
         !parse_flags_tile_grid_replay_scales(&tileGridReplayScales) ||
         !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;
@@ skipping 61 matching lines @@
                 continue;
             }
             moduloStr.printf("[%d.%d] ", gmIndex, moduloDivisor);
         }
 
         const char* shortName = gm->shortName();
 
         if (SkCommandLineFlags::ShouldSkip(FLAGS_match, shortName)) {
             continue;
         }
-        if (FLAGS_ignoreTests.contains(shortName)) {
-            gm->setIgnoreFailures(true);
-        }
 
         gmsRun++;
         SkISize size = gm->getISize();
         gm_fprintf(stdout, "%sdrawing... %s [%d %d]\n", moduloStr.c_str(), shortName,
                    size.width(), size.height());
 
         run_multiple_configs(gmmain, gm, configs, pdfRasterizers, grFactory);
 
         SkBitmap comparisonBitmap;
         const ConfigData compareConfig =
@@ skipping 70 matching lines @@
     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