1 2 /* 3 * Copyright 2013 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 #include "SkCanvas.h" 9 #include "SkRRect.h" 10 #include "SkSurface.h" 11 #include "Test.h" 12 13 #if SK_SUPPORT_GPU 14 #include "GrContextFactory.h" 15 #else 16 class GrContextFactory; 17 class GrContext; 18 #endif 19 20 enum SurfaceType { 21 kRaster_SurfaceType, 22 kGpu_SurfaceType, 23 kPicture_SurfaceType 24 }; 25 26 static SkSurface* createSurface(SurfaceType surfaceType, GrContext* context) { 27 static const SkImage::Info imageSpec = { 28 10, // width 29 10, // height 30 SkImage::kPMColor_ColorType, 31 SkImage::kPremul_AlphaType 32 }; 33 34 switch (surfaceType) { 35 case kRaster_SurfaceType: 36 return SkSurface::NewRaster(imageSpec); 37 case kGpu_SurfaceType: 38 #if SK_SUPPORT_GPU 39 SkASSERT(NULL != context); 40 return SkSurface::NewRenderTarget(context, imageSpec); 41 #else 42 SkASSERT(0); 43 #endif 44 case kPicture_SurfaceType: 45 return SkSurface::NewPicture(10, 10); 46 } 47 SkASSERT(0); 48 return NULL; 49 } 50 51 static void TestSurfaceCopyOnWrite(skiatest::Reporter* reporter, SurfaceType surfaceType, 52 GrContext* context) { 53 // Verify that the right canvas commands trigger a copy on write 54 SkSurface* surface = createSurface(surfaceType, context); 55 SkAutoTUnref<SkSurface> aur_surface(surface); 56 SkCanvas* canvas = surface->getCanvas(); 57 58 const SkRect testRect = 59 SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0), 60 SkIntToScalar(4), SkIntToScalar(5)); 61 SkMatrix testMatrix; 62 testMatrix.reset(); 63 testMatrix.setScale(SkIntToScalar(2), SkIntToScalar(3)); 64 65 SkPath testPath; 66 testPath.addRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0), 67 SkIntToScalar(2), SkIntToScalar(1))); 68 69 const SkIRect testIRect = SkIRect::MakeXYWH(0, 0, 2, 1); 70 71 SkRegion testRegion; 72 testRegion.setRect(testIRect); 73 74 75 const SkColor testColor = 0x01020304; 76 const SkPaint testPaint; 77 const SkPoint testPoints[3] = { 78 {SkIntToScalar(0), SkIntToScalar(0)}, 79 {SkIntToScalar(2), SkIntToScalar(1)}, 80 {SkIntToScalar(0), SkIntToScalar(2)} 81 }; 82 const size_t testPointCount = 3; 83 84 SkBitmap testBitmap; 85 testBitmap.setConfig(SkBitmap::kARGB_8888_Config, 10, 10); 86 testBitmap.allocPixels(); 87 88 SkRRect testRRect; 89 testRRect.setRectXY(testRect, SK_Scalar1, SK_Scalar1); 90 91 SkString testText("Hello World"); 92 const SkPoint testPoints2[] = { 93 { SkIntToScalar(0), SkIntToScalar(1) }, 94 { SkIntToScalar(1), SkIntToScalar(1) }, 95 { SkIntToScalar(2), SkIntToScalar(1) }, 96 { SkIntToScalar(3), SkIntToScalar(1) }, 97 { SkIntToScalar(4), SkIntToScalar(1) }, 98 { SkIntToScalar(5), SkIntToScalar(1) }, 99 { SkIntToScalar(6), SkIntToScalar(1) }, 100 { SkIntToScalar(7), SkIntToScalar(1) }, 101 { SkIntToScalar(8), SkIntToScalar(1) }, 102 { SkIntToScalar(9), SkIntToScalar(1) }, 103 { SkIntToScalar(10), SkIntToScalar(1) }, 104 }; 105 106 #define EXPECT_COPY_ON_WRITE(command) \ 107 { \ 108 SkImage* imageBefore = surface->newImageSnapshot(); \ 109 SkAutoTUnref<SkImage> aur_before(imageBefore); \ 110 canvas-> command ; \ 111 SkImage* imageAfter = surface->newImageSnapshot(); \ 112 SkAutoTUnref<SkImage> aur_after(imageAfter); \ 113 REPORTER_ASSERT(reporter, imageBefore != imageAfter); \ 114 } 115 116 EXPECT_COPY_ON_WRITE(clear(testColor)) 117 EXPECT_COPY_ON_WRITE(drawPaint(testPaint)) 118 EXPECT_COPY_ON_WRITE(drawPoints(SkCanvas::kPoints_PointMode, testPointCount, testPoints, \ 119 testPaint)) 120 EXPECT_COPY_ON_WRITE(drawOval(testRect, testPaint)) 121 EXPECT_COPY_ON_WRITE(drawRect(testRect, testPaint)) 122 EXPECT_COPY_ON_WRITE(drawRRect(testRRect, testPaint)) 123 EXPECT_COPY_ON_WRITE(drawPath(testPath, testPaint)) 124 EXPECT_COPY_ON_WRITE(drawBitmap(testBitmap, 0, 0)) 125 EXPECT_COPY_ON_WRITE(drawBitmapRect(testBitmap, NULL, testRect)) 126 EXPECT_COPY_ON_WRITE(drawBitmapMatrix(testBitmap, testMatrix, NULL)) 127 EXPECT_COPY_ON_WRITE(drawBitmapNine(testBitmap, testIRect, testRect, NULL)) 128 EXPECT_COPY_ON_WRITE(drawSprite(testBitmap, 0, 0, NULL)) 129 EXPECT_COPY_ON_WRITE(drawText(testText.c_str(), testText.size(), 0, 1, testPaint)) 130 EXPECT_COPY_ON_WRITE(drawPosText(testText.c_str(), testText.size(), testPoints2, \ 131 testPaint)) 132 EXPECT_COPY_ON_WRITE(drawTextOnPath(testText.c_str(), testText.size(), testPath, NULL, \ 133 testPaint)) 134 } 135 136 static void TestSurfaceWritableAfterSnapshotRelease(skiatest::Reporter* reporter, 137 SurfaceType surfaceType, 138 GrContext* context) { 139 // This test succeeds by not triggering an assertion. 140 // The test verifies that the surface remains writable (usable) after 141 // acquiring and releasing a snapshot without triggering a copy on write. 142 SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context)); 143 SkCanvas* canvas = surface->getCanvas(); 144 canvas->clear(1); 145 surface->newImageSnapshot()->unref(); // Create and destroy SkImage 146 canvas->clear(2); // Must not assert internally 147 } 148 149 #if SK_SUPPORT_GPU 150 static void Test_crbug263329(skiatest::Reporter* reporter, 151 GrContext* context) { 152 // This is a regression test for crbug.com/263329 153 // Bug was caused by onCopyOnWrite releasing the old surface texture 154 // back to the scratch texture pool even though the texture is used 155 // by and active SkImage_Gpu. 156 SkAutoTUnref<SkSurface> surface1(createSurface(kGpu_SurfaceType, context)); 157 SkAutoTUnref<SkSurface> surface2(createSurface(kGpu_SurfaceType, context)); 158 SkCanvas* canvas1 = surface1->getCanvas(); 159 SkCanvas* canvas2 = surface2->getCanvas(); 160 canvas1->clear(1); 161 SkAutoTUnref<SkImage> image1(surface1->newImageSnapshot()); 162 // Trigger copy on write, new backing is a scratch texture 163 canvas1->clear(2); 164 SkAutoTUnref<SkImage> image2(surface1->newImageSnapshot()); 165 // Trigger copy on write, old backing should not be returned to scratch 166 // pool because it is held by image2 167 canvas1->clear(3); 168 169 canvas2->clear(4); 170 SkAutoTUnref<SkImage> image3(surface2->newImageSnapshot()); 171 // Trigger copy on write on surface2. The new backing store should not 172 // be recycling a texture that is held by an existing image. 173 canvas2->clear(5); 174 SkAutoTUnref<SkImage> image4(surface2->newImageSnapshot()); 175 REPORTER_ASSERT(reporter, image4->getTexture() != image3->getTexture()); 176 // The following assertion checks crbug.com/263329 177 REPORTER_ASSERT(reporter, image4->getTexture() != image2->getTexture()); 178 REPORTER_ASSERT(reporter, image4->getTexture() != image1->getTexture()); 179 REPORTER_ASSERT(reporter, image3->getTexture() != image2->getTexture()); 180 REPORTER_ASSERT(reporter, image3->getTexture() != image1->getTexture()); 181 REPORTER_ASSERT(reporter, image2->getTexture() != image1->getTexture()); 182 } 183 184 static void TestGetTexture(skiatest::Reporter* reporter, 185 SurfaceType surfaceType, 186 GrContext* context) { 187 SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context)); 188 SkAutoTUnref<SkImage> image(surface->newImageSnapshot()); 189 GrTexture* texture = image->getTexture(); 190 if (surfaceType == kGpu_SurfaceType) { 191 REPORTER_ASSERT(reporter, NULL != texture); 192 REPORTER_ASSERT(reporter, 0 != texture->getTextureHandle()); 193 } else { 194 REPORTER_ASSERT(reporter, NULL == texture); 195 } 196 surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode); 197 REPORTER_ASSERT(reporter, image->getTexture() == texture); 198 } 199 #endif 200 201 static void TestSurfaceNoCanvas(skiatest::Reporter* reporter, 202 SurfaceType surfaceType, 203 GrContext* context, 204 SkSurface::ContentChangeMode mode) { 205 // Verifies the robustness of SkSurface for handling use cases where calls 206 // are made before a canvas is created. 207 { 208 // Test passes by not asserting 209 SkSurface* surface = createSurface(surfaceType, context); 210 SkAutoTUnref<SkSurface> aur_surface(surface); 211 surface->notifyContentWillChange(mode); 212 surface->validate(); 213 } 214 { 215 SkSurface* surface = createSurface(surfaceType, context); 216 SkAutoTUnref<SkSurface> aur_surface(surface); 217 SkImage* image1 = surface->newImageSnapshot(); 218 SkAutoTUnref<SkImage> aur_image1(image1); 219 image1->validate(); 220 surface->validate(); 221 surface->notifyContentWillChange(mode); 222 image1->validate(); 223 surface->validate(); 224 SkImage* image2 = surface->newImageSnapshot(); 225 SkAutoTUnref<SkImage> aur_image2(image2); 226 image2->validate(); 227 surface->validate(); 228 REPORTER_ASSERT(reporter, image1 != image2); 229 } 230 231 } 232 233 static void TestSurface(skiatest::Reporter* reporter, GrContextFactory* factory) { 234 TestSurfaceCopyOnWrite(reporter, kRaster_SurfaceType, NULL); 235 TestSurfaceCopyOnWrite(reporter, kPicture_SurfaceType, NULL); 236 TestSurfaceWritableAfterSnapshotRelease(reporter, kRaster_SurfaceType, NULL); 237 TestSurfaceWritableAfterSnapshotRelease(reporter, kPicture_SurfaceType, NULL); 238 TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kDiscard_ContentChangeMode); 239 TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kRetain_ContentChangeMode); 240 #if SK_SUPPORT_GPU 241 TestGetTexture(reporter, kRaster_SurfaceType, NULL); 242 TestGetTexture(reporter, kPicture_SurfaceType, NULL); 243 if (NULL != factory) { 244 GrContext* context = factory->get(GrContextFactory::kNative_GLContextType); 245 Test_crbug263329(reporter, context); 246 TestSurfaceCopyOnWrite(reporter, kGpu_SurfaceType, context); 247 TestSurfaceWritableAfterSnapshotRelease(reporter, kGpu_SurfaceType, context); 248 TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kDiscard_ContentChangeMode); 249 TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kRetain_ContentChangeMode); 250 TestGetTexture(reporter, kGpu_SurfaceType, context); 251 } 252 #endif 253 } 254 255 #include "TestClassDef.h" 256 DEFINE_GPUTESTCLASS("Surface", SurfaceTestClass, TestSurface) 257
