Rename GrAccelData to SkLayerInfo and move it to src/core

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 "SkDecodingImageGenerator.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 "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"
 
 #include "SkLumaColorFilter.h"
 #include "SkColorFilterImageFilter.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) {
@@ skipping 821 matching lines @@
 
     // Nest the previous picture inside a new one.
     canvas = recorder.beginRecording(100, 100);
     {
         canvas->drawPicture(picture.get());
     }
     picture.reset(recorder.endRecording());
     REPORTER_ASSERT(reporter, !picture->suitableForGpuRasterization(NULL));
 }
 
-static void test_gpu_picture_optimization(skiatest::Reporter* reporter,
-                                          GrContextFactory* factory) {
-    for (int i= 0; i < GrContextFactory::kGLContextTypeCnt; ++i) {
-        GrContextFactory::GLContextType glCtxType = (GrContextFactory::GLContextType) i;
-
-        if (!GrContextFactory::IsRenderingGLContext(glCtxType)) {
-            continue;
+#endif
+
+static void test_savelayer_extraction(skiatest::Reporter* reporter) {
+    static const int kWidth = 100;
+    static const int kHeight = 100;
+
+    // Create complex paint that the bounding box computation code can't
+    // optimize away
+    SkScalar blueToRedMatrix[20] = { 0 };
+    blueToRedMatrix[2] = blueToRedMatrix[18] = SK_Scalar1;
+    SkAutoTUnref<SkColorFilter> blueToRed(SkColorMatrixFilter::Create(blueToRedMatrix));
+    SkAutoTUnref<SkImageFilter> filter(SkColorFilterImageFilter::Create(blueToRed.get()));
+
+    SkPaint complexPaint;
+    complexPaint.setImageFilter(filter);
+
+    SkAutoTUnref<SkPicture> pict, child;
+    SkRTreeFactory bbhFactory;
+
+    {
+        SkPictureRecorder recorder;
+
+        SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth), SkIntToScalar(kHeight),
+                                              &bbhFactory,
+                                              SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
+
+        c->saveLayer(NULL, &complexPaint);
+        c->restore();
+
+        child.reset(recorder.endRecording());
+    }
+
+    // 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
+    //          DrawPicture (which has a SaveLayer/Restore pair)
+    //      Restore
+    // 5)
+    //      SaveLayer
+    //          DrawPicture with Matrix & Paint (with SaveLayer/Restore pair)
+    //      Restore
+    {
+        SkPictureRecorder recorder;
+
+        SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth),
+                                              SkIntToScalar(kHeight),
+                                              &bbhFactory,
+                                              SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
+        // 1)
+        c->saveLayer(NULL, &complexPaint); // layer #0
+        c->restore();
+
+        // 2)
+        c->saveLayer(NULL, NULL); // layer #1
+            c->translate(kWidth/2.0f, kHeight/2.0f);
+            SkRect r = SkRect::MakeXYWH(0, 0, kWidth/2, kHeight/2);
+            c->saveLayer(&r, &complexPaint); // layer #2
+            c->restore();
+        c->restore();
+
+        // 3)
+        {
+            c->saveLayer(NULL, &complexPaint); // layer #3
+            c->restore();
         }
 
-        GrContext* context = factory->get(glCtxType);
-
-        if (NULL == context) {
-            continue;
+        SkPaint layerPaint;
+        layerPaint.setColor(SK_ColorRED);  // Non-alpha only to avoid SaveLayerDrawRestoreNooper
+        // 4)
+        {
+            c->saveLayer(NULL, &layerPaint);  // layer #4
+                c->drawPicture(child);  // layer #5 inside picture
+            c->restore();
         }
-
-        static const int kWidth = 100;
-        static const int kHeight = 100;
-
-        // Create complex paint that the bounding box computation code can't
-        // optimize away
-        SkScalar blueToRedMatrix[20] = { 0 };
-        blueToRedMatrix[2] = blueToRedMatrix[18] = SK_Scalar1;
-        SkAutoTUnref<SkColorFilter> blueToRed(SkColorMatrixFilter::Create(blueToRedMatrix));
-        SkAutoTUnref<SkImageFilter> filter(SkColorFilterImageFilter::Create(blueToRed.get()));
-
-        SkPaint complexPaint;
-        complexPaint.setImageFilter(filter);
-
-        SkAutoTUnref<SkPicture> pict, child;
-        SkRTreeFactory bbhFactory;
-
+        // 5
         {
-            SkPictureRecorder recorder;
-
-            SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth), SkIntToScalar(kHeight),
-                                                  &bbhFactory,
-                                                  SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
-
-            c->saveLayer(NULL, &complexPaint);
-            c->restore();
-
-            child.reset(recorder.endRecording());
+            SkPaint picturePaint;
+            SkMatrix trans;
+            trans.setTranslate(10, 10);
+
+            c->saveLayer(NULL, &layerPaint);  // layer #6
+                c->drawPicture(child, &trans, &picturePaint); // layer #7 inside picture
+            c->restore();
         }
 
-        // 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
-        //          DrawPicture (which has a SaveLayer/Restore pair)
-        //      Restore
-        // 5)
-        //      SaveLayer
-        //          DrawPicture with Matrix & Paint (with SaveLayer/Restore pair)
-        //      Restore
-        {
-            SkPictureRecorder recorder;
-
-            SkCanvas* c = recorder.beginRecording(SkIntToScalar(kWidth),
-                                                  SkIntToScalar(kHeight),
-                                                  &bbhFactory,
-                                                  SkPictureRecorder::kComputeSaveLayerInfo_RecordFlag);
-            // 1)
-            c->saveLayer(NULL, &complexPaint); // layer #0
-            c->restore();
-
-            // 2)
-            c->saveLayer(NULL, NULL); // layer #1
-                c->translate(kWidth/2.0f, kHeight/2.0f);
-                SkRect r = SkRect::MakeXYWH(0, 0, kWidth/2, kHeight/2);
-                c->saveLayer(&r, &complexPaint); // layer #2
-                c->restore();
-            c->restore();
-
-            // 3)
-            {
-                c->saveLayer(NULL, &complexPaint); // layer #3
-                c->restore();
-            }
-
-            SkPaint layerPaint;
-            layerPaint.setColor(SK_ColorRED);  // Non-alpha only to avoid SaveLayerDrawRestoreNooper
-            // 4)
-            {
-                c->saveLayer(NULL, &layerPaint);  // layer #4
-                    c->drawPicture(child);  // layer #5 inside picture
-                c->restore();
-            }
-            // 5
-            {
-                SkPaint picturePaint;
-                SkMatrix trans;
-                trans.setTranslate(10, 10);
-
-                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
-        {
-            SkPicture::AccelData::Key key = GrAccelData::ComputeAccelDataKey();
-
-            const SkPicture::AccelData* data = pict->EXPERIMENTAL_getAccelData(key);
-            REPORTER_ASSERT(reporter, data);
-
-            const GrAccelData *gpuData = static_cast<const GrAccelData*>(data);
-            REPORTER_ASSERT(reporter, 8 == gpuData->numSaveLayers());
-
-            const GrAccelData::SaveLayerInfo& info0 = gpuData->saveLayerInfo(0);
-            // The parent/child layers appear in reverse order
-            const GrAccelData::SaveLayerInfo& info1 = gpuData->saveLayerInfo(2);
-            const GrAccelData::SaveLayerInfo& info2 = gpuData->saveLayerInfo(1);
-
-            const GrAccelData::SaveLayerInfo& info3 = gpuData->saveLayerInfo(3);
-
-            // The parent/child layers appear in reverse order
-            const GrAccelData::SaveLayerInfo& info4 = gpuData->saveLayerInfo(5);
-            const GrAccelData::SaveLayerInfo& info5 = gpuData->saveLayerInfo(4);
-
-            // The parent/child layers appear in reverse order
-            const GrAccelData::SaveLayerInfo& info6 = gpuData->saveLayerInfo(7);
-            const GrAccelData::SaveLayerInfo& info7 = gpuData->saveLayerInfo(6);
-
-            REPORTER_ASSERT(reporter, NULL == info0.fPicture);
-            REPORTER_ASSERT(reporter, kWidth == info0.fBounds.width() &&
-                                      kHeight == info0.fBounds.height());
-            REPORTER_ASSERT(reporter, info0.fLocalMat.isIdentity());
-            REPORTER_ASSERT(reporter, info0.fPreMat.isIdentity());
-            REPORTER_ASSERT(reporter, 0 == info0.fBounds.fLeft && 0 == info0.fBounds.fTop);
-            REPORTER_ASSERT(reporter, NULL != info0.fPaint);
-            REPORTER_ASSERT(reporter, !info0.fIsNested && !info0.fHasNestedLayers);
-
-            REPORTER_ASSERT(reporter, NULL == info1.fPicture);
-            REPORTER_ASSERT(reporter, kWidth/2.0 == info1.fBounds.width() &&
-                                      kHeight/2.0 == info1.fBounds.height());
-            REPORTER_ASSERT(reporter, info1.fLocalMat.isIdentity());
-            REPORTER_ASSERT(reporter, info1.fPreMat.isIdentity());
-            REPORTER_ASSERT(reporter, kWidth/2.0 == info1.fBounds.fLeft && 
-                                      kHeight/2.0 == info1.fBounds.fTop);
-            REPORTER_ASSERT(reporter, NULL == info1.fPaint);
-            REPORTER_ASSERT(reporter, !info1.fIsNested &&
-                                      info1.fHasNestedLayers); // has a nested SL
-
-            REPORTER_ASSERT(reporter, NULL == info2.fPicture);
-            REPORTER_ASSERT(reporter, kWidth / 2 == info2.fBounds.width() &&
-                                      kHeight / 2 == info2.fBounds.height()); // bound reduces size
-            REPORTER_ASSERT(reporter, !info2.fLocalMat.isIdentity());
-            REPORTER_ASSERT(reporter, info2.fPreMat.isIdentity());
-            REPORTER_ASSERT(reporter, kWidth / 2 == info2.fBounds.fLeft &&   // translated
-                                      kHeight / 2 == info2.fBounds.fTop);
-            REPORTER_ASSERT(reporter, NULL != info2.fPaint);
-            REPORTER_ASSERT(reporter, info2.fIsNested && !info2.fHasNestedLayers); // is nested
-
-            REPORTER_ASSERT(reporter, NULL == info3.fPicture);
-            REPORTER_ASSERT(reporter, kWidth == info3.fBounds.width() &&
-                                      kHeight == info3.fBounds.height());
-            REPORTER_ASSERT(reporter, info3.fLocalMat.isIdentity());
-            REPORTER_ASSERT(reporter, info3.fPreMat.isIdentity());
-            REPORTER_ASSERT(reporter, 0 == info3.fBounds.fLeft && 0 == info3.fBounds.fTop);
-            REPORTER_ASSERT(reporter, info3.fPaint);
-            REPORTER_ASSERT(reporter, !info3.fIsNested && !info3.fHasNestedLayers);
-
-            REPORTER_ASSERT(reporter, NULL == info4.fPicture);
-            REPORTER_ASSERT(reporter, kWidth == info4.fBounds.width() &&
-                                      kHeight == info4.fBounds.height());
-            REPORTER_ASSERT(reporter, 0 == info4.fBounds.fLeft && 0 == info4.fBounds.fTop);
-            REPORTER_ASSERT(reporter, info4.fLocalMat.isIdentity());
-            REPORTER_ASSERT(reporter, info4.fPreMat.isIdentity());
-            REPORTER_ASSERT(reporter, info4.fPaint);
-            REPORTER_ASSERT(reporter, !info4.fIsNested &&
-                                      info4.fHasNestedLayers); // has a nested SL
-
-            REPORTER_ASSERT(reporter, child == info5.fPicture); // in a child picture
-            REPORTER_ASSERT(reporter, kWidth == info5.fBounds.width() &&
-                                      kHeight == info5.fBounds.height());
-            REPORTER_ASSERT(reporter, 0 == info5.fBounds.fLeft && 0 == info5.fBounds.fTop);
-            REPORTER_ASSERT(reporter, info5.fLocalMat.isIdentity());
-            REPORTER_ASSERT(reporter, info5.fPreMat.isIdentity());
-            REPORTER_ASSERT(reporter, NULL != info5.fPaint);
-            REPORTER_ASSERT(reporter, info5.fIsNested && !info5.fHasNestedLayers); // is nested
-
-            REPORTER_ASSERT(reporter, NULL == info6.fPicture);
-            REPORTER_ASSERT(reporter, kWidth-10 == info6.fBounds.width() &&
-                                      kHeight-10 == info6.fBounds.height());
-            REPORTER_ASSERT(reporter, 10 == info6.fBounds.fLeft && 10 == info6.fBounds.fTop);
-            REPORTER_ASSERT(reporter, info6.fLocalMat.isIdentity());
-            REPORTER_ASSERT(reporter, info6.fPreMat.isIdentity());
-            REPORTER_ASSERT(reporter, info6.fPaint);
-            REPORTER_ASSERT(reporter, !info6.fIsNested &&
-                                      info6.fHasNestedLayers); // has a nested SL
-
-            REPORTER_ASSERT(reporter, child == info7.fPicture); // in a child picture
-            REPORTER_ASSERT(reporter, kWidth == info7.fBounds.width() &&
-                                      kHeight == info7.fBounds.height());
-            REPORTER_ASSERT(reporter, 0 == info7.fBounds.fLeft && 0 == info7.fBounds.fTop);
-            REPORTER_ASSERT(reporter, info7.fLocalMat.isIdentity());
-            REPORTER_ASSERT(reporter, info7.fPreMat.isIdentity());
-            REPORTER_ASSERT(reporter, NULL != info7.fPaint);
-            REPORTER_ASSERT(reporter, info7.fIsNested && !info7.fHasNestedLayers); // is nested
-        }
+        pict.reset(recorder.endRecording());
+    }
+
+    // Now test out the SaveLayer extraction
+    {
+        SkPicture::AccelData::Key key = SkLayerInfo::ComputeKey();
+
+        const SkPicture::AccelData* data = pict->EXPERIMENTAL_getAccelData(key);
+        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);
+
+        const SkLayerInfo::BlockInfo& info3 = gpuData->block(3);
+
+        // The parent/child layers appear in reverse order
+        const SkLayerInfo::BlockInfo& info4 = gpuData->block(5);
+        const SkLayerInfo::BlockInfo& info5 = gpuData->block(4);
+
+        // The parent/child layers appear in reverse order
+        const SkLayerInfo::BlockInfo& info6 = gpuData->block(7);
+        const SkLayerInfo::BlockInfo& info7 = gpuData->block(6);
+
+        REPORTER_ASSERT(reporter, NULL == info0.fPicture);
+        REPORTER_ASSERT(reporter, kWidth == info0.fBounds.width() &&
+                                  kHeight == info0.fBounds.height());
+        REPORTER_ASSERT(reporter, info0.fLocalMat.isIdentity());
+        REPORTER_ASSERT(reporter, info0.fPreMat.isIdentity());
+        REPORTER_ASSERT(reporter, 0 == info0.fBounds.fLeft && 0 == info0.fBounds.fTop);
+        REPORTER_ASSERT(reporter, NULL != info0.fPaint);
+        REPORTER_ASSERT(reporter, !info0.fIsNested && !info0.fHasNestedLayers);
+
+        REPORTER_ASSERT(reporter, NULL == info1.fPicture);
+        REPORTER_ASSERT(reporter, kWidth/2.0 == info1.fBounds.width() &&
+                                  kHeight/2.0 == info1.fBounds.height());
+        REPORTER_ASSERT(reporter, info1.fLocalMat.isIdentity());
+        REPORTER_ASSERT(reporter, info1.fPreMat.isIdentity());
+        REPORTER_ASSERT(reporter, kWidth/2.0 == info1.fBounds.fLeft && 
+                                  kHeight/2.0 == info1.fBounds.fTop);
+        REPORTER_ASSERT(reporter, NULL == info1.fPaint);
+        REPORTER_ASSERT(reporter, !info1.fIsNested &&
+                                  info1.fHasNestedLayers); // has a nested SL
+
+        REPORTER_ASSERT(reporter, NULL == info2.fPicture);
+        REPORTER_ASSERT(reporter, kWidth / 2 == info2.fBounds.width() &&
+                                  kHeight / 2 == info2.fBounds.height()); // bound reduces size
+        REPORTER_ASSERT(reporter, !info2.fLocalMat.isIdentity());
+        REPORTER_ASSERT(reporter, info2.fPreMat.isIdentity());
+        REPORTER_ASSERT(reporter, kWidth / 2 == info2.fBounds.fLeft &&   // translated
+                                  kHeight / 2 == info2.fBounds.fTop);
+        REPORTER_ASSERT(reporter, NULL != info2.fPaint);
+        REPORTER_ASSERT(reporter, info2.fIsNested && !info2.fHasNestedLayers); // is nested
+
+        REPORTER_ASSERT(reporter, NULL == info3.fPicture);
+        REPORTER_ASSERT(reporter, kWidth == info3.fBounds.width() &&
+                                  kHeight == info3.fBounds.height());
+        REPORTER_ASSERT(reporter, info3.fLocalMat.isIdentity());
+        REPORTER_ASSERT(reporter, info3.fPreMat.isIdentity());
+        REPORTER_ASSERT(reporter, 0 == info3.fBounds.fLeft && 0 == info3.fBounds.fTop);
+        REPORTER_ASSERT(reporter, info3.fPaint);
+        REPORTER_ASSERT(reporter, !info3.fIsNested && !info3.fHasNestedLayers);
+
+        REPORTER_ASSERT(reporter, NULL == info4.fPicture);
+        REPORTER_ASSERT(reporter, kWidth == info4.fBounds.width() &&
+                                  kHeight == info4.fBounds.height());
+        REPORTER_ASSERT(reporter, 0 == info4.fBounds.fLeft && 0 == info4.fBounds.fTop);
+        REPORTER_ASSERT(reporter, info4.fLocalMat.isIdentity());
+        REPORTER_ASSERT(reporter, info4.fPreMat.isIdentity());
+        REPORTER_ASSERT(reporter, info4.fPaint);
+        REPORTER_ASSERT(reporter, !info4.fIsNested &&
+                                  info4.fHasNestedLayers); // has a nested SL
+
+        REPORTER_ASSERT(reporter, child == info5.fPicture); // in a child picture
+        REPORTER_ASSERT(reporter, kWidth == info5.fBounds.width() &&
+                                  kHeight == info5.fBounds.height());
+        REPORTER_ASSERT(reporter, 0 == info5.fBounds.fLeft && 0 == info5.fBounds.fTop);
+        REPORTER_ASSERT(reporter, info5.fLocalMat.isIdentity());
+        REPORTER_ASSERT(reporter, info5.fPreMat.isIdentity());
+        REPORTER_ASSERT(reporter, NULL != info5.fPaint);
+        REPORTER_ASSERT(reporter, info5.fIsNested && !info5.fHasNestedLayers); // is nested
+
+        REPORTER_ASSERT(reporter, NULL == info6.fPicture);
+        REPORTER_ASSERT(reporter, kWidth-10 == info6.fBounds.width() &&
+                                  kHeight-10 == info6.fBounds.height());
+        REPORTER_ASSERT(reporter, 10 == info6.fBounds.fLeft && 10 == info6.fBounds.fTop);
+        REPORTER_ASSERT(reporter, info6.fLocalMat.isIdentity());
+        REPORTER_ASSERT(reporter, info6.fPreMat.isIdentity());
+        REPORTER_ASSERT(reporter, info6.fPaint);
+        REPORTER_ASSERT(reporter, !info6.fIsNested &&
+                                  info6.fHasNestedLayers); // has a nested SL
+
+        REPORTER_ASSERT(reporter, child == info7.fPicture); // in a child picture
+        REPORTER_ASSERT(reporter, kWidth == info7.fBounds.width() &&
+                                  kHeight == info7.fBounds.height());
+        REPORTER_ASSERT(reporter, 0 == info7.fBounds.fLeft && 0 == info7.fBounds.fTop);
+        REPORTER_ASSERT(reporter, info7.fLocalMat.isIdentity());
+        REPORTER_ASSERT(reporter, info7.fPreMat.isIdentity());
+        REPORTER_ASSERT(reporter, NULL != info7.fPaint);
+        REPORTER_ASSERT(reporter, info7.fIsNested && !info7.fHasNestedLayers); // is nested
     }
 }
 
-#endif
-
 static void test_has_text(skiatest::Reporter* reporter) {
     SkPictureRecorder recorder;
 
     SkCanvas* canvas = recorder.beginRecording(100,100);
     {
         canvas->drawRect(SkRect::MakeWH(20, 20), SkPaint());
     }
     SkAutoTUnref<SkPicture> picture(recorder.endRecording());
     REPORTER_ASSERT(reporter, !picture->hasText());
 
@@ skipping 647 matching lines @@
 #endif
     test_has_text(reporter);
     test_analysis(reporter);
     test_gatherpixelrefs(reporter);
     test_gatherpixelrefsandrects(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);
 }
 
-#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 129 matching lines @@
 
     // The picture shares the immutable pixels but copies the mutable ones.
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, !immut.pixelRef()->unique());
 
     // When the picture goes away, it's just our bitmaps holding the refs.
     pic.reset(NULL);
     REPORTER_ASSERT(r, mut.pixelRef()->unique());
     REPORTER_ASSERT(r, immut.pixelRef()->unique());
 }