Replace GrStrokeInfo with GrStyle.

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 217 matching lines @@
     GrPipelineBuilder pipelineBuilder(paint, dc->accessRenderTarget(), clip);
 
     TextBlob::Iter iter(blob);
     for (TextRun* run = iter.get(); run; run = iter.next()) {
         run->draw(context, dc, &pipelineBuilder, paint.getColor(), 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;
+}
+
+static inline void write_style_key(uint32_t* dst, const GrStyle& style) {
+    // Pass 1 for the scale since the GPU will apply the style not GrStyle::applyToPath().
+    GrStyle::WriteKey(dst, style, GrStyle::Apply::kPathEffectAndStrokeRec, SK_Scalar1);
+}
+
 const GrStencilAndCoverTextContext::TextBlob&
 GrStencilAndCoverTextContext::findOrCreateTextBlob(const SkTextBlob* skBlob,
                                                    const SkPaint& skPaint) {
     // The font-related parameters are baked into the text blob and will override this skPaint, so
     // the only remaining properties that can affect a TextBlob are the ones related to stroke.
     if (SkPaint::kFill_Style == skPaint.getStyle()) { // Fast path.
         if (TextBlob** found = fBlobIdCache.find(skBlob->uniqueID())) {
             fLRUList.remove(*found);
             fLRUList.addToTail(*found);
             return **found;
         }
         TextBlob* blob = new TextBlob(skBlob->uniqueID(), skBlob, skPaint);
         this->purgeToFit(*blob);
         fBlobIdCache.set(skBlob->uniqueID(), blob);
         fLRUList.addToTail(blob);
         fCacheSize += blob->cpuMemorySize();
         return *blob;
     } else {
-        GrStrokeInfo stroke(skPaint);
+        GrStyle style(skPaint);
         SkSTArray<4, uint32_t, true> key;
-        key.reset(1 + stroke.computeUniqueKeyFragmentData32Cnt());
+        key.reset(1 + style_key_cnt(style));
         key[0] = skBlob->uniqueID();
-        stroke.asUniqueKeyFragment(&key[1]);
+        write_style_key(&key[1], style);
         if (TextBlob** found = fBlobKeyCache.find(key)) {
             fLRUList.remove(*found);
             fLRUList.addToTail(*found);
             return **found;
         }
         TextBlob* blob = new TextBlob(key, skBlob, skPaint);
         this->purgeToFit(*blob);
         fBlobKeyCache.set(blob);
         fLRUList.addToTail(blob);
         fCacheSize += blob->cpuMemorySize();
@@ skipping 75 matching lines @@
     SkPaint                            fFont;
     int                                fBuffIdx;
     int                                fCount;
     uint16_t                           fGlyphIds[kWriteBufferSize];
     SkPoint                            fPositions[kWriteBufferSize];
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrStencilAndCoverTextContext::TextRun::TextRun(const SkPaint& fontAndStroke)
-    : fStroke(fontAndStroke),
+    : fStyle(fontAndStroke),
       fFont(fontAndStroke),
       fTotalGlyphCount(0),
       fFallbackGlyphCount(0),
       fDetachedGlyphCache(nullptr),
       fLastDrawnGlyphsID(SK_InvalidUniqueID) {
     SkASSERT(fFont.getTextSize() > 0);
-    SkASSERT(!fStroke.isHairlineStyle()); // Hairlines are not supported.
+    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() && SkStrokeRec::kStroke_Style != fStroke.getStyle()) {
+    if (fFont.isFakeBoldText() && fStyle.isSimpleFill()) {
+        const SkStrokeRec& stroke = fStyle.strokeRec();
         // Instead of letting fake bold get baked into the glyph outlines, do it with GPU stroke.
         SkScalar fakeBoldScale = SkScalarInterpFunc(fFont.getTextSize(),
                                                     kStdFakeBoldInterpKeys,
                                                     kStdFakeBoldInterpValues,
                                                     kStdFakeBoldInterpLength);
         SkScalar extra = SkScalarMul(fFont.getTextSize(), fakeBoldScale);
-        fStroke.setStrokeStyle(fStroke.needToApply() ? fStroke.getWidth() + extra : extra,
-                               true /*strokeAndFill*/);
 
+        SkStrokeRec strokeRec(SkStrokeRec::kFill_InitStyle);
+        strokeRec.setStrokeStyle(stroke.needToApply() ? stroke.getWidth() + extra : extra,
+                                 true /*strokeAndFill*/);
+        fStyle = GrStyle(strokeRec, fStyle.pathEffect());
         fFont.setFakeBoldText(false);
     }
 
-    if (!fFont.getPathEffect() && !fStroke.isDashed()) {
+    if (!fFont.getPathEffect() && !fStyle.isDashed()) {
+        const SkStrokeRec& stroke = fStyle.strokeRec();
         // We can draw the glyphs from canonically sized paths.
         fTextRatio = fFont.getTextSize() / SkPaint::kCanonicalTextSizeForPaths;
         fTextInverseRatio = SkPaint::kCanonicalTextSizeForPaths / fFont.getTextSize();
 
         // Compensate for the glyphs being scaled by fTextRatio.
-        if (!fStroke.isFillStyle()) {
-            fStroke.setStrokeStyle(fStroke.getWidth() / fTextRatio,
-                                   SkStrokeRec::kStrokeAndFill_Style == fStroke.getStyle());
+        if (!fStyle.isSimpleFill()) {
+            SkStrokeRec strokeRec(SkStrokeRec::kFill_InitStyle);
+            strokeRec.setStrokeStyle(stroke.getWidth() / fTextRatio,
+                                     SkStrokeRec::kStrokeAndFill_Style == stroke.getStyle());
+            fStyle = GrStyle(strokeRec, fStyle.pathEffect());
         }
 
         fFont.setLinearText(true);
         fFont.setLCDRenderText(false);
         fFont.setAutohinted(false);
         fFont.setHinting(SkPaint::kNo_Hinting);
         fFont.setSubpixelText(true);
         fFont.setTextSize(SkIntToScalar(SkPaint::kCanonicalTextSizeForPaths));
 
         fUsingRawGlyphPaths = SK_Scalar1 == fFont.getTextScaleX() &&
                               0 == fFont.getTextSkewX() &&
                               !fFont.isFakeBoldText() &&
                               !fFont.isVerticalText();
     } else {
         fTextRatio = fTextInverseRatio = 1.0f;
         fUsingRawGlyphPaths = false;
     }
 
     // Generate the key that will be used to cache the GPU glyph path objects.
-    if (fUsingRawGlyphPaths && fStroke.isFillStyle()) {
+    if (fUsingRawGlyphPaths && fStyle.isSimpleFill()) {
         static const GrUniqueKey::Domain kRawFillPathGlyphDomain = GrUniqueKey::GenerateDomain();
 
         const SkTypeface* typeface = fFont.getTypeface();
         GrUniqueKey::Builder builder(&fGlyphPathsKey, kRawFillPathGlyphDomain, 1);
         reinterpret_cast<uint32_t&>(builder[0]) = typeface ? typeface->uniqueID() : 0;
     } else {
         static const GrUniqueKey::Domain kPathGlyphDomain = GrUniqueKey::GenerateDomain();
 
-        int strokeDataCount = fStroke.computeUniqueKeyFragmentData32Cnt();
+        int styleDataCount = GrStyle::KeySize(fStyle, GrStyle::Apply::kPathEffectAndStrokeRec);
+        // Key should be valid since we opted out of drawing arbitrary path effects.
+        SkASSERT(styleDataCount >= 0);
         if (fUsingRawGlyphPaths) {
             const SkTypeface* typeface = fFont.getTypeface();
-            GrUniqueKey::Builder builder(&fGlyphPathsKey, kPathGlyphDomain, 2 + strokeDataCount);
+            GrUniqueKey::Builder builder(&fGlyphPathsKey, kPathGlyphDomain, 2 + styleDataCount);
             reinterpret_cast<uint32_t&>(builder[0]) = typeface ? typeface->uniqueID() : 0;
-            reinterpret_cast<uint32_t&>(builder[1]) = strokeDataCount;
-            fStroke.asUniqueKeyFragment(&builder[2]);
+            reinterpret_cast<uint32_t&>(builder[1]) = styleDataCount;
+            if (styleDataCount) {
+                write_style_key(&builder[2], fStyle);
+            }
         } else {
             SkGlyphCache* glyphCache = this->getGlyphCache();
             const SkTypeface* typeface = glyphCache->getScalerContext()->getTypeface();
             const SkDescriptor* desc = &glyphCache->getDescriptor();
             int descDataCount = (desc->getLength() + 3) / 4;
             GrUniqueKey::Builder builder(&fGlyphPathsKey, kPathGlyphDomain,
-                                         2 + strokeDataCount + descDataCount);
+                                         2 + styleDataCount + descDataCount);
             reinterpret_cast<uint32_t&>(builder[0]) = typeface ? typeface->uniqueID() : 0;
-            reinterpret_cast<uint32_t&>(builder[1]) = strokeDataCount | (descDataCount << 16);
-            fStroke.asUniqueKeyFragment(&builder[2]);
-            memcpy(&builder[2 + strokeDataCount], desc, desc->getLength());
+            reinterpret_cast<uint32_t&>(builder[1]) = styleDataCount | (descDataCount << 16);
+            if (styleDataCount) {
+                write_style_key(&builder[2], fStyle);
+            }
+            memcpy(&builder[2 + styleDataCount], desc, desc->getLength());
         }
     }
 }
 
 GrStencilAndCoverTextContext::TextRun::~TextRun() {
     this->releaseGlyphCache();
 }
 
 void GrStencilAndCoverTextContext::TextRun::setText(const char text[], size_t byteLength,
                                                     SkScalar x, SkScalar y) {
@@ skipping 87 matching lines @@
     fFallbackTextBlob.reset(fallback.buildIfNeeded(&fFallbackGlyphCount));
 }
 
 GrPathRange* GrStencilAndCoverTextContext::TextRun::createGlyphs(GrContext* ctx) const {
     GrPathRange* glyphs = static_cast<GrPathRange*>(
             ctx->resourceProvider()->findAndRefResourceByUniqueKey(fGlyphPathsKey));
     if (nullptr == glyphs) {
         if (fUsingRawGlyphPaths) {
             SkScalerContextEffects noeffects;
             glyphs = ctx->resourceProvider()->createGlyphs(fFont.getTypeface(), noeffects,
-                                                           nullptr, fStroke);
+                                                           nullptr, fStyle);
         } else {
             SkGlyphCache* cache = this->getGlyphCache();
             glyphs = ctx->resourceProvider()->createGlyphs(cache->getScalerContext()->getTypeface(),
                                                            cache->getScalerContext()->getEffects(),
                                                            &cache->getDescriptor(),
-                                                           fStroke);
+                                                           fStyle);
         }
         ctx->resourceProvider()->assignUniqueKeyToResource(fGlyphPathsKey, glyphs);
     }
     return glyphs;
 }
 
 inline void GrStencilAndCoverTextContext::TextRun::appendGlyph(const SkGlyph& glyph,
                                                                const SkPoint& pos,
                                                                FallbackBlobBuilder* fallback) {
     // Stick the glyphs we can't draw into the fallback text blob.
@@ skipping 53 matching lines @@
             GrDrawPathRangeBatch::Create(viewMatrix, fTextRatio, fTextInverseRatio * x,
                                          fTextInverseRatio * y, color,
                                          GrPathRendering::kWinding_FillType, glyphs, fInstanceData,
                                          bounds));
 
         dc->drawPathBatch(*pipelineBuilder, batch);
     }
 
     if (fFallbackTextBlob) {
         SkPaint fallbackSkPaint(originalSkPaint);
-        fStroke.applyToPaint(&fallbackSkPaint);
-        if (!fStroke.isFillStyle()) {
-            fallbackSkPaint.setStrokeWidth(fStroke.getWidth() * fTextRatio);
+        fStyle.strokeRec().applyToPaint(&fallbackSkPaint);
+        if (!fStyle.isSimpleFill()) {
+            fallbackSkPaint.setStrokeWidth(fStyle.strokeRec().getWidth() * fTextRatio);
         }
 
         fallbackTextContext->drawTextBlob(ctx, dc, pipelineBuilder->clip(), fallbackSkPaint,
                                           viewMatrix, props, fFallbackTextBlob, x, y, nullptr,
                                           clipBounds);
     }
 }
 
 SkGlyphCache* GrStencilAndCoverTextContext::TextRun::getGlyphCache() const {
     if (!fDetachedGlyphCache) {
@@ skipping 66 matching lines @@
 }
 
 const SkTextBlob* GrStencilAndCoverTextContext::FallbackBlobBuilder::buildIfNeeded(int *count) {
     *count = fCount;
     if (fCount) {
         this->flush();
         return fBuilder->build();
     }
     return nullptr;
 }