add --rasterPDF flag to DM

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"
 #include "SkString.h"
 #include "SkTaskGroup.h"
 #include "Test.h"
 #include "gm.h"
 #include "sk_tool_utils.h"
 #include "sk_tool_utils_flags.h"
 
 #include "DMCpuGMTask.h"
 #include "DMGpuGMTask.h"
 #include "DMGpuSupport.h"
 #include "DMImageTask.h"
 #include "DMJsonWriter.h"
 #include "DMPDFTask.h"
+#include "DMPDFRasterizeTask.h"
 #include "DMReporter.h"
 #include "DMSKPTask.h"
 #include "DMTask.h"
 #include "DMTaskRunner.h"
 #include "DMTestTask.h"
 
 #ifdef SK_BUILD_POPPLER
 #  include "SkPDFRasterizer.h"
 #  define RASTERIZE_PDF_PROC SkPopplerRasterizePDF
 #elif defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
@@ skipping 11 matching lines @@
 using skiatest::TestRegistry;
 
 static const char kGpuAPINameGL[] = "gl";
 static const char kGpuAPINameGLES[] = "gles";
 
 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.");
 DEFINE_string(images, "resources", "Path to directory containing images to decode.");
+DEFINE_bool(rasterPDF, true, "Rasterize PDFs?");
 
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
+static DM::RasterizePdfProc get_pdf_rasterizer_proc() {
+    return reinterpret_cast<DM::RasterizePdfProc>(
+            FLAGS_rasterPDF ? RASTERIZE_PDF_PROC : NULL);
+}
+
 // "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;
@@ skipping 27 matching lines @@
             START("nvprmsaa16", GpuGMTask, nvpr,   gpuAPI, 16, false);
             START("gpudft",     GpuGMTask, native, gpuAPI, 0,  true);
             START("gpunull",    GpuGMTask, null,   gpuAPI, 0,  false);
             START("gpudebug",   GpuGMTask, debug,  gpuAPI, 0,  false);
 #if SK_ANGLE
             START("angle",      GpuGMTask, angle,  gpuAPI, 0,  false);
 #endif
 #if SK_MESA
             START("mesa",       GpuGMTask, mesa,   gpuAPI, 0,  false);
 #endif
-            START("pdf",        PDFTask,   RASTERIZE_PDF_PROC);
+            START("pdf",        PDFTask,   get_pdf_rasterizer_proc());
         }
     }
 #undef START
 }
 
 static void kick_off_tests(const SkTDArray<TestRegistry::Factory>& tests,
                            DM::Reporter* reporter,
                            DM::TaskRunner* tasks) {
     for (int i = 0; i < tests.count(); i++) {
         SkAutoTDelete<Test> test(tests[i](NULL));
@@ skipping 35 matching lines @@
         }
         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, pic, filename)));
-        tasks->add(SkNEW_ARGS(DM::PDFTask, (reporter, tasks, pic, filename, RASTERIZE_PDF_PROC)));
+        tasks->add(SkNEW_ARGS(DM::PDFTask, (reporter, tasks, pic, filename,
+                                            get_pdf_rasterizer_proc())));
     }
 }
 
 static void kick_off_images(const SkTArray<SkString>& images,
                             DM::Reporter* reporter,
                             DM::TaskRunner* tasks) {
     for (int i = 0; i < images.count(); i++) {
         SkAutoTUnref<SkData> image(SkData::NewFromFileName(images[i].c_str()));
         if (!image) {
             SkDebugf("Could not read %s.\n", images[i].c_str());
@@ skipping 109 matching lines @@
     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