Remove SkPicture pointer from SkPicturePlayback

src/core/SkPicture.cpp

 
 /*
  * 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.
  */
 
 
 #include "SkPictureFlat.h"
@@ skipping 113 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPicture::SkPicture()
     : fAccelData(NULL) {
     this->needsNewGenID();
     fPlayback = NULL;
     fWidth = fHeight = 0;
 }
 
 SkPicture::SkPicture(int width, int height,
-                     SkPictureRecord& record,
+                     const SkPictureRecord& record,
                      bool deepCopyOps)
     : fWidth(width)
     , fHeight(height)
     , fAccelData(NULL) {
     this->needsNewGenID();
 
-    fPathHeap.reset(SkSafeRef(record.pathHeap()));
-
     SkPictInfo info;
     this->createHeader(&info);
-    fPlayback = SkNEW_ARGS(SkPicturePlayback, (this, record, info, deepCopyOps));
+    fPlayback = SkNEW_ARGS(SkPicturePlayback, (record, info, deepCopyOps));
 }
 
 SkPicture::SkPicture(const SkPicture& src)
     : INHERITED()
     , fAccelData(NULL) {
     this->needsNewGenID();
     fWidth = src.fWidth;
     fHeight = src.fHeight;
 
-    /*  We want to copy the src's playback. However, if that hasn't been built
-        yet, we need to fake a call to endRecording() without actually calling
-        it (since it is destructive, and we don't want to change src).
-     */
     if (src.fPlayback) {
-        fPlayback = SkNEW_ARGS(SkPicturePlayback, (this, *src.fPlayback));
+        fPlayback = SkNEW_ARGS(SkPicturePlayback, (*src.fPlayback));
         fUniqueID = src.uniqueID();     // need to call method to ensure != 0
     } else {
         fPlayback = NULL;
     }
-
-    fPathHeap.reset(SkSafeRef(src.fPathHeap.get()));
-}
-
-const SkPath& SkPicture::getPath(int index) const {
-    return (*fPathHeap.get())[index];
-}
-
-int SkPicture::addPathToHeap(const SkPath& path) {
-    if (NULL == fPathHeap) {
-        fPathHeap.reset(SkNEW(SkPathHeap));
-    }
-#ifdef SK_DEDUP_PICTURE_PATHS
-    return fPathHeap->insert(path);
-#else
-    return fPathHeap->append(path);
-#endif
-}
-
-void SkPicture::initForPlayback() const {
-    // ensure that the paths bounds are pre-computed
-    if (NULL != fPathHeap.get()) {
-        for (int i = 0; i < fPathHeap->count(); i++) {
-            (*fPathHeap.get())[i].updateBoundsCache();
-        }
-    }
-}
-
-void SkPicture::dumpSize() const {
-    SkDebugf("--- picture size: paths=%d\n",
-             SafeCount(fPathHeap.get()));
 }
 
 SkPicture::~SkPicture() {
     SkDELETE(fPlayback);
     SkSafeUnref(fAccelData);
 }
 
 void SkPicture::swap(SkPicture& other) {
     SkTSwap(fUniqueID, other.fUniqueID);
     SkTSwap(fPlayback, other.fPlayback);
     SkTSwap(fAccelData, other.fAccelData);
     SkTSwap(fWidth, other.fWidth);
     SkTSwap(fHeight, other.fHeight);
-    fPathHeap.swap(&other.fPathHeap);
 }
 
 SkPicture* SkPicture::clone() const {
     SkPicture* clonedPicture = SkNEW(SkPicture);
     this->clone(clonedPicture, 1);
     return clonedPicture;
 }
 
 void SkPicture::clone(SkPicture* pictures, int count) const {
     SkPictCopyInfo copyInfo;
@@ skipping 46 matching lines @@
                         copyInfo.paintData[i] = NULL;
                     }
                 }
                 SkASSERT(SafeCount(fPlayback->fBitmapHeap.get()) == heapSize);
 
                 // needed to create typeface playback
                 copyInfo.controller.setupPlaybacks();
                 copyInfo.initialized = true;
             }
 
-            clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (clone, *fPlayback, &copyInfo));
+            clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fPlayback, &copyInfo));
             clone->fUniqueID = this->uniqueID(); // need to call method to ensure != 0
         } else {
             clone->fPlayback = NULL;
         }
-
-        clone->fPathHeap.reset(SkSafeRef(fPathHeap.get()));
     }
 }
 
 SkPicture::AccelData::Domain SkPicture::AccelData::GenerateDomain() {
     static int32_t gNextID = 0;
 
     int32_t id = sk_atomic_inc(&gNextID);
     if (id >= 1 << (8 * sizeof(Domain))) {
         SK_CRASH();
     }
@@ skipping 89 matching lines @@
     this->needsNewGenID();
 }
 
 SkPicture* SkPicture::CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
     SkPictInfo info;
 
     if (!InternalOnly_StreamIsSKP(stream, &info)) {
         return NULL;
     }
 
-    SkPicture* newPict = SkNEW_ARGS(SkPicture, (NULL, info.fWidth, info.fHeight));
-
     // Check to see if there is a playback to recreate.
     if (stream->readBool()) {
-        SkPicturePlayback* playback = SkPicturePlayback::CreateFromStream(newPict, stream,
-                                                                          info, proc);
+        SkPicturePlayback* playback = SkPicturePlayback::CreateFromStream(stream, info, proc);
         if (NULL == playback) {
-            SkDELETE(newPict);
             return NULL;
         }
-        newPict->fPlayback = playback;
+
+        return SkNEW_ARGS(SkPicture, (playback, info.fWidth, info.fHeight));
     }
 
-    return newPict;
+    return NULL;

[mtklein, 2014/06/11 21:12:58]

Same deal?

 }
 
 SkPicture* SkPicture::CreateFromBuffer(SkReadBuffer& buffer) {
     SkPictInfo info;
 
     if (!InternalOnly_BufferIsSKP(buffer, &info)) {
         return NULL;
     }
 
-    SkPicture* newPict = SkNEW_ARGS(SkPicture, (NULL, info.fWidth, info.fHeight));
-
     // Check to see if there is a playback to recreate.
     if (buffer.readBool()) {
-        SkPicturePlayback* playback = SkPicturePlayback::CreateFromBuffer(newPict, buffer, info);
+        SkPicturePlayback* playback = SkPicturePlayback::CreateFromBuffer(buffer, info);
         if (NULL == playback) {
-            SkDELETE(newPict);
             return NULL;
         }
-        newPict->fPlayback = playback;
+
+        return SkNEW_ARGS(SkPicture, (playback, info.fWidth, info.fHeight));
     }
 
-    return newPict;
+    return NULL;
 }
 
 void SkPicture::createHeader(SkPictInfo* info) const {
     // Copy magic bytes at the beginning of the header
     SkASSERT(sizeof(kMagic) == 8);
     SkASSERT(sizeof(kMagic) == sizeof(info->fMagic));
     memcpy(info->fMagic, kMagic, sizeof(kMagic));
 
     // Set picture info after magic bytes in the header
     info->fVersion = CURRENT_PICTURE_VERSION;
@@ skipping 29 matching lines @@
 void SkPicture::WriteTagSize(SkWriteBuffer& buffer, uint32_t tag, size_t size) {
     buffer.writeUInt(tag);
     buffer.writeUInt(SkToU32(size));
 }
 
 void SkPicture::WriteTagSize(SkWStream* stream, uint32_t tag,  size_t size) {
     stream->write32(tag);
     stream->write32(SkToU32(size));
 }
 
-bool SkPicture::parseBufferTag(SkReadBuffer& buffer,
-                               uint32_t tag,
-                               uint32_t size) {
-    switch (tag) {
-        case SK_PICT_PATH_BUFFER_TAG:
-            if (size > 0) {
-                fPathHeap.reset(SkNEW_ARGS(SkPathHeap, (buffer)));
-            }
-            break;
-        default:
-            // The tag was invalid.
-            return false;
-    }
-
-    return true;    // success
-}
-
-void SkPicture::flattenToBuffer(SkWriteBuffer& buffer) const {
-    int n;
-
-    if ((n = SafeCount(fPathHeap.get())) > 0) {
-        WriteTagSize(buffer, SK_PICT_PATH_BUFFER_TAG, n);
-        fPathHeap->flatten(buffer);
-    }
-}
-
 void SkPicture::flatten(SkWriteBuffer& buffer) const {
     SkPicturePlayback* playback = fPlayback;
 
     SkPictInfo info;
     this->createHeader(&info);
     buffer.writeByteArray(&info, sizeof(info));
     if (playback) {
         buffer.writeBool(true);
         playback->flatten(buffer);
         // delete playback if it is a local version (i.e. cons'd up just now)
@@ skipping 44 matching lines @@
     } while (SK_InvalidGenID == genID);
     return genID;
 }
 
 uint32_t SkPicture::uniqueID() const {
     if (SK_InvalidGenID == fUniqueID) {
         fUniqueID = next_picture_generation_id();
     }
     return fUniqueID;
 }