Update old tools to allow MultiPictureDraw rendering

tools/bench_pictures_main.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "BenchLogger.h"
 #include "Timer.h"
 #include "CopyTilesRenderer.h"
@@ skipping 41 matching lines @@
               " for each picture.");
 DEFINE_bool(trackDeferredCaching, false, "Only meaningful with --deferImageDecoding and "
             "SK_LAZY_CACHE_STATS set to true. Report percentage of cache hits when using "
             "deferred image decoding.");
 
 #if GR_GPU_STATS
 DEFINE_bool(gpuStats, false, "Only meaningful with gpu configurations. "
             "Report some GPU call statistics.");
 #endif
 
-DEFINE_bool(preprocess, false, "If true, perform device specific preprocessing before timing.");
+DEFINE_bool(mpd, false, "If true, use MultiPictureDraw to render.");
 
 // Buildbot-specific parameters
 DEFINE_string(builderName, "", "Name of the builder this is running on.");
 DEFINE_int32(buildNumber, -1, "Build number of the build this test is running on");
 DEFINE_int32(timestamp, 0, "Timestamp of the revision of Skia being tested.");
 DEFINE_string(gitHash, "", "Commit hash of the revision of Skia being run.");
 DEFINE_int32(gitNumber, -1, "Git number of the revision of Skia being run.");
 
 
 static char const * const gFilterTypes[] = {
@@ skipping 122 matching lines @@
     }
     SkAutoTUnref<SkPicture> picture(SkPicture::CreateFromStream(&inputStream, proc));
 
     if (NULL == picture.get()) {
         SkString err;
         err.printf("Could not read an SkPicture from %s\n", inputPath.c_str());
         gLogger.logError(err);
         return false;
     }
 
-    if (FLAGS_preprocess) {
-        // Because the GPU preprocessing step relies on the in-memory picture
-        // statistics we need to rerecord the picture here
-        SkPictureRecorder recorder;
-        picture->playback(recorder.beginRecording(picture->cullRect().width(), 
-                                                  picture->cullRect().height(), 
-                                                  NULL, 0));
-        picture.reset(recorder.endRecording());
-    }
-
     SkString filename = SkOSPath::Basename(inputPath.c_str());
 
     gWriter.bench(filename.c_str(), 
                   SkScalarCeilToInt(picture->cullRect().width()), 
                   SkScalarCeilToInt(picture->cullRect().height()));
 
-    benchmark.run(picture);
+    benchmark.run(picture, FLAGS_mpd);
 
 #if SK_LAZY_CACHE_STATS
     if (FLAGS_trackDeferredCaching) {
         int cacheHits = pool->getCacheHits();
         int cacheMisses = pool->getCacheMisses();
         pool->resetCacheHitsAndMisses();
         SkString hitString;
         hitString.printf("Cache hit rate: %f\n", (double) cacheHits / (cacheHits + cacheMisses));
         gLogger.logProgress(hitString);
         gTotalCacheHits += cacheHits;
@@ skipping 126 matching lines @@
             exit(-1);
         }
         if (!tiledRenderer->supportsTimingIndividualTiles()) {
             gLogger.logError("This renderer does not support --timeIndividualTiles.\n");
             exit(-1);
         }
         benchmark->setTimeIndividualTiles(true);
     }
 
     benchmark->setPurgeDecodedTex(FLAGS_purgeDecodedTex);
-    benchmark->setPreprocess(FLAGS_preprocess);
 
     if (FLAGS_readPath.count() < 1) {
         gLogger.logError(".skp files or directories are required.\n");
         exit(-1);
     }
 
     renderer->setDrawFilters(drawFilters, filtersName(drawFilters));
     if (FLAGS_logPerIter) {
         benchmark->setTimerResultType(TimerData::kPerIter_Result);
     } else if (FLAGS_min) {
@@ skipping 113 matching lines @@
 
     gWriter.end();
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif