Retract SkPicture::kOptimizeForClippedPlayback_RecordingFlag from public API

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 121 matching lines @@
 
     enum RecordingFlags {
         /*  This flag specifies that when clipPath() is called, the path will
             be faithfully recorded, but the recording canvas' current clip will
             only see the path's bounds. This speeds up the recording process
             without compromising the fidelity of the playback. The only side-
             effect for recording is that calling getTotalClip() or related
             clip-query calls will reflect the path's bounds, not the actual
             path.
          */
-        kUsePathBoundsForClip_RecordingFlag = 0x01,
+        kUsePathBoundsForClip_RecordingFlag = 0x01
+    };
+
+#ifndef SK_SUPPORT_DEPRECATED_RECORD_FLAGS
+    // TODO: once kOptimizeForClippedPlayback_RecordingFlag is hidden from
+    // all external consumers, SkPicture::createBBoxHierarchy can also be
+    // cleaned up.
+private:
+#endif
+    enum Deprecated_RecordingFlags {
         /*  This flag causes the picture to compute bounding boxes and build
             up a spatial hierarchy (currently an R-Tree), plus a tree of Canvas'
             usually stack-based clip/etc state. This requires an increase in
             recording time (often ~2x; likely more for very complex pictures),
             but allows us to perform much faster culling at playback time, and
             completely avoid some unnecessary clips and other operations. This
             is ideal for tiled rendering, or any other situation where you're
             drawing a fraction of a large scene into a smaller viewport.
 
             In most cases the record cost is offset by the playback improvement
             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_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
 
     /** Returns the canvas that records the drawing commands.
         @param width the base width for the picture, as if the recording
@@ skipping 157 matching lines @@
 
     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);
 
     // For testing. Derived classes may instantiate an alternate
     // SkBBoxHierarchy implementation
     virtual SkBBoxHierarchy* createBBoxHierarchy() const;
+
 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.
         virtual bool valid() const { return false; }
@@ skipping 49 matching lines @@
 
     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;
+
+private:
+    typedef SkRefCnt INHERITED;
 };
 
 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));
+            recordFlags |= SkPicture::kOptimizeForClippedPlayback_RecordingFlag;
         } 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).
     */
@@ skipping 30 matching lines @@
     }
 
 private:
     SkAutoTUnref<SkPictureFactory> fFactory;
     SkAutoTUnref<SkPicture>        fPicture;
 
     typedef SkNoncopyable INHERITED;
 };
 
 #endif