Remove picture pre-allocation from SkPictureRecorder

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 112 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkPicture::SkPicture()
     : fAccelData(NULL) {
     this->needsNewGenID();
     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) {
+SkPicture::SkPicture(int width, int height,
+                     SkPictureRecord& record,
+                     bool deepCopyOps)
+    : fWidth(width)
+    , fHeight(height)
+    , fAccelData(NULL) {
+    this->needsNewGenID();
+
+    fPathHeap.reset(SkSafeRef(record.pathHeap()));
+
     SkPictInfo info;
-    resourceSrc->createHeader(&info);
-
-    // FakeEndRecording is only called from partialReplay. For that use case
-    // we cannot be certain that the next call to SkWriter32::overwriteTAt
-    // will be preceded by an append (i.e., that the required copy on write
-    // will occur). In this case just force a deep copy of the operations.
-    const bool deepCopyOps = true;
-    return SkNEW_ARGS(SkPicturePlayback, (resourceSrc, record, info, deepCopyOps));
+    this->createHeader(&info);
+    fPlayback = SkNEW_ARGS(SkPicturePlayback, (this, record, info, deepCopyOps));
 }
 
 SkPicture::SkPicture(const SkPicture& src)
     : INHERITED()
-    , fAccelData(NULL)
-    , fContentInfo(src.fContentInfo) {
+    , 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));
@@ skipping 39 matching lines @@
     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);
-    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;
         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);
 
                 /* The alternative to doing this is to have a clone method on the paint and have it
@@ skipping 275 matching lines @@
         if (playback != fPlayback) {
             SkDELETE(playback);
         }
     } else {
         buffer.writeBool(false);
     }
 }
 
 #if SK_SUPPORT_GPU
 bool SkPicture::suitableForGpuRasterization(GrContext* context, const char **reason) const {
-    // TODO: the heuristic used here needs to be refined
-    static const int kNumPaintWithPathEffectUsesTol = 1;
-    static const int kNumAAConcavePaths = 5;
+    if (NULL == fPlayback) {
+        if (NULL != reason) {
+            *reason = "Missing playback object.";
+        }
+        return false;
+    }
 
-    SkASSERT(this->numAAHairlineConcavePaths() <= this->numAAConcavePaths());
-
-    bool ret = this->numPaintWithPathEffectUses() < kNumPaintWithPathEffectUsesTol &&
-               (this->numAAConcavePaths()-this->numAAHairlineConcavePaths()) < kNumAAConcavePaths;
-    if (!ret && reason) {
-        if (this->numPaintWithPathEffectUses() >= kNumPaintWithPathEffectUsesTol)
-            *reason = "Too many path effects.";
-        else if ((this->numAAConcavePaths()-this->numAAHairlineConcavePaths()) >= kNumAAConcavePaths)
-            *reason = "Too many anti-aliased concave paths.";
-        else
-            *reason = "Unknown reason for GPU unsuitability.";
-    }
-    return ret;
+    return fPlayback->suitableForGpuRasterization(context, reason);
 }
 #endif
 
 bool SkPicture::willPlayBackBitmaps() const {
     if (!fPlayback) {
         return false;
     }
     return fPlayback->containsBitmaps();
 }
 
@@ skipping 16 matching lines @@
     } while (SK_InvalidGenID == genID);
     return genID;
 }
 
 uint32_t SkPicture::uniqueID() const {
     if (SK_InvalidGenID == fUniqueID) {
         fUniqueID = next_picture_generation_id();
     }
     return fUniqueID;
 }