SurfaceTest.cpp revision 3bddb38e6468c6294e40e5307f05e6b56bdd6a6c 
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
16class GrContextFactory;
17class GrContext;
18#endif
19
20enum SurfaceType {
21    kRaster_SurfaceType,
22    kGpu_SurfaceType,
23    kPicture_SurfaceType
24};
25
26static 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
51static 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
137static 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
151static 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
185static 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
202static 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
234static 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"
259DEFINE_GPUTESTCLASS("Surface", SurfaceTestClass, TestSurface)
260