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

src/gpu/batches/GrAtlasTextBatch.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAtlasTextBatch.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 114 matching lines @@
                                              &flushInfo.fVertexOffset);
     flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
     flushInfo.fIndexBuffer.reset(target->resourceProvider()->refQuadIndexBuffer());
     if (!vertices || !flushInfo.fVertexBuffer) {
         SkDebugf("Could not allocate vertices\n");
         return;
     }
 
     unsigned char* currVertex = reinterpret_cast<unsigned char*>(vertices);
 
-    // We cache some values to avoid going to the glyphcache for the same fontScaler twice
-    // in a row
-    const SkDescriptor* desc = nullptr;
-    SkGlyphCache* cache = nullptr;
-    SkTypeface* typeface = nullptr;
-
     GrBlobRegenHelper helper(this, target, &flushInfo);
-
+    SkAutoGlyphCache glyphCache;
     for (int i = 0; i < fGeoCount; i++) {
         const Geometry& args = fGeoData[i];
         Blob* blob = args.fBlob;
         size_t byteCount;
         void* blobVertices;
         int subRunGlyphCount;
-        blob->regenInBatch(target, fFontCache, &helper, args.fRun, args.fSubRun, &cache,
-                           &typeface, &desc, vertexStride, args.fViewMatrix, args.fX,
-                           args.fY, args.fColor, &blobVertices, &byteCount, &subRunGlyphCount);
+        blob->regenInBatch(target, fFontCache, &helper, args.fRun, args.fSubRun, &glyphCache,
+                           vertexStride, args.fViewMatrix, args.fX, args.fY, args.fColor,
+                           &blobVertices, &byteCount, &subRunGlyphCount);
 
         // now copy all vertices
         memcpy(currVertex, blobVertices, byteCount);
 
 #ifdef SK_DEBUG
         // bounds sanity check
         SkRect rect;
         rect.setLargestInverted();
         SkPoint* vertex = (SkPoint*) ((char*)blobVertices);
         rect.growToInclude(vertex, vertexStride, kVerticesPerGlyph * subRunGlyphCount);
 
         if (this->usesDistanceFields()) {
             args.fViewMatrix.mapRect(&rect);
         }
         // Allow for small numerical error in the bounds.
         SkRect bounds = fBounds;
         bounds.outset(0.001f, 0.001f);
         SkASSERT(bounds.contains(rect));
 #endif
 
         currVertex += byteCount;
     }
 
-    // Make sure to attach the last cache if applicable
-    if (cache) {
-        SkGlyphCache::AttachCache(cache);
-    }
     this->flush(target, &flushInfo);
 }
 
 void GrAtlasTextBatch::flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const {
     GrMesh mesh;
     int maxGlyphsPerDraw =
         static_cast<int>(flushInfo->fIndexBuffer->gpuMemorySize() / sizeof(uint16_t) / 6);
     mesh.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer,
                        flushInfo->fIndexBuffer, flushInfo->fVertexOffset,
                        kVerticesPerGlyph, kIndicesPerGlyph, flushInfo->fGlyphsToFlush,
@@ skipping 124 matching lines @@
                                                     flags,
                                                     this->usesLocalCoords());
 #endif
     }
 
 }
 
 void GrBlobRegenHelper::flush() {
     fBatch->flush(fTarget, fFlushInfo);
 }