Remove expectations / -r from DM entirely.

dm/DM.cpp

 // Main binary for DM.
 // For a high-level overview, please see dm/README.
 
 #include "CrashHandler.h"
 #include "LazyDecodeBitmap.h"
 #include "SkCommonFlags.h"
 #include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
@@ skipping 25 matching lines @@
 #include <ctype.h>
 
 using skiagm::GM;
 using skiagm::GMRegistry;
 using skiatest::Test;
 using skiatest::TestRegistry;
 
 static const char kGpuAPINameGL[] = "gl";
 static const char kGpuAPINameGLES[] = "gles";
 
-DEFINE_string2(expectations, r, "",
-               "If a directory, compare generated images against images under this path. "
-               "If a file, compare generated images against JSON expectations at this path."
-);
-
 DEFINE_bool(gms, true, "Run GMs?");
 DEFINE_bool(tests, true, "Run tests?");
 DEFINE_bool(reportUsedChars, false, "Output test font construction data to be pasted into"
                                     " create_test_font.cpp.");
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 // "FooBar" -> "foobar".  Obviously, ASCII only.
 static SkString lowercase(SkString s) {
     for (size_t i = 0; i < s.size(); i++) {
         s[i] = tolower(s[i]);
     }
     return s;
 }
 
 static const GrContextFactory::GLContextType native = GrContextFactory::kNative_GLContextType;
 static const GrContextFactory::GLContextType nvpr   = GrContextFactory::kNVPR_GLContextType;
 static const GrContextFactory::GLContextType null   = GrContextFactory::kNull_GLContextType;
 static const GrContextFactory::GLContextType debug  = GrContextFactory::kDebug_GLContextType;
 #if SK_ANGLE
 static const GrContextFactory::GLContextType angle  = GrContextFactory::kANGLE_GLContextType;
 #endif
 #if SK_MESA
 static const GrContextFactory::GLContextType mesa   = GrContextFactory::kMESA_GLContextType;
 #endif
 
 static void kick_off_gms(const SkTDArray<GMRegistry::Factory>& gms,
                          const SkTArray<SkString>& configs,
                          GrGLStandard gpuAPI,
-                         const DM::Expectations& expectations,
                          DM::Reporter* reporter,
                          DM::TaskRunner* tasks) {
 #define START(name, type, ...)                                                              \
     if (lowercase(configs[j]).equals(name)) {                                               \
         tasks->add(SkNEW_ARGS(DM::type, (name, reporter, tasks, gms[i], ## __VA_ARGS__)));  \
     }
     for (int i = 0; i < gms.count(); i++) {
         for (int j = 0; j < configs.count(); j++) {
 
-            START("565",        CpuGMTask, expectations, kRGB_565_SkColorType);
-            START("8888",       CpuGMTask, expectations, kN32_SkColorType);
-            START("gpu",        GpuGMTask, expectations, native, gpuAPI, 0);
-            START("msaa4",      GpuGMTask, expectations, native, gpuAPI, 4);
-            START("msaa16",     GpuGMTask, expectations, native, gpuAPI, 16);
-            START("nvprmsaa4",  GpuGMTask, expectations, nvpr,   gpuAPI, 4);
-            START("nvprmsaa16", GpuGMTask, expectations, nvpr,   gpuAPI, 16);
-            START("gpunull",    GpuGMTask, expectations, null,   gpuAPI, 0);
-            START("gpudebug",   GpuGMTask, expectations, debug,  gpuAPI, 0);
+            START("565",        CpuGMTask, kRGB_565_SkColorType);
+            START("8888",       CpuGMTask, kN32_SkColorType);
+            START("gpu",        GpuGMTask, native, gpuAPI, 0);
+            START("msaa4",      GpuGMTask, native, gpuAPI, 4);
+            START("msaa16",     GpuGMTask, native, gpuAPI, 16);
+            START("nvprmsaa4",  GpuGMTask, nvpr,   gpuAPI, 4);
+            START("nvprmsaa16", GpuGMTask, nvpr,   gpuAPI, 16);
+            START("gpunull",    GpuGMTask, null,   gpuAPI, 0);
+            START("gpudebug",   GpuGMTask, debug,  gpuAPI, 0);
 #if SK_ANGLE
-            START("angle",      GpuGMTask, expectations, angle,  gpuAPI, 0);
+            START("angle",      GpuGMTask, angle,  gpuAPI, 0);
 #endif
 #if SK_MESA
-            START("mesa",       GpuGMTask, expectations, mesa,   gpuAPI, 0);
+            START("mesa",       GpuGMTask, mesa,   gpuAPI, 0);
 #endif
             START("pdf",        PDFTask,   RASTERIZE_PDF_PROC);
         }
     }
 #undef START
 }
 
 static void kick_off_tests(const SkTDArray<TestRegistry::Factory>& tests,
                            DM::Reporter* reporter,
                            DM::TaskRunner* tasks) {
@@ skipping 15 matching lines @@
     SkOSFile::Iter it(FLAGS_skps[0], ".skp");
     SkString filename;
     while (it.next(&filename)) {
         if (!SkCommandLineFlags::ShouldSkip(FLAGS_match, filename.c_str())) {
             skps->push_back(SkOSPath::Join(FLAGS_skps[0], filename.c_str()));
         }
     }
 }
 
 static void kick_off_skps(const SkTArray<SkString>& skps,
-                          const DM::Expectations& expectations,
                           DM::Reporter* reporter,
                           DM::TaskRunner* tasks) {
     for (int i = 0; i < skps.count(); ++i) {
         SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(skps[i].c_str()));
         if (stream.get() == NULL) {
             SkDebugf("Could not read %s.\n", skps[i].c_str());
             exit(1);
         }
         SkAutoTUnref<SkPicture> pic(
                 SkPicture::CreateFromStream(stream.get(), &sk_tools::LazyDecodeBitmap));
         if (pic.get() == NULL) {
             SkDebugf("Could not read %s as an SkPicture.\n", skps[i].c_str());
             exit(1);
         }
 
         SkString filename = SkOSPath::Basename(skps[i].c_str());
-        tasks->add(SkNEW_ARGS(DM::SKPTask, (reporter, tasks, expectations, pic, filename)));
-        tasks->add(SkNEW_ARGS(DM::PDFTask, (reporter, tasks, pic, filename,
-                                            RASTERIZE_PDF_PROC)));
+        tasks->add(SkNEW_ARGS(DM::SKPTask, (reporter, tasks, pic, filename)));
+        tasks->add(SkNEW_ARGS(DM::PDFTask, (reporter, tasks, pic, filename, RASTERIZE_PDF_PROC)));
     }
 }
 
 static void report_failures(const SkTArray<SkString>& failures) {
     if (failures.count() == 0) {
         return;
     }
 
     SkDebugf("Failures:\n");
     for (int i = 0; i < failures.count(); i++) {
@@ skipping 35 matching lines @@
     gPrintInstCount = FLAGS_leaks;
 #endif
 
     SkTArray<SkString> configs;
     for (int i = 0; i < FLAGS_config.count(); i++) {
         SkStrSplit(FLAGS_config[i], ", ", &configs);
     }
 
     GrGLStandard gpuAPI = get_gl_standard();
 
-    SkAutoTDelete<DM::Expectations> expectations(SkNEW(DM::Expectations));
-    if (FLAGS_expectations.count() > 0) {
-        expectations.reset(DM::WriteTask::Expectations::Create(FLAGS_expectations[0]));
-        if (!expectations.get()) {
-            return 1;
-        }
-    }
-
     SkTDArray<GMRegistry::Factory> gms;
     if (FLAGS_gms) {
         append_matching_factories<GM>(GMRegistry::Head(), &gms);
     }
 
     SkTDArray<TestRegistry::Factory> tests;
     if (FLAGS_tests) {
         append_matching_factories<Test>(TestRegistry::Head(), &tests);
     }
 
     SkTArray<SkString> skps;
     find_skps(&skps);
 
     SkDebugf("%d GMs x %d configs, %d tests, %d pictures\n",
              gms.count(), configs.count(), tests.count(), skps.count());
     DM::Reporter reporter;
 
     DM::TaskRunner tasks;
     kick_off_tests(tests, &reporter, &tasks);
-    kick_off_gms(gms, configs, gpuAPI, *expectations, &reporter, &tasks);
-    kick_off_skps(skps, *expectations, &reporter, &tasks);
+    kick_off_gms(gms, configs, gpuAPI, &reporter, &tasks);
+    kick_off_skps(skps, &reporter, &tasks);
     tasks.wait();
 
     DM::WriteTask::DumpJson();
 
     SkDebugf("\n");
 #ifdef SK_DEBUG
     if (FLAGS_portableFonts && FLAGS_reportUsedChars) {
         sk_tool_utils::report_used_chars();
     }
 #endif
 
     SkTArray<SkString> failures;
     reporter.getFailures(&failures);
     report_failures(failures);
     return failures.count() > 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif