Attempt to improve lifetime management of SkGlyphCache in Ganesh atlas text code.

src/gpu/text/GrAtlasTextBlob_regenInBatch.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextBlob.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 124 matching lines @@
         textureCoords[0] = (uint16_t)u1;
         textureCoords[1] = (uint16_t)v0;
     }
 }
 
 template <bool regenPos, bool regenCol, bool regenTexCoords, bool regenGlyphs>
 void GrAtlasTextBlob::regenInBatch(GrDrawBatch::Target* target,
                                    GrBatchFontCache* fontCache,
                                    GrBlobRegenHelper *helper,
                                    Run* run,
-                                   Run::SubRunInfo* info, SkGlyphCache** cache,
-                                   SkTypeface** typeface,
-                                   const SkDescriptor** desc,
+                                   Run::SubRunInfo* info,
+                                   SkAutoGlyphCache* lazyCache,
                                    int glyphCount, size_t vertexStride,
                                    GrColor color, SkScalar transX,
                                    SkScalar transY) const {
+    SkASSERT(lazyCache);
     static_assert(!regenGlyphs || regenTexCoords, "must regenTexCoords along regenGlyphs");
     GrBatchTextStrike* strike = nullptr;
     if (regenTexCoords) {
         info->resetBulkUseToken();
 
-        // We can reuse if we have a valid strike and our descriptors / typeface are the
-        // same.  The override descriptor is only for the non distance field text within
-        // a run
-        const SkDescriptor* newDesc = (run->fOverrideDescriptor && !info->drawAsDistanceFields()) ?
-                                      run->fOverrideDescriptor->getDesc() :
-                                      run->fDescriptor.getDesc();
-        if (!*cache || !SkTypeface::Equal(*typeface, run->fTypeface) ||
-            !(**desc == *newDesc)) {
-            if (*cache) {
-                SkGlyphCache::AttachCache(*cache);
-            }
-            *desc = newDesc;
-            *cache = SkGlyphCache::DetachCache(run->fTypeface, run->fEffects, *desc);
-            *typeface = run->fTypeface;
+        const SkDescriptor* desc = (run->fOverrideDescriptor && !info->drawAsDistanceFields())
+                                      ? run->fOverrideDescriptor->getDesc()
+                                      : run->fDescriptor.getDesc();
+
+        if (!*lazyCache || (*lazyCache)->getDescriptor() != *desc) {
+            lazyCache->reset(SkGlyphCache::DetachCache(run->fTypeface, run->fEffects, desc));
         }
 
         if (regenGlyphs) {
-            strike = fontCache->getStrike(*cache);
+            strike = fontCache->getStrike(lazyCache->get());
         } else {
             strike = info->strike();
         }
     }
 
     bool brokenRun = false;
     for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) {
         GrGlyph* glyph = nullptr;
         int log2Width = 0, log2Height = 0;
         if (regenTexCoords) {
             size_t glyphOffset = glyphIdx + info->glyphStartIndex();
 
             if (regenGlyphs) {
                 // Get the id from the old glyph, and use the new strike to lookup
                 // the glyph.
                 GrGlyph::PackedID id = fGlyphs[glyphOffset]->fPackedID;
-                fGlyphs[glyphOffset] = strike->getGlyph(id, info->maskFormat(), *cache);
+                fGlyphs[glyphOffset] = strike->getGlyph(id, info->maskFormat(), lazyCache->get());
                 SkASSERT(id == fGlyphs[glyphOffset]->fPackedID);
             }
             glyph = fGlyphs[glyphOffset];
             SkASSERT(glyph && glyph->fMaskFormat == info->maskFormat());
 
             if (!fontCache->hasGlyph(glyph) &&
-                !strike->addGlyphToAtlas(target, glyph, *cache, info->maskFormat())) {
+                !strike->addGlyphToAtlas(target, glyph, lazyCache->get(), info->maskFormat())) {
                 helper->flush();
                 brokenRun = glyphIdx > 0;
 
                 SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(target,
                                                                     glyph,
-                                                                    *cache,
+                                                                    lazyCache->get(),
                                                                     info->maskFormat());
                 SkASSERT(success);
             }
             fontCache->addGlyphToBulkAndSetUseToken(info->bulkUseToken(), glyph,
                                                     target->nextDrawToken());
             log2Width = fontCache->log2Width(info->maskFormat());
             log2Height = fontCache->log2Height(info->maskFormat());
         }
 
         intptr_t vertex = reinterpret_cast<intptr_t>(fVertices);
@@ skipping 17 matching lines @@
 }
 
 enum RegenMask {
     kNoRegen    = 0x0,
     kRegenPos   = 0x1,
     kRegenCol   = 0x2,
     kRegenTex   = 0x4,
     kRegenGlyph = 0x8 | kRegenTex, // we have to regenerate the texture coords when we regen glyphs
 
     // combinations
-        kRegenPosCol = kRegenPos | kRegenCol,
+    kRegenPosCol = kRegenPos | kRegenCol,
     kRegenPosTex = kRegenPos | kRegenTex,
     kRegenPosTexGlyph = kRegenPos | kRegenGlyph,
     kRegenPosColTex = kRegenPos | kRegenCol | kRegenTex,
     kRegenPosColTexGlyph = kRegenPos | kRegenCol | kRegenGlyph,
     kRegenColTex = kRegenCol | kRegenTex,
     kRegenColTexGlyph = kRegenCol | kRegenGlyph,
 };
 
-#define REGEN_ARGS target, fontCache, helper, &run, &info, cache, typeface, desc, \
+#define REGEN_ARGS target, fontCache, helper, &run, &info, lazyCache, \
                    *glyphCount, vertexStride, color, transX, transY
 
 void GrAtlasTextBlob::regenInBatch(GrDrawBatch::Target* target,
                                    GrBatchFontCache* fontCache,
                                    GrBlobRegenHelper *helper,
-                                   int runIndex, int subRunIndex, SkGlyphCache** cache,
-                                   SkTypeface** typeface, const SkDescriptor** desc,
+                                   int runIndex, int subRunIndex, SkAutoGlyphCache* lazyCache,
                                    size_t vertexStride, const SkMatrix& viewMatrix,
                                    SkScalar x, SkScalar y, GrColor color,
                                    void** vertices, size_t* byteCount, int* glyphCount) {
     Run& run = fRuns[runIndex];
     Run::SubRunInfo& info = run.fSubRunInfo[subRunIndex];
 
     uint64_t currentAtlasGen = fontCache->atlasGeneration(info.maskFormat());
 
     // Compute translation if any
     SkScalar transX, transY;
@@ skipping 42 matching lines @@
             // set use tokens for all of the glyphs in our subrun.  This is only valid if we
             // have a valid atlas generation
             fontCache->setUseTokenBulk(*info.bulkUseToken(), target->nextDrawToken(),
                                         info.maskFormat());
             break;
     }
 
     *byteCount = info.byteCount();
     *vertices = fVertices + info.vertexStartIndex();
 }