Remove picture pre-allocation from SkPictureRecorder

src/core/SkPicturePlayback.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include <new>
 #include "SkBBoxHierarchy.h"
 #include "SkPicturePlayback.h"
 #include "SkPictureRecord.h"
@@ skipping 81 matching lines @@
     if (record.fTextWrites != 0)
         SkDebugf("text size %zd (text strings:%d) ", record.fTextBytes, record.fTextWrites);
 
     SkDebugf("\n");
 #endif
 #ifdef SK_DEBUG_DUMP
     record.dumpMatrices();
     record.dumpPaints();
 #endif
 
-    record.validate(record.writeStream().bytesWritten(), 0);
-    const SkWriter32& writer = record.writeStream();
     this->init();
-    SkASSERT(!fOpData);
-    if (writer.bytesWritten() == 0) {
-        fOpData = SkData::NewEmpty();
-        return;
-    }
-    if (deepCopyOps) {
-        // Don't try to do anything clever w.r.t. copy on write
-        fOpData = SkData::NewWithCopy(writer.contiguousArray(), writer.bytesWritten());
-    } else {
-        fOpData = writer.snapshotAsData();
-    }
+
+    fOpData = record.opData(deepCopyOps);
 
     fBoundingHierarchy = record.fBoundingHierarchy;
     fStateTree = record.fStateTree;
 
     SkSafeRef(fBoundingHierarchy);
     SkSafeRef(fStateTree);
+    fContentInfo.set(record.fContentInfo);
 
     if (NULL != fBoundingHierarchy) {
         fBoundingHierarchy->flushDeferredInserts();
     }
 
     // copy over the refcnt dictionary to our reader
     record.fFlattenableHeap.setupPlaybacks();
 
     fBitmaps = record.fBitmapHeap->extractBitmaps();
     fPaints = record.fPaints.unflattenToArray();
@@ skipping 27 matching lines @@
     if (paths != 0)
         SkDebugf("paths size %zd (paths:%d) ", pathBytes, paths);
     if (pictures != 0)
         SkDebugf("pictures size %zd (pictures:%d) ", pictureBytes, pictures);
     if (regions != 0)
         SkDebugf("regions size %zd (regions:%d) ", regionBytes, regions);
     SkDebugf("\n");
 #endif
 }
 
-SkPicturePlayback::SkPicturePlayback(const SkPicture* picture, const SkPicturePlayback& src,
+SkPicturePlayback::SkPicturePlayback(const SkPicture* picture, 
+                                     const SkPicturePlayback& src,
                                      SkPictCopyInfo* deepCopyInfo)
     : fPicture(picture)
     , fInfo(src.fInfo) {
     this->init();
 
     fBitmapHeap.reset(SkSafeRef(src.fBitmapHeap.get()));
 
     fOpData = SkSafeRef(src.fOpData);
 
     fBoundingHierarchy = src.fBoundingHierarchy;
     fStateTree = src.fStateTree;
+    fContentInfo.set(src.fContentInfo);
 
     SkSafeRef(fBoundingHierarchy);
     SkSafeRef(fStateTree);
 
     if (deepCopyInfo) {
         SkASSERT(deepCopyInfo->initialized);
 
         int paintCount = SafeCount(src.fPaints);
 
         if (src.fBitmaps) {
@@ skipping 1137 matching lines @@
                 skipCull.fSize;
         SkDebugf("--- Clip skips %d%% rect:%d rrect:%d path:%d rgn:%d cull:%d\n",
              size * 100 / reader.offset(), skipRect.fCount, skipRRect.fCount,
                  skipPath.fCount, skipRegion.fCount, skipCull.fCount);
         SkDebugf("--- Total ops: %d\n", opCount);
     }
 #endif
 //    this->dumpSize();
 }
 
+
+#if SK_SUPPORT_GPU
+bool SkPicturePlayback::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;
+
+    SkASSERT(fContentInfo.numAAHairlineConcavePaths() <= fContentInfo.numAAConcavePaths());
+
+    bool ret = fContentInfo.numPaintWithPathEffectUses() < kNumPaintWithPathEffectUsesTol &&
+                    (fContentInfo.numAAConcavePaths() - fContentInfo.numAAHairlineConcavePaths()) 
+                    < kNumAAConcavePaths;
+    if (!ret && NULL != reason) {
+        if (fContentInfo.numPaintWithPathEffectUses() >= kNumPaintWithPathEffectUsesTol)
+            *reason = "Too many path effects.";
+        else if ((fContentInfo.numAAConcavePaths() - fContentInfo.numAAHairlineConcavePaths()) 
+                 >= kNumAAConcavePaths)
+            *reason = "Too many anti-aliased concave paths.";
+        else
+            *reason = "Unknown reason for GPU unsuitability.";
+    }
+    return ret;
+}
+#endif
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_DEBUG_SIZE
 int SkPicturePlayback::size(size_t* sizePtr) {
     int objects = bitmaps(sizePtr);
     objects += paints(sizePtr);
     objects += paths(sizePtr);
     objects += pictures(sizePtr);
     objects += regions(sizePtr);
     *sizePtr = fOpData.size();
@@ skipping 491 matching lines @@
     for (index = 0; index < fPictureCount; index++)
         bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer),
             "picture%p, ", fPictureRefs[index]);
     if (fPictureCount > 0)
         SkDebugf("%s0};\n", pBuffer);
 
     const_cast<SkPicturePlayback*>(this)->dumpStream();
 }
 
 #endif