Sketch splitting SkPicture into an interface and SkBigPicture.

tests/PictureTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBBoxHierarchy.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
 #include "SkColorMatrixFilter.h"
 #include "SkColorPriv.h"
 #include "SkDashPathEffect.h"
 #include "SkData.h"
 #include "SkImageGenerator.h"
 #include "SkError.h"
 #include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkLayerInfo.h"
 #include "SkPaint.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkPictureUtils.h"
 #include "SkPixelRef.h"
 #include "SkPixelSerializer.h"
+#include "SkMiniRecorder.h"
 #include "SkRRect.h"
 #include "SkRandom.h"
 #include "SkRecord.h"
 #include "SkShader.h"
 #include "SkStream.h"
 #include "sk_tool_utils.h"
 
 #if SK_SUPPORT_GPU
 #include "SkSurface.h"
 #include "GrContextFactory.h"
@@ skipping 320 matching lines @@
             c->saveLayer(NULL, &layerPaint);  // layer #6
                 c->drawPicture(child, &trans, &picturePaint); // layer #7 inside picture
             c->restore();
         }
 
         pict.reset(recorder.endRecording());
     }
 
     // Now test out the SaveLayer extraction
     if (!SkCanvas::Internal_Private_GetIgnoreSaveLayerBounds()) {
-        SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey();
+        const SkBigPicture* bp = pict->asSkBigPicture();
+        REPORTER_ASSERT(reporter, bp);
 
-        const SkPicture::AccelData* data = pict->EXPERIMENTAL_getAccelData(key);
+        const SkBigPicture::AccelData* data = bp->accelData();
         REPORTER_ASSERT(reporter, data);
 
         const SkLayerInfo *gpuData = static_cast<const SkLayerInfo*>(data);
         REPORTER_ASSERT(reporter, 8 == gpuData->numBlocks());
 
         const SkLayerInfo::BlockInfo& info0 = gpuData->block(0);
         // The parent/child layers appear in reverse order
         const SkLayerInfo::BlockInfo& info1 = gpuData->block(2);
         const SkLayerInfo::BlockInfo& info2 = gpuData->block(1);
 
@@ skipping 721 matching lines @@
     SkCanvas* canvas = recorder.beginRecording(1, 1);
     canvas->drawARGB(255, 255, 255, 255);
     SkAutoTUnref<SkPicture> hasData(recorder.endRecording());
     // picture should have a non-zero id after recording
     REPORTER_ASSERT(reporter, hasData->uniqueID() != SK_InvalidGenID);
 
     // both pictures should have different ids
     REPORTER_ASSERT(reporter, hasData->uniqueID() != empty->uniqueID());
 }
 
-static void test_bytes_used(skiatest::Reporter* reporter) {
-    SkPictureRecorder recorder;
-
-    recorder.beginRecording(0, 0);
-    SkAutoTUnref<SkPicture> empty(recorder.endRecording());
-
-    // Sanity check to make sure we aren't under-measuring.
-    REPORTER_ASSERT(reporter, SkPictureUtils::ApproximateBytesUsed(empty.get()) >=
-                              sizeof(SkPicture) + sizeof(SkRecord));
-
-    // Protect against any unintentional bloat.
-    size_t approxUsed = SkPictureUtils::ApproximateBytesUsed(empty.get());
-    REPORTER_ASSERT(reporter, approxUsed <= 432);
-
-    // Sanity check of nested SkPictures.
-    SkPictureRecorder r2;
-    r2.beginRecording(0, 0);
-    r2.getRecordingCanvas()->drawPicture(empty.get());
-    SkAutoTUnref<SkPicture> nested(r2.endRecording());
-
-    REPORTER_ASSERT(reporter, SkPictureUtils::ApproximateBytesUsed(nested.get()) >=
-                              SkPictureUtils::ApproximateBytesUsed(empty.get()));
-}
-
 DEF_TEST(Picture, reporter) {
 #ifdef SK_DEBUG
     test_deleting_empty_picture();
     test_serializing_empty_picture();
 #else
     test_bad_bitmap();
 #endif
     test_unbalanced_save_restores(reporter);
     test_peephole();
 #if SK_SUPPORT_GPU
     test_gpu_veto(reporter);
 #endif
     test_has_text(reporter);
     test_analysis(reporter);
     test_bitmap_with_encoded_data(reporter);
     test_clip_bound_opt(reporter);
     test_clip_expansion(reporter);
     test_hierarchical(reporter);
     test_gen_id(reporter);
     test_savelayer_extraction(reporter);
-    test_bytes_used(reporter);
 }
 
 static void draw_bitmaps(const SkBitmap bitmap, SkCanvas* canvas) {
     const SkPaint paint;
     const SkRect rect = { 5.0f, 5.0f, 8.0f, 8.0f };
     const SkIRect irect =  { 2, 2, 3, 3 };
 
     // Don't care what these record, as long as they're legal.
     canvas->drawBitmap(bitmap, 0.0f, 0.0f, &paint);
     canvas->drawBitmapRectToRect(bitmap, &rect, rect, &paint, SkCanvas::kNone_DrawBitmapRectFlag);
@@ skipping 95 matching lines @@
     SkBBoxHierarchy* fBBH;
 };
 
 // When the canvas clip covers the full picture, we don't need to call the BBH.
 DEF_TEST(Picture_SkipBBH, r) {
     SkRect bound = SkRect::MakeWH(320, 240);
     CountingBBH bbh(bound);
     SpoonFedBBHFactory factory(&bbh);
 
     SkPictureRecorder recorder;
-    recorder.beginRecording(bound, &factory);
+    SkCanvas* c = recorder.beginRecording(bound, &factory);
+    // Record a few ops so we don't hit a small- or empty- picture optimization.
+        c->drawRect(bound, SkPaint());
+        c->drawRect(bound, SkPaint());
     SkAutoTUnref<const SkPicture> picture(recorder.endRecording());
 
     SkCanvas big(640, 480), small(300, 200);
 
     picture->playback(&big);
     REPORTER_ASSERT(r, bbh.searchCalls == 0);
 
     picture->playback(&small);
     REPORTER_ASSERT(r, bbh.searchCalls == 1);
 }
@@ skipping 35 matching lines @@
 DEF_TEST(Picture_getRecordingCanvas, r) {
     SkPictureRecorder rec;
     REPORTER_ASSERT(r, !rec.getRecordingCanvas());
     for (int i = 0; i < 3; i++) {
         rec.beginRecording(100, 100);
         REPORTER_ASSERT(r, rec.getRecordingCanvas());
         rec.endRecording()->unref();
         REPORTER_ASSERT(r, !rec.getRecordingCanvas());
     }
 }
+
+DEF_TEST(MiniRecorderLeftHanging, r) {
+    // Any shader or other ref-counted effect will do just fine here.
+    SkPaint paint;
+    paint.setShader(SkShader::CreateColorShader(SK_ColorRED))->unref();
+
+    SkMiniRecorder rec;
+    REPORTER_ASSERT(r, rec.drawRect(SkRect::MakeWH(20,30), paint));
+    // Don't call rec.detachPicture().  Test succeeds by not asserting or leaking the shader.
+}