Cleanup SkPicture* classes a bit

src/core/SkPictureData.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 SkPictureData_DEFINED
 #define SkPictureData_DEFINED
 
 #include "SkBitmap.h"
 #include "SkPathHeap.h"
 #include "SkPicture.h"
 #include "SkPictureFlat.h"
+#include "SkPictureStateTree.h"
 
 class SkData;
 class SkPictureRecord;
 class SkReader32;
 class SkStream;
 class SkWStream;
 class SkBBoxHierarchy;
 class SkMatrix;
 class SkPaint;
 class SkPath;
 class SkPictureStateTree;
 class SkReadBuffer;
-class SkRegion;
 
 struct SkPictInfo {
     enum Flags {
         kCrossProcess_Flag      = 1 << 0,
         kScalarIsFloat_Flag     = 1 << 1,
         kPtrIs64Bit_Flag        = 1 << 2,
     };
 
     char        fMagic[8];
     uint32_t    fVersion;
@@ skipping 115 matching lines @@
     bool containsBitmaps() const;
 
     const SkData* opData() const { return fOpData; }
 
 protected:
     explicit SkPictureData(const SkPictInfo& info);
 
     bool parseStream(SkStream*, SkPicture::InstallPixelRefProc);
     bool parseBuffer(SkReadBuffer& buffer);
 
-private:
-
+public:
     const SkBitmap& getBitmap(SkReader32* reader) const {
         const int index = reader->readInt();
         if (SkBitmapHeap::INVALID_SLOT == index) {
 #ifdef SK_DEBUG
             SkDebugf("An invalid bitmap was recorded!\n");
 #endif
             return fBadBitmap;
         }
         return (*fBitmaps)[index];
     }
@@ skipping 10 matching lines @@
     }
 
     const SkPaint* getPaint(SkReader32* reader) const {
         int index = reader->readInt();
         if (index == 0) {
             return NULL;
         }
         return &(*fPaints)[index - 1];
     }
 
-    void init();
+    void initIterator(SkPictureStateTree::Iterator* iter, 
+                      const SkTDArray<void*>& draws,
+                      SkCanvas* canvas) const {
+        if (NULL != fStateTree) {
+            fStateTree->initIterator(iter, draws, canvas);
+        }
+    }
 
 #ifdef SK_DEBUG_SIZE
-public:
     int size(size_t* sizePtr);
     int bitmaps(size_t* size);
     int paints(size_t* size);
     int paths(size_t* size);
 #endif
 
 #ifdef SK_DEBUG_DUMP
 private:
     void dumpBitmap(const SkBitmap& bitmap) const;
     void dumpMatrix(const SkMatrix& matrix) const;
@@ skipping 25 matching lines @@
                                      int sampleCount = 0) const;
 
     /**
      * Calls getRecommendedSampleCount with GrPixelConfig and dpi to calculate sampleCount
      * and then calls the above version of suitableForGpuRasterization
      */
     bool suitableForGpuRasterization(GrContext* context, const char **reason,
                                      GrPixelConfig config, SkScalar dpi) const;
 #endif
 
-private:    // these help us with reading/writing
+private:
+    void init();
+
+    // 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);
     void flattenToBuffer(SkWriteBuffer&) const;
 
-private:
-    friend class SkPicture;
-    friend class SkPicturePlayback;
-
     // 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;
 
     SkTRefArray<SkBitmap>* fBitmaps;
     SkTRefArray<SkPaint>* fPaints;
 
     SkData* fOpData;    // opcodes and parameters
@@ skipping 13 matching lines @@
 
     const SkPictInfo fInfo;
 
     static void WriteFactories(SkWStream* stream, const SkFactorySet& rec);
     static void WriteTypefaces(SkWStream* stream, const SkRefCntSet& rec);
 
     void initForPlayback() const;
 };
 
 #endif