Simplify GrDrawBatch uploads and token uage.

src/gpu/batches/GrAAHairLinePathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAHairLinePathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 788 matching lines @@
     const SkMatrix* geometryProcessorLocalM = &invert;
     const SkMatrix* toDevice = nullptr;
     const SkMatrix* toSrc = nullptr;
     if (hasPerspective) {
         geometryProcessorViewM = &this->viewMatrix();
         geometryProcessorLocalM = &SkMatrix::I();
         toDevice = &this->viewMatrix();
         toSrc = &invert;
     }
 
-    SkAutoTUnref<const GrGeometryProcessor> lineGP;
-    {
-        using namespace GrDefaultGeoProcFactory;
-
-        Color color(this->color());
-        Coverage coverage(Coverage::kAttribute_Type);
-        LocalCoords localCoords(this->usesLocalCoords() ? LocalCoords::kUsePosition_Type :
-                                                          LocalCoords::kUnused_Type);
-        localCoords.fMatrix = geometryProcessorLocalM;
-        lineGP.reset(GrDefaultGeoProcFactory::Create(color, coverage, localCoords,
-                                                     *geometryProcessorViewM));
-    }
-
-    SkAutoTUnref<const GrGeometryProcessor> quadGP(
-            GrQuadEffect::Create(this->color(),
-                                 *geometryProcessorViewM,
-                                 kHairlineAA_GrProcessorEdgeType,
-                                 target->caps(),
-                                 *geometryProcessorLocalM,
-                                 this->usesLocalCoords(),
-                                 this->coverage()));
-
-    SkAutoTUnref<const GrGeometryProcessor> conicGP(
-            GrConicEffect::Create(this->color(),
-                                  *geometryProcessorViewM,
-                                  kHairlineAA_GrProcessorEdgeType,
-                                  target->caps(),
-                                  *geometryProcessorLocalM,
-                                  this->usesLocalCoords(),
-                                  this->coverage()));
-
     // This is hand inlined for maximum performance.
     PREALLOC_PTARRAY(128) lines;
     PREALLOC_PTARRAY(128) quads;
     PREALLOC_PTARRAY(128) conics;
     IntArray qSubdivs;
     FloatArray cWeights;
     int quadCount = 0;
 
     int instanceCount = fGeoData.count();
     for (int i = 0; i < instanceCount; i++) {
         const Geometry& args = fGeoData[i];
         quadCount += gather_lines_and_quads(args.fPath, args.fViewMatrix, args.fDevClipBounds,
                                             &lines, &quads, &conics, &qSubdivs, &cWeights);
     }
 
     int lineCount = lines.count() / 2;
     int conicCount = conics.count() / 3;
 
     // do lines first
     if (lineCount) {
+        SkAutoTUnref<const GrGeometryProcessor> lineGP;
+        {
+            using namespace GrDefaultGeoProcFactory;
+
+            Color color(this->color());
+            Coverage coverage(Coverage::kAttribute_Type);
+            LocalCoords localCoords(this->usesLocalCoords() ? LocalCoords::kUsePosition_Type :
+                                    LocalCoords::kUnused_Type);
+            localCoords.fMatrix = geometryProcessorLocalM;
+            lineGP.reset(GrDefaultGeoProcFactory::Create(color, coverage, localCoords,
+                                                         *geometryProcessorViewM));
+        }
+
         SkAutoTUnref<const GrBuffer> linesIndexBuffer(
             ref_lines_index_buffer(target->resourceProvider()));
-        target->initDraw(lineGP);
 
         const GrBuffer* vertexBuffer;
         int firstVertex;
 
         size_t vertexStride = lineGP->getVertexStride();
         int vertexCount = kLineSegNumVertices * lineCount;
         LineVertex* verts = reinterpret_cast<LineVertex*>(
             target->makeVertexSpace(vertexStride, vertexCount, &vertexBuffer, &firstVertex));
 
         if (!verts|| !linesIndexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         SkASSERT(lineGP->getVertexStride() == sizeof(LineVertex));
 
         for (int i = 0; i < lineCount; ++i) {
             add_line(&lines[2*i], toSrc, this->coverage(), &verts);
         }
 
-        {
-            GrMesh mesh;
-            mesh.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, linesIndexBuffer,
-                               firstVertex, kLineSegNumVertices, kIdxsPerLineSeg, lineCount,
-                               kLineSegsNumInIdxBuffer);
-            target->draw(mesh);
-        }
+        GrMesh mesh;
+        mesh.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, linesIndexBuffer,
+                           firstVertex, kLineSegNumVertices, kIdxsPerLineSeg, lineCount,
+                           kLineSegsNumInIdxBuffer);
+        target->draw(lineGP, mesh);
     }
 
     if (quadCount || conicCount) {
+        SkAutoTUnref<const GrGeometryProcessor> quadGP(
+            GrQuadEffect::Create(this->color(),
+                                 *geometryProcessorViewM,
+                                 kHairlineAA_GrProcessorEdgeType,
+                                 target->caps(),
+                                 *geometryProcessorLocalM,
+                                 this->usesLocalCoords(),
+                                 this->coverage()));
+
+        SkAutoTUnref<const GrGeometryProcessor> conicGP(
+            GrConicEffect::Create(this->color(),
+                                  *geometryProcessorViewM,
+                                  kHairlineAA_GrProcessorEdgeType,
+                                  target->caps(),
+                                  *geometryProcessorLocalM,
+                                  this->usesLocalCoords(),
+                                  this->coverage()));
+
         const GrBuffer* vertexBuffer;
         int firstVertex;
 
         SkAutoTUnref<const GrBuffer> quadsIndexBuffer(
             ref_quads_index_buffer(target->resourceProvider()));
 
         size_t vertexStride = sizeof(BezierVertex);
         int vertexCount = kQuadNumVertices * quadCount + kQuadNumVertices * conicCount;
         void *vertices = target->makeVertexSpace(vertexStride, vertexCount,
                                                  &vertexBuffer, &firstVertex);
@@ skipping 11 matching lines @@
             SkASSERT(qSubdivs[i] >= 0);
             add_quads(&quads[3*i], qSubdivs[i], toDevice, toSrc, &bezVerts);
         }
 
         // Start Conics
         for (int i = 0; i < conicCount; ++i) {
             add_conics(&conics[3*i], cWeights[i], toDevice, toSrc, &bezVerts);
         }
 
         if (quadCount > 0) {
-            target->initDraw(quadGP);
-
-            {
-                GrMesh mesh;
-                mesh.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
-                                   firstVertex, kQuadNumVertices, kIdxsPerQuad, quadCount,
-                                   kQuadsNumInIdxBuffer);
-                target->draw(mesh);
-                firstVertex += quadCount * kQuadNumVertices;
-           }
+            GrMesh mesh;
+            mesh.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
+                               firstVertex, kQuadNumVertices, kIdxsPerQuad, quadCount,
+                               kQuadsNumInIdxBuffer);
+            target->draw(quadGP, mesh);
+            firstVertex += quadCount * kQuadNumVertices;
         }
 
         if (conicCount > 0) {
-            target->initDraw(conicGP);
-
-            {
-                GrMesh mesh;
-                mesh.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
-                                   firstVertex, kQuadNumVertices, kIdxsPerQuad, conicCount,
-                                   kQuadsNumInIdxBuffer);
-                target->draw(mesh);
-            }
+            GrMesh mesh;
+            mesh.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
+                               firstVertex, kQuadNumVertices, kIdxsPerQuad, conicCount,
+                               kQuadsNumInIdxBuffer);
+            target->draw(conicGP, mesh);
         }
     }
 }
 
 static GrDrawBatch* create_hairline_batch(GrColor color,
                                           const SkMatrix& viewMatrix,
                                           const SkPath& path,
                                           const GrStrokeInfo& stroke,
                                           const SkIRect& devClipBounds) {
     SkScalar hairlineCoverage;
@@ skipping 33 matching lines @@
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     GrStrokeInfo stroke(SkStrokeRec::kHairline_InitStyle);
     SkPath path = GrTest::TestPath(random);
     SkIRect devClipBounds;
     devClipBounds.setEmpty();
     return create_hairline_batch(color, viewMatrix, path, stroke, devClipBounds);
 }
 
 #endif