Remove SkPicture::kUsePathBoundsForClip_RecordingFlag

bench/benchmain.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "BenchTimer.h"
 #include "ResultsWriter.h"
 #include "SkBenchLogger.h"
@@ skipping 472 matching lines @@
                 }
                 glContext = gContextFactory.getGLContext(config.contextType);
             }
 #endif
 
             SkAutoTUnref<SkCanvas> canvas;
             SkAutoTUnref<SkPicture> recordFrom;
             SkPictureRecorder recorderTo;
             const SkIPoint dim = bench->getSize();
 
-            const SkPicture::RecordingFlags kRecordFlags =
-                SkPicture::kUsePathBoundsForClip_RecordingFlag;
-
             SkAutoTUnref<SkSurface> surface;
             if (SkBenchmark::kNonRendering_Backend != config.backend) {
                 surface.reset(make_surface(config.fColorType,
                                            dim,
                                            config.backend,
                                            config.sampleCount,
                                            context));
                 if (!surface.get()) {
                     logger.logError(SkStringPrintf(
                         "Device creation failure for config %s. Will skip.\n", config.name));
                     continue;
                 }
 
                 switch(benchMode) {
                     case kDeferredSilent_BenchMode:
                     case kDeferred_BenchMode:
                         canvas.reset(SkDeferredCanvas::Create(surface.get()));
                         break;
                     case kRecord_BenchMode:
-                        canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY,
-                                                                     NULL, kRecordFlags)));
+                        canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY)));
                         break;
                     case kPictureRecord_BenchMode: {
                         SkPictureRecorder recorderFrom;
-                        bench->draw(1, recorderFrom.beginRecording(dim.fX, dim.fY,
-                                                                   NULL, kRecordFlags));
+                        bench->draw(1, recorderFrom.beginRecording(dim.fX, dim.fY));
                         recordFrom.reset(recorderFrom.endRecording());
-                        canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY,
-                                                                     NULL, kRecordFlags)));
+                        canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY)));
                         break;
                     }
                     case kNormal_BenchMode:
                         canvas.reset(SkRef(surface->getCanvas()));
                         break;
                     default:
                         SkASSERT(false);
                 }
             }
 
@@ skipping 45 matching lines @@
                         // you've got a computer clocked at several THz or have a broken benchmark.  ;)
                         //     "1B ought to be enough for anybody."
                         logger.logError(SkStringPrintf(
                             "\nCan't get %s %s to converge in %dms (%d loops)",
                              bench->getName(), config.name, FLAGS_maxMs, loopsPerIter));
                         break;
                     }
 
                     if ((benchMode == kRecord_BenchMode || benchMode == kPictureRecord_BenchMode)) {
                         // Clear the recorded commands so that they do not accumulate.
-                        canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY,
-                                                                     NULL, kRecordFlags)));
+                        canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY)));
                     }
 
                     timer.start();
                     // Inner loop that allows us to break the run into smaller
                     // chunks (e.g. frames). This is especially useful for the GPU
                     // as we can flush and/or swap buffers to keep the GPU from
                     // queuing up too much work.
                     for (int loopCount = loopsPerIter; loopCount > 0; ) {
                         // Save and restore around each call to draw() to guarantee a pristine canvas.
                         SkAutoCanvasRestore saveRestore(canvas, true/*also save*/);
@@ skipping 101 matching lines @@
     gContextFactory.destroyContexts();
 #endif
     return 0;
 }
 
 #if !defined(SK_BUILD_FOR_IOS) && !defined(SK_BUILD_FOR_NACL)
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif