Staged removal of SkPicture-derived classes

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
 #define SkPicture_DEFINED
 
 #include "SkBitmap.h"
 #include "SkImageDecoder.h"
 #include "SkRefCnt.h"
 
 #if SK_SUPPORT_GPU
 class GrContext;
 #endif
 
+class SkBBHFactory;
 class SkBBoxHierarchy;
 class SkCanvas;
 class SkDrawPictureCallback;
 class SkData;
 class SkPicturePlayback;
 class SkPictureRecord;
 class SkStream;
 class SkWStream;
 
 struct SkPictInfo;
@@ skipping 136 matching lines @@
             discarded if you serialize into a stream and then deserialize.
         */
         kOptimizeForClippedPlayback_RecordingFlag = 0x02,
     };
 #ifndef SK_SUPPORT_DEPRECATED_RECORD_FLAGS
 public:
 #endif
 
 #ifndef SK_SUPPORT_LEGACY_PICTURE_CAN_RECORD
 private:
-    friend class SkPictureRecorder;
-    friend class SkImage_Picture;
-    friend class SkSurface_Picture;
 #endif
 
+#ifdef SK_SUPPORT_LEGACY_DERIVED_PICTURE_CLASSES
+
     /** 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);
+#endif
 
     /** 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.
     */
@@ skipping 138 matching lines @@
     SkPictureRecord*      fRecord;
     int                   fWidth, fHeight;
     const AccelData*      fAccelData;
 
     void needsNewGenID() { fUniqueID = SK_InvalidGenID; }
 
     // Create a new SkPicture from an existing SkPicturePlayback. Ref count of
     // playback is unchanged.
     SkPicture(SkPicturePlayback*, int width, int height);
 
+#ifdef SK_SUPPORT_LEGACY_DERIVED_PICTURE_CLASSES
     // For testing. Derived classes may instantiate an alternate
     // SkBBoxHierarchy implementation
     virtual SkBBoxHierarchy* createBBoxHierarchy() const;
+#endif
+
+    SkCanvas* beginRecording(int width, int height, SkBBHFactory* factory, uint32_t recordFlags);
 
 private:
     // An OperationList encapsulates a set of operation offsets into the picture byte
     // stream along with the CTMs needed for those operation.
     class OperationList : ::SkNoncopyable {
     public:
         virtual ~OperationList() {}
 
         // If valid returns false then there is no optimization data
         // present. All the draw operations need to be issued.
@@ skipping 19 matching lines @@
         Return the ID of the operation currently being executed when playing
         back. 0 indicates no call is active.
     */
     size_t EXPERIMENTAL_curOpID() const;
 
     void createHeader(SkPictInfo* info) const;
     static bool IsValidPictInfo(const SkPictInfo& info);
 
     friend class SkFlatPicture;
     friend class SkPicturePlayback;
+    friend class SkPictureRecorder;
     friend class SkGpuDevice;
     friend class GrGatherDevice;
     friend class SkDebugCanvas;
 
     typedef SkRefCnt INHERITED;
 };
 
 /**
  *  Subclasses of this can be passed to canvas.drawPicture. During the drawing
  *  of the picture, this callback will periodically be invoked. If its
  *  abortDrawing() returns true, then picture playback will be interrupted.
  *
  *  The resulting drawing is undefined, as there is no guarantee how often the
  *  callback will be invoked. If the abort happens inside some level of nested
  *  calls to save(), restore will automatically be called to return the state
  *  to the same level it was before the drawPicture call was made.
  */
 class SK_API SkDrawPictureCallback {
 public:
     SkDrawPictureCallback() {}
     virtual ~SkDrawPictureCallback() {}
 
     virtual bool abortDrawing() = 0;
 };
 
+#ifdef SK_SUPPORT_LEGACY_DERIVED_PICTURE_CLASSES
+
 class SkPictureFactory : public SkRefCnt {
 public:
     /**
      *  Allocate a new SkPicture. Return NULL on failure.
      */
     virtual SkPicture* create(int width, int height) = 0;
 
 private:
     typedef SkRefCnt INHERITED;
 };
 
+#endif
+
+class SkBBHFactory {
+public:
+    /**
+     *  Allocate a new SkBBoxHierarchy. Return NULL on failure.
+     */
+    virtual SkBBoxHierarchy* operator()(int width, int height) const = 0;
+    virtual ~SkBBHFactory() {};
+};
+
 class SK_API SkPictureRecorder : SkNoncopyable {
 public:
+#ifdef SK_SUPPORT_LEGACY_DERIVED_PICTURE_CLASSES
+
     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));
             recordFlags |= SkPicture::kOptimizeForClippedPlayback_RecordingFlag;
         } else {
             fPicture.reset(SkNEW(SkPicture));
         }
 
         return fPicture->beginRecording(width, height, recordFlags);
     }
+#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 bbhFactory factory to create desired acceleration structure
+        @param recordFlags optional flags that control recording.
+        @return the canvas.
+    */
+    // TODO: allow default parameters once the other beginRecoding entry point is gone
+    SkCanvas* beginRecording(int width, int height, 
+                             SkBBHFactory* bbhFactory /* = NULL */, 
+                             uint32_t recordFlags /* = 0 */) {
+        fPicture.reset(SkNEW(SkPicture));
+        return fPicture->beginRecording(width, height, bbhFactory, 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;
     }
@@ skipping 17 matching lines @@
         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;
+#ifdef SK_SUPPORT_LEGACY_DERIVED_PICTURE_CLASSES
+    SkAutoTUnref<SkPictureFactory>  fFactory;
+#endif
+
+    SkAutoTUnref<SkPicture>         fPicture;
 
     typedef SkNoncopyable INHERITED;
 };
 
 #endif