Reland of Make draw* lines responsible for cache management (patchset #1 id:1 of https://codereview.chromium.org/1552513003/ )

Reason for revert:
might have been premature

Original issue's description:
> Revert of Make draw* lines responsible for cache management (patchset #1 id:1 of https://codereview.chromium.org/1521613002/ )
>
> Reason for revert:
> seeing crashes on android and linux
>
> Original issue's description:
> > Make draw* lines responsible for cache management
> >
> > TBR=bsalomon@google.com
> > BUG=skia:
> >
> > Committed: https://skia.googlesource.com/skia/+/66957946c0c418e71c0f36bb2904cc38c334eba4
>
> TBR=bsalomon@google.com,jvanverth@google.com,joshualitt@chromium.org
> NOPRESUBMIT=true
> NOTREECHECKS=true
> NOTRY=true
> BUG=skia:
>
> Committed: https://skia.googlesource.com/skia/+/90e293dae4990a86cb952663ccde8fae55112d7d

TBR=bsalomon@google.com,jvanverth@google.com,joshualitt@chromium.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=skia:

Review URL: https://codereview.chromium.org/1551563003

6 files changed, 50 insertions, 49 deletions

diff --git a/src/gpu/text/GrAtlasTextBlob.cpp b/src/gpu/text/GrAtlasTextBlob.cpp
index dee6d133e3..f79f82598f 100644
--- a/src/gpu/text/GrAtlasTextBlob.cpp
+++ b/src/gpu/text/GrAtlasTextBlob.cpp
@@ -13,9 +13,25 @@
 #include "GrTextUtils.h"
 #include "SkColorFilter.h"
 #include "SkDrawFilter.h"
+#include "SkGlyphCache.h"
 #include "SkTextBlobRunIterator.h"
 #include "batches/GrAtlasTextBatch.h"
 
+SkGlyphCache* GrAtlasTextBlob::setupCache(int runIndex,
+                                          const SkSurfaceProps& props,
+                                          const SkPaint& skPaint,
+                                          const SkMatrix* viewMatrix,
+                                          bool noGamma) {
+    GrAtlasTextBlob::Run* run = &fRuns[runIndex];
+
+    // if we have an override descriptor for the run, then we should use that
+    SkAutoDescriptor* desc = run->fOverrideDescriptor.get() ? run->fOverrideDescriptor.get() :
+                                                              &run->fDescriptor;
+    skPaint.getScalerContextDescriptor(desc, props, viewMatrix, noGamma);
+    run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
+    return SkGlyphCache::DetachCache(run->fTypeface, desc->getDesc());
+}
+
 void GrAtlasTextBlob::appendGlyph(int runIndex,
                                   const SkRect& positions,
                                   GrColor color,
diff --git a/src/gpu/text/GrAtlasTextBlob.h b/src/gpu/text/GrAtlasTextBlob.h
index d99ae707e0..c24dabd010 100644
--- a/src/gpu/text/GrAtlasTextBlob.h
+++ b/src/gpu/text/GrAtlasTextBlob.h
@@ -290,6 +290,12 @@ public:
         }
     }
 
+    SkGlyphCache* setupCache(int runIndex,
+                             const SkSurfaceProps& props,
+                             const SkPaint& skPaint,
+                             const SkMatrix* viewMatrix,
+                             bool noGamma);
+
     // Appends a glyph to the blob.  If the glyph is too large, the glyph will be appended
     // as a path.
     void appendGlyph(int runIndex,
diff --git a/src/gpu/text/GrAtlasTextContext.cpp b/src/gpu/text/GrAtlasTextContext.cpp
index 3769b0b439..37cd53d080 100644
--- a/src/gpu/text/GrAtlasTextContext.cpp
+++ b/src/gpu/text/GrAtlasTextContext.cpp
@@ -105,15 +105,6 @@ bool GrAtlasTextContext::HasLCD(const SkTextBlob* blob) {
     return false;
 }
 
-inline SkGlyphCache* GrAtlasTextContext::setupCache(GrAtlasTextBlob::Run* run,
-                                                    const SkPaint& skPaint,
-                                                    const SkMatrix* viewMatrix,
-                                                    bool noGamma) {
-    skPaint.getScalerContextDescriptor(&run->fDescriptor, fSurfaceProps, viewMatrix, noGamma);
-    run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
-    return SkGlyphCache::DetachCache(run->fTypeface, run->fDescriptor.getDesc());
-}
-
 void GrAtlasTextContext::drawTextBlob(GrDrawContext* dc,
                                       const GrClip& clip, const SkPaint& skPaint,
                                       const SkMatrix& viewMatrix, const SkTextBlob* blob,
@@ -291,18 +282,17 @@ void GrAtlasTextContext::regenerateTextBlob(GrAtlasTextBlob* cacheBlob,
             PerSubRunInfo& subRun = runIdx.fSubRunInfo.back();
             subRun.setUseLCDText(runPaint.isLCDRenderText());
             subRun.setDrawAsDistanceFields();
-            SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], dfPaint, nullptr, true);
 
             switch (it.positioning()) {
                 case SkTextBlob::kDefault_Positioning: {
-                    this->internalDrawDFText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
+                    this->internalDrawDFText(cacheBlob, run, dfPaint, color, viewMatrix,
                                              (const char *)it.glyphs(), textLen,
                                              x + offset.x(), y + offset.y(), textRatio, runPaint);
                     break;
                 }
                 case SkTextBlob::kHorizontal_Positioning: {
                     SkPoint dfOffset = SkPoint::Make(x, y + offset.y());
-                    this->internalDrawDFPosText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
+                    this->internalDrawDFPosText(cacheBlob, run, dfPaint, color, viewMatrix,
                                                 (const char*)it.glyphs(), textLen, it.pos(),
                                                 1, dfOffset, textRatio,
                                                 runPaint);
@@ -310,40 +300,36 @@ void GrAtlasTextContext::regenerateTextBlob(GrAtlasTextBlob* cacheBlob,
                 }
                 case SkTextBlob::kFull_Positioning: {
                     SkPoint dfOffset = SkPoint::Make(x, y);
-                    this->internalDrawDFPosText(cacheBlob, run, cache, dfPaint, color, viewMatrix,
+                    this->internalDrawDFPosText(cacheBlob, run, dfPaint, color, viewMatrix,
                                                 (const char*)it.glyphs(), textLen, it.pos(),
                                                 2, dfOffset, textRatio, runPaint);
                     break;
                 }
             }
-            SkGlyphCache::AttachCache(cache);
         } else if (SkDraw::ShouldDrawTextAsPaths(runPaint, viewMatrix)) {
             cacheBlob->fRuns[run].fDrawAsPaths = true;
         } else {
             cacheBlob->setHasBitmap();
-            SkGlyphCache* cache = this->setupCache(&cacheBlob->fRuns[run], runPaint, &viewMatrix,
-                                                   false);
             switch (it.positioning()) {
                 case SkTextBlob::kDefault_Positioning:
                     GrTextUtils::DrawBmpText(cacheBlob, run, fContext->getBatchFontCache(),
-                                             cache, runPaint, color, viewMatrix,
+                                             fSurfaceProps, runPaint, color, viewMatrix,
                                              (const char *)it.glyphs(), textLen,
                                              x + offset.x(), y + offset.y());
                     break;
                 case SkTextBlob::kHorizontal_Positioning:
                     GrTextUtils::DrawBmpPosText(cacheBlob, run, fContext->getBatchFontCache(),
-                                                cache, runPaint, color, viewMatrix,
+                                                fSurfaceProps, runPaint, color, viewMatrix,
                                                 (const char*)it.glyphs(), textLen, it.pos(), 1,
                                                 SkPoint::Make(x, y + offset.y()));
                     break;
                 case SkTextBlob::kFull_Positioning:
                     GrTextUtils::DrawBmpPosText(cacheBlob, run, fContext->getBatchFontCache(),
-                                                cache, runPaint, color, viewMatrix,
+                                                fSurfaceProps, runPaint, color, viewMatrix,
                                                 (const char*)it.glyphs(), textLen, it.pos(), 2,
                                                 SkPoint::Make(x, y));
                     break;
             }
-            SkGlyphCache::AttachCache(cache);
         }
 
         if (drawFilter) {
@@ -422,14 +408,9 @@ inline void GrAtlasTextContext::fallbackDrawPosText(GrAtlasTextBlob* blob,
     // Push back a new subrun to fill and set the override descriptor
     run.push_back();
     run.fOverrideDescriptor.reset(new SkAutoDescriptor);
-    skPaint.getScalerContextDescriptor(run.fOverrideDescriptor,
-                                       fSurfaceProps, &viewMatrix, false);
-    SkGlyphCache* cache = SkGlyphCache::DetachCache(run.fTypeface,
-                                                    run.fOverrideDescriptor->getDesc());
-    GrTextUtils::DrawBmpPosText(blob, runIndex, fContext->getBatchFontCache(), cache, skPaint,
-                                color, viewMatrix, fallbackTxt.begin(), fallbackTxt.count(),
+    GrTextUtils::DrawBmpPosText(blob, runIndex, fContext->getBatchFontCache(), fSurfaceProps,
+                                skPaint, color, viewMatrix, fallbackTxt.begin(), fallbackTxt.count(),
                                 fallbackPos.begin(), scalarsPerPosition, offset);
-    SkGlyphCache::AttachCache(cache);
 }
 
 inline GrAtlasTextBlob*
@@ -461,19 +442,15 @@ GrAtlasTextContext::createDrawTextBlob(const GrPaint& paint, const SkPaint& skPa
         SkPaint dfPaint;
         SkScalar textRatio;
         blob = this->setupDFBlob(glyphCount, skPaint, viewMatrix, &dfPaint, &textRatio);
-        SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], dfPaint, nullptr, true);
 
-        this->internalDrawDFText(blob, 0, cache, dfPaint, paint.getColor(), viewMatrix, text,
+        this->internalDrawDFText(blob, 0, dfPaint, paint.getColor(), viewMatrix, text,
                                  byteLength, x, y, textRatio, skPaint);
-        SkGlyphCache::AttachCache(cache);
     } else {
         blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
         blob->fViewMatrix = viewMatrix;
 
-        SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
-        GrTextUtils::DrawBmpText(blob, 0, fContext->getBatchFontCache(), cache, skPaint,
+        GrTextUtils::DrawBmpText(blob, 0, fContext->getBatchFontCache(), fSurfaceProps, skPaint,
                                  paint.getColor(), viewMatrix, text, byteLength, x, y);
-        SkGlyphCache::AttachCache(cache);
     }
     return blob;
 }
@@ -491,20 +468,16 @@ GrAtlasTextContext::createDrawPosTextBlob(const GrPaint& paint, const SkPaint& s
         SkPaint dfPaint;
         SkScalar textRatio;
         blob = this->setupDFBlob(glyphCount, skPaint, viewMatrix, &dfPaint, &textRatio);
-        SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], dfPaint, nullptr, true);
 
-        this->internalDrawDFPosText(blob, 0, cache, dfPaint, paint.getColor(), viewMatrix, text,
+        this->internalDrawDFPosText(blob, 0, dfPaint, paint.getColor(), viewMatrix, text,
                                     byteLength, pos, scalarsPerPosition, offset, textRatio,
                                     skPaint);
-        SkGlyphCache::AttachCache(cache);
     } else {
         blob = fCache->createBlob(glyphCount, 1, GrAtlasTextBlob::kGrayTextVASize);
         blob->fViewMatrix = viewMatrix;
-        SkGlyphCache* cache = this->setupCache(&blob->fRuns[0], skPaint, &viewMatrix, false);
-        GrTextUtils::DrawBmpPosText(blob, 0, fContext->getBatchFontCache(), cache, skPaint,
+        GrTextUtils::DrawBmpPosText(blob, 0, fContext->getBatchFontCache(), fSurfaceProps, skPaint,
                                     paint.getColor(), viewMatrix, text,
                                     byteLength, pos, scalarsPerPosition, offset);
-        SkGlyphCache::AttachCache(cache);
     }
     return blob;
 }
@@ -539,7 +512,6 @@ void GrAtlasTextContext::onDrawPosText(GrDrawContext* dc,
 }
 
 void GrAtlasTextContext::internalDrawDFText(GrAtlasTextBlob* blob, int runIndex,
-                                            SkGlyphCache* cache,
                                             const SkPaint& skPaint, GrColor color,
                                             const SkMatrix& viewMatrix,
                                             const char text[], size_t byteLength,
@@ -605,12 +577,11 @@ void GrAtlasTextContext::internalDrawDFText(GrAtlasTextBlob* blob, int runIndex,
     y -= alignY;
     SkPoint offset = SkPoint::Make(x, y);
 
-    this->internalDrawDFPosText(blob, runIndex, cache, skPaint, color, viewMatrix, text, byteLength,
+    this->internalDrawDFPosText(blob, runIndex, skPaint, color, viewMatrix, text, byteLength,
                                 positions.begin(), 2, offset, textRatio, origPaint);
 }
 
 void GrAtlasTextContext::internalDrawDFPosText(GrAtlasTextBlob* blob, int runIndex,
-                                               SkGlyphCache* cache,
                                                const SkPaint& skPaint,
                                                GrColor color,
                                                const SkMatrix& viewMatrix,
@@ -633,6 +604,7 @@ void GrAtlasTextContext::internalDrawDFPosText(GrAtlasTextBlob* blob, int runInd
 
     fCurrStrike = nullptr;
 
+    SkGlyphCache* cache = blob->setupCache(runIndex, fSurfaceProps, skPaint, nullptr, true);
     SkDrawCacheProc glyphCacheProc = skPaint.getDrawCacheProc();
     GrFontScaler* fontScaler = GetGrFontScaler(cache);
 
@@ -697,6 +669,7 @@ void GrAtlasTextContext::internalDrawDFPosText(GrAtlasTextBlob* blob, int runInd
         }
     }
 
+    SkGlyphCache::AttachCache(cache);
     if (fallbackTxt.count()) {
         this->fallbackDrawPosText(blob, runIndex, origPaint.getColor(), origPaint, viewMatrix,
                                   fallbackTxt, fallbackPos, scalarsPerPosition, offset);
diff --git a/src/gpu/text/GrAtlasTextContext.h b/src/gpu/text/GrAtlasTextContext.h
index e38243d480..3971352e96 100644
--- a/src/gpu/text/GrAtlasTextContext.h
+++ b/src/gpu/text/GrAtlasTextContext.h
@@ -74,13 +74,13 @@ private:
                                     const SkPoint& offset);
 
     void internalDrawDFText(GrAtlasTextBlob*, int runIndex,
-                            SkGlyphCache*, const SkPaint&,
+                            const SkPaint&,
                             GrColor color, const SkMatrix& viewMatrix,
                             const char text[], size_t byteLength,
                             SkScalar x, SkScalar y,
                             SkScalar textRatio, const SkPaint& origPaint);
     void internalDrawDFPosText(GrAtlasTextBlob*, int runIndex,
-                               SkGlyphCache*, const SkPaint&,
+                               const SkPaint&,
                                GrColor color, const SkMatrix& viewMatrix,
                                const char text[], size_t byteLength,
                                const SkScalar pos[], int scalarsPerPosition,
@@ -90,7 +90,6 @@ private:
 
     // sets up the descriptor on the blob and returns a detached cache.  Client must attach
     inline static GrColor ComputeCanonicalColor(const SkPaint&, bool lcd);
-    inline SkGlyphCache* setupCache(Run*, const SkPaint&, const SkMatrix* viewMatrix, bool noGamma);
     void regenerateTextBlob(GrAtlasTextBlob* bmp, const SkPaint& skPaint, GrColor,
                             const SkMatrix& viewMatrix,
                             const SkTextBlob* blob, SkScalar x, SkScalar y,
diff --git a/src/gpu/text/GrTextUtils.cpp b/src/gpu/text/GrTextUtils.cpp
index 293ea4d891..9d6bb2c857 100644
--- a/src/gpu/text/GrTextUtils.cpp
+++ b/src/gpu/text/GrTextUtils.cpp
@@ -23,7 +23,7 @@
 
 void GrTextUtils::DrawBmpText(GrAtlasTextBlob* blob, int runIndex,
                               GrBatchFontCache* fontCache,
-                              SkGlyphCache* cache, const SkPaint& skPaint,
+                              const SkSurfaceProps& props, const SkPaint& skPaint,
                               GrColor color,
                               const SkMatrix& viewMatrix,
                               const char text[], size_t byteLength,
@@ -38,6 +38,7 @@ void GrTextUtils::DrawBmpText(GrAtlasTextBlob* blob, int runIndex,
     GrBatchTextStrike* currStrike = nullptr;
 
     // Get GrFontScaler from cache
+    SkGlyphCache* cache = blob->setupCache(runIndex, props, skPaint, &viewMatrix, false);
     GrFontScaler* fontScaler = GrTextContext::GetGrFontScaler(cache);
 
     SkFindAndPlaceGlyph::ProcessText(
@@ -52,11 +53,13 @@ void GrTextUtils::DrawBmpText(GrAtlasTextBlob* blob, int runIndex,
                 color, fontScaler);
         }
     );
+
+    SkGlyphCache::AttachCache(cache);
 }
 
 void GrTextUtils::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
                                  GrBatchFontCache* fontCache,
-                                 SkGlyphCache* cache, const SkPaint& skPaint,
+                                 const SkSurfaceProps& props, const SkPaint& skPaint,
                                  GrColor color,
                                  const SkMatrix& viewMatrix,
                                  const char text[], size_t byteLength,
@@ -73,6 +76,7 @@ void GrTextUtils::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
     GrBatchTextStrike* currStrike = nullptr;
 
     // Get GrFontScaler from cache
+    SkGlyphCache* cache = blob->setupCache(runIndex, props, skPaint, &viewMatrix, false);
     GrFontScaler* fontScaler = GrTextContext::GetGrFontScaler(cache);
 
     SkFindAndPlaceGlyph::ProcessPosText(
@@ -87,6 +91,8 @@ void GrTextUtils::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
                 color, fontScaler);
         }
     );
+
+    SkGlyphCache::AttachCache(cache);
 }
 
 void GrTextUtils::BmpAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
diff --git a/src/gpu/text/GrTextUtils.h b/src/gpu/text/GrTextUtils.h
index 8f673afbed..0996f655a3 100644
--- a/src/gpu/text/GrTextUtils.h
+++ b/src/gpu/text/GrTextUtils.h
@@ -35,13 +35,14 @@ class GrTextUtils {
 public:
     // Functions for appending BMP text to GrAtlasTextBlob
     static void DrawBmpText(GrAtlasTextBlob*, int runIndex,
-                            GrBatchFontCache*, SkGlyphCache*, const SkPaint&,
+                            GrBatchFontCache*, const SkSurfaceProps&,
+                            const SkPaint&,
                             GrColor, const SkMatrix& viewMatrix,
                             const char text[], size_t byteLength,
                             SkScalar x, SkScalar y);
 
     static void DrawBmpPosText(GrAtlasTextBlob*, int runIndex,
-                               GrBatchFontCache*, SkGlyphCache*, const SkPaint&,
+                               GrBatchFontCache*, const SkSurfaceProps&, const SkPaint&,
                                GrColor, const SkMatrix& viewMatrix,
                                const char text[], size_t byteLength,
                                const SkScalar pos[], int scalarsPerPosition,