Proposed SkCanvas API for preLoading textures to VRAM v2.0

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 99 matching lines @@
 }
 #endif
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPicture::SkPicture() {
     fRecord = NULL;
     fPlayback = NULL;
     fWidth = fHeight = 0;
+    fAccelData = NULL;
 }
 
-SkPicture::SkPicture(const SkPicture& src) : INHERITED() {
+SkPicture::SkPicture(const SkPicture& src) 
+    : INHERITED()
+    , fAccelData(NULL) {
     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));
     } else if (src.fRecord) {
         // here we do a fake src.endRecording()
         fPlayback = SkNEW_ARGS(SkPicturePlayback, (*src.fRecord));
     } 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(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);
     return clonedPicture;
 }
 
@@ skipping 16 matching lines @@
             clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fPlayback, &copyInfo));
         } else if (fRecord) {
             // here we do a fake src.endRecording()
             clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fRecord, true));
         } else {
             clone->fPlayback = NULL;
         }
     }
 }
 
+SkPicture::AccelData::Domain SkPicture::AccelData::GenerateDomain() {
+    static int32_t gNextID = 0;
+
+    int32_t id = sk_atomic_inc(&gNextID);
+    if (id >= 1 << (8 * sizeof(Domain))) {

[bsalomon, 2014/03/14 13:59:43]

Ben will be so unhappy with you for making these bold assumptions.

+        SK_CRASH();
+    }
+
+    return static_cast<Domain>(id);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 SkCanvas* SkPicture::beginRecording(int width, int height,
                                     uint32_t recordingFlags) {
     if (fPlayback) {
         SkDELETE(fPlayback);
         fPlayback = NULL;
     }
-
+    SkSafeUnref(fAccelData);
     SkSafeSetNull(fRecord);
 
     // 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();
@@ skipping 33 matching lines @@
             fRecord->endRecording();
             fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fRecord));
             SkSafeSetNull(fRecord);
         }
     }
     SkASSERT(NULL == fRecord);
 }
 
 void SkPicture::draw(SkCanvas* surface, SkDrawPictureCallback* callback) {
     this->endRecording();
-    if (fPlayback) {
+    if (NULL != fPlayback) {
         fPlayback->draw(*surface, callback);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkStream.h"
 
 static const char kMagic[] = { 's', 'k', 'i', 'a', 'p', 'i', 'c', 't' };
 static const size_t kHeaderSize = sizeof(kMagic) + sizeof(SkPictInfo);
@@ skipping 45 matching lines @@
 
     if (pInfo != NULL) {
         *pInfo = info;
     }
     return true;
 }
 
 SkPicture::SkPicture(SkPicturePlayback* playback, int width, int height)
     : fPlayback(playback)
     , fRecord(NULL)
+    , fAccelData(NULL)
     , fWidth(width)
     , fHeight(height) {}
 
 SkPicture* SkPicture::CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
     SkPictInfo info;
 
     if (!InternalOnly_StreamIsSKP(stream, &info)) {
         return NULL;
     }
 
@@ skipping 89 matching lines @@
         // delete playback if it is a local version (i.e. cons'd up just now)
         if (playback != fPlayback) {
             SkDELETE(playback);
         }
     } else {
         buffer.writeBool(false);
     }
 }
 
 bool SkPicture::willPlayBackBitmaps() const {
-    if (!fPlayback) return false;
+    if (!fPlayback) {
+        return false;
+    }
     return fPlayback->containsBitmaps();
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
 void SkPicture::abortPlayback() {
     if (NULL == fPlayback) {
         return;
     }
     fPlayback->abort();
 }
 #endif