split SkPictureRecorder out of SkPicture

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 102 matching lines @@
 }
 
 void PictureRenderer::init(SkPicture* pict, const SkString* outputDir,
                            const SkString* inputFilename, bool useChecksumBasedFilenames) {
     this->CopyString(&fOutputDir, outputDir);
     this->CopyString(&fInputFilename, inputFilename);
     fUseChecksumBasedFilenames = useChecksumBasedFilenames;
 
     SkASSERT(NULL == fPicture);
     SkASSERT(NULL == fCanvas.get());
-    if (fPicture != NULL || NULL != fCanvas.get()) {
+    if (NULL != fPicture || NULL != fCanvas.get()) {
         return;
     }
 
     SkASSERT(pict != NULL);
     if (NULL == pict) {
         return;
     }
 
-    fPicture = pict;
-    fPicture->ref();
+    fPicture.reset(pict)->ref();
     fCanvas.reset(this->setupCanvas());
 }
 
 void PictureRenderer::CopyString(SkString* dest, const SkString* src) {
     if (NULL != src) {
         dest->set(*src);
     } else {
         dest->reset();
     }
 }
@@ skipping 95 matching lines @@
 
 void PictureRenderer::scaleToScaleFactor(SkCanvas* canvas) {
     SkASSERT(canvas != NULL);
     if (fScaleFactor != SK_Scalar1) {
         canvas->scale(fScaleFactor, fScaleFactor);
     }
 }
 
 void PictureRenderer::end() {
     this->resetState(true);
-    SkSafeUnref(fPicture);
-    fPicture = NULL;
+    fPicture.reset(NULL);
     fCanvas.reset(NULL);
 }
 
 int PictureRenderer::getViewWidth() {
     SkASSERT(fPicture != NULL);
     int width = SkScalarCeilToInt(fPicture->width() * fScaleFactor);
     if (fViewport.width() > 0) {
         width = SkMin32(width, fViewport.width());
     }
     return width;
 }
 
 int PictureRenderer::getViewHeight() {
     SkASSERT(fPicture != NULL);
     int height = SkScalarCeilToInt(fPicture->height() * fScaleFactor);
     if (fViewport.height() > 0) {
         height = SkMin32(height, fViewport.height());
     }
     return height;
 }
 
 /** Converts fPicture to a picture that uses a BBoxHierarchy.
  *  PictureRenderer subclasses that are used to test picture playback
  *  should call this method during init.
  */
 void PictureRenderer::buildBBoxHierarchy() {
     SkASSERT(NULL != fPicture);
     if (kNone_BBoxHierarchyType != fBBoxHierarchyType && NULL != fPicture) {
-        SkPicture* newPicture = this->createPicture();
-        SkCanvas* recorder = newPicture->beginRecording(fPicture->width(), fPicture->height(),
-                                                        this->recordFlags());
-        fPicture->draw(recorder);
-        newPicture->endRecording();
-        fPicture->unref();
-        fPicture = newPicture;
+        SkAutoTUnref<SkPictureFactory> factory(this->getFactory());
+        SkPictureRecorder recorder(factory);
+        SkCanvas* canvas = recorder.beginRecording(fPicture->width(), fPicture->height(),
+                                                   this->recordFlags());
+        fPicture->draw(canvas);
+        fPicture.reset(recorder.endRecording());
     }
 }
 
 void PictureRenderer::resetState(bool callFinish) {
 #if SK_SUPPORT_GPU
     SkGLContextHelper* glContext = this->getGLContext();
     if (NULL == glContext) {
         SkASSERT(kBitmap_DeviceType == fDeviceType);
         return;
     }
@@ skipping 135 matching lines @@
     // defer the canvas setup until the render step
     return NULL;
 }
 
 // the size_t* parameter is deprecated, so we ignore it
 static SkData* encode_bitmap_to_data(size_t*, const SkBitmap& bm) {
     return SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, 100);
 }
 
 bool RecordPictureRenderer::render(SkBitmap** out) {
-    SkAutoTUnref<SkPicture> replayer(this->createPicture());
-    SkCanvas* recorder = replayer->beginRecording(this->getViewWidth(), this->getViewHeight(),
-                                                  this->recordFlags());
-    this->scaleToScaleFactor(recorder);
-    fPicture->draw(recorder);
-    replayer->endRecording();
+    SkAutoTUnref<SkPictureFactory> factory(this->getFactory());
+    SkPictureRecorder recorder(factory);
+    SkCanvas* canvas = recorder.beginRecording(this->getViewWidth(), this->getViewHeight(),
+                                               this->recordFlags());
+    this->scaleToScaleFactor(canvas);
+    fPicture->draw(canvas);
+    SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     if (!fOutputDir.isEmpty()) {
         // Record the new picture as a new SKP with PNG encoded bitmaps.
         SkString skpPath = SkOSPath::SkPathJoin(fOutputDir.c_str(), fInputFilename.c_str());
         SkFILEWStream stream(skpPath.c_str());
-        replayer->serialize(&stream, &encode_bitmap_to_data);
+        picture->serialize(&stream, &encode_bitmap_to_data);
         return true;
     }
     return false;
 }
 
 SkString RecordPictureRenderer::getConfigNameInternal() {
     return SkString("record");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ skipping 30 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 void SimplePictureRenderer::init(SkPicture* picture, const SkString* outputDir,
                                  const SkString* inputFilename, bool useChecksumBasedFilenames) {
     INHERITED::init(picture, outputDir, inputFilename, useChecksumBasedFilenames);
     this->buildBBoxHierarchy();
 }
 
 bool SimplePictureRenderer::render(SkBitmap** out) {
     SkASSERT(fCanvas.get() != NULL);
-    SkASSERT(fPicture != NULL);
+    SkASSERT(NULL != fPicture);
     if (NULL == fCanvas.get() || NULL == fPicture) {
         return false;
     }
 
     fCanvas->drawPicture(*fPicture);
     fCanvas->flush();
     if (!fOutputDir.isEmpty()) {
         return write(fCanvas, fOutputDir, fInputFilename, fJsonSummaryPtr,
                      fUseChecksumBasedFilenames);
     }
@@ skipping 18 matching lines @@
     , fTileHeight(kDefaultTileHeight)
     , fTileWidthPercentage(0.0)
     , fTileHeightPercentage(0.0)
     , fTileMinPowerOf2Width(0)
     , fCurrentTileOffset(-1)
     , fTilesX(0)
     , fTilesY(0) { }
 
 void TiledPictureRenderer::init(SkPicture* pict, const SkString* outputDir,
                                 const SkString* inputFilename, bool useChecksumBasedFilenames) {
-    SkASSERT(pict != NULL);
+    SkASSERT(NULL != pict);
     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 = SkRef(pict);
+    fPicture.reset(pict)->ref();
     this->CopyString(&fOutputDir, outputDir);
     this->CopyString(&fInputFilename, inputFilename);
     fUseChecksumBasedFilenames = useChecksumBasedFilenames;
     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));
@@ skipping 389 matching lines @@
 
 SkString MultiCorePictureRenderer::getConfigNameInternal() {
     SkString name = this->INHERITED::getConfigNameInternal();
     name.appendf("_multi_%i_threads", fNumThreads);
     return name;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 
 void PlaybackCreationRenderer::setup() {
-    fReplayer.reset(this->createPicture());
-    SkCanvas* recorder = fReplayer->beginRecording(this->getViewWidth(), this->getViewHeight(),
-                                                   this->recordFlags());
-    this->scaleToScaleFactor(recorder);
-    recorder->drawPicture(*fPicture);
+    SkAutoTUnref<SkPictureFactory> factory(this->getFactory());
+    fRecorder.reset(SkNEW_ARGS(SkPictureRecorder, (factory)));
+    SkCanvas* canvas = fRecorder->beginRecording(this->getViewWidth(), this->getViewHeight(),
+                                                 this->recordFlags());
+    this->scaleToScaleFactor(canvas);
+    canvas->drawPicture(*fPicture);
 }
 
 bool PlaybackCreationRenderer::render(SkBitmap** out) {
-    fReplayer->endRecording();
+    fPicture.reset(fRecorder->endRecording());
     // Since this class does not actually render, return false.
     return false;
 }
 
 SkString PlaybackCreationRenderer::getConfigNameInternal() {
     return SkString("playback_creation");
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // SkPicture variants for each BBoxHierarchy type
 
 class RTreePicture : public SkPicture {
 public:
-    virtual SkBBoxHierarchy* createBBoxHierarchy() const SK_OVERRIDE{
+    virtual SkBBoxHierarchy* createBBoxHierarchy() const SK_OVERRIDE {
         static const int kRTreeMinChildren = 6;
         static const int kRTreeMaxChildren = 11;
         SkScalar aspectRatio = SkScalarDiv(SkIntToScalar(fWidth),
                                            SkIntToScalar(fHeight));
         bool sortDraws = false;
         return SkRTree::Create(kRTreeMinChildren, kRTreeMaxChildren,
                                aspectRatio, sortDraws);
     }
 };
 
-SkPicture* PictureRenderer::createPicture() {
+class SkRTreePictureFactory : public SkPictureFactory {
+private:
+    virtual SkPicture* create(int width, int height) SK_OVERRIDE {
+        return SkNEW(RTreePicture);   
+    }
+
+private:
+    typedef SkPictureFactory INHERITED;
+};
+
+SkPictureFactory* PictureRenderer::getFactory() {
     switch (fBBoxHierarchyType) {
         case kNone_BBoxHierarchyType:
-            return SkNEW(SkPicture);
+            return NULL;
         case kQuadTree_BBoxHierarchyType:
-            return SkNEW_ARGS(SkQuadTreePicture, (SkIRect::MakeWH(fPicture->width(),
-                                                                  fPicture->height())));
+            return SkNEW(SkQuadTreePictureFactory);
         case kRTree_BBoxHierarchyType:
-            return SkNEW(RTreePicture);
+            return SkNEW(SkRTreePictureFactory);
         case kTileGrid_BBoxHierarchyType:
-            return SkNEW_ARGS(SkTileGridPicture, (fPicture->width(),
-                                                  fPicture->height(), fGridInfo));
+            return new SkTileGridPictureFactory(fGridInfo);
     }
     SkASSERT(0); // invalid bbhType
     return NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GatherRenderer : public PictureRenderer {
 public:
     virtual bool render(SkBitmap** out = NULL) SK_OVERRIDE {
@@ skipping 32 matching lines @@
     virtual SkString getConfigNameInternal() SK_OVERRIDE {
         return SkString("picture_clone");
     }
 };
 
 PictureRenderer* CreatePictureCloneRenderer() {
     return SkNEW(PictureCloneRenderer);
 }
 
 } // namespace sk_tools