First pass at splitting out SkPictureRecord from 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 108 matching lines @@
     SkASSERT(perspY == 0);
 }
 #endif
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPicture::SkPicture()
     : fAccelData(NULL) {
     this->needsNewGenID();
-    fRecord = NULL;
     fPlayback = NULL;
     fWidth = fHeight = 0;
 }
 
 // This method makes a SkPicturePlayback object from an in-progress recording.
 // Unfortunately, it does not include the restoreToCount of a real endRecording
 // call.
 SkPicturePlayback* SkPicture::FakeEndRecording(const SkPicture* resourceSrc,
                                                const SkPictureRecord& record,
                                                bool deepCopy) {
     SkPictInfo info;
     resourceSrc->createHeader(&info);
     return SkNEW_ARGS(SkPicturePlayback, (resourceSrc, record, info, deepCopy));
 }
 
 SkPicture::SkPicture(const SkPicture& src)
     : INHERITED()
     , fAccelData(NULL)
     , fContentInfo(src.fContentInfo) {
     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, (this, *src.fPlayback));
-        SkASSERT(NULL == src.fRecord);
         fUniqueID = src.uniqueID();     // need to call method to ensure != 0
-    } else if (src.fRecord) {
-        fPlayback = FakeEndRecording(this, *src.fRecord, false);
     } else {
         fPlayback = NULL;
     }
 
     fPathHeap.reset(SkSafeRef(src.fPathHeap.get()));
 }
 
 const SkPath& SkPicture::getPath(int index) const {
     return (*fPathHeap.get())[index];
 }
@@ skipping 17 matching lines @@
         }
     }
 }
 
 void SkPicture::dumpSize() const {
     SkDebugf("--- picture size: paths=%d\n",
              SafeCount(fPathHeap.get()));
 }
 
 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(fUniqueID, other.fUniqueID);
-    SkTSwap(fRecord, other.fRecord);
     SkTSwap(fPlayback, other.fPlayback);
     SkTSwap(fAccelData, other.fAccelData);
     SkTSwap(fWidth, other.fWidth);
     SkTSwap(fHeight, other.fHeight);
     fPathHeap.swap(&other.fPathHeap);
     fContentInfo.swap(&other.fContentInfo);
 }
 
 SkPicture* SkPicture::clone() const {
     SkPicture* clonedPicture = SkNEW(SkPicture);
     this->clone(clonedPicture, 1);
     return clonedPicture;
 }
 
 void SkPicture::clone(SkPicture* pictures, int count) const {
     SkPictCopyInfo copyInfo;
 
     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);
         clone->fContentInfo.set(fContentInfo);
 
         /*  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) {
             if (!copyInfo.initialized) {
                 int paintCount = SafeCount(fPlayback->fPaints);
@@ skipping 31 matching lines @@
                     }
                 }
                 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));
-            SkASSERT(NULL == fRecord);
             clone->fUniqueID = this->uniqueID(); // need to call method to ensure != 0
-        } else if (fRecord) {
-            clone->fPlayback = FakeEndRecording(clone, *fRecord, true);
         } 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();
     }
 
     return static_cast<Domain>(id);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-SkCanvas* SkPicture::beginRecording(int width, int height,
-                                    SkBBHFactory* bbhFactory,
-                                    uint32_t recordingFlags) {
-    if (fPlayback) {
-        SkDELETE(fPlayback);
-        fPlayback = NULL;
-    }
-    SkSafeUnref(fAccelData);
-    SkSafeSetNull(fRecord);
-    SkASSERT(NULL == fPathHeap);
-    fContentInfo.reset();
-
-    this->needsNewGenID();
-
-    fWidth = width;
-    fHeight = height;
-
-    const SkISize size = SkISize::Make(width, height);
-
-    if (NULL != bbhFactory) {
-        SkAutoTUnref<SkBBoxHierarchy> tree((*bbhFactory)(width, height));
-        SkASSERT(NULL != tree);
-        fRecord = SkNEW_ARGS(SkBBoxHierarchyRecord, (this, size, recordingFlags, tree.get()));
-    } else {
-        fRecord = SkNEW_ARGS(SkPictureRecord, (this, size, recordingFlags));
-    }
-    fRecord->beginRecording();
-
-    return fRecord;
-}
-
-SkCanvas* SkPicture::getRecordingCanvas() const {
-    // will be null if we are not recording
-    return fRecord;
-}
-
-void SkPicture::endRecording() {
-    if (NULL == fPlayback) {
-        if (NULL != fRecord) {
-            fRecord->endRecording();
-            SkPictInfo info;
-            this->createHeader(&info);
-            fPlayback = SkNEW_ARGS(SkPicturePlayback, (this, *fRecord, info));
-            SkSafeSetNull(fRecord);
-        }
-    }
-    SkASSERT(NULL == fRecord);
-}
-
 const SkPicture::OperationList& SkPicture::OperationList::InvalidList() {
     static OperationList gInvalid;
     return gInvalid;
 }
 
 const SkPicture::OperationList& SkPicture::EXPERIMENTAL_getActiveOps(const SkIRect& queryRect) const {
-    SkASSERT(NULL != fPlayback && NULL == fRecord);
+    SkASSERT(NULL != fPlayback);
     if (NULL != fPlayback) {
         return fPlayback->getActiveOps(queryRect);
     }
     return OperationList::InvalidList();
 }
 
 size_t SkPicture::EXPERIMENTAL_curOpID() const {
     if (NULL != fPlayback) {
         return fPlayback->curOpID();
     }
     return 0;
 }
 
 void SkPicture::draw(SkCanvas* surface, SkDrawPictureCallback* callback) const {
-    SkASSERT(NULL != fPlayback && NULL == fRecord);
+    SkASSERT(NULL != fPlayback);
     if (NULL != fPlayback) {
         fPlayback->draw(*surface, callback);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkStream.h"
 
 static const char kMagic[] = { 's', 'k', 'i', 'a', 'p', 'i', 'c', 't' };
@@ skipping 38 matching lines @@
     }
 
     if (pInfo != NULL) {
         *pInfo = info;
     }
     return true;
 }
 
 SkPicture::SkPicture(SkPicturePlayback* playback, int width, int height)
     : fPlayback(playback)
-    , fRecord(NULL)
     , fWidth(width)
     , fHeight(height)
     , fAccelData(NULL) {
     this->needsNewGenID();
 }
 
 SkPicture* SkPicture::CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
     SkPictInfo info;
 
     if (!InternalOnly_StreamIsSKP(stream, &info)) {
@@ skipping 53 matching lines @@
     info->fFlags |= SkPictInfo::kScalarIsFloat_Flag;
 
     if (8 == sizeof(void*)) {
         info->fFlags |= SkPictInfo::kPtrIs64Bit_Flag;
     }
 }
 
 void SkPicture::serialize(SkWStream* stream, EncodeBitmap encoder) const {
     SkPicturePlayback* playback = fPlayback;
 
-    if (NULL == playback && fRecord) {
-        playback = FakeEndRecording(this, *fRecord, false);
-    }
-
     SkPictInfo info;
     this->createHeader(&info);
     stream->write(&info, sizeof(info));
     if (playback) {
         stream->writeBool(true);
         playback->serialize(stream, encoder);
         // delete playback if it is a local version (i.e. cons'd up just now)
         if (playback != fPlayback) {
             SkDELETE(playback);
         }
@@ skipping 34 matching lines @@
 
     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;
 
-    if (NULL == playback && fRecord) {
-        playback = FakeEndRecording(this, *fRecord, false);
-    }
-
     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)
         if (playback != fPlayback) {
             SkDELETE(playback);
         }
@@ skipping 45 matching lines @@
     // 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 (SK_InvalidGenID == genID);
     return genID;
 }
 
 uint32_t SkPicture::uniqueID() const {
-    if (NULL != fRecord) {
-        SkASSERT(NULL == fPlayback);
-        return SK_InvalidGenID;
-    }
-
     if (SK_InvalidGenID == fUniqueID) {
         fUniqueID = next_picture_generation_id();
     }
     return fUniqueID;
 }