reuse scaler across consecutive textbatch flushes

src/gpu/GrAtlasTextContext.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 "GrAtlasTextContext.h"
 
 #include "GrAtlas.h"
 #include "GrBatch.h"
@@ skipping 1486 matching lines @@
         GrDrawTarget::DrawInfo drawInfo;
         drawInfo.setPrimitiveType(kTriangles_GrPrimitiveType);
         drawInfo.setStartVertex(0);
         drawInfo.setStartIndex(0);
         drawInfo.setVerticesPerInstance(kVerticesPerGlyph);
         drawInfo.setIndicesPerInstance(kIndicesPerGlyph);
         drawInfo.adjustStartVertex(firstVertex);
         drawInfo.setVertexBuffer(vertexBuffer);
         drawInfo.setIndexBuffer(quadIndexBuffer);
 
+        // We cache some values to avoid going to the glyphcache for the same fontScaler twice
+        // in a row
+        const SkDescriptor* desc = NULL;
+        SkGlyphCache* cache = NULL;
+        GrFontScaler* scaler = NULL;
+        GrBatchTextStrike* strike = NULL;
+        SkTypeface* typeface = NULL;
+
         int instancesToFlush = 0;
         for (int i = 0; i < instanceCount; i++) {
             Geometry& args = fGeoData[i];
             Blob* blob = args.fBlob;
             Run& run = blob->fRuns[args.fRun];
             TextInfo& info = run.fSubRunInfo[args.fSubRun];
 
             uint64_t currentAtlasGen = fFontCache->atlasGeneration(fMaskFormat);
             bool regenerateTextureCoords = info.fAtlasGeneration != currentAtlasGen;
             bool regenerateColors;
             if (fUseDistanceFields) {
                 regenerateColors = !fUseLCDText && run.fColor != args.fColor;
             } else {
                 regenerateColors = kA8_GrMaskFormat == fMaskFormat && run.fColor != args.fColor;
             }
             bool regeneratePositions = args.fTransX != 0.f || args.fTransY != 0.f;
             int glyphCount = info.fGlyphEndIndex - info.fGlyphStartIndex;
 
             // We regenerate both texture coords and colors in the blob itself, and update the
             // atlas generation.  If we don't end up purging any unused plots, we can avoid
             // regenerating the coords.  We could take a finer grained approach to updating texture
             // coords but its not clear if the extra bookkeeping would offset any gains.
             // To avoid looping over the glyphs twice, we do one loop and conditionally update color
             // or coords as needed.  One final note, if we have to break a run for an atlas eviction
             // then we can't really trust the atlas has all of the correct data.  Atlas evictions
             // should be pretty rare, so we just always regenerate in those cases
             if (regenerateTextureCoords || regenerateColors || regeneratePositions) {
                 // first regenerate texture coordinates / colors if need be
-                const SkDescriptor* desc = NULL;
-                SkGlyphCache* cache = NULL;
-                GrFontScaler* scaler = NULL;
-                GrBatchTextStrike* strike = NULL;
                 bool brokenRun = false;
                 if (regenerateTextureCoords) {
                     info.fBulkUseToken.reset();
-                    desc = info.fOverrideDescriptor ? info.fOverrideDescriptor->getDesc() :
-                                                      run.fDescriptor.getDesc();
-                    cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
-                    scaler = GrTextContext::GetGrFontScaler(cache);
-                    strike = fFontCache->getStrike(scaler);
+
+                    // We can reuse if we have a valid strike and our descriptors / typeface are the
+                    // same
+                    const SkDescriptor* newDesc = info.fOverrideDescriptor ?
+                                                  info.fOverrideDescriptor->getDesc() :
+                                                  run.fDescriptor.getDesc();
+                    if (!cache || !SkTypeface::Equal(typeface, run.fTypeface) ||
+                                  !(desc->equals(*newDesc))) {
+                        if (cache) {
+                            SkGlyphCache::AttachCache(cache);
+                        }
+                        desc = newDesc;
+                        cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
+                        scaler = GrTextContext::GetGrFontScaler(cache);
+                        strike = fFontCache->getStrike(scaler);
+                        typeface = run.fTypeface;
+                    }
                 }
                 for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) {
                     GrGlyph::PackedID glyphID = blob->fGlyphIDs[glyphIdx + info.fGlyphStartIndex];
 
                     if (regenerateTextureCoords) {
                         // Upload the glyph only if needed
                         GrGlyph* glyph = strike->getGlyph(glyphID, scaler);
                         SkASSERT(glyph);
 
                         if (!fFontCache->hasGlyph(glyph) &&
@@ skipping 35 matching lines @@
                         SkScalar transX = args.fTransX;
                         SkScalar transY = args.fTransY;
                         this->regeneratePositions(vertex, vertexStride, transX, transY);
                     }
                     instancesToFlush++;
                 }
 
                 // We my have changed the color so update it here
                 run.fColor = args.fColor;
                 if (regenerateTextureCoords) {
-                    SkGlyphCache::AttachCache(cache);
                     info.fAtlasGeneration = brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration :
                                                         fFontCache->atlasGeneration(fMaskFormat);
                 }
             } else {
                 instancesToFlush += glyphCount;
 
                 // set use tokens for all of the glyphs in our subrun.  This is only valid if we
                 // have a valid atlas generation
                 fFontCache->setUseTokenBulk(info.fBulkUseToken,
                                             batchTarget->currentToken(),
                                             fMaskFormat);
             }
 
             // now copy all vertices
             size_t byteCount = info.fVertexEndIndex - info.fVertexStartIndex;
             memcpy(currVertex, blob->fVertices + info.fVertexStartIndex, byteCount);
 
             currVertex += byteCount;
         }
-
+        // Make sure to attach the last cache if applicable
+        if (cache) {
+            SkGlyphCache::AttachCache(cache);
+        }
         this->flush(batchTarget, &drawInfo, instancesToFlush, maxInstancesPerDraw);
     }
 
     // The minimum number of Geometry we will try to allocate.
     static const int kMinAllocated = 32;
 
     // Total number of Geometry this Batch owns
     int instanceCount() const { return fInstanceCount; }
     SkAutoSTMalloc<kMinAllocated, Geometry>* geoData() { return &fGeoData; }
 
@@ skipping 439 matching lines @@
     pipelineBuilder.setFromPaint(grPaint, rt, clip);
 
     GrColor color = grPaint.getColor();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
         this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, 0, 0, skPaint);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, rt, grPaint, clip, 0, 0);
 }