gfx/skia/patches/archive/skia_restrict_problem.patch@129ffea94266
gfx/skia/patches/archive/skia_restrict_problem.patch
Sat, 03 Jan 2015 20:18:00 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Sat, 03 Jan 2015 20:18:00 +0100
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
- permissions
- -rw-r--r--
Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.
1 diff --git a/gfx/skia/src/effects/SkGradientShader.cpp b/gfx/skia/src/effects/SkGradientShader.cpp
2 --- a/gfx/skia/src/effects/SkGradientShader.cpp
3 +++ b/gfx/skia/src/effects/SkGradientShader.cpp
4 @@ -1184,116 +1184,17 @@ public:
5 {
6 // make sure our table is insync with our current #define for kSQRT_TABLE_SIZE
7 SkASSERT(sizeof(gSqrt8Table) == kSQRT_TABLE_SIZE);
9 rad_to_unit_matrix(center, radius, &fPtsToUnit);
10 }
12 virtual void shadeSpan(int x, int y, SkPMColor* dstC, int count) SK_OVERRIDE;
13 - virtual void shadeSpan16(int x, int y, uint16_t* SK_RESTRICT dstC, int count) SK_OVERRIDE {
14 - SkASSERT(count > 0);
15 -
16 - SkPoint srcPt;
17 - SkMatrix::MapXYProc dstProc = fDstToIndexProc;
18 - TileProc proc = fTileProc;
19 - const uint16_t* SK_RESTRICT cache = this->getCache16();
20 - int toggle = ((x ^ y) & 1) << kCache16Bits;
21 -
22 - if (fDstToIndexClass != kPerspective_MatrixClass) {
23 - dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
24 - SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
25 - SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
26 - SkFixed dy, fy = SkScalarToFixed(srcPt.fY);
27 -
28 - if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
29 - SkFixed storage[2];
30 - (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &storage[0], &storage[1]);
31 - dx = storage[0];
32 - dy = storage[1];
33 - } else {
34 - SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
35 - dx = SkScalarToFixed(fDstToIndex.getScaleX());
36 - dy = SkScalarToFixed(fDstToIndex.getSkewY());
37 - }
38 -
39 - if (proc == clamp_tileproc) {
40 - const uint8_t* SK_RESTRICT sqrt_table = gSqrt8Table;
41 -
42 - /* knock these down so we can pin against +- 0x7FFF, which is an immediate load,
43 - rather than 0xFFFF which is slower. This is a compromise, since it reduces our
44 - precision, but that appears to be visually OK. If we decide this is OK for
45 - all of our cases, we could (it seems) put this scale-down into fDstToIndex,
46 - to avoid having to do these extra shifts each time.
47 - */
48 - fx >>= 1;
49 - dx >>= 1;
50 - fy >>= 1;
51 - dy >>= 1;
52 - if (dy == 0) { // might perform this check for the other modes, but the win will be a smaller % of the total
53 - fy = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
54 - fy *= fy;
55 - do {
56 - unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
57 - unsigned fi = (xx * xx + fy) >> (14 + 16 - kSQRT_TABLE_BITS);
58 - fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
59 - fx += dx;
60 - *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
61 - toggle ^= (1 << kCache16Bits);
62 - } while (--count != 0);
63 - } else {
64 - do {
65 - unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
66 - unsigned fi = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
67 - fi = (xx * xx + fi * fi) >> (14 + 16 - kSQRT_TABLE_BITS);
68 - fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
69 - fx += dx;
70 - fy += dy;
71 - *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
72 - toggle ^= (1 << kCache16Bits);
73 - } while (--count != 0);
74 - }
75 - } else if (proc == mirror_tileproc) {
76 - do {
77 - SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
78 - unsigned fi = mirror_tileproc(dist);
79 - SkASSERT(fi <= 0xFFFF);
80 - fx += dx;
81 - fy += dy;
82 - *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
83 - toggle ^= (1 << kCache16Bits);
84 - } while (--count != 0);
85 - } else {
86 - SkASSERT(proc == repeat_tileproc);
87 - do {
88 - SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
89 - unsigned fi = repeat_tileproc(dist);
90 - SkASSERT(fi <= 0xFFFF);
91 - fx += dx;
92 - fy += dy;
93 - *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
94 - toggle ^= (1 << kCache16Bits);
95 - } while (--count != 0);
96 - }
97 - } else { // perspective case
98 - SkScalar dstX = SkIntToScalar(x);
99 - SkScalar dstY = SkIntToScalar(y);
100 - do {
101 - dstProc(fDstToIndex, dstX, dstY, &srcPt);
102 - unsigned fi = proc(SkScalarToFixed(srcPt.length()));
103 - SkASSERT(fi <= 0xFFFF);
104 -
105 - int index = fi >> (16 - kCache16Bits);
106 - *dstC++ = cache[toggle + index];
107 - toggle ^= (1 << kCache16Bits);
108 -
109 - dstX += SK_Scalar1;
110 - } while (--count != 0);
111 - }
112 - }
113 + virtual void shadeSpan16(int x, int y, uint16_t* dstC, int count) SK_OVERRIDE;
115 virtual BitmapType asABitmap(SkBitmap* bitmap,
116 SkMatrix* matrix,
117 TileMode* xy,
118 SkScalar* twoPointRadialParams) const SK_OVERRIDE {
119 if (bitmap) {
120 this->commonAsABitmap(bitmap);
121 }
122 @@ -1507,16 +1408,117 @@ void Radial_Gradient::shadeSpan(int x, i
123 unsigned fi = proc(SkScalarToFixed(srcPt.length()));
124 SkASSERT(fi <= 0xFFFF);
125 *dstC++ = cache[fi >> (16 - kCache32Bits)];
126 dstX += SK_Scalar1;
127 } while (--count != 0);
128 }
129 }
131 +void Radial_Gradient::shadeSpan16(int x, int y, uint16_t* SK_RESTRICT dstC, int count) {
132 + SkASSERT(count > 0);
133 +
134 + SkPoint srcPt;
135 + SkMatrix::MapXYProc dstProc = fDstToIndexProc;
136 + TileProc proc = fTileProc;
137 + const uint16_t* SK_RESTRICT cache = this->getCache16();
138 + int toggle = ((x ^ y) & 1) << kCache16Bits;
139 +
140 + if (fDstToIndexClass != kPerspective_MatrixClass) {
141 + dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
142 + SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
143 + SkFixed dx, fx = SkScalarToFixed(srcPt.fX);
144 + SkFixed dy, fy = SkScalarToFixed(srcPt.fY);
145 +
146 + if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
147 + SkFixed storage[2];
148 + (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &storage[0], &storage[1]);
149 + dx = storage[0];
150 + dy = storage[1];
151 + } else {
152 + SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
153 + dx = SkScalarToFixed(fDstToIndex.getScaleX());
154 + dy = SkScalarToFixed(fDstToIndex.getSkewY());
155 + }
156 +
157 + if (proc == clamp_tileproc) {
158 + const uint8_t* SK_RESTRICT sqrt_table = gSqrt8Table;
159 +
160 + /* knock these down so we can pin against +- 0x7FFF, which is an immediate load,
161 + rather than 0xFFFF which is slower. This is a compromise, since it reduces our
162 + precision, but that appears to be visually OK. If we decide this is OK for
163 + all of our cases, we could (it seems) put this scale-down into fDstToIndex,
164 + to avoid having to do these extra shifts each time.
165 + */
166 + fx >>= 1;
167 + dx >>= 1;
168 + fy >>= 1;
169 + dy >>= 1;
170 + if (dy == 0) { // might perform this check for the other modes, but the win will be a smaller % of the total
171 + fy = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
172 + fy *= fy;
173 + do {
174 + unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
175 + unsigned fi = (xx * xx + fy) >> (14 + 16 - kSQRT_TABLE_BITS);
176 + fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
177 + fx += dx;
178 + *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
179 + toggle ^= (1 << kCache16Bits);
180 + } while (--count != 0);
181 + } else {
182 + do {
183 + unsigned xx = SkPin32(fx, -0xFFFF >> 1, 0xFFFF >> 1);
184 + unsigned fi = SkPin32(fy, -0xFFFF >> 1, 0xFFFF >> 1);
185 + fi = (xx * xx + fi * fi) >> (14 + 16 - kSQRT_TABLE_BITS);
186 + fi = SkFastMin32(fi, 0xFFFF >> (16 - kSQRT_TABLE_BITS));
187 + fx += dx;
188 + fy += dy;
189 + *dstC++ = cache[toggle + (sqrt_table[fi] >> (8 - kCache16Bits))];
190 + toggle ^= (1 << kCache16Bits);
191 + } while (--count != 0);
192 + }
193 + } else if (proc == mirror_tileproc) {
194 + do {
195 + SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
196 + unsigned fi = mirror_tileproc(dist);
197 + SkASSERT(fi <= 0xFFFF);
198 + fx += dx;
199 + fy += dy;
200 + *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
201 + toggle ^= (1 << kCache16Bits);
202 + } while (--count != 0);
203 + } else {
204 + SkASSERT(proc == repeat_tileproc);
205 + do {
206 + SkFixed dist = SkFixedSqrt(SkFixedSquare(fx) + SkFixedSquare(fy));
207 + unsigned fi = repeat_tileproc(dist);
208 + SkASSERT(fi <= 0xFFFF);
209 + fx += dx;
210 + fy += dy;
211 + *dstC++ = cache[toggle + (fi >> (16 - kCache16Bits))];
212 + toggle ^= (1 << kCache16Bits);
213 + } while (--count != 0);
214 + }
215 + } else { // perspective case
216 + SkScalar dstX = SkIntToScalar(x);
217 + SkScalar dstY = SkIntToScalar(y);
218 + do {
219 + dstProc(fDstToIndex, dstX, dstY, &srcPt);
220 + unsigned fi = proc(SkScalarToFixed(srcPt.length()));
221 + SkASSERT(fi <= 0xFFFF);
222 +
223 + int index = fi >> (16 - kCache16Bits);
224 + *dstC++ = cache[toggle + index];
225 + toggle ^= (1 << kCache16Bits);
226 +
227 + dstX += SK_Scalar1;
228 + } while (--count != 0);
229 + }
230 +}
231 +
232 /* Two-point radial gradients are specified by two circles, each with a center
233 point and radius. The gradient can be considered to be a series of
234 concentric circles, with the color interpolated from the start circle
235 (at t=0) to the end circle (at t=1).
237 For each point (x, y) in the span, we want to find the
238 interpolated circle that intersects that point. The center
239 of the desired circle (Cx, Cy) falls at some distance t
240 @@ -1661,109 +1663,17 @@ public:
241 info->fPoint[0] = fCenter1;
242 info->fPoint[1] = fCenter2;
243 info->fRadius[0] = fRadius1;
244 info->fRadius[1] = fRadius2;
245 }
246 return kRadial2_GradientType;
247 }
249 - virtual void shadeSpan(int x, int y, SkPMColor* SK_RESTRICT dstC, int count) SK_OVERRIDE {
250 - SkASSERT(count > 0);
251 -
252 - // Zero difference between radii: fill with transparent black.
253 - // TODO: Is removing this actually correct? Two circles with the
254 - // same radius, but different centers doesn't sound like it
255 - // should be cleared
256 - if (fDiffRadius == 0 && fCenter1 == fCenter2) {
257 - sk_bzero(dstC, count * sizeof(*dstC));
258 - return;
259 - }
260 - SkMatrix::MapXYProc dstProc = fDstToIndexProc;
261 - TileProc proc = fTileProc;
262 - const SkPMColor* SK_RESTRICT cache = this->getCache32();
263 -
264 - SkScalar foura = fA * 4;
265 - bool posRoot = fDiffRadius < 0;
266 - if (fDstToIndexClass != kPerspective_MatrixClass) {
267 - SkPoint srcPt;
268 - dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
269 - SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
270 - SkScalar dx, fx = srcPt.fX;
271 - SkScalar dy, fy = srcPt.fY;
272 -
273 - if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
274 - SkFixed fixedX, fixedY;
275 - (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY);
276 - dx = SkFixedToScalar(fixedX);
277 - dy = SkFixedToScalar(fixedY);
278 - } else {
279 - SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
280 - dx = fDstToIndex.getScaleX();
281 - dy = fDstToIndex.getSkewY();
282 - }
283 - SkScalar b = (SkScalarMul(fDiff.fX, fx) +
284 - SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
285 - SkScalar db = (SkScalarMul(fDiff.fX, dx) +
286 - SkScalarMul(fDiff.fY, dy)) * 2;
287 - if (proc == clamp_tileproc) {
288 - for (; count > 0; --count) {
289 - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
290 - if (t < 0) {
291 - *dstC++ = cache[-1];
292 - } else if (t > 0xFFFF) {
293 - *dstC++ = cache[kCache32Count * 2];
294 - } else {
295 - SkASSERT(t <= 0xFFFF);
296 - *dstC++ = cache[t >> (16 - kCache32Bits)];
297 - }
298 - fx += dx;
299 - fy += dy;
300 - b += db;
301 - }
302 - } else if (proc == mirror_tileproc) {
303 - for (; count > 0; --count) {
304 - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
305 - SkFixed index = mirror_tileproc(t);
306 - SkASSERT(index <= 0xFFFF);
307 - *dstC++ = cache[index >> (16 - kCache32Bits)];
308 - fx += dx;
309 - fy += dy;
310 - b += db;
311 - }
312 - } else {
313 - SkASSERT(proc == repeat_tileproc);
314 - for (; count > 0; --count) {
315 - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
316 - SkFixed index = repeat_tileproc(t);
317 - SkASSERT(index <= 0xFFFF);
318 - *dstC++ = cache[index >> (16 - kCache32Bits)];
319 - fx += dx;
320 - fy += dy;
321 - b += db;
322 - }
323 - }
324 - } else { // perspective case
325 - SkScalar dstX = SkIntToScalar(x);
326 - SkScalar dstY = SkIntToScalar(y);
327 - for (; count > 0; --count) {
328 - SkPoint srcPt;
329 - dstProc(fDstToIndex, dstX, dstY, &srcPt);
330 - SkScalar fx = srcPt.fX;
331 - SkScalar fy = srcPt.fY;
332 - SkScalar b = (SkScalarMul(fDiff.fX, fx) +
333 - SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
334 - SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
335 - SkFixed index = proc(t);
336 - SkASSERT(index <= 0xFFFF);
337 - *dstC++ = cache[index >> (16 - kCache32Bits)];
338 - dstX += SK_Scalar1;
339 - }
340 - }
341 - }
342 + virtual void shadeSpan(int x, int y, SkPMColor* dstC, int count) SK_OVERRIDE;
344 virtual bool setContext(const SkBitmap& device,
345 const SkPaint& paint,
346 const SkMatrix& matrix) SK_OVERRIDE {
347 if (!this->INHERITED::setContext(device, paint, matrix)) {
348 return false;
349 }
351 @@ -1817,16 +1727,110 @@ private:
352 fA = SkScalarSquare(fDiff.fX) + SkScalarSquare(fDiff.fY) - SK_Scalar1;
353 fOneOverTwoA = fA ? SkScalarInvert(fA * 2) : 0;
355 fPtsToUnit.setTranslate(-fCenter1.fX, -fCenter1.fY);
356 fPtsToUnit.postScale(inv, inv);
357 }
358 };
360 +void Two_Point_Radial_Gradient::shadeSpan(int x, int y, SkPMColor* SK_RESTRICT dstC, int count) {
361 + SkASSERT(count > 0);
362 +
363 + // Zero difference between radii: fill with transparent black.
364 + // TODO: Is removing this actually correct? Two circles with the
365 + // same radius, but different centers doesn't sound like it
366 + // should be cleared
367 + if (fDiffRadius == 0 && fCenter1 == fCenter2) {
368 + sk_bzero(dstC, count * sizeof(*dstC));
369 + return;
370 + }
371 + SkMatrix::MapXYProc dstProc = fDstToIndexProc;
372 + TileProc proc = fTileProc;
373 + const SkPMColor* SK_RESTRICT cache = this->getCache32();
374 +
375 + SkScalar foura = fA * 4;
376 + bool posRoot = fDiffRadius < 0;
377 + if (fDstToIndexClass != kPerspective_MatrixClass) {
378 + SkPoint srcPt;
379 + dstProc(fDstToIndex, SkIntToScalar(x) + SK_ScalarHalf,
380 + SkIntToScalar(y) + SK_ScalarHalf, &srcPt);
381 + SkScalar dx, fx = srcPt.fX;
382 + SkScalar dy, fy = srcPt.fY;
383 +
384 + if (fDstToIndexClass == kFixedStepInX_MatrixClass) {
385 + SkFixed fixedX, fixedY;
386 + (void)fDstToIndex.fixedStepInX(SkIntToScalar(y), &fixedX, &fixedY);
387 + dx = SkFixedToScalar(fixedX);
388 + dy = SkFixedToScalar(fixedY);
389 + } else {
390 + SkASSERT(fDstToIndexClass == kLinear_MatrixClass);
391 + dx = fDstToIndex.getScaleX();
392 + dy = fDstToIndex.getSkewY();
393 + }
394 + SkScalar b = (SkScalarMul(fDiff.fX, fx) +
395 + SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
396 + SkScalar db = (SkScalarMul(fDiff.fX, dx) +
397 + SkScalarMul(fDiff.fY, dy)) * 2;
398 + if (proc == clamp_tileproc) {
399 + for (; count > 0; --count) {
400 + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
401 + if (t < 0) {
402 + *dstC++ = cache[-1];
403 + } else if (t > 0xFFFF) {
404 + *dstC++ = cache[kCache32Count * 2];
405 + } else {
406 + SkASSERT(t <= 0xFFFF);
407 + *dstC++ = cache[t >> (16 - kCache32Bits)];
408 + }
409 + fx += dx;
410 + fy += dy;
411 + b += db;
412 + }
413 + } else if (proc == mirror_tileproc) {
414 + for (; count > 0; --count) {
415 + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
416 + SkFixed index = mirror_tileproc(t);
417 + SkASSERT(index <= 0xFFFF);
418 + *dstC++ = cache[index >> (16 - kCache32Bits)];
419 + fx += dx;
420 + fy += dy;
421 + b += db;
422 + }
423 + } else {
424 + SkASSERT(proc == repeat_tileproc);
425 + for (; count > 0; --count) {
426 + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
427 + SkFixed index = repeat_tileproc(t);
428 + SkASSERT(index <= 0xFFFF);
429 + *dstC++ = cache[index >> (16 - kCache32Bits)];
430 + fx += dx;
431 + fy += dy;
432 + b += db;
433 + }
434 + }
435 + } else { // perspective case
436 + SkScalar dstX = SkIntToScalar(x);
437 + SkScalar dstY = SkIntToScalar(y);
438 + for (; count > 0; --count) {
439 + SkPoint srcPt;
440 + dstProc(fDstToIndex, dstX, dstY, &srcPt);
441 + SkScalar fx = srcPt.fX;
442 + SkScalar fy = srcPt.fY;
443 + SkScalar b = (SkScalarMul(fDiff.fX, fx) +
444 + SkScalarMul(fDiff.fY, fy) - fStartRadius) * 2;
445 + SkFixed t = two_point_radial(b, fx, fy, fSr2D2, foura, fOneOverTwoA, posRoot);
446 + SkFixed index = proc(t);
447 + SkASSERT(index <= 0xFFFF);
448 + *dstC++ = cache[index >> (16 - kCache32Bits)];
449 + dstX += SK_Scalar1;
450 + }
451 + }
452 +}
453 +
454 ///////////////////////////////////////////////////////////////////////////////
456 class Sweep_Gradient : public Gradient_Shader {
457 public:
458 Sweep_Gradient(SkScalar cx, SkScalar cy, const SkColor colors[],
459 const SkScalar pos[], int count, SkUnitMapper* mapper)
460 : Gradient_Shader(colors, pos, count, SkShader::kClamp_TileMode, mapper),
461 fCenter(SkPoint::Make(cx, cy))
