Revert "Have Renderer use combined path code"

This reverts commit 5dee1802ae.

Reason for revert: breaking ios-simulator bot on Chrome roll.
Something to do with SK_SUPPORT_GPU?

https://logs.chromium.org/logs/chromium/buildbucket/cr-buildbucket.appspot.com/8934155862192553888/+/steps/compile__with_patch_/0/stdout

Original change's description:
> Have Renderer use combined path code
> 
> Currently, the GPU code uses the unified code path
> in painter to draw. Have the remote glyph cache use it too.
> 
> Change-Id: Ibb1728a9602dbb3ace3a57781c5e7a20cdbe3cdf
> Reviewed-on: https://skia-review.googlesource.com/157521
> Reviewed-by: Mike Klein <mtklein@google.com>
> Commit-Queue: Mike Klein <mtklein@google.com>

TBR=mtklein@google.com,herb@google.com

Change-Id: Ica31880f38a9d3a62a8616e64cbb84e6ae9827a4
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://skia-review.googlesource.com/157740
Reviewed-by: Mike Klein <mtklein@google.com>
Commit-Queue: Mike Klein <mtklein@google.com>

src/core/SkGlyphRunPainter.cpp

@@ -595,12 +595,10 @@ void GrTextContext::regenerateGlyphRunList(GrTextBlob* cacheBlob,
             // Given a glyph that is not ARGB, draw it.
             auto perPath = [textScale, runIndex, cacheBlob, &pathCache]
                            (const SkGlyph& glyph, SkPoint position) {
-                if (!glyph.isEmpty()) {
+                const SkPath* path = pathCache->findPath(glyph);
-                    const SkPath* path = pathCache->findPath(glyph);
+                if (path != nullptr) {
-                    if (path != nullptr) {
+                    cacheBlob->appendPathGlyph(
-                        cacheBlob->appendPathGlyph(
+                            runIndex, *path, position.fX, position.fY, textScale, false);
-                                runIndex, *path, position.fX, position.fY, textScale, false);
-                    }
                 }
             };
 

src/core/SkGlyphRunPainter.h

@@ -175,13 +175,15 @@ void SkGlyphRunListPainter::drawGlyphRunAsPathWithARGBFallback(
             (SkGlyphID glyphID, SkPoint position) {
                 if (SkScalarsAreFinite(position.x(), position.y())) {
                     const SkGlyph& glyph = pathCache->getGlyphMetrics(glyphID, {0, 0});
-                    if (glyph.fMaskFormat != SkMask::kARGB32_Format) {
+                    if (!glyph.isEmpty()) {
-                        perPath(glyph, origin + position);
+                        if (glyph.fMaskFormat != SkMask::kARGB32_Format) {
-                    } else {
+                            perPath(glyph, origin + position);
-                        SkScalar largestDimension = std::max(glyph.fWidth, glyph.fHeight);
+                        } else {
-                        maxFallbackDimension = std::max(maxFallbackDimension, largestDimension);
+                            SkScalar largestDimension = std::max(glyph.fWidth, glyph.fHeight);
-                        fARGBGlyphsIDs.push_back(glyphID);
+                            maxFallbackDimension = std::max(maxFallbackDimension, largestDimension);
-                        fARGBPositions.push_back(position);
+                            fARGBGlyphsIDs.push_back(glyphID);
+                            fARGBPositions.push_back(position);
+                        }
                     }
                 }
             };

src/core/SkRemoteGlyphCache.cpp

@@ -182,6 +182,7 @@ bool read_path(Deserializer* deserializer, SkGlyph* glyph, SkGlyphCache* cache)
     return cache->initializePath(glyph, path, pathSize);
 }
 
+#if SK_SUPPORT_GPU
 void add_glyph_to_cache(SkStrikeServer::SkGlyphCacheState* cache, SkTypeface* tf,
                         const SkScalerContextEffects& effects, SkGlyphID glyphID) {
     SkASSERT(cache != nullptr);
@@ -189,7 +190,6 @@ void add_glyph_to_cache(SkStrikeServer::SkGlyphCacheState* cache, SkTypeface* tf
     cache->addGlyph(SkPackedGlyphID(glyphID, 0, 0), false);
 }
 
-#if SK_SUPPORT_GPU
 void add_fallback_text_to_cache(const GrTextContext::FallbackGlyphRunHelper& helper,
                                 const SkSurfaceProps& props,
                                 const SkMatrix& matrix,
@@ -272,7 +272,7 @@ void SkTextBlobCacheDiffCanvas::TrackLayerDevice::processGlyphRun(
     } else
     #endif
     if (SkDraw::ShouldDrawTextAsPaths(runPaint, runMatrix)) {
-        this->processGlyphRunForPaths(glyphRun, runMatrix, origin);
+        this->processGlyphRunForPaths(glyphRun, runMatrix);
     } else {
         this->processGlyphRunForMask(glyphRun, runMatrix, origin);
     }
@@ -306,44 +306,43 @@ void SkTextBlobCacheDiffCanvas::TrackLayerDevice::processGlyphRunForMask(
 }
 
 void SkTextBlobCacheDiffCanvas::TrackLayerDevice::processGlyphRunForPaths(
-        const SkGlyphRun& glyphRun, const SkMatrix& runMatrix, SkPoint origin) {
+        const SkGlyphRun& glyphRun, const SkMatrix& runMatrix) {
     TRACE_EVENT0("skia", "SkTextBlobCacheDiffCanvas::processGlyphRunForPaths");
     const SkPaint& runPaint = glyphRun.paint();
-    SkPaint pathPaint{runPaint};
 
-    SkScalar textScale = pathPaint.setupForAsPaths();
+    // The code below borrowed from GrTextContext::DrawBmpPosTextAsPaths.
+    SkPaint pathPaint(runPaint);
+#if SK_SUPPORT_GPU
+    SkScalar matrixScale = pathPaint.setupForAsPaths();
+    GrTextContext::FallbackGlyphRunHelper fallbackTextHelper(runMatrix, runPaint, matrixScale);
+#else
+    pathPaint.setupForAsPaths();
+#endif
 
     SkScalerContextEffects effects;
     auto* glyphCacheState = fStrikeServer->getOrCreateCache(
             pathPaint, this->surfaceProps(), SkMatrix::I(),
             SkScalerContextFlags::kFakeGammaAndBoostContrast, &effects);
 
-    auto perPath = [glyphCacheState](const SkGlyph& glyph, SkPoint position) {
+    const bool asPath = true;
-        const bool asPath = true;
+    auto glyphs = glyphRun.shuntGlyphsIDs();
-        glyphCacheState->addGlyph(glyph.getGlyphID(), asPath);
+    for (uint32_t index = 0; index < glyphRun.runSize(); index++) {
-    };
+        auto glyphID = glyphs[index];
-
+#if SK_SUPPORT_GPU
-    auto argbFallback = [this, &runMatrix]
+        const auto& glyph = glyphCacheState->findGlyph(glyphID);
-            (const SkPaint& fallbackPaint, SkSpan<const SkGlyphID> glyphIDs,
+        if (SkMask::kARGB32_Format == glyph.fMaskFormat) {
-             SkSpan<const SkPoint> positions, SkScalar textScale,
+            // Note that we send data for the original glyph even in the case of fallback
-             const SkMatrix& glyphCacheMatrix,
+            // since its glyph metrics will still be used on the client.
-             SkGlyphRunListPainter::NeedsTransform needsTransform) {
+            fallbackTextHelper.appendGlyph(glyph, glyphID, {0, 0});
-        TRACE_EVENT0("skia", "argbFallback_path");
-        SkMatrix fallbackMatrix = runMatrix;
-
-        SkScalerContextEffects effects;
-        auto* glyphCacheState =
-                fStrikeServer->getOrCreateCache(
-                        fallbackPaint, surfaceProps(), fallbackMatrix,
-                        SkScalerContextFlags::kFakeGammaAndBoostContrast, &effects);
-
-        for (auto glyphID : glyphIDs) {
-            add_glyph_to_cache(glyphCacheState, fallbackPaint.getTypeface(), effects, glyphID);
         }
-    };
+#endif
+        glyphCacheState->addGlyph(glyphID, asPath);
+    }
 
-    fPainter.drawGlyphRunAsPathWithARGBFallback(
+#if SK_SUPPORT_GPU
-            glyphCacheState, glyphRun, origin, runMatrix, textScale, perPath, argbFallback);
+    add_fallback_text_to_cache(fallbackTextHelper, this->surfaceProps(), runMatrix, runPaint,
+                               fStrikeServer);
+#endif
 }
 
 #if SK_SUPPORT_GPU

src/core/SkRemoteGlyphCacheImpl.h

@@ -100,8 +100,7 @@ private:
     void processGlyphRunForMask(
             const SkGlyphRun& glyphRun, const SkMatrix& runMatrix, SkPoint origin);
 
-    void processGlyphRunForPaths(
+    void processGlyphRunForPaths(const SkGlyphRun& glyphRun, const SkMatrix& runMatrix);
-            const SkGlyphRun& glyphRun, const SkMatrix& runMatrix, SkPoint origin);
 
 #if SK_SUPPORT_GPU
     bool maybeProcessGlyphRunForDFT(const SkGlyphRun& glyphRun, const SkMatrix& runMatrix);