Text blob run paints should be filtered.

src/core/SkDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDevice.h"
 #include "SkDeviceProperties.h"
 #include "SkDraw.h"
+#include "SkDrawFilter.h"
 #include "SkMetaData.h"
 #include "SkPatchUtils.h"
 #include "SkPathMeasure.h"
 #include "SkRasterClip.h"
 #include "SkShader.h"
 #include "SkTextBlob.h"
 #include "SkTextToPathIter.h"
 
 SkBaseDevice::SkBaseDevice()
     : fLeakyProperties(SkNEW_ARGS(SkDeviceProperties, (SkDeviceProperties::kLegacyLCD_InitType)))
@@ skipping 93 matching lines @@
     // It automatically adjusts lodX and lodY in case it exceeds the number of indices.
     // If it fails to generate the vertices, then we do not draw. 
     if (SkPatchUtils::getVertexData(&data, cubics, colors, texCoords, lod.width(), lod.height())) {
         this->drawVertices(draw, SkCanvas::kTriangles_VertexMode, data.fVertexCount, data.fPoints,
                            data.fTexCoords, data.fColors, xmode, data.fIndices, data.fIndexCount,
                            paint);
     }
 }
 
 void SkBaseDevice::drawTextBlob(const SkDraw& draw, const SkTextBlob* blob, SkScalar x, SkScalar y,
-                                const SkPaint &paint) {
+                                const SkPaint &paint, SkDrawFilter* drawFilter) {
 
     SkPaint runPaint = paint;
 
     SkTextBlob::RunIterator it(blob);
-    while (!it.done()) {
+    for (;!it.done(); it.next()) {
         size_t textLen = it.glyphCount() * sizeof(uint16_t);
         const SkPoint& offset = it.offset();
         // applyFontToPaint() always overwrites the exact same attributes,
-        // so it is safe to not re-seed the paint.
+        // so it is safe to not re-seed the paint for this reason.
         it.applyFontToPaint(&runPaint);
+
+        if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) {
+            // A false return from filter() means we should abort the current draw.
+            runPaint = paint;
+            continue;
+        }
+
         runPaint.setFlags(this->filterTextFlags(runPaint));
 
         switch (it.positioning()) {
         case SkTextBlob::kDefault_Positioning:
             this->drawText(draw, it.glyphs(), textLen, x + offset.x(), y + offset.y(), runPaint);
             break;
         case SkTextBlob::kHorizontal_Positioning:
             this->drawPosText(draw, it.glyphs(), textLen, it.pos(), 1,
                               SkPoint::Make(x, y + offset.y()), runPaint);
             break;
         case SkTextBlob::kFull_Positioning:
             this->drawPosText(draw, it.glyphs(), textLen, it.pos(), 2,
                               SkPoint::Make(x, y), runPaint);
             break;
         default:
             SkFAIL("unhandled positioning mode");
         }
 
-        it.next();
+        if (drawFilter) {
+            // A draw filter may change the paint arbitrarily, so we must re-seed in this case.
+            runPaint = paint;
+        }
     }
 }
 
 bool SkBaseDevice::readPixels(const SkImageInfo& info, void* dstP, size_t rowBytes, int x, int y) {
 #ifdef SK_DEBUG
     SkASSERT(info.width() > 0 && info.height() > 0);
     SkASSERT(dstP);
     SkASSERT(rowBytes >= info.minRowBytes());
     SkASSERT(x >= 0 && y >= 0);
 
@@ skipping 184 matching lines @@
     if (kUnknown_SkPixelGeometry == fLeakyProperties->pixelGeometry()
         || this->onShouldDisableLCD(paint)) {
 
         flags &= ~SkPaint::kLCDRenderText_Flag;
         flags |= SkPaint::kGenA8FromLCD_Flag;
     }
 
     return flags;
 }