Update DM to allow Src's to have optional options.

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 115 matching lines @@
         path.append("/dm.json");
         if (!JsonWriter::ReadJson(path.c_str(), add_gold)) {
             fail(SkStringPrintf("Couldn't read %s for golden results.", path.c_str()));
         }
     }
 }
 
 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
 
 template <typename T>
-struct Tagged : public SkAutoTDelete<T> { const char* tag; };
+struct Tagged : public SkAutoTDelete<T> {
+  const char* tag;
+  const char* options;

[djsollen, 2015/04/02 17:25:07]

I'm thinking of storing an SkString on this struct that contains <tag>-<options>
so that when we want to print or check the blacklist we can use that field.

[mtklein, 2015/04/02 17:48:08]

Let's leave them apart for now, given that we're not doing that yet.

+};
 
 static const bool kMemcpyOK = true;
 
 static SkTArray<Tagged<Src>,  kMemcpyOK>  gSrcs;
 static SkTArray<Tagged<Sink>, kMemcpyOK> gSinks;
 
-static void push_src(const char* tag, Src* s) {
+static void push_src(const char* tag, Src* s, const char* options = nullptr) {

[mtklein, 2015/04/02 17:48:09]

Let's pass this as the second argument and explicitly pass "" for everyone else.

     SkAutoTDelete<Src> src(s);
     if (FLAGS_src.contains(tag) &&
         !SkCommandLineFlags::ShouldSkip(FLAGS_match, src->name().c_str())) {
         Tagged<Src>& s = gSrcs.push_back();
         s.reset(src.detach());
         s.tag = tag;
+        s.options = options;
     }
 }
 
 static bool codec_supported(const char* ext) {
     // FIXME: Once other versions of SkCodec are available, we can add them to this
     // list (and eventually we can remove this check once they are all supported).
     static const char* const exts[] = {
         "bmp", "gif", "png", "ico", "wbmp",
         "BMP", "GIF", "PNG", "ICO", "WBMP"
     };
@@ skipping 25 matching lines @@
         "bmp", "gif", "jpg", "jpeg", "png", "webp", "ktx", "astc", "wbmp", "ico",
         "BMP", "GIF", "JPG", "JPEG", "PNG", "WEBP", "KTX", "ASTC", "WBMP", "ICO",
     };
     for (int i = 0; i < FLAGS_images.count(); i++) {
         const char* flag = FLAGS_images[i];
         if (sk_isdir(flag)) {
             for (size_t j = 0; j < SK_ARRAY_COUNT(exts); j++) {
                 SkOSFile::Iter it(flag, exts[j]);
                 for (SkString file; it.next(&file); ) {
                     SkString path = SkOSPath::Join(flag, file.c_str());
-                    push_src("image", new ImageSrc(path));     // Decode entire image.
-                    push_src("subset", new ImageSrc(path, 2)); // Decode into 2 x 2 subsets
+                    push_src("image", new ImageSrc(path), "image");     // Decode entire image

[mtklein, 2015/04/02 17:48:08]

Might want this "image" to be "default" so we don't get confused about
image/image?

+                    push_src("image", new ImageSrc(path, 2), "subset"); // Decode into 2x2 subsets
                     if (codec_supported(exts[j])) {
-                        push_src("codec", new CodecSrc(path, CodecSrc::kNormal_Mode));
-                        push_src("scanline", new CodecSrc(path, CodecSrc::kScanline_Mode));
+                        push_src("image", new CodecSrc(path, CodecSrc::kNormal_Mode), "codec");
+                        push_src("image", new CodecSrc(path, CodecSrc::kScanline_Mode), "scanline");
                     }
                 }
             }
         } else if (sk_exists(flag)) {
             // assume that FLAGS_images[i] is a valid image if it is a file.
-            push_src("image", new ImageSrc(flag));     // Decode entire image.
-            push_src("subset", new ImageSrc(flag, 2)); // Decode into 2 x 2 subsets
-            push_src("codec", new CodecSrc(flag, CodecSrc::kNormal_Mode));
-            push_src("scanline", new CodecSrc(flag, CodecSrc::kScanline_Mode));
+            push_src("image", new ImageSrc(flag), "image");     // Decode entire image.
+            push_src("image", new ImageSrc(flag, 2), "subset"); // Decode into 2 x 2 subsets
+            push_src("image", new CodecSrc(flag, CodecSrc::kNormal_Mode), "codec");
+            push_src("image", new CodecSrc(flag, CodecSrc::kScanline_Mode), "scanline");
         }
     }
 }
 
 static GrGLStandard get_gpu_api() {
     if (FLAGS_gpuAPI.contains("gl"))   { return kGL_GrGLStandard; }
     if (FLAGS_gpuAPI.contains("gles")) { return kGLES_GrGLStandard; }
     return kNone_GrGLStandard;
 }
 
@@ skipping 212 matching lines @@
         timer.end();
         done(timer.fWall, task->sink.tag, task->src.tag, name, note, log);
     }
 
     static void WriteToDisk(const Task& task,
                             SkString md5,
                             const char* ext,
                             SkStream* data, size_t len,
                             const SkBitmap* bitmap) {
         JsonWriter::BitmapResult result;
-        result.name       = task.src->name();
-        result.config     = task.sink.tag;
-        result.sourceType = task.src.tag;
-        result.ext        = ext;
-        result.md5        = md5;
+        result.name          = task.src->name();
+        result.config        = task.sink.tag;
+        result.sourceType    = task.src.tag;
+        result.sourceOptions = task.src.options;
+        result.ext           = ext;
+        result.md5           = md5;
         JsonWriter::AddBitmapResult(result);
 
         const char* dir = FLAGS_writePath[0];
         if (0 == strcmp(dir, "@")) {  // Needed for iOS.
             dir = FLAGS_resourcePath[0];
         }
         sk_mkdir(dir);
 
         SkString path;
         if (FLAGS_nameByHash) {
@@ skipping 200 matching lines @@
     }
     return 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