return pictures as sk_sp

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 "SkImageDecoder.h"
 #include "SkRefCnt.h"
 #include "SkTypes.h"
 
 class GrContext;
 class SkBigPicture;
 class SkBitmap;
 class SkCanvas;
 class SkPictureData;
 class SkPixelSerializer;
 class SkRefCntSet;
 class SkStream;
 class SkTypefacePlayback;
 class SkWStream;
 struct SkPictInfo;
 
+#define SK_SUPPORT_LEGACY_PICTURE_PTR
+
 /** \class SkPicture
 
     An SkPicture records drawing commands made to a canvas to be played back at a later time.
     This base class handles serialization and a few other miscellany.
 */
 class SK_API SkPicture : public SkRefCnt {
 public:
     virtual ~SkPicture();
 
     /**
@@ skipping 10 matching lines @@
     typedef bool (*InstallPixelRefProc)(const void* src, size_t length, SkBitmap* dst);
 
     /**
      *  Recreate a picture that was serialized into a stream.
      *  @param SkStream Serialized picture data. Ownership is unchanged by this call.
      *  @param proc Function pointer for installing pixelrefs on SkBitmaps representing the
      *              encoded bitmap data from the stream.
      *  @return A new SkPicture representing the serialized data, or NULL if the stream is
      *          invalid.
      */
-    static SkPicture* CreateFromStream(SkStream*, InstallPixelRefProc proc);
+    static sk_sp<SkPicture> MakeFromStream(SkStream*, InstallPixelRefProc proc);
 
     /**
      *  Recreate a picture that was serialized into a stream.
      *
      *  Any serialized images in the stream will be passed to
      *  SkImageGenerator::NewFromEncoded.
      *
      *  @param SkStream Serialized picture data. Ownership is unchanged by this call.
      *  @return A new SkPicture representing the serialized data, or NULL if the stream is
      *          invalid.
      */
-    static SkPicture* CreateFromStream(SkStream*);
+    static sk_sp<SkPicture> MakeFromStream(SkStream*);
 
     /**
      *  Recreate a picture that was serialized into a buffer. If the creation requires bitmap
      *  decoding, the decoder must be set on the SkReadBuffer parameter by calling
      *  SkReadBuffer::setBitmapDecoder() before calling SkPicture::CreateFromBuffer().
      *  @param SkReadBuffer Serialized picture data.
      *  @return A new SkPicture representing the serialized data, or NULL if the buffer is
      *          invalid.
      */
-    static SkPicture* CreateFromBuffer(SkReadBuffer&);
+    static sk_sp<SkPicture> MakeFromBuffer(SkReadBuffer&);
 
     /**
     *  Subclasses of this can be passed to playback(). During the playback
     *  of the picture, this callback will periodically be invoked. If its
     *  abort() 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 playback call was made.
@@ skipping 70 matching lines @@
     // Sent via SkMessageBus from destructor.
     struct DeletionMessage { int32_t fUniqueID; };  // TODO: -> uint32_t?
 
     // Returns NULL if this is not an SkBigPicture.
     virtual const SkBigPicture* asSkBigPicture() const { return NULL; }
 
     // Global setting to enable or disable security precautions for serialization.
     static void SetPictureIOSecurityPrecautionsEnabled_Dangerous(bool set);
     static bool PictureIOSecurityPrecautionsEnabled();
 
+#ifdef SK_SUPPORT_LEGACY_PICTURE_PTR
+    static SkPicture* CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
+        return MakeFromStream(stream, proc).release();
+    }
+    static SkPicture* CreateFromStream(SkStream* stream) {
+        return MakeFromStream(stream).release();
+    }
+    static SkPicture* CreateFromBuffer(SkReadBuffer& rbuf) {
+        return MakeFromBuffer(rbuf).release();
+    }
+#endif
+
 private:
     // Subclass whitelist.
     SkPicture();
     friend class SkBigPicture;
     friend class SkEmptyPicture;
     template <typename> friend class SkMiniPicture;
 
     void serialize(SkWStream*, SkPixelSerializer*, SkRefCntSet* typefaces) const;
-    static SkPicture* CreateFromStream(SkStream*,
-                                       InstallPixelRefProc proc,
-                                       SkTypefacePlayback*);
+    static sk_sp<SkPicture> MakeFromStream(SkStream*, InstallPixelRefProc, SkTypefacePlayback*);
     friend class SkPictureData;
 
     virtual int numSlowPaths() const = 0;
     friend struct SkPathCounter;
 
     // V35: Store SkRect (rather then width & height) in header
     // V36: Remove (obsolete) alphatype from SkColorTable
     // V37: Added shadow only option to SkDropShadowImageFilter (last version to record CLEAR)
     // V38: Added PictureResolution option to SkPictureImageFilter
     // V39: Added FilterLevel option to SkPictureImageFilter
@@ skipping 10 matching lines @@
     static_assert(MIN_PICTURE_VERSION <= 41,
                   "Remove kFontFileName and related code from SkFontDescriptor.cpp.");
 
     static_assert(MIN_PICTURE_VERSION <= 42,
                   "Remove COMMENT API handlers from SkPicturePlayback.cpp");
 
     static_assert(MIN_PICTURE_VERSION <= 43,
                   "Remove SkBitmapSourceDeserializer.");
     
     static bool IsValidPictInfo(const SkPictInfo& info);
-    static SkPicture* Forwardport(const SkPictInfo&, const SkPictureData*);
+    static sk_sp<SkPicture> Forwardport(const SkPictInfo&, const SkPictureData*);
 
     SkPictInfo createHeader() const;
     SkPictureData* backport() const;
 
     mutable uint32_t fUniqueID;
 };
 
 #endif