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 "SkDevice.h"
9 #include "SkColorFilter.h"
10 #include "SkDraw.h"
11 #include "SkDrawFilter.h"
12 #include "SkImageCacherator.h"
13 #include "SkImageFilter.h"
14 #include "SkImageFilterCache.h"
15 #include "SkImagePriv.h"
16 #include "SkImage_Base.h"
17 #include "SkLatticeIter.h"
18 #include "SkPatchUtils.h"
19 #include "SkPathMeasure.h"
20 #include "SkPathPriv.h"
21 #include "SkRSXform.h"
22 #include "SkRasterClip.h"
23 #include "SkShader.h"
24 #include "SkSpecialImage.h"
25 #include "SkTLazy.h"
26 #include "SkTextBlobRunIterator.h"
27 #include "SkTextToPathIter.h"
28 #include "SkVertices.h"
29
SkBaseDevice(const SkImageInfo & info,const SkSurfaceProps & surfaceProps)30 SkBaseDevice::SkBaseDevice(const SkImageInfo& info, const SkSurfaceProps& surfaceProps)
31 : fInfo(info)
32 , fSurfaceProps(surfaceProps)
33 {
34 fOrigin.setZero();
35 fCTM.reset();
36 }
37
setOrigin(const SkMatrix & globalCTM,int x,int y)38 void SkBaseDevice::setOrigin(const SkMatrix& globalCTM, int x, int y) {
39 fOrigin.set(x, y);
40 fCTM = globalCTM;
41 fCTM.postTranslate(SkIntToScalar(-x), SkIntToScalar(-y));
42 }
43
setGlobalCTM(const SkMatrix & ctm)44 void SkBaseDevice::setGlobalCTM(const SkMatrix& ctm) {
45 fCTM = ctm;
46 if (fOrigin.fX | fOrigin.fY) {
47 fCTM.postTranslate(-SkIntToScalar(fOrigin.fX), -SkIntToScalar(fOrigin.fY));
48 }
49 }
50
clipIsWideOpen() const51 bool SkBaseDevice::clipIsWideOpen() const {
52 if (kRect_ClipType == this->onGetClipType()) {
53 SkRegion rgn;
54 this->onAsRgnClip(&rgn);
55 SkASSERT(rgn.isRect());
56 return rgn.getBounds() == SkIRect::MakeWH(this->width(), this->height());
57 } else {
58 return false;
59 }
60 }
61
AdjustGeometry(const SkImageInfo & info,TileUsage tileUsage,SkPixelGeometry geo,bool preserveLCDText)62 SkPixelGeometry SkBaseDevice::CreateInfo::AdjustGeometry(const SkImageInfo& info,
63 TileUsage tileUsage,
64 SkPixelGeometry geo,
65 bool preserveLCDText) {
66 switch (tileUsage) {
67 case kPossible_TileUsage:
68 // (we think) for compatibility with old clients, we assume this layer can support LCD
69 // even though they may not have marked it as opaque... seems like we should update
70 // our callers (reed/robertphilips).
71 break;
72 case kNever_TileUsage:
73 if (!preserveLCDText) {
74 geo = kUnknown_SkPixelGeometry;
75 }
76 break;
77 }
78 return geo;
79 }
80
is_int(float x)81 static inline bool is_int(float x) {
82 return x == (float) sk_float_round2int(x);
83 }
84
drawRegion(const SkRegion & region,const SkPaint & paint)85 void SkBaseDevice::drawRegion(const SkRegion& region, const SkPaint& paint) {
86 const SkMatrix& ctm = this->ctm();
87 bool isNonTranslate = ctm.getType() & ~(SkMatrix::kTranslate_Mask);
88 bool complexPaint = paint.getStyle() != SkPaint::kFill_Style || paint.getMaskFilter() ||
89 paint.getPathEffect();
90 bool antiAlias = paint.isAntiAlias() && (!is_int(ctm.getTranslateX()) ||
91 !is_int(ctm.getTranslateY()));
92 if (isNonTranslate || complexPaint || antiAlias) {
93 SkPath path;
94 region.getBoundaryPath(&path);
95 return this->drawPath(path, paint, nullptr, false);
96 }
97
98 SkRegion::Iterator it(region);
99 while (!it.done()) {
100 this->drawRect(SkRect::Make(it.rect()), paint);
101 it.next();
102 }
103 }
104
drawArc(const SkRect & oval,SkScalar startAngle,SkScalar sweepAngle,bool useCenter,const SkPaint & paint)105 void SkBaseDevice::drawArc(const SkRect& oval, SkScalar startAngle,
106 SkScalar sweepAngle, bool useCenter, const SkPaint& paint) {
107 SkPath path;
108 bool isFillNoPathEffect = SkPaint::kFill_Style == paint.getStyle() && !paint.getPathEffect();
109 SkPathPriv::CreateDrawArcPath(&path, oval, startAngle, sweepAngle, useCenter,
110 isFillNoPathEffect);
111 this->drawPath(path, paint);
112 }
113
drawDRRect(const SkRRect & outer,const SkRRect & inner,const SkPaint & paint)114 void SkBaseDevice::drawDRRect(const SkRRect& outer,
115 const SkRRect& inner, const SkPaint& paint) {
116 SkPath path;
117 path.addRRect(outer);
118 path.addRRect(inner);
119 path.setFillType(SkPath::kEvenOdd_FillType);
120 path.setIsVolatile(true);
121
122 const SkMatrix* preMatrix = nullptr;
123 const bool pathIsMutable = true;
124 this->drawPath(path, paint, preMatrix, pathIsMutable);
125 }
126
drawPatch(const SkPoint cubics[12],const SkColor colors[4],const SkPoint texCoords[4],SkBlendMode bmode,const SkPaint & paint)127 void SkBaseDevice::drawPatch(const SkPoint cubics[12], const SkColor colors[4],
128 const SkPoint texCoords[4], SkBlendMode bmode, const SkPaint& paint) {
129 SkPatchUtils::VertexData data;
130
131 SkISize lod = SkPatchUtils::GetLevelOfDetail(cubics, &this->ctm());
132 auto vertices = SkPatchUtils::MakeVertices(cubics, colors, texCoords, lod.width(), lod.height());
133 if (vertices) {
134 this->drawVertices(vertices.get(), bmode, paint);
135 }
136 }
137
drawTextBlob(const SkTextBlob * blob,SkScalar x,SkScalar y,const SkPaint & paint,SkDrawFilter * drawFilter)138 void SkBaseDevice::drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
139 const SkPaint &paint, SkDrawFilter* drawFilter) {
140
141 SkPaint runPaint = paint;
142
143 SkTextBlobRunIterator it(blob);
144 for (;!it.done(); it.next()) {
145 size_t textLen = it.glyphCount() * sizeof(uint16_t);
146 const SkPoint& offset = it.offset();
147 // applyFontToPaint() always overwrites the exact same attributes,
148 // so it is safe to not re-seed the paint for this reason.
149 it.applyFontToPaint(&runPaint);
150
151 if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) {
152 // A false return from filter() means we should abort the current draw.
153 runPaint = paint;
154 continue;
155 }
156
157 runPaint.setFlags(this->filterTextFlags(runPaint));
158
159 switch (it.positioning()) {
160 case SkTextBlob::kDefault_Positioning:
161 this->drawText(it.glyphs(), textLen, x + offset.x(), y + offset.y(), runPaint);
162 break;
163 case SkTextBlob::kHorizontal_Positioning:
164 this->drawPosText(it.glyphs(), textLen, it.pos(), 1,
165 SkPoint::Make(x, y + offset.y()), runPaint);
166 break;
167 case SkTextBlob::kFull_Positioning:
168 this->drawPosText(it.glyphs(), textLen, it.pos(), 2,
169 SkPoint::Make(x, y), runPaint);
170 break;
171 default:
172 SkFAIL("unhandled positioning mode");
173 }
174
175 if (drawFilter) {
176 // A draw filter may change the paint arbitrarily, so we must re-seed in this case.
177 runPaint = paint;
178 }
179 }
180 }
181
drawImage(const SkImage * image,SkScalar x,SkScalar y,const SkPaint & paint)182 void SkBaseDevice::drawImage(const SkImage* image, SkScalar x, SkScalar y,
183 const SkPaint& paint) {
184 SkBitmap bm;
185 if (as_IB(image)->getROPixels(&bm, this->imageInfo().colorSpace())) {
186 this->drawBitmap(bm, SkMatrix::MakeTrans(x, y), paint);
187 }
188 }
189
drawImageRect(const SkImage * image,const SkRect * src,const SkRect & dst,const SkPaint & paint,SkCanvas::SrcRectConstraint constraint)190 void SkBaseDevice::drawImageRect(const SkImage* image, const SkRect* src,
191 const SkRect& dst, const SkPaint& paint,
192 SkCanvas::SrcRectConstraint constraint) {
193 SkBitmap bm;
194 if (as_IB(image)->getROPixels(&bm, this->imageInfo().colorSpace())) {
195 this->drawBitmapRect(bm, src, dst, paint, constraint);
196 }
197 }
198
drawImageNine(const SkImage * image,const SkIRect & center,const SkRect & dst,const SkPaint & paint)199 void SkBaseDevice::drawImageNine(const SkImage* image, const SkIRect& center,
200 const SkRect& dst, const SkPaint& paint) {
201 SkLatticeIter iter(image->width(), image->height(), center, dst);
202
203 SkRect srcR, dstR;
204 while (iter.next(&srcR, &dstR)) {
205 this->drawImageRect(image, &srcR, dstR, paint, SkCanvas::kStrict_SrcRectConstraint);
206 }
207 }
208
drawBitmapNine(const SkBitmap & bitmap,const SkIRect & center,const SkRect & dst,const SkPaint & paint)209 void SkBaseDevice::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
210 const SkRect& dst, const SkPaint& paint) {
211 SkLatticeIter iter(bitmap.width(), bitmap.height(), center, dst);
212
213 SkRect srcR, dstR;
214 while (iter.next(&srcR, &dstR)) {
215 this->drawBitmapRect(bitmap, &srcR, dstR, paint, SkCanvas::kStrict_SrcRectConstraint);
216 }
217 }
218
drawImageLattice(const SkImage * image,const SkCanvas::Lattice & lattice,const SkRect & dst,const SkPaint & paint)219 void SkBaseDevice::drawImageLattice(const SkImage* image,
220 const SkCanvas::Lattice& lattice, const SkRect& dst,
221 const SkPaint& paint) {
222 SkLatticeIter iter(lattice, dst);
223
224 SkRect srcR, dstR;
225 while (iter.next(&srcR, &dstR)) {
226 this->drawImageRect(image, &srcR, dstR, paint, SkCanvas::kStrict_SrcRectConstraint);
227 }
228 }
229
drawBitmapLattice(const SkBitmap & bitmap,const SkCanvas::Lattice & lattice,const SkRect & dst,const SkPaint & paint)230 void SkBaseDevice::drawBitmapLattice(const SkBitmap& bitmap,
231 const SkCanvas::Lattice& lattice, const SkRect& dst,
232 const SkPaint& paint) {
233 SkLatticeIter iter(lattice, dst);
234
235 SkRect srcR, dstR;
236 while (iter.next(&srcR, &dstR)) {
237 this->drawBitmapRect(bitmap, &srcR, dstR, paint, SkCanvas::kStrict_SrcRectConstraint);
238 }
239 }
240
drawAtlas(const SkImage * atlas,const SkRSXform xform[],const SkRect tex[],const SkColor colors[],int count,SkBlendMode mode,const SkPaint & paint)241 void SkBaseDevice::drawAtlas(const SkImage* atlas, const SkRSXform xform[],
242 const SkRect tex[], const SkColor colors[], int count,
243 SkBlendMode mode, const SkPaint& paint) {
244 SkPath path;
245 path.setIsVolatile(true);
246
247 for (int i = 0; i < count; ++i) {
248 SkPoint quad[4];
249 xform[i].toQuad(tex[i].width(), tex[i].height(), quad);
250
251 SkMatrix localM;
252 localM.setRSXform(xform[i]);
253 localM.preTranslate(-tex[i].left(), -tex[i].top());
254
255 SkPaint pnt(paint);
256 sk_sp<SkShader> shader = atlas->makeShader(SkShader::kClamp_TileMode,
257 SkShader::kClamp_TileMode,
258 &localM);
259 if (!shader) {
260 break;
261 }
262 pnt.setShader(std::move(shader));
263
264 if (colors) {
265 pnt.setColorFilter(SkColorFilter::MakeModeFilter(colors[i], (SkBlendMode)mode));
266 }
267
268 path.rewind();
269 path.addPoly(quad, 4, true);
270 path.setConvexity(SkPath::kConvex_Convexity);
271 this->drawPath(path, pnt, nullptr, true);
272 }
273 }
274
275 ///////////////////////////////////////////////////////////////////////////////////////////////////
276
drawSpecial(SkSpecialImage *,int x,int y,const SkPaint &)277 void SkBaseDevice::drawSpecial(SkSpecialImage*, int x, int y, const SkPaint&) {}
makeSpecial(const SkBitmap &)278 sk_sp<SkSpecialImage> SkBaseDevice::makeSpecial(const SkBitmap&) { return nullptr; }
makeSpecial(const SkImage *)279 sk_sp<SkSpecialImage> SkBaseDevice::makeSpecial(const SkImage*) { return nullptr; }
snapSpecial()280 sk_sp<SkSpecialImage> SkBaseDevice::snapSpecial() { return nullptr; }
281
282 ///////////////////////////////////////////////////////////////////////////////////////////////////
283
readPixels(const SkImageInfo & info,void * dstP,size_t rowBytes,int x,int y)284 bool SkBaseDevice::readPixels(const SkImageInfo& info, void* dstP, size_t rowBytes, int x, int y) {
285 return this->onReadPixels(info, dstP, rowBytes, x, y);
286 }
287
writePixels(const SkImageInfo & info,const void * pixels,size_t rowBytes,int x,int y)288 bool SkBaseDevice::writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes,
289 int x, int y) {
290 return this->onWritePixels(info, pixels, rowBytes, x, y);
291 }
292
onWritePixels(const SkImageInfo &,const void *,size_t,int,int)293 bool SkBaseDevice::onWritePixels(const SkImageInfo&, const void*, size_t, int, int) {
294 return false;
295 }
296
onReadPixels(const SkImageInfo &,void *,size_t,int x,int y)297 bool SkBaseDevice::onReadPixels(const SkImageInfo&, void*, size_t, int x, int y) {
298 return false;
299 }
300
accessPixels(SkPixmap * pmap)301 bool SkBaseDevice::accessPixels(SkPixmap* pmap) {
302 SkPixmap tempStorage;
303 if (nullptr == pmap) {
304 pmap = &tempStorage;
305 }
306 return this->onAccessPixels(pmap);
307 }
308
peekPixels(SkPixmap * pmap)309 bool SkBaseDevice::peekPixels(SkPixmap* pmap) {
310 SkPixmap tempStorage;
311 if (nullptr == pmap) {
312 pmap = &tempStorage;
313 }
314 return this->onPeekPixels(pmap);
315 }
316
317 //////////////////////////////////////////////////////////////////////////////////////////
318
morphpoints(SkPoint dst[],const SkPoint src[],int count,SkPathMeasure & meas,const SkMatrix & matrix)319 static void morphpoints(SkPoint dst[], const SkPoint src[], int count,
320 SkPathMeasure& meas, const SkMatrix& matrix) {
321 SkMatrix::MapXYProc proc = matrix.getMapXYProc();
322
323 for (int i = 0; i < count; i++) {
324 SkPoint pos;
325 SkVector tangent;
326
327 proc(matrix, src[i].fX, src[i].fY, &pos);
328 SkScalar sx = pos.fX;
329 SkScalar sy = pos.fY;
330
331 if (!meas.getPosTan(sx, &pos, &tangent)) {
332 // set to 0 if the measure failed, so that we just set dst == pos
333 tangent.set(0, 0);
334 }
335
336 /* This is the old way (that explains our approach but is way too slow
337 SkMatrix matrix;
338 SkPoint pt;
339
340 pt.set(sx, sy);
341 matrix.setSinCos(tangent.fY, tangent.fX);
342 matrix.preTranslate(-sx, 0);
343 matrix.postTranslate(pos.fX, pos.fY);
344 matrix.mapPoints(&dst[i], &pt, 1);
345 */
346 dst[i].set(pos.fX - tangent.fY * sy, pos.fY + tangent.fX * sy);
347 }
348 }
349
350 /* TODO
351
352 Need differentially more subdivisions when the follow-path is curvy. Not sure how to
353 determine that, but we need it. I guess a cheap answer is let the caller tell us,
354 but that seems like a cop-out. Another answer is to get Rob Johnson to figure it out.
355 */
morphpath(SkPath * dst,const SkPath & src,SkPathMeasure & meas,const SkMatrix & matrix)356 static void morphpath(SkPath* dst, const SkPath& src, SkPathMeasure& meas,
357 const SkMatrix& matrix) {
358 SkPath::Iter iter(src, false);
359 SkPoint srcP[4], dstP[3];
360 SkPath::Verb verb;
361
362 while ((verb = iter.next(srcP)) != SkPath::kDone_Verb) {
363 switch (verb) {
364 case SkPath::kMove_Verb:
365 morphpoints(dstP, srcP, 1, meas, matrix);
366 dst->moveTo(dstP[0]);
367 break;
368 case SkPath::kLine_Verb:
369 // turn lines into quads to look bendy
370 srcP[0].fX = SkScalarAve(srcP[0].fX, srcP[1].fX);
371 srcP[0].fY = SkScalarAve(srcP[0].fY, srcP[1].fY);
372 morphpoints(dstP, srcP, 2, meas, matrix);
373 dst->quadTo(dstP[0], dstP[1]);
374 break;
375 case SkPath::kQuad_Verb:
376 morphpoints(dstP, &srcP[1], 2, meas, matrix);
377 dst->quadTo(dstP[0], dstP[1]);
378 break;
379 case SkPath::kCubic_Verb:
380 morphpoints(dstP, &srcP[1], 3, meas, matrix);
381 dst->cubicTo(dstP[0], dstP[1], dstP[2]);
382 break;
383 case SkPath::kClose_Verb:
384 dst->close();
385 break;
386 default:
387 SkDEBUGFAIL("unknown verb");
388 break;
389 }
390 }
391 }
392
drawTextOnPath(const void * text,size_t byteLength,const SkPath & follow,const SkMatrix * matrix,const SkPaint & paint)393 void SkBaseDevice::drawTextOnPath(const void* text, size_t byteLength,
394 const SkPath& follow, const SkMatrix* matrix,
395 const SkPaint& paint) {
396 SkASSERT(byteLength == 0 || text != nullptr);
397
398 // nothing to draw
399 if (text == nullptr || byteLength == 0) {
400 return;
401 }
402
403 SkTextToPathIter iter((const char*)text, byteLength, paint, true);
404 SkPathMeasure meas(follow, false);
405 SkScalar hOffset = 0;
406
407 // need to measure first
408 if (paint.getTextAlign() != SkPaint::kLeft_Align) {
409 SkScalar pathLen = meas.getLength();
410 if (paint.getTextAlign() == SkPaint::kCenter_Align) {
411 pathLen = SkScalarHalf(pathLen);
412 }
413 hOffset += pathLen;
414 }
415
416 const SkPath* iterPath;
417 SkScalar xpos;
418 SkMatrix scaledMatrix;
419 SkScalar scale = iter.getPathScale();
420
421 scaledMatrix.setScale(scale, scale);
422
423 while (iter.next(&iterPath, &xpos)) {
424 if (iterPath) {
425 SkPath tmp;
426 SkMatrix m(scaledMatrix);
427
428 tmp.setIsVolatile(true);
429 m.postTranslate(xpos + hOffset, 0);
430 if (matrix) {
431 m.postConcat(*matrix);
432 }
433 morphpath(&tmp, *iterPath, meas, m);
434 this->drawPath(tmp, iter.getPaint(), nullptr, true);
435 }
436 }
437 }
438
439 #include "SkUtils.h"
440 typedef int (*CountTextProc)(const char* text);
count_utf16(const char * text)441 static int count_utf16(const char* text) {
442 const uint16_t* prev = (uint16_t*)text;
443 (void)SkUTF16_NextUnichar(&prev);
444 return SkToInt((const char*)prev - text);
445 }
return_4(const char * text)446 static int return_4(const char* text) { return 4; }
return_2(const char * text)447 static int return_2(const char* text) { return 2; }
448
drawTextRSXform(const void * text,size_t len,const SkRSXform xform[],const SkPaint & paint)449 void SkBaseDevice::drawTextRSXform(const void* text, size_t len,
450 const SkRSXform xform[], const SkPaint& paint) {
451 CountTextProc proc = nullptr;
452 switch (paint.getTextEncoding()) {
453 case SkPaint::kUTF8_TextEncoding:
454 proc = SkUTF8_CountUTF8Bytes;
455 break;
456 case SkPaint::kUTF16_TextEncoding:
457 proc = count_utf16;
458 break;
459 case SkPaint::kUTF32_TextEncoding:
460 proc = return_4;
461 break;
462 case SkPaint::kGlyphID_TextEncoding:
463 proc = return_2;
464 break;
465 }
466
467 SkMatrix localM, currM;
468 const void* stopText = (const char*)text + len;
469 while ((const char*)text < (const char*)stopText) {
470 localM.setRSXform(*xform++);
471 currM.setConcat(this->ctm(), localM);
472 SkAutoDeviceCTMRestore adc(this, currM);
473
474 int subLen = proc((const char*)text);
475 this->drawText(text, subLen, 0, 0, paint);
476 text = (const char*)text + subLen;
477 }
478 }
479
480 //////////////////////////////////////////////////////////////////////////////////////////
481
filterTextFlags(const SkPaint & paint) const482 uint32_t SkBaseDevice::filterTextFlags(const SkPaint& paint) const {
483 uint32_t flags = paint.getFlags();
484
485 if (!paint.isLCDRenderText() || !paint.isAntiAlias()) {
486 return flags;
487 }
488
489 if (kUnknown_SkPixelGeometry == fSurfaceProps.pixelGeometry()
490 || this->onShouldDisableLCD(paint)) {
491
492 flags &= ~SkPaint::kLCDRenderText_Flag;
493 flags |= SkPaint::kGenA8FromLCD_Flag;
494 }
495
496 return flags;
497 }
498
makeSurface(SkImageInfo const &,SkSurfaceProps const &)499 sk_sp<SkSurface> SkBaseDevice::makeSurface(SkImageInfo const&, SkSurfaceProps const&) {
500 return nullptr;
501 }
502
503 //////////////////////////////////////////////////////////////////////////////////////////
504
LogDrawScaleFactor(const SkMatrix & matrix,SkFilterQuality filterQuality)505 void SkBaseDevice::LogDrawScaleFactor(const SkMatrix& matrix, SkFilterQuality filterQuality) {
506 #if SK_HISTOGRAMS_ENABLED
507 enum ScaleFactor {
508 kUpscale_ScaleFactor,
509 kNoScale_ScaleFactor,
510 kDownscale_ScaleFactor,
511 kLargeDownscale_ScaleFactor,
512
513 kLast_ScaleFactor = kLargeDownscale_ScaleFactor
514 };
515
516 float rawScaleFactor = matrix.getMinScale();
517
518 ScaleFactor scaleFactor;
519 if (rawScaleFactor < 0.5f) {
520 scaleFactor = kLargeDownscale_ScaleFactor;
521 } else if (rawScaleFactor < 1.0f) {
522 scaleFactor = kDownscale_ScaleFactor;
523 } else if (rawScaleFactor > 1.0f) {
524 scaleFactor = kUpscale_ScaleFactor;
525 } else {
526 scaleFactor = kNoScale_ScaleFactor;
527 }
528
529 switch (filterQuality) {
530 case kNone_SkFilterQuality:
531 SK_HISTOGRAM_ENUMERATION("DrawScaleFactor.NoneFilterQuality", scaleFactor,
532 kLast_ScaleFactor + 1);
533 break;
534 case kLow_SkFilterQuality:
535 SK_HISTOGRAM_ENUMERATION("DrawScaleFactor.LowFilterQuality", scaleFactor,
536 kLast_ScaleFactor + 1);
537 break;
538 case kMedium_SkFilterQuality:
539 SK_HISTOGRAM_ENUMERATION("DrawScaleFactor.MediumFilterQuality", scaleFactor,
540 kLast_ScaleFactor + 1);
541 break;
542 case kHigh_SkFilterQuality:
543 SK_HISTOGRAM_ENUMERATION("DrawScaleFactor.HighFilterQuality", scaleFactor,
544 kLast_ScaleFactor + 1);
545 break;
546 }
547
548 // Also log filter quality independent scale factor.
549 SK_HISTOGRAM_ENUMERATION("DrawScaleFactor.AnyFilterQuality", scaleFactor,
550 kLast_ScaleFactor + 1);
551
552 // Also log an overall histogram of filter quality.
553 SK_HISTOGRAM_ENUMERATION("FilterQuality", filterQuality, kLast_SkFilterQuality + 1);
554 #endif
555 }
556
557