Use SkFont in GPU drawing step 1

Use SkFont in most places, but save setupCache for
its own CL.

Change-Id: I2c603c03e23e132edd3e164d256a1fb753523d36
Reviewed-on: https://skia-review.googlesource.com/c/175841
Commit-Queue: Herb Derby <herb@google.com>
Reviewed-by: Mike Reed <reed@google.com>

Author: herbderby

include/core/SkFont.h

@@ -495,6 +495,7 @@ class SK_API SkFont {
 
     void glyphsToUnichars(const SkGlyphID glyphs[], int count, SkUnichar text[]) const;
 
+    friend class GrTextBlob;
     friend class SkCanonicalizeFont;
     friend class SkFontPriv;
     friend class SkGlyphRunListPainter;

src/core/SkGlyphRunPainter.cpp

@@ -329,7 +329,7 @@ void SkGlyphRunListPainter::processARGBFallback(
 template <typename PerEmptyT, typename PerPathT>
 void SkGlyphRunListPainter::drawGlyphRunAsPathWithARGBFallback(
         SkGlyphCacheInterface* pathCache, const SkGlyphRun& glyphRun,
-        SkPoint origin, const SkPaint& paint, const SkMatrix& viewMatrix, SkScalar textScale,
+        SkPoint origin, const SkPaint& runPaint, const SkMatrix& viewMatrix, SkScalar textScale,
         PerEmptyT&& perEmpty, PerPathT&& perPath, ARGBFallback&& argbFallback) {
     fARGBGlyphsIDs.clear();
     fARGBPositions.clear();
@@ -356,10 +356,10 @@ void SkGlyphRunListPainter::drawGlyphRunAsPathWithARGBFallback(
     }
 
     if (!fARGBGlyphsIDs.empty()) {
-        SkPaint runPaint{paint};
-        glyphRun.font().LEGACY_applyToPaint(&runPaint);
+        SkPaint fallbackPaint{runPaint};
+        glyphRun.font().LEGACY_applyToPaint(&fallbackPaint);
         this->processARGBFallback(
-                maxFallbackDimension, runPaint, viewMatrix, textScale,
+                maxFallbackDimension, fallbackPaint, viewMatrix, textScale,
                 std::move(argbFallback));
 
     }
@@ -701,31 +701,33 @@ void GrTextBlob::generateFromGlyphRunList(GrGlyphCache* glyphCache,
     };
 
     SkPoint origin = glyphRunList.origin();
-    this->initReusableBlob(
-            glyphRunList.paint().computeLuminanceColor(), viewMatrix, origin.x(), origin.y());
+    const SkPaint& runPaint = glyphRunList.paint();
+    this->initReusableBlob(runPaint.computeLuminanceColor(), viewMatrix, origin.x(), origin.y());
 
     for (const auto& glyphRun : glyphRunList) {
-        SkPaint runPaint {glyphRunList.paint()};
-        glyphRun.font().LEGACY_applyToPaint(&runPaint);
+        const SkFont& runFont = glyphRun.font();
+
         Run* run = this->pushBackRun();
 
-        run->setRunFontAntiAlias(runPaint.isAntiAlias());
+        run->setRunFontAntiAlias(runFont.hasSomeAntiAliasing());
 
-        if (GrTextContext::CanDrawAsDistanceFields(runPaint,
-                                   SkFont::LEGACY_ExtractFromPaint(runPaint), viewMatrix, props,
+        if (GrTextContext::CanDrawAsDistanceFields(runPaint, runFont, viewMatrix, props,
                                     shaderCaps.supportsDistanceFieldText(), options)) {
             bool hasWCoord = viewMatrix.hasPerspective()
                              || options.fDistanceFieldVerticesAlwaysHaveW;
 
             // Setup distance field runPaint and text ratio
             SkScalar textScale;
             SkPaint distanceFieldPaint{runPaint};
+            runFont.LEGACY_applyToPaint(&distanceFieldPaint);
             SkScalerContextFlags flags;
             GrTextContext::InitDistanceFieldPaint(this, &distanceFieldPaint, viewMatrix,
                                                   options, &textScale, &flags);
             this->setHasDistanceField();
-            run->setSubRunHasDistanceFields(runPaint.isLCDRenderText(),
-                                            runPaint.isAntiAlias(), hasWCoord);
+            run->setSubRunHasDistanceFields(
+                    runFont.getEdging() == SkFont::Edging::kSubpixelAntiAlias,
+                    runFont.hasSomeAntiAliasing(),
+                    hasWCoord);
 
             {
                 auto cache = run->setupCache(distanceFieldPaint, props, flags, SkMatrix::I());
@@ -759,23 +761,24 @@ void GrTextBlob::generateFromGlyphRunList(GrGlyphCache* glyphCache,
                     std::move(perEmpty), std::move(perSDF), std::move(perPath),
                     std::move(argbFallback));
             }
-        } else if (SkGlyphRunListPainter::ShouldDrawAsPath(
-                glyphRunList.paint(), glyphRun.font(), viewMatrix)) {
+
+        } else if (SkGlyphRunListPainter::ShouldDrawAsPath(runPaint, runFont, viewMatrix)) {
             // The glyphs are big, so use paths to draw them.
 
             // Ensure the blob is set for bitmaptext
             this->setHasBitmap();
 
             // setup our std runPaint, in hopes of getting hits in the cache
-            SkPaint pathPaint(runPaint);
-
-            auto perEmpty = [](const SkGlyph&, SkPoint) {};
+            SkPaint pathPaint{runPaint};
+            SkFont pathFont{runFont};
+            SkScalar textScale = pathFont.setupForAsPaths(&pathPaint);
 
-            SkScalar textScale = pathPaint.setupForAsPaths();
             auto pathCache = SkStrikeCache::FindOrCreateStrikeExclusive(
-                                SkFont::LEGACY_ExtractFromPaint(pathPaint), pathPaint, props,
+                                pathFont, pathPaint, props,
                                 scalerContextFlags, SkMatrix::I());
 
+            auto perEmpty = [](const SkGlyph&, SkPoint) {};
+
             // Given a glyph that is not ARGB, draw it.
             auto perPath = [textScale, run]
                            (const SkGlyph& glyph, SkPoint position) {
@@ -785,8 +788,7 @@ void GrTextBlob::generateFromGlyphRunList(GrGlyphCache* glyphCache,
                 }
             };
 
-            ARGBFallbackHelper argbFallback{this, run, props, scalerContextFlags,
-                                            glyphCache};
+            ARGBFallbackHelper argbFallback{this, run, props, scalerContextFlags, glyphCache};
 
             glyphPainter->drawGlyphRunAsPathWithARGBFallback(
                 pathCache.get(), glyphRun, origin, runPaint, viewMatrix, textScale,
@@ -795,7 +797,9 @@ void GrTextBlob::generateFromGlyphRunList(GrGlyphCache* glyphCache,
             // Ensure the blob is set for bitmaptext
             this->setHasBitmap();
 
-            auto cache = run->setupCache(runPaint, props, scalerContextFlags, viewMatrix);
+            SkPaint cachePaint{runPaint};
+            runFont.LEGACY_applyToPaint(&cachePaint);
+            auto cache = run->setupCache(cachePaint, props, scalerContextFlags, viewMatrix);
 
             sk_sp<GrTextStrike> currStrike = glyphCache->getStrike(cache.get());