Add generation ID to SkPicture

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 100 matching lines @@
     SkASSERT(scaleY == 0 || skewY == 0);
     SkASSERT(perspX == 0);
     SkASSERT(perspY == 0);
 }
 #endif
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPicture::SkPicture() {
+    this->needsNewGenID();
     fRecord = NULL;
     fPlayback = NULL;
     fWidth = fHeight = 0;
     fAccelData = NULL;
 }
 
 SkPicture::SkPicture(const SkPicture& src)
     : INHERITED()
     , fAccelData(NULL) {
+    this->needsNewGenID();
     fWidth = src.fWidth;
     fHeight = src.fHeight;
     fRecord = NULL;
 
     /*  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, (*src.fPlayback));
+        SkASSERT(NULL == src.fRecord);
+        fGenerationID = src.getGenerationID();     // need to call method to ensure != 0
     } else if (src.fRecord) {
         SkPictInfo info;
         this->createHeader(&info);
         // here we do a fake src.endRecording()
         fPlayback = SkNEW_ARGS(SkPicturePlayback, (*src.fRecord, info));
     } else {
         fPlayback = NULL;
     }
 }
 
 SkPicture::~SkPicture() {
     SkSafeUnref(fRecord);
     SkDELETE(fPlayback);
     SkSafeUnref(fAccelData);
 }
 
 void SkPicture::internalOnly_EnableOpts(bool enableOpts) {
     if (NULL != fRecord) {
         fRecord->internalOnly_EnableOpts(enableOpts);
     }
 }
 
 void SkPicture::swap(SkPicture& other) {
+    SkTSwap(fGenerationID, other.fGenerationID);
     SkTSwap(fRecord, other.fRecord);
     SkTSwap(fPlayback, other.fPlayback);
     SkTSwap(fAccelData, other.fAccelData);
     SkTSwap(fWidth, other.fWidth);
     SkTSwap(fHeight, other.fHeight);
 }
 
 SkPicture* SkPicture::clone() const {
     SkPicture* clonedPicture = SkNEW(SkPicture);
-    clone(clonedPicture, 1);
+    this->clone(clonedPicture, 1);
     return clonedPicture;
 }
 
 void SkPicture::clone(SkPicture* pictures, int count) const {
     SkPictCopyInfo copyInfo;
     SkPictInfo info;
     this->createHeader(&info);
 
     for (int i = 0; i < count; i++) {
         SkPicture* clone = &pictures[i];
 
+        clone->needsNewGenID();
         clone->fWidth = fWidth;
         clone->fHeight = fHeight;
         SkSafeSetNull(clone->fRecord);
         SkDELETE(clone->fPlayback);
 
         /*  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 (fPlayback) {
             clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fPlayback, &copyInfo));
+            SkASSERT(NULL == fRecord);
+            clone->fGenerationID = this->getGenerationID(); // need to call method to ensure != 0
         } else if (fRecord) {
             // here we do a fake src.endRecording()
             clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fRecord, info, true));
         } else {
             clone->fPlayback = NULL;
         }
     }
 }
 
 SkPicture::AccelData::Domain SkPicture::AccelData::GenerateDomain() {
@@ skipping 11 matching lines @@
 
 SkCanvas* SkPicture::beginRecording(int width, int height,
                                     uint32_t recordingFlags) {
     if (fPlayback) {
         SkDELETE(fPlayback);
         fPlayback = NULL;
     }
     SkSafeUnref(fAccelData);
     SkSafeSetNull(fRecord);
 
+    this->needsNewGenID();
+
     // Must be set before calling createBBoxHierarchy
     fWidth = width;
     fHeight = height;
 
     const SkISize size = SkISize::Make(width, height);
 
     if (recordingFlags & kOptimizeForClippedPlayback_RecordingFlag) {
         SkBBoxHierarchy* tree = this->createBBoxHierarchy();
         SkASSERT(NULL != tree);
         fRecord = SkNEW_ARGS(SkBBoxHierarchyRecord, (size, recordingFlags, tree));
@@ skipping 114 matching lines @@
         *pInfo = info;
     }
     return true;
 }
 
 SkPicture::SkPicture(SkPicturePlayback* playback, int width, int height)
     : fPlayback(playback)
     , fRecord(NULL)
     , fWidth(width)
     , fHeight(height)
-    , fAccelData(NULL) {}
+    , fAccelData(NULL) {
+    this->needsNewGenID();
+}
 
 SkPicture* SkPicture::CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
     SkPictInfo info;
 
     if (!InternalOnly_StreamIsSKP(stream, &info)) {
         return NULL;
     }
 
     SkPicturePlayback* playback;
     // Check to see if there is a playback to recreate.
@@ skipping 108 matching lines @@
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 void SkPicture::abortPlayback() {
     if (NULL == fPlayback) {
         return;
     }
     fPlayback->abort();
 }
 #endif
+
+static int32_t next_picture_generation_id() {
+    static int32_t  gPictureGenerationID = 0;
+    // do a loop in case our global wraps around, as we never want to
+    // return a 0
+    int32_t genID;
+    do {
+        genID = sk_atomic_inc(&gPictureGenerationID) + 1;
+    } while (((int32_t)SkPicture::kInvalidGenID) == genID);
+    return genID;
+}
+
+uint32_t SkPicture::getGenerationID() const {
+    if (NULL != fRecord) {
+        SkASSERT(NULL == fPlayback);
+        return kInvalidGenID;
+    }
+
+    if (kInvalidGenID == fGenerationID) {
+        fGenerationID = next_picture_generation_id();
+    }
+    return fGenerationID;
+}