Allow Srcs to veto Sinks based on their broad type.

dm/DM.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "CrashHandler.h"
 #include "DMJsonWriter.h"
 #include "DMSrcSink.h"
@@ skipping 147 matching lines @@
         SkTArray<SkString> hashes;
         SkStrSplit((const char*)data->data(), "\n", &hashes);
         for (const SkString& hash : hashes) {
             gUninterestingHashes.add(hash);
         }
     }
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
-template <typename T>
-struct Tagged : public SkAutoTDelete<T> {
-  const char* tag;
-  const char* options;
+struct TaggedSrc : public SkAutoTDelete<Src> {
+    const char* tag;
+    const char* options;
+};
+
+struct TaggedSink : public SkAutoTDelete<Sink> {
+    const char* tag;
+    const char* options;
+    SinkType type;
 };
 
 static const bool kMemcpyOK = true;
 
-static SkTArray<Tagged<Src>,  kMemcpyOK>  gSrcs;
-static SkTArray<Tagged<Sink>, kMemcpyOK> gSinks;
+static SkTArray<TaggedSrc,  kMemcpyOK>  gSrcs;
+static SkTArray<TaggedSink, kMemcpyOK> gSinks;
 
 static bool in_shard() {
     static int N = 0;
     return N++ % FLAGS_shards == FLAGS_shard;
 }
 
 static void push_src(const char* tag, const char* options, Src* s) {
     SkAutoTDelete<Src> src(s);
     if (in_shard() &&
         FLAGS_src.contains(tag) &&
         !SkCommandLineFlags::ShouldSkip(FLAGS_match, src->name().c_str())) {
-        Tagged<Src>& s = gSrcs.push_back();
+        TaggedSrc& s = gSrcs.push_back();
         s.reset(src.detach());
         s.tag = tag;
         s.options = options;
     }
 }
 
 static void push_codec_srcs(Path path) {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(path.c_str()));
     if (!encoded) {
         SkDebugf("Couldn't read %s.", path.c_str());
@@ skipping 122 matching lines @@
     if (FLAGS_gpuAPI.contains("gl"))   { return kGL_GrGLStandard; }
     if (FLAGS_gpuAPI.contains("gles")) { return kGLES_GrGLStandard; }
     return kNone_GrGLStandard;
 }
 
 static void push_sink(const char* tag, Sink* s) {
     SkAutoTDelete<Sink> sink(s);
     if (!FLAGS_config.contains(tag)) {
         return;
     }
-    // Try a noop Src as a canary.  If it fails, skip this sink.
+    // Try a simple Src as a canary.  If it fails, skip this sink.
     struct : public Src {
-        Error draw(SkCanvas*) const override { return ""; }
+        Error draw(SkCanvas* c) const override {
+            c->drawRect(SkRect::MakeWH(1,1), SkPaint());
+            return "";
+        }
         SkISize size() const override { return SkISize::Make(16, 16); }
-        Name name() const override { return "noop"; }
-    } noop;
+        Name name() const override { return "justOneRect"; }
+    } justOneRect;
 
     SkBitmap bitmap;
     SkDynamicMemoryWStream stream;
     SkString log;
-    Error err = sink->draw(noop, &bitmap, &stream, &log);
+    Error err = sink->draw(justOneRect, &bitmap, &stream, &log);
     if (err.isFatal()) {
         SkDebugf("Could not run %s: %s\n", tag, err.c_str());
         exit(1);
     }
 
-    Tagged<Sink>& ts = gSinks.push_back();
+    SinkType type = kRaster_SinkType;
+    if (sink->enclave() == kGPU_Enclave) { type = kGPU_SinkType; }
+    if (stream.bytesWritten() > 0) { type = kVector_SinkType; }
+
+    TaggedSink& ts = gSinks.push_back();
     ts.reset(sink.detach());
     ts.tag = tag;
+    ts.type = type;
 }
 
 static bool gpu_supported() {
 #if SK_SUPPORT_GPU
     return FLAGS_gpu;
 #else
     return false;
 #endif
 }
 
@@ skipping 104 matching lines @@
                                   FLAGS_blacklist[i+0], FLAGS_blacklist[i+1],
                                   FLAGS_blacklist[i+2], FLAGS_blacklist[i+3]);
         }
     }
     return "";
 }
 
 // The finest-grained unit of work we can run: draw a single Src into a single Sink,
 // report any errors, and perhaps write out the output: a .png of the bitmap, or a raw stream.
 struct Task {
-    Task(const Tagged<Src>& src, const Tagged<Sink>& sink) : src(src), sink(sink) {}
-    const Tagged<Src>&  src;
-    const Tagged<Sink>& sink;
+    Task(const TaggedSrc& src, const TaggedSink& sink) : src(src), sink(sink) {}
+    const TaggedSrc&  src;
+    const TaggedSink& sink;
 
     static void Run(Task* task) {
         SkString name = task->src->name();
-        SkString note;
+
+        // We'll skip drawing this Src/Sink pair if:
+        //   - the Src vetoes the Sink;
+        //   - this Src / Sink combination is on the blacklist;
+        //   - it's a dry run.
+        SkString note(task->src->veto(task->sink.type) ? " (veto)" : "");
         SkString whyBlacklisted = is_blacklisted(task->sink.tag, task->src.tag,
                                                  task->src.options, name.c_str());
         if (!whyBlacklisted.isEmpty()) {
             note.appendf(" (--blacklist %s)", whyBlacklisted.c_str());
         }
+
         SkString log;
         WallTimer timer;
         timer.start();
-        if (!FLAGS_dryRun && whyBlacklisted.isEmpty()) {
+        if (!FLAGS_dryRun && note.isEmpty()) {
             SkBitmap bitmap;
             SkDynamicMemoryWStream stream;
             if (FLAGS_pre_log) {
                 SkDebugf("\nRunning %s->%s", name.c_str(), task->sink.tag);
             }
             start(task->sink.tag, task->src.tag, task->src.options, name.c_str());
             Error err = task->sink->draw(*task->src, &bitmap, &stream, &log);
             if (!err.isEmpty()) {
                 timer.end();
                 if (err.isFatal()) {
@@ skipping 325 matching lines @@
     }
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS)
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return dm_main();
 }
 #endif