1 /*
2  * Copyright 2013 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #include "CanvasStateHelpers.h"
9 #include "SkBitmap.h"
10 #include "SkCanvas.h"
11 #include "SkClipOpPriv.h"
12 #include "SkCanvasStateUtils.h"
13 #include "SkCommandLineFlags.h"
14 #include "SkDrawFilter.h"
15 #include "SkPaint.h"
16 #include "SkRegion.h"
17 #include "SkRRect.h"
18 #include "SkRect.h"
19 #include "SkTLazy.h"
20 #include "Test.h"
21 
22 // dlopen and the library flag are only used for tests which require this flag.
23 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
24 #include <dlfcn.h>
25 
26 DEFINE_string(library, "", "Support library to use for CanvasState test. If empty (the default), "
27                            "the test will be run without crossing a library boundary. Otherwise, "
28                            "it is expected to be a full path to a shared library file, which will"
29                            " be dynamically loaded. Functions from the library will be called to "
30                            "test SkCanvasState. Instructions for generating the library are in "
31                            "gyp/canvas_state_lib.gyp");
32 
33 
34 // This class calls dlopen on the library passed in to the command line flag library, and handles
35 // calling dlclose when it goes out of scope.
36 class OpenLibResult {
37 public:
38     // If the flag library was passed to this run of the test, attempt to open it using dlopen and
39     // report whether it succeeded.
40     OpenLibResult(skiatest::Reporter* reporter) {
41         if (FLAGS_library.count() == 1) {
42             fHandle = dlopen(FLAGS_library[0], RTLD_LAZY | RTLD_LOCAL);
43             REPORTER_ASSERT(reporter, fHandle != nullptr, "Failed to open library!");
44         } else {
45             fHandle = nullptr;
46         }
47     }
48 
49     // Automatically call dlclose when going out of scope.
50     ~OpenLibResult() {
51         if (fHandle) {
52             dlclose(fHandle);
53         }
54     }
55 
56     // Pointer to the shared library object.
57     void* handle() { return fHandle; }
58 
59 private:
60     void* fHandle;
61 };
62 
63 DEF_TEST(CanvasState_test_complex_layers, reporter) {
64     const int WIDTH = 400;
65     const int HEIGHT = 400;
66     const int SPACER = 10;
67 
68     SkRect rect = SkRect::MakeXYWH(SkIntToScalar(SPACER), SkIntToScalar(SPACER),
69                                    SkIntToScalar(WIDTH-(2*SPACER)),
70                                    SkIntToScalar((HEIGHT-(2*SPACER)) / 7));
71 
72     const SkColorType colorTypes[] = {
73         kRGB_565_SkColorType, kN32_SkColorType
74     };
75 
76     const int layerAlpha[] = { 255, 255, 0 };
77     const SkCanvas::SaveLayerFlags flags[] = {
78         static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
79         0,
80         static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
81     };
82     REPORTER_ASSERT(reporter, sizeof(layerAlpha) == sizeof(flags));
83 
84     bool (*drawFn)(SkCanvasState* state, float l, float t,
85                    float r, float b, int32_t s);
86 
87     OpenLibResult openLibResult(reporter);
88     if (openLibResult.handle() != nullptr) {
89         *(void**) (&drawFn) = dlsym(openLibResult.handle(),
90                                     "complex_layers_draw_from_canvas_state");
91     } else {
92         drawFn = complex_layers_draw_from_canvas_state;
93     }
94 
95     REPORTER_ASSERT(reporter, drawFn);
96     if (!drawFn) {
97         return;
98     }
99 
100     for (size_t i = 0; i < SK_ARRAY_COUNT(colorTypes); ++i) {
101         SkBitmap bitmaps[2];
102         for (int j = 0; j < 2; ++j) {
103             bitmaps[j].allocPixels(SkImageInfo::Make(WIDTH, HEIGHT,
104                                                      colorTypes[i],
105                                                      kPremul_SkAlphaType));
106 
107             SkCanvas canvas(bitmaps[j]);
108 
109             canvas.drawColor(SK_ColorRED);
110 
111             for (size_t k = 0; k < SK_ARRAY_COUNT(layerAlpha); ++k) {
112                 SkTLazy<SkPaint> paint;
113                 if (layerAlpha[k] != 0xFF) {
114                     paint.init()->setAlpha(layerAlpha[k]);
115                 }
116 
117                 // draw a rect within the layer's bounds and again outside the layer's bounds
118                 canvas.saveLayer(SkCanvas::SaveLayerRec(&rect, paint.getMaybeNull(), flags[k]));
119 
120                 if (j) {
121                     // Capture from the first Skia.
122                     SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
123                     REPORTER_ASSERT(reporter, state);
124 
125                     // And draw to it in the second Skia.
126                     bool success = complex_layers_draw_from_canvas_state(state,
127                             rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, SPACER);
128                     REPORTER_ASSERT(reporter, success);
129 
130                     // And release it in the *first* Skia.
131                     SkCanvasStateUtils::ReleaseCanvasState(state);
132                 } else {
133                     // Draw in the first Skia.
134                     complex_layers_draw(&canvas, rect.fLeft, rect.fTop,
135                                         rect.fRight, rect.fBottom, SPACER);
136                 }
137 
138                 canvas.restore();
139 
140                 // translate the canvas for the next iteration
141                 canvas.translate(0, 2*(rect.height() + SPACER));
142             }
143         }
144 
145         // now we memcmp the two bitmaps
146         REPORTER_ASSERT(reporter, bitmaps[0].computeByteSize() == bitmaps[1].computeByteSize());
147         REPORTER_ASSERT(reporter, !memcmp(bitmaps[0].getPixels(),
148                                           bitmaps[1].getPixels(),
149                                           bitmaps[0].computeByteSize()));
150     }
151 }
152 #endif
153 
154 ////////////////////////////////////////////////////////////////////////////////
155 
156 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
157 DEF_TEST(CanvasState_test_complex_clips, reporter) {
158     const int WIDTH = 400;
159     const int HEIGHT = 400;
160     const int SPACER = 10;
161 
162     SkIRect layerRect = SkIRect::MakeWH(WIDTH, HEIGHT / 4);
163     layerRect.inset(2*SPACER, 2*SPACER);
164 
165     SkIRect clipRect = layerRect;
166     clipRect.fRight = clipRect.fLeft + (clipRect.width() / 2) - (2*SPACER);
167     clipRect.outset(SPACER, SPACER);
168 
169     SkIRect regionBounds = clipRect;
170     regionBounds.offset(clipRect.width() + (2*SPACER), 0);
171 
172     SkIRect regionInterior = regionBounds;
173     regionInterior.inset(SPACER*3, SPACER*3);
174 
175     SkRegion clipRegion;
176     clipRegion.setRect(regionBounds);
177     clipRegion.op(regionInterior, SkRegion::kDifference_Op);
178 
179 
180     const SkRegion::Op clipOps[] = { SkRegion::kIntersect_Op,
181                                      SkRegion::kIntersect_Op,
182                                      SkRegion::kReplace_Op,
183     };
184     const SkCanvas::SaveLayerFlags flags[] = {
185         static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
186         0,
187         static_cast<SkCanvas::SaveLayerFlags>(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag),
188     };
189     REPORTER_ASSERT(reporter, sizeof(clipOps) == sizeof(flags));
190 
191     bool (*drawFn)(SkCanvasState* state, int32_t l, int32_t t,
192                    int32_t r, int32_t b, int32_t clipOp,
193                    int32_t regionRects, int32_t* rectCoords);
194 
195     OpenLibResult openLibResult(reporter);
196     if (openLibResult.handle() != nullptr) {
197         *(void**) (&drawFn) = dlsym(openLibResult.handle(),
198                                     "complex_clips_draw_from_canvas_state");
199     } else {
200         drawFn = complex_clips_draw_from_canvas_state;
201     }
202 
203     REPORTER_ASSERT(reporter, drawFn);
204     if (!drawFn) {
205         return;
206     }
207 
208     SkBitmap bitmaps[2];
209     for (int i = 0; i < 2; ++i) {
210         bitmaps[i].allocN32Pixels(WIDTH, HEIGHT);
211 
212         SkCanvas canvas(bitmaps[i]);
213 
214         canvas.drawColor(SK_ColorRED);
215 
216         SkRegion localRegion = clipRegion;
217 
218         SkPaint paint;
219         paint.setAlpha(128);
220         for (size_t j = 0; j < SK_ARRAY_COUNT(flags); ++j) {
221             SkRect layerBounds = SkRect::Make(layerRect);
222             canvas.saveLayer(SkCanvas::SaveLayerRec(&layerBounds, &paint, flags[j]));
223 
224             if (i) {
225                 SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
226                 REPORTER_ASSERT(reporter, state);
227 
228                 SkRegion::Iterator iter(localRegion);
229                 SkTDArray<int32_t> rectCoords;
230                 for (; !iter.done(); iter.next()) {
231                     const SkIRect& rect = iter.rect();
232                     *rectCoords.append() = rect.fLeft;
233                     *rectCoords.append() = rect.fTop;
234                     *rectCoords.append() = rect.fRight;
235                     *rectCoords.append() = rect.fBottom;
236                 }
237                 bool success = drawFn(state, clipRect.fLeft, clipRect.fTop,
238                                       clipRect.fRight, clipRect.fBottom, clipOps[j],
239                                       rectCoords.count() / 4, rectCoords.begin());
240                 REPORTER_ASSERT(reporter, success);
241 
242                 SkCanvasStateUtils::ReleaseCanvasState(state);
243             } else {
244                 complex_clips_draw(&canvas, clipRect.fLeft, clipRect.fTop,
245                                    clipRect.fRight, clipRect.fBottom, clipOps[j],
246                                    localRegion);
247             }
248 
249             canvas.restore();
250 
251             // translate the canvas and region for the next iteration
252             canvas.translate(0, SkIntToScalar(2*(layerRect.height() + (SPACER))));
253             localRegion.translate(0, 2*(layerRect.height() + SPACER));
254         }
255     }
256 
257     // now we memcmp the two bitmaps
258     REPORTER_ASSERT(reporter, bitmaps[0].computeByteSize() == bitmaps[1].computeByteSize());
259     REPORTER_ASSERT(reporter, !memcmp(bitmaps[0].getPixels(),
260                                       bitmaps[1].getPixels(),
261                                       bitmaps[0].computeByteSize()));
262 }
263 #endif
264 
265 ////////////////////////////////////////////////////////////////////////////////
266 
267 #ifdef SK_SUPPORT_LEGACY_DRAWFILTER
268 
269 class TestDrawFilter : public SkDrawFilter {
270 public:
271     bool filter(SkPaint*, Type) override { return true; }
272 };
273 
274 DEF_TEST(CanvasState_test_draw_filters, reporter) {
275     TestDrawFilter drawFilter;
276     SkBitmap bitmap;
277     bitmap.allocN32Pixels(10, 10);
278     SkCanvas canvas(bitmap);
279 
280     canvas.setDrawFilter(&drawFilter);
281 
282     SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
283     REPORTER_ASSERT(reporter, state);
284     std::unique_ptr<SkCanvas> tmpCanvas = SkCanvasStateUtils::MakeFromCanvasState(state);
285     REPORTER_ASSERT(reporter, tmpCanvas);
286 
287     REPORTER_ASSERT(reporter, canvas.getDrawFilter());
288     REPORTER_ASSERT(reporter, nullptr == tmpCanvas->getDrawFilter());
289 
290     SkCanvasStateUtils::ReleaseCanvasState(state);
291 }
292 
293 #endif
294 
295 ////////////////////////////////////////////////////////////////////////////////
296 
297 DEF_TEST(CanvasState_test_soft_clips, reporter) {
298     SkBitmap bitmap;
299     bitmap.allocN32Pixels(10, 10);
300     SkCanvas canvas(bitmap);
301 
302     SkRRect roundRect;
303     roundRect.setOval(SkRect::MakeWH(5, 5));
304 
305     canvas.clipRRect(roundRect, kIntersect_SkClipOp, true);
306 
307     SkCanvasState* state = SkCanvasStateUtils::CaptureCanvasState(&canvas);
308     REPORTER_ASSERT(reporter, !state);
309 }
310 
311 DEF_TEST(CanvasState_test_saveLayer_clip, reporter) {
312     const uint32_t dontSaveFlag = 1 << 31;    // secret flag for don't save
313 #ifdef SK_SUPPORT_LEGACY_CLIPTOLAYERFLAG
314     static_assert(SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag == dontSaveFlag, "");
315 #endif
316     const int WIDTH = 100;
317     const int HEIGHT = 100;
318     const int LAYER_WIDTH = 50;
319     const int LAYER_HEIGHT = 50;
320 
321     SkBitmap bitmap;
322     bitmap.allocN32Pixels(WIDTH, HEIGHT);
323     SkCanvas canvas(bitmap);
324 
325     SkRect bounds = SkRect::MakeWH(SkIntToScalar(LAYER_WIDTH), SkIntToScalar(LAYER_HEIGHT));
326     canvas.clipRect(SkRect::MakeWH(SkIntToScalar(WIDTH), SkIntToScalar(HEIGHT)));
327 
328     SkIRect devClip;
329     // Check that saveLayer without the kClipToLayer_SaveFlag leaves the clip unchanged.
330     canvas.saveLayer(SkCanvas::SaveLayerRec(&bounds, nullptr, dontSaveFlag));
331     devClip = canvas.getDeviceClipBounds();
332     REPORTER_ASSERT(reporter, canvas.isClipRect());
333     REPORTER_ASSERT(reporter, devClip.width() == WIDTH);
334     REPORTER_ASSERT(reporter, devClip.height() == HEIGHT);
335     canvas.restore();
336 
337     // Check that saveLayer with the kClipToLayer_SaveFlag sets the clip
338     // stack to the layer bounds.
339     canvas.saveLayer(&bounds, nullptr);
340     devClip = canvas.getDeviceClipBounds();
341     REPORTER_ASSERT(reporter, canvas.isClipRect());
342     REPORTER_ASSERT(reporter, devClip.width() == LAYER_WIDTH);
343     REPORTER_ASSERT(reporter, devClip.height() == LAYER_HEIGHT);
344     canvas.restore();
345 }
346