Adding bulk plot reffer to cached textblobs

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 803 matching lines @@
             // 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) {
                 // 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 = run.fDescriptor.getDesc();
                     cache = SkGlyphCache::DetachCache(run.fTypeface, desc);
                     scaler = GrTextContext::GetGrFontScaler(cache);
                     strike = fFontCache->getStrike(scaler);
                 }
                 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) &&
                             !strike->addGlyphToAtlas(batchTarget, glyph, scaler)) {
                             this->flush(batchTarget, &drawInfo, instancesToFlush,
                                         maxInstancesPerDraw);
                             this->initDraw(batchTarget, gp, pipeline);
                             instancesToFlush = 0;
                             brokenRun = glyphIdx > 0;
 
                             SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(batchTarget, glyph,
                                                                                 scaler);
                             SkASSERT(success);
                         }
-
-                        fFontCache->setGlyphRefToken(glyph, batchTarget->currentToken());
+                        fFontCache->addGlyphToBulkAndSetUseToken(&info.fBulkUseToken, glyph,
+                                                                 batchTarget->currentToken());
 
                         // Texture coords are the last vertex attribute so we get a pointer to the
                         // first one and then map with stride in regenerateTextureCoords
                         intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
                         vertex += info.fVertexStartIndex;
                         vertex += vertexStride * glyphIdx * kVerticesPerGlyph;
                         vertex += vertexStride - sizeof(SkIPoint16);
 
                         this->regenerateTextureCoords(glyph, vertex, vertexStride);
                     }
 
                     if (regenerateColors) {
                         intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices);
                         vertex += info.fVertexStartIndex;
                         vertex += vertexStride * glyphIdx * kVerticesPerGlyph + sizeof(SkPoint);
                         this->regenerateColors(vertex, vertexStride, args.fColor);
                     }
 
                     instancesToFlush++;
                 }
 
                 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;
         }
 
         this->flush(batchTarget, &drawInfo, instancesToFlush, maxInstancesPerDraw);
@@ skipping 242 matching lines @@
 
     GrColor color = grPaint.getColor();
     uint8_t paintAlpha = skPaint.getAlpha();
     for (int run = 0; run < cacheBlob->fRunCount; run++) {
         this->flushRun(target, &pipelineBuilder, cacheBlob, run, color, paintAlpha);
     }
 
     // Now flush big glyphs
     this->flushBigGlyphs(cacheBlob, rt, grPaint, clip);
 }