save/restore the canvas around every bench draw call

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.
  */
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
@@ skipping 575 matching lines @@
                          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(recordTo.beginRecording(dim.fX, dim.fY, kRecordFlags));
                 }
 
                 timer.start();
-                if (NULL != canvas) {
-                    canvas->save();
-                }
-
                 // 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; ) {
+                    if (NULL != canvas) {

[reed1, 2013/10/14 13:18:04]

We have SkAutoCanvasRestore. One if its smarts is that it records the
save-count, and then in its destructor calls restoreToCount(), ensuring that we
achieve balance (and harmony). Can we use this idea here too?

+                        canvas->save();
+                    }
                     if (frameIntervalComputed && loopCount > loopsPerFrame) {
                         bench->setLoops(loopsPerFrame);
                         loopCount -= loopsPerFrame;
                     } else {
                         bench->setLoops(loopCount);
                         loopCount = 0;
                     }
 
                     if (benchMode == kPictureRecord_BenchMode) {
                         recordFrom.draw(canvas);
                     } else {
                         bench->draw(canvas);
                     }
 
                     if (kDeferredSilent_BenchMode == benchMode) {
                         static_cast<SkDeferredCanvas*>(canvas.get())->silentFlush();
                     } else if (NULL != canvas) {
                         canvas->flush();
                     }
 
 #if SK_SUPPORT_GPU
                     // swap drawing buffers on each frame to prevent the GPU
                     // from queuing up too much work
                     if (NULL != glContext) {
                         glContext->swapBuffers();
                     }
 #endif
-                }
-
-                if (NULL != canvas) {
-                    canvas->restore();
+                    if (NULL != canvas) {
+                        canvas->restore();
+                    }
                 }
 
 
+
                 // Stop truncated timers before GL calls complete, and stop the full timers after.
                 timer.truncatedEnd();
 #if SK_SUPPORT_GPU
                 if (NULL != glContext) {
                     context->flush();
                     SK_GL(*glContext, Finish());
                 }
 #endif
                 timer.end();
 
@@ skipping 62 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