Actually identify required saveLayers in SkGpuDevice::EXPERIMENTAL_drawPicture

tools/PictureRenderer.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 "PictureRenderer.h"
 #include "picture_utils.h"
 #include "SamplePipeControllers.h"
@@ skipping 477 matching lines @@
 void TiledPictureRenderer::init(SkPicture* pict, const SkString* outputDir,
                                 const SkString* inputFilename, bool useChecksumBasedFilenames) {
     SkASSERT(pict != NULL);
     SkASSERT(0 == fTileRects.count());
     if (NULL == pict || fTileRects.count() != 0) {
         return;
     }
 
     // Do not call INHERITED::init(), which would create a (potentially large) canvas which is not
     // used by bench_pictures.
     fPicture = pict;

[bsalomon, 2014/03/26 17:29:21]

could be
fPicture = SkRef(pict);

[robertphillips, 2014/03/28 11:48:16]

Done.

+    fPicture->ref();
     this->CopyString(&fOutputDir, outputDir);
     this->CopyString(&fInputFilename, inputFilename);
     fUseChecksumBasedFilenames = useChecksumBasedFilenames;
-    fPicture->ref();
     this->buildBBoxHierarchy();
 
     if (fTileWidthPercentage > 0) {
         fTileWidth = sk_float_ceil2int(float(fTileWidthPercentage * fPicture->width() / 100));
     }
     if (fTileHeightPercentage > 0) {
         fTileHeight = sk_float_ceil2int(float(fTileHeightPercentage * fPicture->height() / 100));
     }
 
     if (fTileMinPowerOf2Width > 0) {
@@ skipping 174 matching lines @@
             } else {
                 success = false;
             }
         }
     }
     return success;
 }
 
 SkCanvas* TiledPictureRenderer::setupCanvas(int width, int height) {
     SkCanvas* canvas = this->INHERITED::setupCanvas(width, height);
-    SkASSERT(fPicture != NULL);
+    SkASSERT(NULL != fPicture);
     // Clip the tile to an area that is completely inside both the SkPicture and the viewport. This
     // is mostly important for tiles on the right and bottom edges as they may go over this area and
     // the picture may have some commands that draw outside of this area and so should not actually
     // be written.
     // Uses a clipRegion so that it will be unaffected by the scale factor, which may have been set
     // by INHERITED::setupCanvas.
     SkRegion clipRegion;
     clipRegion.setRect(0, 0, this->getViewWidth(), this->getViewHeight());
     canvas->clipRegion(clipRegion);
     return canvas;
@@ skipping 195 matching lines @@
     return name;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 void PlaybackCreationRenderer::setup() {
     fReplayer.reset(this->createPicture());
     SkCanvas* recorder = fReplayer->beginRecording(this->getViewWidth(), this->getViewHeight(),
                                                    this->recordFlags());
     this->scaleToScaleFactor(recorder);
-    fPicture->draw(recorder);
+    recorder->drawPicture(*fPicture);
 }
 
 bool PlaybackCreationRenderer::render(SkBitmap** out) {
     fReplayer->endRecording();
     // Since this class does not actually render, return false.
     return false;
 }
 
 SkString PlaybackCreationRenderer::getConfigNameInternal() {
     return SkString("playback_creation");
@@ skipping 14 matching lines @@
                                aspectRatio, sortDraws);
     }
 };
 
 SkPicture* PictureRenderer::createPicture() {
     switch (fBBoxHierarchyType) {
         case kNone_BBoxHierarchyType:
             return SkNEW(SkPicture);
         case kQuadTree_BBoxHierarchyType:
             return SkNEW_ARGS(SkQuadTreePicture, (SkIRect::MakeWH(fPicture->width(),
-                fPicture->height())));
+                                                                  fPicture->height())));
         case kRTree_BBoxHierarchyType:
             return SkNEW(RTreePicture);
         case kTileGrid_BBoxHierarchyType:
             return SkNEW_ARGS(SkTileGridPicture, (fPicture->width(),
-                fPicture->height(), fGridInfo));
+                                                  fPicture->height(), fGridInfo));
     }
     SkASSERT(0); // invalid bbhType
     return NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GatherRenderer : public PictureRenderer {
 public:
-    virtual bool render(SkBitmap** out = NULL)
-            SK_OVERRIDE {
+    virtual bool render(SkBitmap** out = NULL) SK_OVERRIDE {
         SkRect bounds = SkRect::MakeWH(SkIntToScalar(fPicture->width()),
                                        SkIntToScalar(fPicture->height()));
         SkData* data = SkPictureUtils::GatherPixelRefs(fPicture, bounds);
         SkSafeUnref(data);
 
         return (fOutputDir.isEmpty());    // we don't have anything to write
     }
 
 private:
     virtual SkString getConfigNameInternal() SK_OVERRIDE {
         return SkString("gather_pixelrefs");
     }
 };
 
 PictureRenderer* CreateGatherPixelRefsRenderer() {
     return SkNEW(GatherRenderer);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class PictureCloneRenderer : public PictureRenderer {
 public:
-    virtual bool render(SkBitmap** out = NULL)
-            SK_OVERRIDE {
+    virtual bool render(SkBitmap** out = NULL) SK_OVERRIDE {
         for (int i = 0; i < 100; ++i) {
             SkPicture* clone = fPicture->clone();
             SkSafeUnref(clone);
         }
 
         return (fOutputDir.isEmpty());    // we don't have anything to write
     }
 
 private:
     virtual SkString getConfigNameInternal() SK_OVERRIDE {
         return SkString("picture_clone");
     }
 };
 
 PictureRenderer* CreatePictureCloneRenderer() {
     return SkNEW(PictureCloneRenderer);
 }
 
 } // namespace sk_tools