More cleanup: streamline paths and bitmaps.

src/core/SkPictureData.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include <new>
 #include "SkBBoxHierarchy.h"
 #include "SkDrawPictureCallback.h"
 #include "SkPictureData.h"
@@ skipping 12 matching lines @@
     return obj ? obj->count() : 0;
 }
 
 SkPictureData::SkPictureData(const SkPictInfo& info)
     : fInfo(info) {
     this->init();
 }
 
 void SkPictureData::initForPlayback() const {
     // ensure that the paths bounds are pre-computed
-    if (fPathHeap.get()) {
-        for (int i = 0; i < fPathHeap->count(); i++) {
-            (*fPathHeap.get())[i].updateBoundsCache();
-        }
+    for (int i = 0; i < fPaths->count(); i++) {
+        (*fPaths)[i].updateBoundsCache();
     }
 }
 
 SkPictureData::SkPictureData(const SkPictureRecord& record,
                              const SkPictInfo& info,
                              bool deepCopyOps)
     : fInfo(info) {
 
     this->init();
 
     fOpData = record.opData(deepCopyOps);
 
     fContentInfo.set(record.fContentInfo);
 
-    fBitmaps = record.fBitmapHeap->extractBitmaps();
-    fPaints = SkTRefArray<SkPaint>::Create(record.fPaints.begin(), record.fPaints.count());
-
-    fBitmapHeap.reset(SkSafeRef(record.fBitmapHeap));
-    fPathHeap.reset(SkSafeRef(record.pathHeap()));
+    fBitmaps = SkTRefArray<SkBitmap>::Create(record.fBitmaps.begin(), record.fBitmaps.count());
+    fPaints  = SkTRefArray<SkPaint> ::Create(record.fPaints .begin(), record.fPaints .count());
+    fPaths   = SkTRefArray<SkPath>  ::Create(record.fPaths  .begin(), record.fPaths  .count());
 
     this->initForPlayback();
 
     const SkTDArray<const SkPicture* >& pictures = record.getPictureRefs();
     fPictureCount = pictures.count();
     if (fPictureCount > 0) {
         fPictureRefs = SkNEW_ARRAY(const SkPicture*, fPictureCount);
         for (int i = 0; i < fPictureCount; i++) {
             fPictureRefs[i] = pictures[i];
             fPictureRefs[i]->ref();
         }
     }
 
     // templatize to consolidate with similar picture logic?
     const SkTDArray<const SkTextBlob*>& blobs = record.getTextBlobRefs();
     fTextBlobCount = blobs.count();
     if (fTextBlobCount > 0) {
         fTextBlobRefs = SkNEW_ARRAY(const SkTextBlob*, fTextBlobCount);
         for (int i = 0; i < fTextBlobCount; ++i) {
             fTextBlobRefs[i] = SkRef(blobs[i]);
         }
     }
 }
 
 void SkPictureData::init() {
     fBitmaps = NULL;
     fPaints = NULL;
+    fPaths = NULL;
     fPictureRefs = NULL;
     fPictureCount = 0;
     fTextBlobRefs = NULL;
     fTextBlobCount = 0;
     fOpData = NULL;
     fFactoryPlayback = NULL;
 }
 
 SkPictureData::~SkPictureData() {
     SkSafeUnref(fOpData);
 
     SkSafeUnref(fBitmaps);
     SkSafeUnref(fPaints);
+    SkSafeUnref(fPaths);
 
     for (int i = 0; i < fPictureCount; i++) {
         fPictureRefs[i]->unref();
     }
     SkDELETE_ARRAY(fPictureRefs);
 
     for (int i = 0; i < fTextBlobCount; i++) {
         fTextBlobRefs[i]->unref();
     }
     SkDELETE_ARRAY(fTextBlobRefs);
@@ skipping 97 matching lines @@
         }
     }
 
     if ((n = SafeCount(fPaints)) > 0) {
         write_tag_size(buffer, SK_PICT_PAINT_BUFFER_TAG, n);
         for (i = 0; i < n; i++) {
             buffer.writePaint((*fPaints)[i]);
         }
     }
 
-    if ((n = SafeCount(fPathHeap.get())) > 0) {
+    if ((n = SafeCount(fPaths)) > 0) {
         write_tag_size(buffer, SK_PICT_PATH_BUFFER_TAG, n);
-        fPathHeap->flatten(buffer);
+        buffer.writeInt(n);
+        for (int i = 0; i < n; i++) {
+            buffer.writePath((*fPaths)[i]);
+        }
     }
 
     if (fTextBlobCount > 0) {
         write_tag_size(buffer, SK_PICT_TEXTBLOB_BUFFER_TAG, fTextBlobCount);
         for (i = 0; i  < fTextBlobCount; ++i) {
             fTextBlobRefs[i]->flatten(buffer);
         }
     }
 }
 
@@ skipping 208 matching lines @@
         } break;
         case SK_PICT_PAINT_BUFFER_TAG: {
             const int count = SkToInt(size);
             fPaints = SkTRefArray<SkPaint>::Create(size);
             for (int i = 0; i < count; ++i) {
                 buffer.readPaint(&fPaints->writableAt(i));
             }
         } break;
         case SK_PICT_PATH_BUFFER_TAG:
             if (size > 0) {
-                fPathHeap.reset(SkNEW_ARGS(SkPathHeap, (buffer)));
-            }
-            break;
+                const int count = buffer.readInt();
+                fPaths = SkTRefArray<SkPath>::Create(count);
+                for (int i = 0; i < count; i++) {
+                    buffer.readPath(&fPaths->writableAt(i));
+                }
+            } break;
         case SK_PICT_TEXTBLOB_BUFFER_TAG: {
             if (!buffer.validate((0 == fTextBlobCount) && (NULL == fTextBlobRefs))) {
                 return false;
             }
             fTextBlobCount = size;
             fTextBlobRefs = SkNEW_ARRAY(const SkTextBlob*, fTextBlobCount);
             bool success = true;
             int i = 0;
             for ( ; i < fTextBlobCount; i++) {
                 fTextBlobRefs[i] = SkTextBlob::CreateFromBuffer(buffer);
@@ skipping 129 matching lines @@
     }
 }
 
 bool SkPictureData::suitableForLayerOptimization() const {
     return fContentInfo.numLayers() > 0;
 }
 #endif
 ///////////////////////////////////////////////////////////////////////////////