Minor cleanup of GrStencilAndCoverTextContext

src/gpu/text/GrStencilAndCoverTextContext.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrStencilAndCoverTextContext.h"
 #include "GrAtlasTextContext.h"
 #include "GrContext.h"
@@ skipping 65 matching lines @@
                                             const SkPaint& skPaint, const SkMatrix& viewMatrix,
                                             const SkSurfaceProps& props,
                                             const char text[], size_t byteLength,
                                             SkScalar x, SkScalar y, const SkIRect& clipBounds) {
     if (context->abandoned()) {
         return;
     } else if (this->canDraw(skPaint, viewMatrix)) {
         if (skPaint.getTextSize() > 0) {
             TextRun run(skPaint);
             run.setText(text, byteLength, x, y);
-            run.draw(context, dc, paint, clip, paint.getColor(), viewMatrix, props, 0, 0,
+            run.draw(context, dc, paint, clip, viewMatrix, props, 0, 0,
                      clipBounds, fFallbackTextContext, skPaint);
         }
         return;
     } else if (fFallbackTextContext->canDraw(skPaint, viewMatrix, props,
                                              *context->caps()->shaderCaps())) {
         fFallbackTextContext->drawText(context, dc, clip, paint, skPaint, viewMatrix, props, text,
                                        byteLength, x, y, clipBounds);
         return;
     }
 
@@ skipping 13 matching lines @@
                                                const SkScalar pos[],
                                                int scalarsPerPosition,
                                                const SkPoint& offset,
                                                const SkIRect& clipBounds) {
     if (context->abandoned()) {
         return;
     } else if (this->canDraw(skPaint, viewMatrix)) {
         if (skPaint.getTextSize() > 0) {
             TextRun run(skPaint);
             run.setPosText(text, byteLength, pos, scalarsPerPosition, offset);
-            run.draw(context, dc, paint, clip, paint.getColor(), viewMatrix, props, 0, 0,
+            run.draw(context, dc, paint, clip, viewMatrix, props, 0, 0,
                      clipBounds, fFallbackTextContext, skPaint);
         }
         return;
     } else if (fFallbackTextContext->canDraw(skPaint, viewMatrix, props,
                                              *context->caps()->shaderCaps())) {
         fFallbackTextContext->drawPosText(context, dc, clip, paint, skPaint, viewMatrix, props,
                                           text, byteLength, pos,
                                           scalarsPerPosition, offset, clipBounds);
         return;
     }
@@ skipping 88 matching lines @@
 
     GrPaint paint;
     if (!SkPaintToGrPaint(context, skPaint, viewMatrix, dc->isGammaCorrect(), &paint)) {
         return;
     }
 
     const TextBlob& blob = this->findOrCreateTextBlob(skBlob, skPaint);
 
     TextBlob::Iter iter(blob);
     for (TextRun* run = iter.get(); run; run = iter.next()) {
-        run->draw(context, dc, paint, clip, paint.getColor(), viewMatrix, props,  x, y,
+        // The run's "font" overrides the anti-aliasing of the passed in paint!
+        paint.setAntiAlias(run->isAntiAlias());
+        run->draw(context, dc, paint, clip, viewMatrix, props,  x, y,
                   clipBounds, fFallbackTextContext, skPaint);
         run->releaseGlyphCache();
     }
 }
 
 static inline int style_key_cnt(const GrStyle& style) {
     int cnt = GrStyle::KeySize(style, GrStyle::Apply::kPathEffectAndStrokeRec);
     // We should be able to make a key because we filtered out arbitrary path effects.
     SkASSERT(cnt > 0);
     return cnt;
@@ skipping 115 matching lines @@
     SkPaint                            fFont;
     int                                fBuffIdx;
     int                                fCount;
     uint16_t                           fGlyphIds[kWriteBufferSize];
     SkPoint                            fPositions[kWriteBufferSize];
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrStencilAndCoverTextContext::TextRun::TextRun(const SkPaint& fontAndStroke)
-    : fStyle(fontAndStroke),
-      fFont(fontAndStroke),
-      fTotalGlyphCount(0),
-      fFallbackGlyphCount(0),
-      fDetachedGlyphCache(nullptr),
-      fLastDrawnGlyphsID(SK_InvalidUniqueID) {
+    : fStyle(fontAndStroke)
+    , fFont(fontAndStroke)
+    , fTotalGlyphCount(0)
+    , fFallbackGlyphCount(0)
+    , fDetachedGlyphCache(nullptr)
+    , fLastDrawnGlyphsID(SK_InvalidUniqueID) {
     SkASSERT(fFont.getTextSize() > 0);
     SkASSERT(!fStyle.hasNonDashPathEffect()); // Arbitrary path effects not supported.
     SkASSERT(!fStyle.isSimpleHairline()); // Hairlines are not supported.
 
     // Setting to "fill" ensures that no strokes get baked into font outlines. (We use the GPU path
     // rendering API for stroking).
     fFont.setStyle(SkPaint::kFill_Style);
 
     if (fFont.isFakeBoldText() && fStyle.isSimpleFill()) {
         const SkStrokeRec& stroke = fStyle.strokeRec();
@@ skipping 211 matching lines @@
     } else {
         fInstanceData->append(glyph.getGlyphID(), fTextInverseRatio * pos.x(),
                               fTextInverseRatio * pos.y());
     }
 }
 
 void GrStencilAndCoverTextContext::TextRun::draw(GrContext* ctx,
                                                  GrDrawContext* drawContext,
                                                  const GrPaint& grPaint,
                                                  const GrClip& clip,
-                                                 GrColor color,
                                                  const SkMatrix& viewMatrix,
                                                  const SkSurfaceProps& props,
                                                  SkScalar x, SkScalar y,
                                                  const SkIRect& clipBounds,
                                                  GrAtlasTextContext* fallbackTextContext,
                                                  const SkPaint& originalSkPaint) const {
     SkASSERT(fInstanceData);
-    SkASSERT(drawContext->isStencilBufferMultisampled() || !fFont.isAntiAlias());
+    SkASSERT(drawContext->isStencilBufferMultisampled() || !grPaint.isAntiAlias());
 
     if (fInstanceData->count()) {
         static constexpr GrUserStencilSettings kCoverPass(
             GrUserStencilSettings::StaticInit<
                 0x0000,
                 GrUserStencilTest::kNotEqual, // Stencil pass accounts for clip.
                 0xffff,
                 GrUserStencilOp::kZero,
                 GrUserStencilOp::kKeep,
                 0xffff>()
         );
 
         SkAutoTUnref<GrPathRange> glyphs(this->createGlyphs(ctx));
         if (fLastDrawnGlyphsID != glyphs->getUniqueID()) {
             // Either this is the first draw or the glyphs object was purged since last draw.
             glyphs->loadPathsIfNeeded(fInstanceData->indices(), fInstanceData->count());
             fLastDrawnGlyphsID = glyphs->getUniqueID();
         }
 
         // Don't compute a bounding box. For dst copy texture, we'll opt instead for it to just copy
         // the entire dst. Realistically this is a moot point, because any context that supports
         // NV_path_rendering will also support NV_blend_equation_advanced.
         // For clipping we'll just skip any optimizations based on the bounds. This does, however,
         // hurt batching.
         const SkRect bounds = SkRect::MakeIWH(drawContext->width(), drawContext->height());
 
         SkAutoTUnref<GrDrawBatch> batch(
             GrDrawPathRangeBatch::Create(viewMatrix, fTextRatio, fTextInverseRatio * x,
-                                         fTextInverseRatio * y, color,
+                                         fTextInverseRatio * y, grPaint.getColor(),
                                          GrPathRendering::kWinding_FillType, glyphs, fInstanceData,
                                          bounds));
 
         GrPipelineBuilder pipelineBuilder(grPaint);
-        pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_Flag, fFont.isAntiAlias());
+        pipelineBuilder.setState(GrPipelineBuilder::kHWAntialias_Flag, grPaint.isAntiAlias());
         pipelineBuilder.setUserStencil(&kCoverPass);
 
         drawContext->drawBatch(pipelineBuilder, clip, batch);
     }
 
     if (fFallbackTextBlob) {
         SkPaint fallbackSkPaint(originalSkPaint);
         fStyle.strokeRec().applyToPaint(&fallbackSkPaint);
         if (!fStyle.isSimpleFill()) {
             fallbackSkPaint.setStrokeWidth(fStyle.strokeRec().getWidth() * fTextRatio);
@@ skipping 75 matching lines @@
 }
 
 const SkTextBlob* GrStencilAndCoverTextContext::FallbackBlobBuilder::buildIfNeeded(int *count) {
     *count = fCount;
     if (fCount) {
         this->flush();
         return fBuilder->build();
     }
     return nullptr;
 }