Replace SkPicture(SkStream) constructors with a factory.

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"
 
 class SkBBoxHierarchy;
 class SkCanvas;
 class SkDrawPictureCallback;
 class SkData;
 class SkPicturePlayback;
 class SkPictureRecord;
 class SkStream;
 class SkWStream;
 
+struct SkPictInfo;
+
 /** \class SkPicture
 
     The SkPicture class records the drawing commands made to a canvas, to
     be played back at a later time.
 */
 class SK_API SkPicture : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(SkPicture)
 
     /** The constructor prepares the picture to record.
         @param width the width of the virtual device the picture records.
         @param height the height of the virtual device the picture records.
     */
     SkPicture();
     /** Make a copy of the contents of src. If src records more drawing after
         this call, those elements will not appear in this picture.
     */
     SkPicture(const SkPicture& src);
 
     /**
-     *  Recreate a picture that was serialized into a stream.
-     *  On failure, silently creates an empty picture.
-     *  @param SkStream Serialized picture data.
-     */
-    explicit SkPicture(SkStream*);
-
-    /**
      *  Function signature defining a function that sets up an SkBitmap from encoded data. On
      *  success, the SkBitmap should have its Config, width, height, rowBytes and pixelref set.
      *  If the installed pixelref has decoded the data into pixels, then the src buffer need not be
      *  copied. If the pixelref defers the actual decode until its lockPixels() is called, then it
      *  must make a copy of the src buffer.
      *  @param src Encoded data.
      *  @param length Size of the encoded data, in bytes.
      *  @param dst SkBitmap to install the pixel ref on.
      *  @param bool Whether or not a pixel ref was successfully installed.
      */
     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.
-     *  @param success Output parameter. If non-NULL, will be set to true if the picture was
-     *                 deserialized successfully and false otherwise.
      *  @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.
      */
-    SkPicture(SkStream*, bool* success, InstallPixelRefProc proc);
+    static SkPicture* CreateFromStream(SkStream*,
+                                       InstallPixelRefProc proc = &SkImageDecoder::DecodeMemory);
 
     virtual ~SkPicture();
 
     /**
      *  Swap the contents of the two pictures. Guaranteed to succeed.
      */
     void swap(SkPicture& other);
 
     /**
      *  Creates a thread-safe clone of the picture that is ready for playback.
@@ skipping 130 matching lines @@
     // V12: add conics to SkPath, use new SkPathRef flattening
     static const uint32_t PICTURE_VERSION = 12;
 
     // fPlayback, fRecord, fWidth & fHeight are protected to allow derived classes to
     // install their own SkPicturePlayback-derived players,SkPictureRecord-derived
     // recorders and set the picture size
     SkPicturePlayback* fPlayback;
     SkPictureRecord* fRecord;
     int fWidth, fHeight;
 
+    // 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;
 
+    // Return true if the SkStream represents a serialized picture, and fills out
+    // SkPictInfo. After this function returns, the SkStream is not rewound; it
+    // will be ready to be parsed to create an SkPicturePlayback.
+    // If false is returned, SkPictInfo is unmodified.
+    static bool StreamIsSKP(SkStream*, SkPictInfo*);
 private:
-    void initFromStream(SkStream*, bool* success, InstallPixelRefProc);
-
     friend class SkFlatPicture;
     friend class SkPicturePlayback;
 
     typedef SkRefCnt INHERITED;
 };
 
 class SkAutoPictureRecord : SkNoncopyable {
 public:
     SkAutoPictureRecord(SkPicture* pict, int width, int height,
                         uint32_t recordingFlags = 0) {
@@ skipping 25 matching lines @@
  */
 class SK_API SkDrawPictureCallback {
 public:
     SkDrawPictureCallback() {}
     virtual ~SkDrawPictureCallback() {}
 
     virtual bool abortDrawing() = 0;
 };
 
 #endif