Switch non-MPD nanobench path to use a separate canvas per tile

bench/SKPBench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SKPBench.h"
 #include "SkCommandLineFlags.h"
 #include "SkMultiPictureDraw.h"
@@ skipping 22 matching lines @@
 
 const char* SKPBench::onGetName() {
     return fName.c_str();
 }
 
 const char* SKPBench::onGetUniqueName() {
     return fUniqueName.c_str();
 }
 
 void SKPBench::onPerCanvasPreDraw(SkCanvas* canvas) {
-    if (!fUseMultiPictureDraw) {
-        return;
-    }
-
     SkIRect bounds;
     SkAssertResult(canvas->getClipDeviceBounds(&bounds));
 
     int xTiles = SkScalarCeilToInt(bounds.width()  / SkIntToScalar(FLAGS_benchTile));
     int yTiles = SkScalarCeilToInt(bounds.height() / SkIntToScalar(FLAGS_benchTile));
 
     fSurfaces.setReserve(xTiles * yTiles);
     fTileRects.setReserve(xTiles * yTiles);
 
     SkImageInfo ii = canvas->imageInfo().makeWH(FLAGS_benchTile, FLAGS_benchTile);
@@ skipping 10 matching lines @@
             clip.offset(-SkIntToScalar(tileRect.fLeft), -SkIntToScalar(tileRect.fTop));
             fSurfaces.top()->getCanvas()->clipRect(clip);
 
             fSurfaces.top()->getCanvas()->setMatrix(canvas->getTotalMatrix());
             fSurfaces.top()->getCanvas()->scale(fScale, fScale);
         }
     }
 }
 
 void SKPBench::onPerCanvasPostDraw(SkCanvas* canvas) {
-    if (!fUseMultiPictureDraw) {
-        return;
-    }
-
     // Draw the last set of tiles into the master canvas in case we're
     // saving the images
     for (int i = 0; i < fTileRects.count(); ++i) {
         SkAutoTUnref<SkImage> image(fSurfaces[i]->newImageSnapshot());
         canvas->drawImage(image,
                           SkIntToScalar(fTileRects[i].fLeft), SkIntToScalar(fTileRects[i].fTop));
         SkSafeSetNull(fSurfaces[i]);
     }
 
     fSurfaces.rewind();
     fTileRects.rewind();
 }
 
 bool SKPBench::isSuitableFor(Backend backend) {
     return backend != kNonRendering_Backend;
 }
 
 SkIPoint SKPBench::onGetSize() {
     return SkIPoint::Make(fClip.width(), fClip.height());
 }
 
 void SKPBench::onDraw(const int loops, SkCanvas* canvas) {
     if (fUseMultiPictureDraw) {
         for (int i = 0; i < loops; i++) {
             SkMultiPictureDraw mpd;
 
-            for (int i = 0; i < fTileRects.count(); ++i) {
+            for (int j = 0; j < fTileRects.count(); ++j) {
                 SkMatrix trans;
-                trans.setTranslate(-fTileRects[i].fLeft/fScale,
-                                   -fTileRects[i].fTop/fScale);
-                mpd.add(fSurfaces[i]->getCanvas(), fPic, &trans);
+                trans.setTranslate(-fTileRects[j].fLeft/fScale,
+                                   -fTileRects[j].fTop/fScale);
+                mpd.add(fSurfaces[j]->getCanvas(), fPic, &trans);
             }
 
             mpd.draw();
 
-            for (int i = 0; i < fTileRects.count(); ++i) {
-                fSurfaces[i]->getCanvas()->flush();
+            for (int j = 0; j < fTileRects.count(); ++j) {
+                fSurfaces[j]->getCanvas()->flush();
             }
         }
     } else {
-        SkIRect bounds;
-        SkAssertResult(canvas->getClipDeviceBounds(&bounds));
-
-        SkAutoCanvasRestore overall(canvas, true/*save now*/);
-        canvas->scale(fScale, fScale);
-
         for (int i = 0; i < loops; i++) {
-            for (int y = bounds.fTop; y < bounds.fBottom; y += FLAGS_benchTile) {
-                for (int x = bounds.fLeft; x < bounds.fRight; x += FLAGS_benchTile) {
-                    SkAutoCanvasRestore perTile(canvas, true/*save now*/);
-                    canvas->clipRect(SkRect::MakeXYWH(x/fScale, y/fScale,
-                                                      FLAGS_benchTile/fScale,
-                                                      FLAGS_benchTile/fScale));
-                    fPic->playback(canvas);
-                }
+            for (int j = 0; j < fTileRects.count(); ++j) {
+                SkMatrix trans;
+                trans.setTranslate(-fTileRects[j].fLeft / fScale,
+                                   -fTileRects[j].fTop / fScale);
+                fSurfaces[j]->getCanvas()->drawPicture(fPic, &trans, NULL);
             }
 
-            canvas->flush();
+            for (int j = 0; j < fTileRects.count(); ++j) {
+                fSurfaces[j]->getCanvas()->flush();
+            }
         }
     }
 }