First step in pulling SkPicturePlayback & SkPictureRecord out of SkPicture

src/core/SkPicturePlayback.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPicturePlayback_DEFINED
 #define SkPicturePlayback_DEFINED
 
@@ skipping 57 matching lines @@
 struct SkPictCopyInfo {
     SkPictCopyInfo() : initialized(false), controller(1024) {}
 
     bool initialized;
     SkChunkFlatController controller;
     SkTDArray<SkFlatData*> paintData;
 };
 
 class SkPicturePlayback {
 public:
-    SkPicturePlayback(const SkPicturePlayback& src, SkPictCopyInfo* deepCopyInfo = NULL);
-    SkPicturePlayback(const SkPictureRecord& record, const SkPictInfo&, bool deepCopy = false);
-    static SkPicturePlayback* CreateFromStream(SkStream*,
+    SkPicturePlayback(const SkPicture* picture, const SkPicturePlayback& src, 
+                      SkPictCopyInfo* deepCopyInfo = NULL);
+    SkPicturePlayback(const SkPicture* picture, const SkPictureRecord& record, const SkPictInfo&, 
+                      bool deepCopy = false);
+    static SkPicturePlayback* CreateFromStream(SkPicture* picture,
+                                               SkStream*,
                                                const SkPictInfo&,
                                                SkPicture::InstallPixelRefProc);
-    static SkPicturePlayback* CreateFromBuffer(SkReadBuffer&, const SkPictInfo&);
+    static SkPicturePlayback* CreateFromBuffer(SkPicture* picture, 
+                                               SkReadBuffer&, 
+                                               const SkPictInfo&);
 
     virtual ~SkPicturePlayback();
 
     const SkPicture::OperationList& getActiveOps(const SkIRect& queryRect);
 
     void draw(SkCanvas& canvas, SkDrawPictureCallback*);
 
     void serialize(SkWStream*, SkPicture::EncodeBitmap) const;
     void flatten(SkWriteBuffer&) const;
 
     void dumpSize() const;
 
     bool containsBitmaps() const;
 
 #ifdef SK_BUILD_FOR_ANDROID
     // Can be called in the middle of playback (the draw() call). WIll abort the
     // drawing and return from draw() after the "current" op code is done
     void abort() { fAbortCurrentPlayback = true; }
 #endif
 
     size_t curOpID() const { return fCurOffset; }
     void resetOpID() { fCurOffset = 0; }
 
 protected:
-    explicit SkPicturePlayback(const SkPictInfo& info);
+    explicit SkPicturePlayback(const SkPicture* picture, const SkPictInfo& info);
 
-    bool parseStream(SkStream*, SkPicture::InstallPixelRefProc);
-    bool parseBuffer(SkReadBuffer& buffer);
+    bool parseStream(SkPicture* picture, SkStream*, SkPicture::InstallPixelRefProc);
+    bool parseBuffer(SkPicture* picture, SkReadBuffer& buffer);
 #ifdef SK_DEVELOPER
     virtual bool preDraw(int opIndex, int type);
     virtual void postDraw(int opIndex);
 #endif
 
 private:
     class TextContainer {
     public:
         size_t length() { return fByteLength; }
         const void* text() { return (const void*) fText; }
@@ skipping 10 matching lines @@
             return fBadBitmap;
         }
         return (*fBitmaps)[index];
     }
 
     void getMatrix(SkReader32& reader, SkMatrix* matrix) {
         reader.readMatrix(matrix);
     }
 
     const SkPath& getPath(SkReader32& reader) {
-        return (*fPathHeap)[reader.readInt() - 1];
+        return fPicture->getPath(reader.readInt() - 1);
     }
 
     SkPicture& getPicture(SkReader32& reader) {
         int index = reader.readInt();
         SkASSERT(index > 0 && index <= fPictureCount);
         return *fPictureRefs[index - 1];
     }
 
     const SkPaint* getPaint(SkReader32& reader) {
         int index = reader.readInt();
@@ skipping 55 matching lines @@
     int dumpRectPtr(char* bufferPtr, char* buffer, char* name);
     int dumpScalar(char* bufferPtr, char* buffer, char* name);
     void dumpText(char** bufferPtrPtr, char* buffer);
     void dumpStream();
 
 public:
     void dump() const;
 #endif
 
 private:    // these help us with reading/writing
-    bool parseStreamTag(SkStream*, uint32_t tag, uint32_t size, SkPicture::InstallPixelRefProc);
-    bool parseBufferTag(SkReadBuffer&, uint32_t tag, uint32_t size);
+    bool parseStreamTag(SkPicture* picture, SkStream*, uint32_t tag, uint32_t size, 
+                        SkPicture::InstallPixelRefProc);
+    bool parseBufferTag(SkPicture* picture, SkReadBuffer&, uint32_t tag, uint32_t size);
     void flattenToBuffer(SkWriteBuffer&) const;
 
 private:
+    // The picture that owns this SkPicturePlayback object
+    const SkPicture* fPicture;
+
     // Only used by getBitmap() if the passed in index is SkBitmapHeap::INVALID_SLOT. This empty
     // bitmap allows playback to draw nothing and move on.
     SkBitmap fBadBitmap;
 
     SkAutoTUnref<SkBitmapHeap> fBitmapHeap;
-    SkAutoTUnref<SkPathHeap> fPathHeap;
 
     SkTRefArray<SkBitmap>* fBitmaps;
     SkTRefArray<SkPaint>* fPaints;
 
     SkData* fOpData;    // opcodes and parameters
 
     SkPicture** fPictureRefs;
     int fPictureCount;
 
     SkBBoxHierarchy* fBoundingHierarchy;
@@ skipping 23 matching lines @@
     CachedOperationList* fCachedActiveOps;
 
     SkTypefacePlayback fTFPlayback;
     SkFactoryPlayback* fFactoryPlayback;
 
     // The offset of the current operation when within the draw method
     size_t fCurOffset;
 
     const SkPictInfo fInfo;
 
+    static void WriteFactories(SkWStream* stream, const SkFactorySet& rec);
+    static void WriteTypefaces(SkWStream* stream, const SkRefCntSet& rec);
+
 #ifdef SK_BUILD_FOR_ANDROID
     SkMutex fDrawMutex;
     bool fAbortCurrentPlayback;
 #endif
 };
 
 #endif