Infrastructure changes to support pull saveLayers forward task

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 "SkBitmapDevice.h"
+#if SK_SUPPORT_GPU
+#include "SkBlurImageFilter.h"
+#endif
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkDashPathEffect.h"
 #include "SkData.h"
 #include "SkDecodingImageGenerator.h"
 #include "SkError.h"
+#if SK_SUPPORT_GPU
+#include "SkGpuDevice.h"
+#endif
 #include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkPaint.h"
 #include "SkPicture.h"
 #include "SkPictureRecorder.h"
 #include "SkPictureUtils.h"
 #include "SkRRect.h"
 #include "SkRandom.h"
 #include "SkShader.h"
 #include "SkStream.h"
+
+#if SK_SUPPORT_GPU
+#include "SkSurface.h"
+#include "GrContextFactory.h"
+#include "GrPictureUtils.h"
+#endif
 #include "Test.h"
 
 static const int gColorScale = 30;
 static const int gColorOffset = 60;
 
 static void make_bm(SkBitmap* bm, int w, int h, SkColor color, bool immutable) {
     bm->allocN32Pixels(w, h);
     bm->eraseColor(color);
     if (immutable) {
         bm->setImmutable();
@@ skipping 723 matching lines @@
         paint.setStyle(SkPaint::kStroke_Style);
         paint.setStrokeWidth(0);
         for (int i = 0; i < 50; ++i) {
             canvas->drawPath(path, paint);
         }
     }
     picture.reset(recorder.endRecording());
     // hairline stroked AA concave paths are fine for GPU rendering
     REPORTER_ASSERT(reporter, picture->suitableForGpuRasterization(NULL));
 }
+
+static void test_gpu_picture_optimization(skiatest::Reporter* reporter,
+                                          GrContextFactory* factory) {
+
+    GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
+
+    static const int kWidth = 100;
+    static const int kHeight = 100;
+
+    SkAutoTUnref<SkPicture> pict;
+
+    // create a picture with the structure:
+    // 1)
+    //      SaveLayer
+    //      Restore
+    // 2)
+    //      SaveLayer
+    //          Translate 
+    //          SaveLayer w/ bound
+    //          Restore
+    //      Restore
+    // 3)
+    //      SaveLayer w/ copyable paint
+    //      Restore
+    // 4)
+    //      SaveLayer w/ non-copyable paint
+    //      Restore
+    {
+        SkPictureRecorder recorder;
+
+        SkCanvas* c = recorder.beginRecording(kWidth, kHeight, NULL, 0);
+        // 1)
+        c->saveLayer(NULL, NULL);
+        c->restore();
+
+        // 2)
+        c->saveLayer(NULL, NULL);
+            c->translate(kWidth/2, kHeight/2);
+            SkRect r = SkRect::MakeXYWH(0, 0, kWidth/2, kHeight/2);
+            c->saveLayer(&r, NULL);
+            c->restore();
+        c->restore();
+
+        // 3)
+        {
+            SkPaint p;
+            p.setColor(SK_ColorRED);
+            c->saveLayer(NULL, &p);
+            c->restore();
+        }
+        // 4)
+        // TODO: this case will need to be removed once the paint's are immutable
+        {
+            SkPaint p;
+            SkBitmap bmp;
+            bmp.allocN32Pixels(10, 10);
+            bmp.eraseColor(SK_ColorGREEN);
+            bmp.setAlphaType(kOpaque_SkAlphaType);
+            SkShader* shader = SkShader::CreateBitmapShader(bmp,
+                                    SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
+            p.setShader(shader)->unref();
+
+            c->saveLayer(NULL, &p);
+            c->restore();
+        }
+
+        pict.reset(recorder.endRecording());
+    }
+
+    // Now test out the SaveLayer extraction
+    {
+        SkImageInfo info = SkImageInfo::MakeN32Premul(kWidth, kHeight);
+
+        SkAutoTUnref<SkSurface> surface(SkSurface::NewScratchRenderTarget(context, info));
+
+        SkCanvas* canvas = surface->getCanvas();   
+
+        canvas->EXPERIMENTAL_optimize(pict);
+
+        SkPicture::AccelData::Key key = GPUAccelData::ComputeAccelDataKey();
+
+        const SkPicture::AccelData* data = pict->EXPERIMENTAL_getAccelData(key);
+        REPORTER_ASSERT(reporter, NULL != data);
+
+        const GPUAccelData *gpuData = static_cast<const GPUAccelData*>(data);
+        REPORTER_ASSERT(reporter, 5 == gpuData->numSaveLayers());
+
+        const GPUAccelData::SaveLayerInfo& info0 = gpuData->saveLayerInfo(0);
+        // The parent/child layer appear in reverse order
+        const GPUAccelData::SaveLayerInfo& info1 = gpuData->saveLayerInfo(2);
+        const GPUAccelData::SaveLayerInfo& info2 = gpuData->saveLayerInfo(1);
+        const GPUAccelData::SaveLayerInfo& info3 = gpuData->saveLayerInfo(3);
+        const GPUAccelData::SaveLayerInfo& info4 = gpuData->saveLayerInfo(4);
+
+        REPORTER_ASSERT(reporter, info0.fValid);
+        REPORTER_ASSERT(reporter, kWidth == info0.fSize.fWidth && kHeight == info0.fSize.fHeight);
+        REPORTER_ASSERT(reporter, info0.fCTM.isIdentity());
+        REPORTER_ASSERT(reporter, 0 == info0.fOffset.fX && 0 == info0.fOffset.fY);
+        REPORTER_ASSERT(reporter, NULL != info0.fPaint);
+        REPORTER_ASSERT(reporter, !info0.fIsNested && !info0.fHasNestedLayers);
+
+        REPORTER_ASSERT(reporter, info1.fValid);
+        REPORTER_ASSERT(reporter, kWidth == info1.fSize.fWidth && kHeight == info1.fSize.fHeight);
+        REPORTER_ASSERT(reporter, info1.fCTM.isIdentity());
+        REPORTER_ASSERT(reporter, 0 == info1.fOffset.fX && 0 == info1.fOffset.fY);
+        REPORTER_ASSERT(reporter, NULL != info1.fPaint);
+        REPORTER_ASSERT(reporter, !info1.fIsNested && info1.fHasNestedLayers); // has a nested SL
+
+        REPORTER_ASSERT(reporter, info2.fValid);
+        REPORTER_ASSERT(reporter, kWidth/2 == info2.fSize.fWidth && 
+                                  kHeight/2 == info2.fSize.fHeight); // bound reduces size
+        REPORTER_ASSERT(reporter, info2.fCTM.isIdentity());         // translated
+        REPORTER_ASSERT(reporter, 0 == info2.fOffset.fX && 0 == info2.fOffset.fY);
+        REPORTER_ASSERT(reporter, NULL != info1.fPaint);
+        REPORTER_ASSERT(reporter, info2.fIsNested && !info2.fHasNestedLayers); // is nested
+
+        REPORTER_ASSERT(reporter, info3.fValid);
+        REPORTER_ASSERT(reporter, kWidth == info3.fSize.fWidth && kHeight == info3.fSize.fHeight);
+        REPORTER_ASSERT(reporter, info3.fCTM.isIdentity());
+        REPORTER_ASSERT(reporter, 0 == info3.fOffset.fX && 0 == info3.fOffset.fY);
+        REPORTER_ASSERT(reporter, NULL != info3.fPaint);
+        REPORTER_ASSERT(reporter, !info3.fIsNested && !info3.fHasNestedLayers);
+
+        REPORTER_ASSERT(reporter, !info4.fValid);                 // paint is/was uncopyable
+        REPORTER_ASSERT(reporter, kWidth == info4.fSize.fWidth && kHeight == info4.fSize.fHeight); 
+        REPORTER_ASSERT(reporter, 0 == info4.fOffset.fX && 0 == info4.fOffset.fY);
+        REPORTER_ASSERT(reporter, info4.fCTM.isIdentity());
+        REPORTER_ASSERT(reporter, NULL == info4.fPaint);     // paint is/was uncopyable
+        REPORTER_ASSERT(reporter, !info4.fIsNested && !info4.fHasNestedLayers);
+    }
+}
+
 #endif
 
 static void set_canvas_to_save_count_4(SkCanvas* canvas) {
     canvas->restoreToCount(1);
     canvas->save();
     canvas->save();
     canvas->save();
 }
 
 static void test_unbalanced_save_restores(skiatest::Reporter* reporter) {
@@ skipping 499 matching lines @@
     test_gatherpixelrefsandrects(reporter);
     test_bitmap_with_encoded_data(reporter);
     test_clone_empty(reporter);
     test_draw_empty(reporter);
     test_clip_bound_opt(reporter);
     test_clip_expansion(reporter);
     test_hierarchical(reporter);
     test_gen_id(reporter);
 }
 
+#if SK_SUPPORT_GPU
+DEF_GPUTEST(GPUPicture, reporter, factory) {
+    test_gpu_picture_optimization(reporter, factory);
+}
+#endif
+
 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);
     canvas->drawBitmapMatrix(bitmap, SkMatrix::I(), &paint);
     canvas->drawBitmapNine(bitmap, irect, rect, &paint);
@@ skipping 13 matching lines @@
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
 }
 
 DEF_TEST(Canvas_EmptyBitmap, r) {
     SkBitmap dst;
     dst.allocN32Pixels(10, 10);
     SkCanvas canvas(dst);
 
     test_draw_bitmaps(&canvas);
 }