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
createSurface(SurfaceType surfaceType,GrContext * context)26 static SkSurface* createSurface(SurfaceType surfaceType, GrContext* context) {
27 static const SkImageInfo imageSpec = {
28 10, // width
29 10, // height
30 kPMColor_SkColorType,
31 kPremul_SkAlphaType
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
TestSurfaceCopyOnWrite(skiatest::Reporter * reporter,SurfaceType surfaceType,GrContext * context)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 testBitmap.eraseColor(0);
88
89 SkRRect testRRect;
90 testRRect.setRectXY(testRect, SK_Scalar1, SK_Scalar1);
91
92 SkString testText("Hello World");
93 const SkPoint testPoints2[] = {
94 { SkIntToScalar(0), SkIntToScalar(1) },
95 { SkIntToScalar(1), SkIntToScalar(1) },
96 { SkIntToScalar(2), SkIntToScalar(1) },
97 { SkIntToScalar(3), SkIntToScalar(1) },
98 { SkIntToScalar(4), SkIntToScalar(1) },
99 { SkIntToScalar(5), SkIntToScalar(1) },
100 { SkIntToScalar(6), SkIntToScalar(1) },
101 { SkIntToScalar(7), SkIntToScalar(1) },
102 { SkIntToScalar(8), SkIntToScalar(1) },
103 { SkIntToScalar(9), SkIntToScalar(1) },
104 { SkIntToScalar(10), SkIntToScalar(1) },
105 };
106
107 #define EXPECT_COPY_ON_WRITE(command) \
108 { \
109 SkImage* imageBefore = surface->newImageSnapshot(); \
110 SkAutoTUnref<SkImage> aur_before(imageBefore); \
111 canvas-> command ; \
112 SkImage* imageAfter = surface->newImageSnapshot(); \
113 SkAutoTUnref<SkImage> aur_after(imageAfter); \
114 REPORTER_ASSERT(reporter, imageBefore != imageAfter); \
115 }
116
117 EXPECT_COPY_ON_WRITE(clear(testColor))
118 EXPECT_COPY_ON_WRITE(drawPaint(testPaint))
119 EXPECT_COPY_ON_WRITE(drawPoints(SkCanvas::kPoints_PointMode, testPointCount, testPoints, \
120 testPaint))
121 EXPECT_COPY_ON_WRITE(drawOval(testRect, testPaint))
122 EXPECT_COPY_ON_WRITE(drawRect(testRect, testPaint))
123 EXPECT_COPY_ON_WRITE(drawRRect(testRRect, testPaint))
124 EXPECT_COPY_ON_WRITE(drawPath(testPath, testPaint))
125 EXPECT_COPY_ON_WRITE(drawBitmap(testBitmap, 0, 0))
126 EXPECT_COPY_ON_WRITE(drawBitmapRect(testBitmap, NULL, testRect))
127 EXPECT_COPY_ON_WRITE(drawBitmapMatrix(testBitmap, testMatrix, NULL))
128 EXPECT_COPY_ON_WRITE(drawBitmapNine(testBitmap, testIRect, testRect, NULL))
129 EXPECT_COPY_ON_WRITE(drawSprite(testBitmap, 0, 0, NULL))
130 EXPECT_COPY_ON_WRITE(drawText(testText.c_str(), testText.size(), 0, 1, testPaint))
131 EXPECT_COPY_ON_WRITE(drawPosText(testText.c_str(), testText.size(), testPoints2, \
132 testPaint))
133 EXPECT_COPY_ON_WRITE(drawTextOnPath(testText.c_str(), testText.size(), testPath, NULL, \
134 testPaint))
135 }
136
TestSurfaceWritableAfterSnapshotRelease(skiatest::Reporter * reporter,SurfaceType surfaceType,GrContext * context)137 static void TestSurfaceWritableAfterSnapshotRelease(skiatest::Reporter* reporter,
138 SurfaceType surfaceType,
139 GrContext* context) {
140 // This test succeeds by not triggering an assertion.
141 // The test verifies that the surface remains writable (usable) after
142 // acquiring and releasing a snapshot without triggering a copy on write.
143 SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context));
144 SkCanvas* canvas = surface->getCanvas();
145 canvas->clear(1);
146 surface->newImageSnapshot()->unref(); // Create and destroy SkImage
147 canvas->clear(2); // Must not assert internally
148 }
149
150 #if SK_SUPPORT_GPU
Test_crbug263329(skiatest::Reporter * reporter,GrContext * context)151 static void Test_crbug263329(skiatest::Reporter* reporter,
152 GrContext* context) {
153 // This is a regression test for crbug.com/263329
154 // Bug was caused by onCopyOnWrite releasing the old surface texture
155 // back to the scratch texture pool even though the texture is used
156 // by and active SkImage_Gpu.
157 SkAutoTUnref<SkSurface> surface1(createSurface(kGpu_SurfaceType, context));
158 SkAutoTUnref<SkSurface> surface2(createSurface(kGpu_SurfaceType, context));
159 SkCanvas* canvas1 = surface1->getCanvas();
160 SkCanvas* canvas2 = surface2->getCanvas();
161 canvas1->clear(1);
162 SkAutoTUnref<SkImage> image1(surface1->newImageSnapshot());
163 // Trigger copy on write, new backing is a scratch texture
164 canvas1->clear(2);
165 SkAutoTUnref<SkImage> image2(surface1->newImageSnapshot());
166 // Trigger copy on write, old backing should not be returned to scratch
167 // pool because it is held by image2
168 canvas1->clear(3);
169
170 canvas2->clear(4);
171 SkAutoTUnref<SkImage> image3(surface2->newImageSnapshot());
172 // Trigger copy on write on surface2. The new backing store should not
173 // be recycling a texture that is held by an existing image.
174 canvas2->clear(5);
175 SkAutoTUnref<SkImage> image4(surface2->newImageSnapshot());
176 REPORTER_ASSERT(reporter, image4->getTexture() != image3->getTexture());
177 // The following assertion checks crbug.com/263329
178 REPORTER_ASSERT(reporter, image4->getTexture() != image2->getTexture());
179 REPORTER_ASSERT(reporter, image4->getTexture() != image1->getTexture());
180 REPORTER_ASSERT(reporter, image3->getTexture() != image2->getTexture());
181 REPORTER_ASSERT(reporter, image3->getTexture() != image1->getTexture());
182 REPORTER_ASSERT(reporter, image2->getTexture() != image1->getTexture());
183 }
184
TestGetTexture(skiatest::Reporter * reporter,SurfaceType surfaceType,GrContext * context)185 static void TestGetTexture(skiatest::Reporter* reporter,
186 SurfaceType surfaceType,
187 GrContext* context) {
188 SkAutoTUnref<SkSurface> surface(createSurface(surfaceType, context));
189 SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
190 GrTexture* texture = image->getTexture();
191 if (surfaceType == kGpu_SurfaceType) {
192 REPORTER_ASSERT(reporter, NULL != texture);
193 REPORTER_ASSERT(reporter, 0 != texture->getTextureHandle());
194 } else {
195 REPORTER_ASSERT(reporter, NULL == texture);
196 }
197 surface->notifyContentWillChange(SkSurface::kDiscard_ContentChangeMode);
198 REPORTER_ASSERT(reporter, image->getTexture() == texture);
199 }
200 #endif
201
TestSurfaceNoCanvas(skiatest::Reporter * reporter,SurfaceType surfaceType,GrContext * context,SkSurface::ContentChangeMode mode)202 static void TestSurfaceNoCanvas(skiatest::Reporter* reporter,
203 SurfaceType surfaceType,
204 GrContext* context,
205 SkSurface::ContentChangeMode mode) {
206 // Verifies the robustness of SkSurface for handling use cases where calls
207 // are made before a canvas is created.
208 {
209 // Test passes by not asserting
210 SkSurface* surface = createSurface(surfaceType, context);
211 SkAutoTUnref<SkSurface> aur_surface(surface);
212 surface->notifyContentWillChange(mode);
213 SkDEBUGCODE(surface->validate();)
214 }
215 {
216 SkSurface* surface = createSurface(surfaceType, context);
217 SkAutoTUnref<SkSurface> aur_surface(surface);
218 SkImage* image1 = surface->newImageSnapshot();
219 SkAutoTUnref<SkImage> aur_image1(image1);
220 SkDEBUGCODE(image1->validate();)
221 SkDEBUGCODE(surface->validate();)
222 surface->notifyContentWillChange(mode);
223 SkDEBUGCODE(image1->validate();)
224 SkDEBUGCODE(surface->validate();)
225 SkImage* image2 = surface->newImageSnapshot();
226 SkAutoTUnref<SkImage> aur_image2(image2);
227 SkDEBUGCODE(image2->validate();)
228 SkDEBUGCODE(surface->validate();)
229 REPORTER_ASSERT(reporter, image1 != image2);
230 }
231
232 }
233
TestSurface(skiatest::Reporter * reporter,GrContextFactory * factory)234 static void TestSurface(skiatest::Reporter* reporter, GrContextFactory* factory) {
235 TestSurfaceCopyOnWrite(reporter, kRaster_SurfaceType, NULL);
236 TestSurfaceCopyOnWrite(reporter, kPicture_SurfaceType, NULL);
237 TestSurfaceWritableAfterSnapshotRelease(reporter, kRaster_SurfaceType, NULL);
238 TestSurfaceWritableAfterSnapshotRelease(reporter, kPicture_SurfaceType, NULL);
239 TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kDiscard_ContentChangeMode);
240 TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kRetain_ContentChangeMode);
241 #if SK_SUPPORT_GPU
242 TestGetTexture(reporter, kRaster_SurfaceType, NULL);
243 TestGetTexture(reporter, kPicture_SurfaceType, NULL);
244 if (NULL != factory) {
245 GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
246 if (NULL != context) {
247 Test_crbug263329(reporter, context);
248 TestSurfaceCopyOnWrite(reporter, kGpu_SurfaceType, context);
249 TestSurfaceWritableAfterSnapshotRelease(reporter, kGpu_SurfaceType, context);
250 TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kDiscard_ContentChangeMode);
251 TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kRetain_ContentChangeMode);
252 TestGetTexture(reporter, kGpu_SurfaceType, context);
253 }
254 }
255 #endif
256 }
257
258 #include "TestClassDef.h"
259 DEFINE_GPUTESTCLASS("Surface", SurfaceTestClass, TestSurface)
260