split SkPictureRecorder out of SkPicture

include/core/SkPicture.h

 
 /*
  * Copyright 2007 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkPicture_DEFINED
@@ skipping 142 matching lines @@
             after a frame or two of tiled rendering (and complex pictures that
             induce the worst record times will generally get the largest
             speedups at playback time).
 
             Note: Currently this is not serializable, the bounding data will be
             discarded if you serialize into a stream and then deserialize.
         */
         kOptimizeForClippedPlayback_RecordingFlag = 0x02,
     };
 
+#ifndef SK_SUPPORT_LEGACY_PICTURE_CAN_RECORD
+private:
+    friend class SkPictureRecorder;
+    friend class SkImage_Picture;
+    friend class SkSurface_Picture;
+#endif
+
     /** 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 picture canvas.
     */
     SkCanvas* beginRecording(int width, int height, uint32_t recordFlags = 0);
 
     /** 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() const;
     /** Signal that the caller is done recording. This invalidates the canvas
         returned by beginRecording/getRecordingCanvas, and prepares the picture
         for drawing. Note: this happens implicitly the first time the picture
         is drawn.
     */
     void endRecording();
 
+#ifndef SK_SUPPORT_LEGACY_PICTURE_CAN_RECORD
+public:
+#endif
+
     /** Replays the drawing commands on the specified canvas. This internally
         calls endRecording() if that has not already been called.
         @param canvas the canvas receiving the drawing commands.
     */
     void draw(SkCanvas* canvas, SkDrawPictureCallback* = NULL);
 
     /** Return the width of the picture's recording canvas. This
         value reflects what was passed to setSize(), and does not necessarily
         reflect the bounds of what has been recorded into the picture.
         @return the width of the picture's recording canvas
@@ skipping 187 matching lines @@
  *  to the same level it was before the drawPicture call was made.
  */
 class SK_API SkDrawPictureCallback {
 public:
     SkDrawPictureCallback() {}
     virtual ~SkDrawPictureCallback() {}
 
     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 : SkNoncopyable {
+public:
+    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 SkNoncopyable INHERITED;
+};
+
 #endif