Simplify GrDrawBatch uploads and token uage.

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 79 matching lines @@
     }
 
     GrTexture* texture = fFontCache->getTexture(this->maskFormat());
     if (!texture) {
         SkDebugf("Could not allocate backing texture for atlas\n");
         return;
     }
 
     GrMaskFormat maskFormat = this->maskFormat();
 
-    SkAutoTUnref<const GrGeometryProcessor> gp;
+    FlushInfo flushInfo;
     if (this->usesDistanceFields()) {
-        gp.reset(this->setupDfProcessor(this->viewMatrix(), fFilteredColor, this->color(),
-                                        texture));
+        flushInfo.fGeometryProcessor.reset(
+            this->setupDfProcessor(this->viewMatrix(), fFilteredColor, this->color(), texture));
     } else {
         GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kNone_FilterMode);
-        gp.reset(GrBitmapTextGeoProc::Create(this->color(),
-                                             texture,
-                                             params,
-                                             maskFormat,
-                                             localMatrix,
-                                             this->usesLocalCoords()));
+        flushInfo.fGeometryProcessor.reset(
+            GrBitmapTextGeoProc::Create(this->color(),
+                                        texture,
+                                        params,
+                                        maskFormat,
+                                        localMatrix,
+                                        this->usesLocalCoords()));
     }
 
-    FlushInfo flushInfo;
     flushInfo.fGlyphsToFlush = 0;
-    size_t vertexStride = gp->getVertexStride();
+    size_t vertexStride = flushInfo.fGeometryProcessor->getVertexStride();
     SkASSERT(vertexStride == GrAtlasTextBlob::GetVertexStride(maskFormat));
 
-    target->initDraw(gp);
-
     int glyphCount = this->numGlyphs();
     const GrBuffer* vertexBuffer;
 
     void* vertices = target->makeVertexSpace(vertexStride,
                                              glyphCount * kVerticesPerGlyph,
                                              &vertexBuffer,
                                              &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;
     GrFontScaler* scaler = nullptr;
     SkTypeface* typeface = nullptr;
 
-    GrBlobRegenHelper helper(this, target, &flushInfo, gp);
+    GrBlobRegenHelper helper(this, target, &flushInfo);
 
     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, &scaler, &desc, vertexStride, args.fViewMatrix, args.fX,
                            args.fY, args.fColor, &blobVertices, &byteCount, &subRunGlyphCount);
@@ skipping 25 matching lines @@
 }
 
 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,
                        maxGlyphsPerDraw);
-    target->draw(mesh);
+    target->draw(flushInfo->fGeometryProcessor, mesh);
     flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
     flushInfo->fGlyphsToFlush = 0;
 }
 
 bool GrAtlasTextBatch::onCombineIfPossible(GrBatch* t, const GrCaps& caps) {
     GrAtlasTextBatch* that = t->cast<GrAtlasTextBatch>();
     if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                 that->bounds(), caps)) {
         return false;
     }
@@ skipping 106 matching lines @@
                                                     params,
                                                     flags,
                                                     this->usesLocalCoords());
 #endif
     }
 
 }
 
 void GrBlobRegenHelper::flush() {
     fBatch->flush(fTarget, fFlushInfo);
-    fTarget->initDraw(fGP);
 }