split SkPictureRecorder out of SkPicture

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 104 matching lines @@
     SkString filename;
     make_filename(name, &filename);
     filename.appendf("_%s.png", config);
     SkString path = SkOSPath::SkPathJoin(dir, filename.c_str());
     ::remove(path.c_str());
 
     SkFILEWStream   stream(path.c_str());
     stream.write(data->data(), data->size());
 }
 
-static void performClip(SkCanvas* canvas, int w, int h) {
+static void perform_clip(SkCanvas* canvas, int w, int h) {
     SkRect r;
 
     r.set(SkIntToScalar(10), SkIntToScalar(10),
           SkIntToScalar(w*2/3), SkIntToScalar(h*2/3));
     canvas->clipRect(r, SkRegion::kIntersect_Op);
 
     r.set(SkIntToScalar(w/3), SkIntToScalar(h/3),
           SkIntToScalar(w-10), SkIntToScalar(h-10));
     canvas->clipRect(r, SkRegion::kXOR_Op);
 }
 
-static void performRotate(SkCanvas* canvas, int w, int h) {
+static void perform_rotate(SkCanvas* canvas, int w, int h) {
     const SkScalar x = SkIntToScalar(w) / 2;
     const SkScalar y = SkIntToScalar(h) / 2;
 
     canvas->translate(x, y);
     canvas->rotate(SkIntToScalar(35));
     canvas->translate(-x, -y);
 }
 
-static void performScale(SkCanvas* canvas, int w, int h) {
+static void perform_scale(SkCanvas* canvas, int w, int h) {
     const SkScalar x = SkIntToScalar(w) / 2;
     const SkScalar y = SkIntToScalar(h) / 2;
 
     canvas->translate(x, y);
     // just enough so we can't take the sprite case
     canvas->scale(SK_Scalar1 * 99/100, SK_Scalar1 * 99/100);
     canvas->translate(-x, -y);
 }
 
 static SkSurface* make_surface(SkColorType colorType, const SkIPoint& size,
@@ skipping 316 matching lines @@
             if (SkBenchmark::kGPU_Backend == config.backend) {
                 context = gContextFactory.get(config.contextType);
                 if (NULL == context) {
                     continue;
                 }
                 glContext = gContextFactory.getGLContext(config.contextType);
             }
 #endif
 
             SkAutoTUnref<SkCanvas> canvas;
-            SkPicture recordFrom, recordTo;
+            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(recordTo.beginRecording(dim.fX, dim.fY, kRecordFlags)));
+                        canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY, kRecordFlags)));
                         break;
-                    case kPictureRecord_BenchMode:
-                        bench->draw(1, recordFrom.beginRecording(dim.fX, dim.fY, kRecordFlags));
-                        recordFrom.endRecording();
-                        canvas.reset(SkRef(recordTo.beginRecording(dim.fX, dim.fY, kRecordFlags)));
+                    case kPictureRecord_BenchMode: {
+                        SkPictureRecorder recorderFrom;
+                        bench->draw(1, recorderFrom.beginRecording(dim.fX, dim.fY, kRecordFlags));
+                        recordFrom.reset(recorderFrom.endRecording());
+                        canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY, kRecordFlags)));
                         break;
+                    }
                     case kNormal_BenchMode:
                         canvas.reset(SkRef(surface->getCanvas()));
                         break;
                     default:
                         SkASSERT(false);
                 }
             }
 
             if (NULL != canvas) {
                 canvas->clear(SK_ColorWHITE);
-                if (FLAGS_clip)   {   performClip(canvas, dim.fX, dim.fY); }
-                if (FLAGS_scale)  {  performScale(canvas, dim.fX, dim.fY); }
-                if (FLAGS_rotate) { performRotate(canvas, dim.fX, dim.fY); }
+                if (FLAGS_clip)   {   
+                    perform_clip(canvas, dim.fX, dim.fY); 
+                }
+                if (FLAGS_scale)  {  
+                    perform_scale(canvas, dim.fX, dim.fY); 
+                }
+                if (FLAGS_rotate) { 
+                    perform_rotate(canvas, dim.fX, dim.fY); 
+                }
             }
 
             if (!loggedBenchName) {
                 loggedBenchName = true;
                 writer.bench(bench->getName(), dim.fX, dim.fY);
             }
 
 #if SK_SUPPORT_GPU
             SkGLContextHelper* contextHelper = NULL;
             if (SkBenchmark::kGPU_Backend == config.backend) {
@@ skipping 24 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(recordTo.beginRecording(dim.fX, dim.fY, kRecordFlags)));
+                        canvas.reset(SkRef(recorderTo.beginRecording(dim.fX, dim.fY, kRecordFlags)));
                     }
 
                     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*/);
 
                         int loops;
                         if (frameIntervalComputed && loopCount > loopsPerFrame) {
                             loops = loopsPerFrame;
                             loopCount -= loopsPerFrame;
                         } else {
                             loops = loopCount;
                             loopCount = 0;
                         }
 
                         if (benchMode == kPictureRecord_BenchMode) {
-                            recordFrom.draw(canvas);
+                            recordFrom->draw(canvas);
                         } else {
                             bench->draw(loops, canvas);
                         }
 
                         if (kDeferredSilent_BenchMode == benchMode) {
                             static_cast<SkDeferredCanvas*>(canvas.get())->silentFlush();
                         } else if (NULL != canvas) {
                             canvas->flush();
                         }
 
@@ skipping 79 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