1 /*
2 * Copyright 2011 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 "SkCanvas.h"
9 #include "SkColorPriv.h"
10 #include "SkColorShader.h"
11 #include "SkGradientShader.h"
12 #include "SkShader.h"
13 #include "SkSurface.h"
14 #include "SkTemplates.h"
15 #include "SkTLazy.h"
16 #include "Test.h"
17
18 // https://code.google.com/p/chromium/issues/detail?id=448299
19 // Giant (inverse) matrix causes overflow when converting/computing using 32.32
20 // Before the fix, we would assert (and then crash).
test_big_grad(skiatest::Reporter * reporter)21 static void test_big_grad(skiatest::Reporter* reporter) {
22 const SkColor colors[] = { SK_ColorRED, SK_ColorBLUE };
23 const SkPoint pts[] = {{ 15, 14.7112684f }, { 0.709064007f, 12.6108112f }};
24 SkPaint paint;
25 paint.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2,
26 SkShader::kClamp_TileMode));
27
28 SkBitmap bm;
29 bm.allocN32Pixels(2000, 1);
30 SkCanvas c(bm);
31
32 const SkScalar affine[] = {
33 1.06608627e-06f, 4.26434525e-07f, 6.2855f, 2.6611f, 273.4393f, 244.0046f
34 };
35 SkMatrix matrix;
36 matrix.setAffine(affine);
37 c.concat(matrix);
38
39 c.drawPaint(paint);
40 }
41
42 struct GradRec {
43 int fColorCount;
44 const SkColor* fColors;
45 const SkScalar* fPos;
46 const SkPoint* fPoint; // 2
47 const SkScalar* fRadius; // 2
48 SkShader::TileMode fTileMode;
49
gradCheckGradRec50 void gradCheck(skiatest::Reporter* reporter, const sk_sp<SkShader>& shader,
51 SkShader::GradientInfo* info,
52 SkShader::GradientType gt) const {
53 SkAutoTMalloc<SkColor> colorStorage(fColorCount);
54 SkAutoTMalloc<SkScalar> posStorage(fColorCount);
55
56 info->fColorCount = fColorCount;
57 info->fColors = colorStorage;
58 info->fColorOffsets = posStorage.get();
59 REPORTER_ASSERT(reporter, shader->asAGradient(info) == gt);
60
61 REPORTER_ASSERT(reporter, info->fColorCount == fColorCount);
62 REPORTER_ASSERT(reporter,
63 !memcmp(info->fColors, fColors, fColorCount * sizeof(SkColor)));
64 REPORTER_ASSERT(reporter,
65 !memcmp(info->fColorOffsets, fPos, fColorCount * sizeof(SkScalar)));
66 REPORTER_ASSERT(reporter, fTileMode == info->fTileMode);
67 }
68 };
69
70
none_gradproc(skiatest::Reporter * reporter,const GradRec &,const GradRec &)71 static void none_gradproc(skiatest::Reporter* reporter, const GradRec&, const GradRec&) {
72 sk_sp<SkShader> s(SkShader::MakeEmptyShader());
73 REPORTER_ASSERT(reporter, SkShader::kNone_GradientType == s->asAGradient(nullptr));
74 }
75
color_gradproc(skiatest::Reporter * reporter,const GradRec & rec,const GradRec &)76 static void color_gradproc(skiatest::Reporter* reporter, const GradRec& rec, const GradRec&) {
77 sk_sp<SkShader> s(new SkColorShader(rec.fColors[0]));
78 REPORTER_ASSERT(reporter, SkShader::kColor_GradientType == s->asAGradient(nullptr));
79
80 SkShader::GradientInfo info;
81 info.fColors = nullptr;
82 info.fColorCount = 0;
83 s->asAGradient(&info);
84 REPORTER_ASSERT(reporter, 1 == info.fColorCount);
85 }
86
linear_gradproc(skiatest::Reporter * reporter,const GradRec & buildRec,const GradRec & checkRec)87 static void linear_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
88 const GradRec& checkRec) {
89 sk_sp<SkShader> s(SkGradientShader::MakeLinear(buildRec.fPoint, buildRec.fColors, buildRec.fPos,
90 buildRec.fColorCount, buildRec.fTileMode));
91
92 SkShader::GradientInfo info;
93 checkRec.gradCheck(reporter, s, &info, SkShader::kLinear_GradientType);
94 REPORTER_ASSERT(reporter, !memcmp(info.fPoint, checkRec.fPoint, 2 * sizeof(SkPoint)));
95 }
96
radial_gradproc(skiatest::Reporter * reporter,const GradRec & buildRec,const GradRec & checkRec)97 static void radial_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
98 const GradRec& checkRec) {
99 sk_sp<SkShader> s(SkGradientShader::MakeRadial(buildRec.fPoint[0], buildRec.fRadius[0],
100 buildRec.fColors, buildRec.fPos,
101 buildRec.fColorCount, buildRec.fTileMode));
102
103 SkShader::GradientInfo info;
104 checkRec.gradCheck(reporter, s, &info, SkShader::kRadial_GradientType);
105 REPORTER_ASSERT(reporter, info.fPoint[0] == checkRec.fPoint[0]);
106 REPORTER_ASSERT(reporter, info.fRadius[0] == checkRec.fRadius[0]);
107 }
108
sweep_gradproc(skiatest::Reporter * reporter,const GradRec & buildRec,const GradRec & checkRec)109 static void sweep_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
110 const GradRec& checkRec) {
111 sk_sp<SkShader> s(SkGradientShader::MakeSweep(buildRec.fPoint[0].fX, buildRec.fPoint[0].fY,
112 buildRec.fColors, buildRec.fPos,
113 buildRec.fColorCount));
114
115 SkShader::GradientInfo info;
116 checkRec.gradCheck(reporter, s, &info, SkShader::kSweep_GradientType);
117 REPORTER_ASSERT(reporter, info.fPoint[0] == checkRec.fPoint[0]);
118 }
119
conical_gradproc(skiatest::Reporter * reporter,const GradRec & buildRec,const GradRec & checkRec)120 static void conical_gradproc(skiatest::Reporter* reporter, const GradRec& buildRec,
121 const GradRec& checkRec) {
122 sk_sp<SkShader> s(SkGradientShader::MakeTwoPointConical(buildRec.fPoint[0],
123 buildRec.fRadius[0],
124 buildRec.fPoint[1],
125 buildRec.fRadius[1],
126 buildRec.fColors,
127 buildRec.fPos,
128 buildRec.fColorCount,
129 buildRec.fTileMode));
130
131 SkShader::GradientInfo info;
132 checkRec.gradCheck(reporter, s, &info, SkShader::kConical_GradientType);
133 REPORTER_ASSERT(reporter, !memcmp(info.fPoint, checkRec.fPoint, 2 * sizeof(SkPoint)));
134 REPORTER_ASSERT(reporter, !memcmp(info.fRadius, checkRec.fRadius, 2 * sizeof(SkScalar)));
135 }
136
137 // Ensure that repeated color gradients behave like drawing a single color
TestConstantGradient(skiatest::Reporter *)138 static void TestConstantGradient(skiatest::Reporter*) {
139 const SkPoint pts[] = {
140 { 0, 0 },
141 { SkIntToScalar(10), 0 }
142 };
143 SkColor colors[] = { SK_ColorBLUE, SK_ColorBLUE };
144 const SkScalar pos[] = { 0, SK_Scalar1 };
145 SkPaint paint;
146 paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
147 SkBitmap outBitmap;
148 outBitmap.allocN32Pixels(10, 1);
149 SkCanvas canvas(outBitmap);
150 canvas.drawPaint(paint);
151 for (int i = 0; i < 10; i++) {
152 // The following is commented out because it currently fails
153 // Related bug: https://code.google.com/p/skia/issues/detail?id=1098
154
155 // REPORTER_ASSERT(reporter, SK_ColorBLUE == outBitmap.getColor(i, 0));
156 }
157 }
158
159 typedef void (*GradProc)(skiatest::Reporter* reporter, const GradRec&, const GradRec&);
160
TestGradientShaders(skiatest::Reporter * reporter)161 static void TestGradientShaders(skiatest::Reporter* reporter) {
162 static const SkColor gColors[] = { SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE };
163 static const SkScalar gPos[] = { 0, SK_ScalarHalf, SK_Scalar1 };
164 static const SkPoint gPts[] = {
165 { 0, 0 },
166 { SkIntToScalar(10), SkIntToScalar(20) }
167 };
168 static const SkScalar gRad[] = { SkIntToScalar(1), SkIntToScalar(2) };
169
170 GradRec rec;
171 rec.fColorCount = SK_ARRAY_COUNT(gColors);
172 rec.fColors = gColors;
173 rec.fPos = gPos;
174 rec.fPoint = gPts;
175 rec.fRadius = gRad;
176 rec.fTileMode = SkShader::kClamp_TileMode;
177
178 static const GradProc gProcs[] = {
179 none_gradproc,
180 color_gradproc,
181 linear_gradproc,
182 radial_gradproc,
183 sweep_gradproc,
184 conical_gradproc,
185 };
186
187 for (size_t i = 0; i < SK_ARRAY_COUNT(gProcs); ++i) {
188 gProcs[i](reporter, rec, rec);
189 }
190 }
191
TestGradientOptimization(skiatest::Reporter * reporter)192 static void TestGradientOptimization(skiatest::Reporter* reporter) {
193 static const struct {
194 GradProc fProc;
195 bool fIsClampRestricted;
196 } gProcInfo[] = {
197 { linear_gradproc , false },
198 { radial_gradproc , false },
199 { sweep_gradproc , true }, // sweep is funky in that it always pretends to be kClamp.
200 { conical_gradproc, false },
201 };
202
203 static const SkColor gC_00[] = { 0xff000000, 0xff000000 };
204 static const SkColor gC_01[] = { 0xff000000, 0xffffffff };
205 static const SkColor gC_11[] = { 0xffffffff, 0xffffffff };
206 static const SkColor gC_001[] = { 0xff000000, 0xff000000, 0xffffffff };
207 static const SkColor gC_011[] = { 0xff000000, 0xffffffff, 0xffffffff };
208 static const SkColor gC_0011[] = { 0xff000000, 0xff000000, 0xffffffff, 0xffffffff };
209
210 static const SkScalar gP_01[] = { 0, 1 };
211 static const SkScalar gP_001[] = { 0, 0, 1 };
212 static const SkScalar gP_011[] = { 0, 1, 1 };
213 static const SkScalar gP_0x1[] = { 0, .5f, 1 };
214 static const SkScalar gP_0011[] = { 0, 0, 1, 1 };
215
216 static const SkPoint gPts[] = { {0, 0}, {1, 1} };
217 static const SkScalar gRadii[] = { 1, 2 };
218
219 static const struct {
220 const SkColor* fCol;
221 const SkScalar* fPos;
222 int fCount;
223
224 const SkColor* fExpectedCol;
225 const SkScalar* fExpectedPos;
226 int fExpectedCount;
227 bool fRequiresNonClamp;
228 } gTests[] = {
229 { gC_001, gP_001, 3, gC_01, gP_01, 2, false },
230 { gC_001, gP_011, 3, gC_00, gP_01, 2, true },
231 { gC_001, gP_0x1, 3, gC_001, gP_0x1, 3, false },
232 { gC_001, nullptr, 3, gC_001, gP_0x1, 3, false },
233
234 { gC_011, gP_001, 3, gC_11, gP_01, 2, true },
235 { gC_011, gP_011, 3, gC_01, gP_01, 2, false },
236 { gC_011, gP_0x1, 3, gC_011, gP_0x1, 3, false },
237 { gC_011, nullptr, 3, gC_011, gP_0x1, 3, false },
238
239 { gC_0011, gP_0011, 4, gC_0011, gP_0011, 4, false },
240 };
241
242 const SkShader::TileMode modes[] = {
243 SkShader::kClamp_TileMode, SkShader::kRepeat_TileMode, SkShader::kMirror_TileMode,
244 // TODO: add kDecal_TileMode when it is implemented
245 };
246 for (size_t i = 0; i < SK_ARRAY_COUNT(gProcInfo); ++i) {
247 for (auto mode : modes) {
248 if (gProcInfo[i].fIsClampRestricted && mode != SkShader::kClamp_TileMode) {
249 continue;
250 }
251
252 for (size_t t = 0; t < SK_ARRAY_COUNT(gTests); ++t) {
253 GradRec rec;
254 rec.fColorCount = gTests[t].fCount;
255 rec.fColors = gTests[t].fCol;
256 rec.fPos = gTests[t].fPos;
257 rec.fTileMode = static_cast<SkShader::TileMode>(mode);
258 rec.fPoint = gPts;
259 rec.fRadius = gRadii;
260
261 GradRec expected = rec;
262 if (!gTests[t].fRequiresNonClamp || mode != SkShader::kClamp_TileMode) {
263 expected.fColorCount = gTests[t].fExpectedCount;
264 expected.fColors = gTests[t].fExpectedCol;
265 expected.fPos = gTests[t].fExpectedPos;
266 }
267
268 gProcInfo[i].fProc(reporter, rec, expected);
269 }
270 }
271 }
272 }
273
test_nearly_vertical(skiatest::Reporter * reporter)274 static void test_nearly_vertical(skiatest::Reporter* reporter) {
275 auto surface(SkSurface::MakeRasterN32Premul(200, 200));
276
277 const SkPoint pts[] = {{ 100, 50 }, { 100.0001f, 50000 }};
278 const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
279 const SkScalar pos[] = { 0, 1 };
280 SkPaint paint;
281 paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
282
283 surface->getCanvas()->drawPaint(paint);
284 }
285
test_vertical(skiatest::Reporter * reporter)286 static void test_vertical(skiatest::Reporter* reporter) {
287 auto surface(SkSurface::MakeRasterN32Premul(200, 200));
288
289 const SkPoint pts[] = {{ 100, 50 }, { 100, 50 }};
290 const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE };
291 const SkScalar pos[] = { 0, 1 };
292 SkPaint paint;
293 paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 2, SkShader::kClamp_TileMode));
294
295 surface->getCanvas()->drawPaint(paint);
296 }
297
298 // A linear gradient interval can, due to numerical imprecision (likely in the divide)
299 // finish an interval with the final fx not landing outside of [p0...p1].
300 // The old code had an assert which this test triggered.
301 // We now explicitly clamp the resulting fx value.
test_linear_fuzz(skiatest::Reporter * reporter)302 static void test_linear_fuzz(skiatest::Reporter* reporter) {
303 auto surface(SkSurface::MakeRasterN32Premul(1300, 630));
304
305 const SkPoint pts[] = {{ 179.5f, -179.5f }, { 1074.5f, 715.5f }};
306 const SkColor colors[] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorBLACK, SK_ColorWHITE };
307 const SkScalar pos[] = {0, 0.200000003f, 0.800000012f, 1 };
308
309 SkPaint paint;
310 paint.setShader(SkGradientShader::MakeLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode));
311
312 SkRect r = {0, 83, 1254, 620};
313 surface->getCanvas()->drawRect(r, paint);
314 }
315
316 // https://bugs.chromium.org/p/skia/issues/detail?id=5023
317 // We should still shade pixels for which the radius is exactly 0.
test_two_point_conical_zero_radius(skiatest::Reporter * reporter)318 static void test_two_point_conical_zero_radius(skiatest::Reporter* reporter) {
319 auto surface(SkSurface::MakeRasterN32Premul(5, 5));
320 surface->getCanvas()->clear(SK_ColorRED);
321
322 const SkColor colors[] = { SK_ColorGREEN, SK_ColorBLUE };
323 SkPaint p;
324 p.setShader(SkGradientShader::MakeTwoPointConical(
325 SkPoint::Make(2.5f, 2.5f), 0,
326 SkPoint::Make(3.0f, 3.0f), 10,
327 colors, nullptr, SK_ARRAY_COUNT(colors), SkShader::kClamp_TileMode));
328 surface->getCanvas()->drawPaint(p);
329
330 // r == 0 for the center pixel.
331 // verify that we draw it (no red bleed)
332 SkPMColor centerPMColor;
333 surface->readPixels(SkImageInfo::MakeN32Premul(1, 1), ¢erPMColor, sizeof(SkPMColor), 2, 2);
334 REPORTER_ASSERT(reporter, SkGetPackedR32(centerPMColor) == 0);
335 }
336
337 // http://crbug.com/599458
test_clamping_overflow(skiatest::Reporter *)338 static void test_clamping_overflow(skiatest::Reporter*) {
339 SkPaint p;
340 const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
341 const SkPoint pts1[] = { SkPoint::Make(1001, 1000001), SkPoint::Make(1000.99f, 1000000) };
342
343 p.setShader(SkGradientShader::MakeLinear(pts1, colors, nullptr, 2, SkShader::kClamp_TileMode));
344
345 sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
346 surface->getCanvas()->scale(100, 100);
347 surface->getCanvas()->drawPaint(p);
348
349 const SkPoint pts2[] = { SkPoint::Make(10000.99f, 1000000), SkPoint::Make(10001, 1000001) };
350 p.setShader(SkGradientShader::MakeLinear(pts2, colors, nullptr, 2, SkShader::kClamp_TileMode));
351 surface->getCanvas()->drawPaint(p);
352
353 // Passes if we don't trigger asserts.
354 }
355
356 // http://crbug.com/636194
test_degenerate_linear(skiatest::Reporter *)357 static void test_degenerate_linear(skiatest::Reporter*) {
358 SkPaint p;
359 const SkColor colors[] = { SK_ColorRED, SK_ColorGREEN };
360 const SkPoint pts[] = {
361 SkPoint::Make(-46058024627067344430605278824628224.0f, 0),
362 SkPoint::Make(SK_ScalarMax, 0)
363 };
364
365 p.setShader(SkGradientShader::MakeLinear(pts, colors, nullptr, 2, SkShader::kClamp_TileMode));
366 sk_sp<SkSurface> surface(SkSurface::MakeRasterN32Premul(50, 50));
367 surface->getCanvas()->drawPaint(p);
368
369 // Passes if we don't trigger asserts.
370 }
371
372 // "Interesting" fuzzer values.
test_linear_fuzzer(skiatest::Reporter *)373 static void test_linear_fuzzer(skiatest::Reporter*) {
374 static const SkColor gColors0[] = { 0x30303030, 0x30303030 };
375 static const SkColor gColors1[] = { 0x30303030, 0x30303030, 0x30303030 };
376
377 static const SkScalar gPos1[] = { 0, 0, 1 };
378
379 static const SkScalar gMatrix0[9] = {
380 6.40969056e-10f, 0 , 6.40969056e-10f,
381 0 , 4.42539023e-39f, 6.40969056e-10f,
382 0 , 0 , 1
383 };
384 static const SkScalar gMatrix1[9] = {
385 -2.75294113f , 6.40969056e-10f, 6.40969056e-10f,
386 6.40969056e-10f, 6.40969056e-10f, -3.32810161e+24f,
387 6.40969056e-10f, 6.40969056e-10f, 0
388 };
389 static const SkScalar gMatrix2[9] = {
390 7.93481258e+17f, 6.40969056e-10f, 6.40969056e-10f,
391 6.40969056e-10f, 6.40969056e-10f, 6.40969056e-10f,
392 6.40969056e-10f, 6.40969056e-10f, 0.688235283f
393 };
394 static const SkScalar gMatrix3[9] = {
395 1.89180674e+11f, 6.40969056e-10f, 6.40969056e-10f,
396 6.40969056e-10f, 6.40969056e-10f, 6.40969056e-10f,
397 6.40969056e-10f, 11276.0469f , 8.12524808e+20f
398 };
399
400 static const struct {
401 SkPoint fPts[2];
402 const SkColor* fColors;
403 const SkScalar* fPos;
404 int fCount;
405 SkShader::TileMode fTileMode;
406 uint32_t fFlags;
407 const SkScalar* fLocalMatrix;
408 const SkScalar* fGlobalMatrix;
409 } gConfigs[] = {
410 {
411 {{0, -2.752941f}, {0, 0}},
412 gColors0,
413 nullptr,
414 SK_ARRAY_COUNT(gColors0),
415 SkShader::kClamp_TileMode,
416 0,
417 gMatrix0,
418 nullptr
419 },
420 {
421 {{4.42539023e-39f, -4.42539023e-39f}, {9.78041162e-15f, 4.42539023e-39f}},
422 gColors1,
423 gPos1,
424 SK_ARRAY_COUNT(gColors1),
425 SkShader::kClamp_TileMode,
426 0,
427 nullptr,
428 gMatrix1
429 },
430 {
431 {{4.42539023e-39f, 6.40969056e-10f}, {6.40969056e-10f, 1.49237238e-19f}},
432 gColors1,
433 gPos1,
434 SK_ARRAY_COUNT(gColors1),
435 SkShader::kClamp_TileMode,
436 0,
437 nullptr,
438 gMatrix2
439 },
440 {
441 {{6.40969056e-10f, 6.40969056e-10f}, {6.40969056e-10f, -0.688235283f}},
442 gColors0,
443 nullptr,
444 SK_ARRAY_COUNT(gColors0),
445 SkShader::kClamp_TileMode,
446 0,
447 gMatrix3,
448 nullptr
449 },
450 };
451
452 sk_sp<SkColorSpace> srgb = SkColorSpace::MakeSRGB();
453 SkColorSpace* colorSpaces[] = {
454 nullptr, // hits the legacy gradient impl
455 srgb.get(), // triggers 4f/raster-pipeline
456 };
457
458 SkPaint paint;
459
460 for (auto colorSpace : colorSpaces) {
461
462 sk_sp<SkSurface> surface = SkSurface::MakeRaster(SkImageInfo::Make(100, 100,
463 kN32_SkColorType,
464 kPremul_SkAlphaType,
465 sk_ref_sp(colorSpace)));
466 SkCanvas* canvas = surface->getCanvas();
467
468 for (const auto& config : gConfigs) {
469 SkAutoCanvasRestore acr(canvas, false);
470 SkTLazy<SkMatrix> localMatrix;
471 if (config.fLocalMatrix) {
472 localMatrix.init();
473 localMatrix.get()->set9(config.fLocalMatrix);
474 }
475
476 paint.setShader(SkGradientShader::MakeLinear(config.fPts,
477 config.fColors,
478 config.fPos,
479 config.fCount,
480 config.fTileMode,
481 config.fFlags,
482 localMatrix.getMaybeNull()));
483 if (config.fGlobalMatrix) {
484 SkMatrix m;
485 m.set9(config.fGlobalMatrix);
486 canvas->save();
487 canvas->concat(m);
488 }
489
490 canvas->drawPaint(paint);
491 }
492 }
493 }
494
test_sweep_fuzzer(skiatest::Reporter *)495 static void test_sweep_fuzzer(skiatest::Reporter*) {
496 static const SkColor gColors0[] = { 0x30303030, 0x30303030, 0x30303030 };
497 static const SkScalar gPos0[] = { -47919293023455565225163489280.0f, 0, 1 };
498 static const SkScalar gMatrix0[9] = {
499 1.12116716e-13f, 0 , 8.50489682e+16f,
500 4.1917041e-41f , 3.51369881e-23f, -2.54344271e-26f,
501 9.61111907e+17f, -3.35263808e-29f, -1.35659403e+14f
502 };
503 static const struct {
504 SkPoint fCenter;
505 const SkColor* fColors;
506 const SkScalar* fPos;
507 int fCount;
508 const SkScalar* fGlobalMatrix;
509 } gConfigs[] = {
510 {
511 { 0, 0 },
512 gColors0,
513 gPos0,
514 SK_ARRAY_COUNT(gColors0),
515 gMatrix0
516 },
517 };
518
519 sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(100, 100);
520 SkCanvas* canvas = surface->getCanvas();
521 SkPaint paint;
522
523 for (const auto& config : gConfigs) {
524 paint.setShader(SkGradientShader::MakeSweep(config.fCenter.x(),
525 config.fCenter.y(),
526 config.fColors,
527 config.fPos,
528 config.fCount));
529
530 SkAutoCanvasRestore acr(canvas, false);
531 if (config.fGlobalMatrix) {
532 SkMatrix m;
533 m.set9(config.fGlobalMatrix);
534 canvas->save();
535 canvas->concat(m);
536 }
537 canvas->drawPaint(paint);
538 }
539 }
540
DEF_TEST(Gradient,reporter)541 DEF_TEST(Gradient, reporter) {
542 TestGradientShaders(reporter);
543 TestGradientOptimization(reporter);
544 TestConstantGradient(reporter);
545 test_big_grad(reporter);
546 test_nearly_vertical(reporter);
547 test_vertical(reporter);
548 test_linear_fuzz(reporter);
549 test_two_point_conical_zero_radius(reporter);
550 test_clamping_overflow(reporter);
551 test_degenerate_linear(reporter);
552 test_linear_fuzzer(reporter);
553 test_sweep_fuzzer(reporter);
554 }
555