split SkPictureRecorder out of SkPicture

include/core/SkPicture.h

Index: include/core/SkPicture.h
===================================================================
--- include/core/SkPicture.h	(revision 13963)
+++ include/core/SkPicture.h	(working copy)
@@ -384,4 +384,83 @@
     virtual bool abortDrawing() = 0;
 };
 
+class SkPictureFactory : public SkRefCnt {
+public:
+    /**
+     *  Allocate a new SkPicture. Return NULL on failure.
+     */
+    virtual SkPicture* create(int width, int height) = 0;
+};
+
+class SK_API SkPictureRecorder : public SkRefCnt {

[mtklein, 2014/03/27 21:09:11]

What's this extra level of indirection get us?  I'd have expected

class SkPictureRecorder : public SkCanvas {
  SkPictureRecorder(int w, int h);
  SkPicture* endRecording();
  ...
};

Are we ever refcounting SkPictureRecorders?  I'm seeing most of them on the
stack.

+public:
+    SK_DECLARE_INST_COUNT(SkPictureRecorder)
+
+    SkPictureRecorder(SkPictureFactory* factory = NULL) {
+        fFactory.reset(factory);
+        if (NULL != fFactory.get()) {
+            fFactory.get()->ref();
+        }
+    }
+
+    /** Returns the canvas that records the drawing commands.
+        @param width the base width for the picture, as if the recording
+                     canvas' bitmap had this width.
+        @param height the base width for the picture, as if the recording
+                     canvas' bitmap had this height.
+        @param recordFlags optional flags that control recording.
+        @return the canvas.
+    */
+    SkCanvas* beginRecording(int width, int height, uint32_t recordFlags = 0) {
+        if (NULL != fFactory) {
+            fPicture.reset(fFactory->create(width, height));
+        } else {
+            fPicture.reset(SkNEW(SkPicture));
+        }
+
+        return fPicture->beginRecording(width, height, recordFlags);
+    }
+
+    /** Returns the recording canvas if one is active, or NULL if recording is
+        not active. This does not alter the refcnt on the canvas (if present).
+    */
+    SkCanvas* getRecordingCanvas() {
+        if (NULL != fPicture.get()) {
+            return fPicture->getRecordingCanvas();
+        }
+        return NULL;
+    }
+
+    /** Signal that the caller is done recording. This invalidates the canvas
+        returned by beginRecording/getRecordingCanvas, and returns the 
+        created SkPicture. Note that the returned picture has its creation
+        ref which the caller must take ownership of. 
+    */
+    SkPicture* endRecording() {
+        if (NULL != fPicture.get()) {
+            fPicture->endRecording();
+            return fPicture.detach();
+        }
+        return NULL;
+    }
+
+    /** Enable/disable all the picture recording optimizations (i.e.,
+        those in SkPictureRecord). It is mainly intended for testing the
+        existing optimizations (i.e., to actually have the pattern
+        appear in an .skp we have to disable the optimization). Call right
+        after 'beginRecording'.
+    */
+    void internalOnly_EnableOpts(bool enableOpts) {
+        if (NULL != fPicture.get()) {
+            fPicture->internalOnly_EnableOpts(enableOpts);
+        }
+    }
+
+private:
+    SkAutoTUnref<SkPictureFactory> fFactory;
+    SkAutoTUnref<SkPicture>        fPicture;
+
+    typedef SkRefCnt INHERITED;
+};
+
 #endif