Remove attach and detach glyph cache.

BUG=skia:7515

Change-Id: Ib978e3cf4cfffdefe6453feb520e5e73684abf2e
Reviewed-on: https://skia-review.googlesource.com/112560
Reviewed-by: Ben Wagner <bungeman@google.com>
Commit-Queue: Herb Derby <herb@google.com>

10 files changed, 139 insertions, 156 deletions

diff --git a/src/core/SkGlyphCache.cpp b/src/core/SkGlyphCache.cpp
index 9bb43604a6..668f0e49b2 100644
--- a/src/core/SkGlyphCache.cpp
+++ b/src/core/SkGlyphCache.cpp
@@ -505,6 +505,23 @@ SkExclusiveStrikePtr SkGlyphCache::FindOrCreateStrikeExclusive(
     return FindOrCreateStrikeExclusive(desc, creator);
 }
 
+SkExclusiveStrikePtr SkGlyphCache::FindOrCreateStrikeExclusive(
+    const SkPaint& paint,
+    const SkSurfaceProps* surfaceProps,
+    SkScalerContextFlags scalerContextFlags,
+    const SkMatrix* deviceMatrix)
+{
+    SkAutoDescriptor ad;
+    SkScalerContextEffects effects;
+
+    auto desc = SkScalerContext::CreateDescriptorAndEffectsUsingPaint(
+        paint, surfaceProps, scalerContextFlags, deviceMatrix, &ad, &effects);
+
+    auto tf = SkPaintPriv::GetTypefaceOrDefault(paint);
+
+    return FindOrCreateStrikeExclusive(*desc, effects, *tf);
+}
+
 void SkGlyphCache::AttachCache(SkGlyphCache* cache) {
     SkGlyphCache_Globals::AttachCache(cache);
 }
@@ -786,22 +803,3 @@ void SkGraphics::PurgeFontCache() {
 size_t SkGraphics::GetTLSFontCacheLimit() { return 0; }
 void SkGraphics::SetTLSFontCacheLimit(size_t bytes) { }
 
-SkGlyphCache* SkGlyphCache::DetachCache(
-    SkTypeface* typeface, const SkScalerContextEffects& effects, const SkDescriptor* desc)
-{
-    auto cache = FindOrCreateStrikeExclusive(*desc, effects, *typeface);
-    return cache.release();
-}
-
-SkGlyphCache* SkGlyphCache::DetachCacheUsingPaint(const SkPaint& paint,
-                                                  const SkSurfaceProps* surfaceProps,
-                                                  SkScalerContextFlags scalerContextFlags,
-                                                  const SkMatrix* deviceMatrix) {
-    SkAutoDescriptor ad;
-    SkScalerContextEffects effects;
-
-    auto desc = SkScalerContext::CreateDescriptorAndEffectsUsingPaint(
-        paint, surfaceProps, scalerContextFlags, deviceMatrix, &ad, &effects);
-
-    return SkGlyphCache::DetachCache(SkPaintPriv::GetTypefaceOrDefault(paint), effects, desc);
-}
diff --git a/src/core/SkGlyphCache.h b/src/core/SkGlyphCache.h
index 8c335af859..a161f6f448 100644
--- a/src/core/SkGlyphCache.h
+++ b/src/core/SkGlyphCache.h
@@ -148,6 +148,12 @@ public:
         const SkScalerContextEffects& effects,
         const SkTypeface& typeface);
 
+    static SkExclusiveStrikePtr FindOrCreateStrikeExclusive(
+        const SkPaint& paint,
+        const SkSurfaceProps* surfaceProps,
+        SkScalerContextFlags scalerContextFlags,
+        const SkMatrix* deviceMatrix);
+
     template <typename ScalerContextCreator>
     static SkExclusiveStrikePtr CreateStrikeExclusive(
         const SkDescriptor& desc, ScalerContextCreator creator)
@@ -167,22 +173,6 @@ public:
         return SkExclusiveStrikePtr(new SkGlyphCache(desc, std::move(context)));
     }
 
-    /** Detach a strike from the global cache matching the specified descriptor. Once detached,
-        it can be queried/modified by the current thread, and when finished, be reattached to the
-        global cache with AttachCache(). While detached, if another request is made with the same
-        descriptor, a different strike will be generated. This is fine. It does mean we can have
-        more than 1 strike for the same descriptor, but that will eventually get purged, and the
-        win is that different thread will never block each other while a strike is being used.
-        DEPRECATED
-    */
-    static SkGlyphCache* DetachCache(
-        SkTypeface* typeface, const SkScalerContextEffects& effects, const SkDescriptor* desc);
-
-    static SkGlyphCache* DetachCacheUsingPaint(const SkPaint& paint,
-                                               const SkSurfaceProps* surfaceProps,
-                                               SkScalerContextFlags scalerContextFlags,
-                                               const SkMatrix* deviceMatrix);
-
     static void Dump();
 
     /** Dump memory usage statistics of all the attaches caches in the process using the
@@ -296,20 +286,17 @@ private:
 
 class SkAutoGlyphCache : public SkExclusiveStrikePtr {
 public:
-    /** deprecated: use get() */
-    SkGlyphCache* getCache() const { return this->get(); }
     SkAutoGlyphCache() = default;
     SkAutoGlyphCache(SkGlyphCache* cache) : INHERITED(cache) {}
     SkAutoGlyphCache(SkTypeface* typeface, const SkScalerContextEffects& effects,
                      const SkDescriptor* desc)
-        : INHERITED(SkGlyphCache::DetachCache(typeface, effects, desc))
-    {}
+        : INHERITED(SkGlyphCache::FindOrCreateStrikeExclusive(*desc, effects, *typeface)) {}
     /** deprecated: always enables fake gamma */
     SkAutoGlyphCache(const SkPaint& paint,
                      const SkSurfaceProps* surfaceProps,
                      const SkMatrix* matrix)
         : INHERITED(
-        SkGlyphCache::DetachCacheUsingPaint(
+        SkGlyphCache::FindOrCreateStrikeExclusive(
             paint, surfaceProps,
             SkScalerContextFlags::kFakeGammaAndBoostContrast, matrix))
     {}
@@ -318,8 +305,8 @@ public:
                      SkScalerContextFlags scalerContextFlags,
                      const SkMatrix* matrix)
         : INHERITED(
-            SkGlyphCache::DetachCacheUsingPaint(paint, surfaceProps, scalerContextFlags, matrix))
-    {}
+            SkGlyphCache::FindOrCreateStrikeExclusive(
+                paint, surfaceProps, scalerContextFlags, matrix)) {}
 private:
     using INHERITED = SkExclusiveStrikePtr;
 };
diff --git a/src/core/SkPaint.cpp b/src/core/SkPaint.cpp
index e3680713b5..210b8e5a3a 100644
--- a/src/core/SkPaint.cpp
+++ b/src/core/SkPaint.cpp
@@ -431,7 +431,7 @@ int SkPaint::textToGlyphs(const void* textData, size_t byteLength, uint16_t glyp
     }
 
     SkAutoGlyphCache autoCache(*this, nullptr, nullptr);
-    SkGlyphCache*    cache = autoCache.getCache();
+    SkGlyphCache*    cache = autoCache.get();
 
     const char* text = (const char*)textData;
     const char* stop = text + byteLength;
@@ -489,7 +489,7 @@ bool SkPaint::containsText(const void* textData, size_t byteLength) const {
     }
 
     SkAutoGlyphCache autoCache(*this, nullptr, nullptr);
-    SkGlyphCache*    cache = autoCache.getCache();
+    SkGlyphCache*    cache = autoCache.get();
 
     switch (this->getTextEncoding()) {
         case SkPaint::kUTF8_TextEncoding: {
@@ -539,7 +539,7 @@ void SkPaint::glyphsToUnichars(const uint16_t glyphs[], int count, SkUnichar tex
 
     SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
     SkAutoGlyphCache autoCache(*this, &props, nullptr);
-    SkGlyphCache*    cache = autoCache.getCache();
+    SkGlyphCache*    cache = autoCache.get();
 
     for (int index = 0; index < count; index++) {
         textData[index] = cache->glyphToUnichar(glyphs[index]);
@@ -805,7 +805,7 @@ SkScalar SkPaint::measureText(const void* textData, size_t length, SkRect* bound
     SkScalar scale = canon.getScale();
 
     SkAutoGlyphCache    autoCache(paint, nullptr, nullptr);
-    SkGlyphCache*       cache = autoCache.getCache();
+    SkGlyphCache*       cache = autoCache.get();
 
     SkScalar width = 0;
 
@@ -859,7 +859,7 @@ size_t SkPaint::breakText(const void* textD, size_t length, SkScalar maxWidth,
     }
 
     SkAutoGlyphCache    autoCache(paint, nullptr, nullptr);
-    SkGlyphCache*       cache = autoCache.getCache();
+    SkGlyphCache*       cache = autoCache.get();
 
     GlyphCacheProc   glyphCacheProc = SkPaint::GetGlyphCacheProc(paint.getTextEncoding(),
                                                                  paint.isDevKernText(),
@@ -965,7 +965,7 @@ int SkPaint::getTextWidths(const void* textData, size_t byteLength,
     SkScalar scale = canon.getScale();
 
     SkAutoGlyphCache    autoCache(paint, nullptr, nullptr);
-    SkGlyphCache*       cache = autoCache.getCache();
+    SkGlyphCache*       cache = autoCache.get();
     GlyphCacheProc      glyphCacheProc = SkPaint::GetGlyphCacheProc(paint.getTextEncoding(),
                                                                     paint.isDevKernText(),
                                                                     nullptr != bounds);
@@ -1748,9 +1748,8 @@ SkTextBaseIter::SkTextBaseIter(const char text[], size_t length,
     }
 
     // SRGBTODO: Is this correct?
-    fCache = SkGlyphCache::DetachCacheUsingPaint(fPaint, nullptr,
-                                                 SkScalerContextFlags::kFakeGammaAndBoostContrast,
-                                                 nullptr);
+    fCache = SkGlyphCache::FindOrCreateStrikeExclusive(
+        fPaint, nullptr, SkScalerContextFlags::kFakeGammaAndBoostContrast, nullptr);
 
     SkPaint::Style  style = SkPaint::kFill_Style;
     sk_sp<SkPathEffect> pe;
@@ -1768,7 +1767,7 @@ SkTextBaseIter::SkTextBaseIter(const char text[], size_t length,
     SkScalar xOffset = 0;
     if (paint.getTextAlign() != SkPaint::kLeft_Align) { // need to measure first
         int      count;
-        SkScalar width = fPaint.measure_text(fCache, text, length, &count, nullptr) * fScale;
+        SkScalar width = fPaint.measure_text(fCache.get(), text, length, &count, nullptr) * fScale;
         if (paint.getTextAlign() == SkPaint::kCenter_Align) {
             width = SkScalarHalf(width);
         }
@@ -1783,13 +1782,9 @@ SkTextBaseIter::SkTextBaseIter(const char text[], size_t length,
     fXYIndex = paint.isVerticalText() ? 1 : 0;
 }
 
-SkTextBaseIter::~SkTextBaseIter() {
-    SkGlyphCache::AttachCache(fCache);
-}
-
 bool SkTextToPathIter::next(const SkPath** path, SkScalar* xpos) {
     if (fText < fStop) {
-        const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
+        const SkGlyph& glyph = fGlyphCacheProc(fCache.get(), &fText);
 
         fXPos += (fPrevAdvance + fAutoKern.adjust(glyph)) * fScale;
         fPrevAdvance = advance(glyph, fXYIndex);   // + fPaint.getTextTracking();
@@ -1812,7 +1807,7 @@ bool SkTextToPathIter::next(const SkPath** path, SkScalar* xpos) {
 }
 
 bool SkTextInterceptsIter::next(SkScalar* array, int* count) {
-    const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
+    const SkGlyph& glyph = fGlyphCacheProc(fCache.get(), &fText);
     fXPos += (fPrevAdvance + fAutoKern.adjust(glyph)) * fScale;
     fPrevAdvance = advance(glyph, fXYIndex);   // + fPaint.getTextTracking();
     if (fCache->findPath(glyph)) {
diff --git a/src/core/SkTextToPathIter.h b/src/core/SkTextToPathIter.h
index 6de12a84ce..8bcbc21b4d 100644
--- a/src/core/SkTextToPathIter.h
+++ b/src/core/SkTextToPathIter.h
@@ -9,22 +9,21 @@
 #define SkTextToPathIter_DEFINED
 
 #include "SkAutoKern.h"
+#include "SkGlyphCache.h"
 #include "SkPaint.h"
 
-class SkGlyphCache;
 
 class SkTextBaseIter {
 protected:
     SkTextBaseIter(const char text[], size_t length, const SkPaint& paint,
                    bool applyStrokeAndPathEffects);
-    ~SkTextBaseIter();
-
-    SkGlyphCache*   fCache;
-    SkPaint         fPaint;
-    SkScalar        fScale;
-    SkScalar        fPrevAdvance;
-    const char*     fText;
-    const char*     fStop;
+
+    SkExclusiveStrikePtr fCache;
+    SkPaint              fPaint;
+    SkScalar             fScale;
+    SkScalar             fPrevAdvance;
+    const char*          fText;
+    const char*          fStop;
     SkPaint::GlyphCacheProc fGlyphCacheProc;
 
     SkScalar        fXPos;      // accumulated xpos, returned in next
@@ -74,7 +73,7 @@ public:
         if (TextType::kPosText == fTextType
                 && fPaint.getTextAlign() != SkPaint::kLeft_Align) { // need to measure first
             const char* text = fText;
-            const SkGlyph& glyph = fGlyphCacheProc(fCache, &text);
+            const SkGlyph& glyph = fGlyphCacheProc(fCache.get(), &text);
             SkScalar width = (&glyph.fAdvanceX)[0] * fScale;
             if (fPaint.getTextAlign() == SkPaint::kCenter_Align) {
                 width = SkScalarHalf(width);
diff --git a/src/gpu/text/GrAtlasTextBlob.cpp b/src/gpu/text/GrAtlasTextBlob.cpp
index b4404c3ef9..dfe3312f99 100644
--- a/src/gpu/text/GrAtlasTextBlob.cpp
+++ b/src/gpu/text/GrAtlasTextBlob.cpp
@@ -55,11 +55,11 @@ sk_sp<GrAtlasTextBlob> GrAtlasTextBlob::Make(GrMemoryPool* pool, int glyphCount,
     return cacheBlob;
 }
 
-SkGlyphCache* GrAtlasTextBlob::setupCache(int runIndex,
-                                          const SkSurfaceProps& props,
-                                          SkScalerContextFlags scalerContextFlags,
-                                          const SkPaint& skPaint,
-                                          const SkMatrix* viewMatrix) {
+SkExclusiveStrikePtr GrAtlasTextBlob::setupCache(int runIndex,
+                                                 const SkSurfaceProps& props,
+                                                 SkScalerContextFlags scalerContextFlags,
+                                                 const SkPaint& skPaint,
+                                                 const SkMatrix* viewMatrix) {
     GrAtlasTextBlob::Run* run = &fRuns[runIndex];
 
     // if we have an override descriptor for the run, then we should use that
@@ -71,7 +71,8 @@ SkGlyphCache* GrAtlasTextBlob::setupCache(int runIndex,
     run->fTypeface = SkPaintPriv::RefTypefaceOrDefault(skPaint);
     run->fPathEffect = sk_ref_sp(effects.fPathEffect);
     run->fMaskFilter = sk_ref_sp(effects.fMaskFilter);
-    return SkGlyphCache::DetachCache(run->fTypeface.get(), effects, desc->getDesc());
+    return SkGlyphCache::FindOrCreateStrikeExclusive(
+        *desc->getDesc(), effects, *run->fTypeface.get());
 }
 
 void GrAtlasTextBlob::appendGlyph(int runIndex,
diff --git a/src/gpu/text/GrAtlasTextBlob.h b/src/gpu/text/GrAtlasTextBlob.h
index b4a11a496d..e5a931d3cf 100644
--- a/src/gpu/text/GrAtlasTextBlob.h
+++ b/src/gpu/text/GrAtlasTextBlob.h
@@ -170,11 +170,11 @@ public:
         run.fOverrideDescriptor.reset(new SkAutoDescriptor);
     }
 
-    SkGlyphCache* setupCache(int runIndex,
-                             const SkSurfaceProps& props,
-                             SkScalerContextFlags scalerContextFlags,
-                             const SkPaint& skPaint,
-                             const SkMatrix* viewMatrix);
+    SkExclusiveStrikePtr setupCache(int runIndex,
+                                    const SkSurfaceProps& props,
+                                    SkScalerContextFlags scalerContextFlags,
+                                    const SkPaint& skPaint,
+                                    const SkMatrix* viewMatrix);
 
     // Appends a glyph to the blob.  If the glyph is too large, the glyph will be appended
     // as a path.
@@ -607,7 +607,7 @@ private:
     GrDeferredUploadTarget* fUploadTarget;
     GrGlyphCache* fGlyphCache;
     GrAtlasManager* fFullAtlasManager;
-    SkAutoGlyphCache* fLazyCache;
+    SkExclusiveStrikePtr* fLazyCache;
     Run* fRun;
     Run::SubRunInfo* fSubRun;
     GrColor fColor;
diff --git a/src/gpu/text/GrAtlasTextBlobVertexRegenerator.cpp b/src/gpu/text/GrAtlasTextBlobVertexRegenerator.cpp
index 296df22f51..188f34c461 100644
--- a/src/gpu/text/GrAtlasTextBlobVertexRegenerator.cpp
+++ b/src/gpu/text/GrAtlasTextBlobVertexRegenerator.cpp
@@ -244,7 +244,8 @@ Regenerator::Result Regenerator::doRegen() {
             SkScalerContextEffects effects;
             effects.fPathEffect = fRun->fPathEffect.get();
             effects.fMaskFilter = fRun->fMaskFilter.get();
-            fLazyCache->reset(SkGlyphCache::DetachCache(fRun->fTypeface.get(), effects, desc));
+            *fLazyCache =
+                SkGlyphCache::FindOrCreateStrikeExclusive(*desc, effects, *fRun->fTypeface.get());
         }
 
         if (regenGlyphs) {
diff --git a/src/gpu/text/GrAtlasTextContext.cpp b/src/gpu/text/GrAtlasTextContext.cpp
index ad708d7d7f..72f5b5b1f7 100644
--- a/src/gpu/text/GrAtlasTextContext.cpp
+++ b/src/gpu/text/GrAtlasTextContext.cpp
@@ -386,20 +386,18 @@ void GrAtlasTextContext::DrawBmpText(GrAtlasTextBlob* blob, int runIndex,
         return;
     }
 
-    sk_sp<GrTextStrike> currStrike;
-    SkGlyphCache* cache = blob->setupCache(runIndex, props, scalerContextFlags, paint, &viewMatrix);
+    sk_sp<GrTextStrike> currStrike = nullptr;
+    auto cache = blob->setupCache(runIndex, props, scalerContextFlags, paint, &viewMatrix);
     SkFindAndPlaceGlyph::ProcessText(paint.skPaint().getTextEncoding(), text, byteLength, {x, y},
-                                     viewMatrix, paint.skPaint().getTextAlign(), cache,
+                                     viewMatrix, paint.skPaint().getTextAlign(), cache.get(),
                                      [&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
                                          position += rounding;
                                          BmpAppendGlyph(blob, runIndex, glyphCache, &currStrike,
                                                         glyph, SkScalarFloorToScalar(position.fX),
                                                         SkScalarFloorToScalar(position.fY),
-                                                        paint.filteredPremulColor(), cache,
+                                                        paint.filteredPremulColor(), cache.get(),
                                                         SK_Scalar1);
                                      });
-
-    SkGlyphCache::AttachCache(cache);
 }
 
 void GrAtlasTextContext::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
@@ -426,20 +424,19 @@ void GrAtlasTextContext::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
         return;
     }
 
-    sk_sp<GrTextStrike> currStrike;
-    SkGlyphCache* cache = blob->setupCache(runIndex, props, scalerContextFlags, paint, &viewMatrix);
+    sk_sp<GrTextStrike> currStrike = nullptr;
+
+    auto cache = blob->setupCache(runIndex, props, scalerContextFlags, paint, &viewMatrix);
     SkFindAndPlaceGlyph::ProcessPosText(
             paint.skPaint().getTextEncoding(), text, byteLength, offset, viewMatrix, pos,
-            scalarsPerPosition, paint.skPaint().getTextAlign(), cache,
+            scalarsPerPosition, paint.skPaint().getTextAlign(), cache.get(),
             [&](const SkGlyph& glyph, SkPoint position, SkPoint rounding) {
                 position += rounding;
                 BmpAppendGlyph(blob, runIndex, glyphCache, &currStrike, glyph,
                                SkScalarFloorToScalar(position.fX),
                                SkScalarFloorToScalar(position.fY),
-                               paint.filteredPremulColor(), cache, SK_Scalar1);
+                               paint.filteredPremulColor(), cache.get(), SK_Scalar1);
             });
-
-    SkGlyphCache::AttachCache(cache);
 }
 
 void GrAtlasTextContext::DrawBmpTextAsPaths(GrAtlasTextBlob* blob, int runIndex,
@@ -508,7 +505,7 @@ void GrAtlasTextContext::DrawBmpPosTextAsPaths(GrAtlasTextBlob* blob, int runInd
                                                                         pathPaint.isDevKernText(),
                                                                         true);
     SkAutoGlyphCache           autoCache(pathPaint, &props, nullptr);
-    SkGlyphCache*              cache = autoCache.getCache();
+    SkGlyphCache*              cache = autoCache.get();
 
     const char*        stop = text + byteLength;
     const char*        lastText = text;
@@ -693,41 +690,48 @@ void GrAtlasTextContext::drawDFText(GrAtlasTextBlob* blob, int runIndex,
     // passed-in scaler context flags. (It's only used when we fall-back to bitmap text).
     SkScalerContext::CreateDescriptorAndEffectsUsingPaint(
         skPaint, &props, SkScalerContextFlags::kNone, nullptr, &desc, &effects);
-    auto typeface = SkPaintPriv::GetTypefaceOrDefault(skPaint);
-    SkGlyphCache* origPaintCache =
-            SkGlyphCache::DetachCache(typeface, effects, desc.getDesc());
 
     SkTArray<SkScalar> positions;
-
-    const char* textPtr = text;
     SkScalar stopX = 0;
     SkScalar stopY = 0;
-    SkScalar origin = 0;
-    switch (skPaint.getTextAlign()) {
-        case SkPaint::kRight_Align: origin = SK_Scalar1; break;
-        case SkPaint::kCenter_Align: origin = SK_ScalarHalf; break;
-        case SkPaint::kLeft_Align: origin = 0; break;
-    }
+    {
+        auto tf = SkPaintPriv::GetTypefaceOrDefault(skPaint);
+        auto origPaintCache = SkGlyphCache::FindOrCreateStrikeExclusive(
+            *desc.getDesc(), effects, *tf);
+
+
+        const char* textPtr = text;
+        SkScalar origin = 0;
+        switch (skPaint.getTextAlign()) {
+            case SkPaint::kRight_Align:
+                origin = SK_Scalar1;
+                break;
+            case SkPaint::kCenter_Align:
+                origin = SK_ScalarHalf;
+                break;
+            case SkPaint::kLeft_Align:
+                origin = 0;
+                break;
+        }
 
-    SkAutoKern autokern;
-    const char* stop = text + byteLength;
-    while (textPtr < stop) {
-        // don't need x, y here, since all subpixel variants will have the
-        // same advance
-        const SkGlyph& glyph = glyphCacheProc(origPaintCache, &textPtr);
+        SkAutoKern autokern;
+        const char* stop = text + byteLength;
+        while (textPtr < stop) {
+            // don't need x, y here, since all subpixel variants will have the
+            // same advance
+            const SkGlyph& glyph = glyphCacheProc(origPaintCache.get(), &textPtr);
 
-        SkScalar width = SkFloatToScalar(glyph.fAdvanceX) + autokern.adjust(glyph);
-        positions.push_back(stopX + origin * width);
+            SkScalar width = SkFloatToScalar(glyph.fAdvanceX) + autokern.adjust(glyph);
+            positions.push_back(stopX + origin * width);
 
-        SkScalar height = SkFloatToScalar(glyph.fAdvanceY);
-        positions.push_back(stopY + origin * height);
+            SkScalar height = SkFloatToScalar(glyph.fAdvanceY);
+            positions.push_back(stopY + origin * height);
 
-        stopX += width;
-        stopY += height;
+            stopX += width;
+            stopY += height;
+        }
+        SkASSERT(textPtr == stop);
     }
-    SkASSERT(textPtr == stop);
-
-    SkGlyphCache::AttachCache(origPaintCache);
 
     // now adjust starting point depending on alignment
     SkScalar alignX = stopX;
@@ -778,40 +782,40 @@ void GrAtlasTextContext::drawDFPosText(GrAtlasTextBlob* blob, int runIndex,
 
     // We apply the fake-gamma by altering the distance in the shader, so we ignore the
     // passed-in scaler context flags. (It's only used when we fall-back to bitmap text).
-    SkGlyphCache* cache =
+    {
+        auto cache =
             blob->setupCache(runIndex, props, SkScalerContextFlags::kNone, dfPaint, nullptr);
-    SkPaint::GlyphCacheProc glyphCacheProc =
+        SkPaint::GlyphCacheProc glyphCacheProc =
             SkPaint::GetGlyphCacheProc(dfPaint.getTextEncoding(), dfPaint.isDevKernText(), true);
 
-    const char* stop = text + byteLength;
+        const char* stop = text + byteLength;
 
-    SkPaint::Align align = dfPaint.getTextAlign();
-    SkScalar alignMul = SkPaint::kCenter_Align == align ? SK_ScalarHalf :
-                        (SkPaint::kRight_Align == align ? SK_Scalar1 : 0);
-    while (text < stop) {
-        const char* lastText = text;
-        // the last 2 parameters are ignored
-        const SkGlyph& glyph = glyphCacheProc(cache, &text);
-
-        if (glyph.fWidth) {
-            SkPoint glyphPos(offset);
-            glyphPos.fX += pos[0] - SkFloatToScalar(glyph.fAdvanceX) * alignMul * textRatio;
-            glyphPos.fY += (2 == scalarsPerPosition ? pos[1] : 0) -
-                           SkFloatToScalar(glyph.fAdvanceY) * alignMul * textRatio;
-
-            if (glyph.fMaskFormat != SkMask::kARGB32_Format) {
-                DfAppendGlyph(blob, runIndex, glyphCache, &currStrike, glyph, glyphPos.fX,
-                              glyphPos.fY, paint.filteredPremulColor(), cache, textRatio);
-            } else {
-                // can't append color glyph to SDF batch, send to fallback
-                fallbackTextHelper.appendText(glyph, SkToInt(text - lastText), lastText, glyphPos);
+        SkPaint::Align align = dfPaint.getTextAlign();
+        SkScalar alignMul = SkPaint::kCenter_Align == align ? SK_ScalarHalf :
+                            (SkPaint::kRight_Align == align ? SK_Scalar1 : 0);
+        while (text < stop) {
+            const char* lastText = text;
+            // the last 2 parameters are ignored
+            const SkGlyph& glyph = glyphCacheProc(cache.get(), &text);
+
+            if (glyph.fWidth) {
+                SkPoint glyphPos(offset);
+                glyphPos.fX += pos[0] - SkFloatToScalar(glyph.fAdvanceX) * alignMul * textRatio;
+                glyphPos.fY += (2 == scalarsPerPosition ? pos[1] : 0) -
+                               SkFloatToScalar(glyph.fAdvanceY) * alignMul * textRatio;
+
+                if (glyph.fMaskFormat != SkMask::kARGB32_Format) {
+                    DfAppendGlyph(blob, runIndex, glyphCache, &currStrike, glyph, glyphPos.fX,
+                                  glyphPos.fY, paint.filteredPremulColor(), cache.get(), textRatio);
+                } else {
+                    // can't append color glyph to SDF batch, send to fallback
+                    fallbackTextHelper.appendText(glyph, SkToInt(text - lastText), lastText,
+                                                  glyphPos);
+                }
+                pos += scalarsPerPosition;
             }
         }
-        pos += scalarsPerPosition;
     }
-
-    SkGlyphCache::AttachCache(cache);
-
     fallbackTextHelper.drawText(blob, runIndex, glyphCache, props, paint, scalerContextFlags);
 }
 
@@ -883,7 +887,7 @@ void GrAtlasTextContext::FallbackTextHelper::drawText(GrAtlasTextBlob* blob, int
     if (fFallbackTxt.count()) {
         blob->initOverride(runIndex);
         blob->setHasBitmap();
-        SkGlyphCache* cache = nullptr;
+        SkExclusiveStrikePtr cache;
         const SkPaint& skPaint = paint.skPaint();
         SkPaint::GlyphCacheProc glyphCacheProc =
             SkPaint::GetGlyphCacheProc(skPaint.getTextEncoding(),
@@ -913,14 +917,12 @@ void GrAtlasTextContext::FallbackTextHelper::drawText(GrAtlasTextBlob* blob, int
         const char* stop = text + fFallbackTxt.count();
         SkPoint* glyphPos = fFallbackPos.begin();
         while (text < stop) {
-            const SkGlyph& glyph = glyphCacheProc(cache, &text);
+            const SkGlyph& glyph = glyphCacheProc(cache.get(), &text);
             GrAtlasTextContext::BmpAppendGlyph(blob, runIndex, glyphCache, &currStrike, glyph,
                                                glyphPos->fX, glyphPos->fY, textColor,
-                                               cache, textRatio);
+                                               cache.get(), textRatio);
             glyphPos++;
         }
-
-        SkGlyphCache::AttachCache(cache);
     }
 }
 
diff --git a/src/gpu/text/GrTextUtils.cpp b/src/gpu/text/GrTextUtils.cpp
index 680e262766..7d693d1e29 100644
--- a/src/gpu/text/GrTextUtils.cpp
+++ b/src/gpu/text/GrTextUtils.cpp
@@ -81,7 +81,7 @@ bool GrTextUtils::PathTextIter::next(const SkGlyph** skGlyph, const SkPath** pat
     SkASSERT(path);
     SkASSERT(xpos);
     if (fText < fStop) {
-        const SkGlyph& glyph = fGlyphCacheProc(fCache, &fText);
+        const SkGlyph& glyph = fGlyphCacheProc(fCache.get(), &fText);
 
         fXPos += (fPrevAdvance + fAutoKern.adjust(glyph)) * fScale;
         SkASSERT(0 == fXYIndex || 1 == fXYIndex);
diff --git a/src/xps/SkXPSDevice.cpp b/src/xps/SkXPSDevice.cpp
index 9f1a9609c1..b8387b9206 100644
--- a/src/xps/SkXPSDevice.cpp
+++ b/src/xps/SkXPSDevice.cpp
@@ -1877,7 +1877,7 @@ HRESULT SkXPSDevice::CreateTypefaceUse(const SkPaint& paint,
     newTypefaceUse.xpsFont = xpsFontResource.release();
 
     SkAutoGlyphCache agc(paint, &this->surfaceProps(), &SkMatrix::I());
-    SkGlyphCache* glyphCache = agc.getCache();
+    SkGlyphCache* glyphCache = agc.get();
     unsigned int glyphCount = glyphCache->getGlyphCount();
     newTypefaceUse.glyphsUsed = new SkBitSet(glyphCount);
 
@@ -2064,7 +2064,7 @@ void SkXPSDevice::drawText(const void* text, size_t byteLen,
     const SkMatrix& matrix = SkMatrix::I();
 
     SkAutoGlyphCache    autoCache(paint, &this->surfaceProps(), &matrix);
-    SkGlyphCache*       cache = autoCache.getCache();
+    SkGlyphCache*       cache = autoCache.get();
 
     // Advance width and offsets for glyphs measured in hundredths of the font em size
     // (XPS Spec 5.1.3).
@@ -2122,7 +2122,7 @@ void SkXPSDevice::drawPosText(const void* text, size_t byteLen,
     const SkMatrix& matrix = SkMatrix::I();
 
     SkAutoGlyphCache    autoCache(paint, &this->surfaceProps(), &matrix);
-    SkGlyphCache*       cache = autoCache.getCache();
+    SkGlyphCache*       cache = autoCache.get();
 
     // Advance width and offsets for glyphs measured in hundredths of the font em size
     // (XPS Spec 5.1.3).