Make GrVertexBatch objects hold their own draws during GrDrawTarget flush

src/gpu/batches/GrDrawVerticesBatch.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 "GrDrawVerticesBatch.h"
 
-#include "GrBatchTarget.h"
+#include "GrBatchFlushState.h"
 #include "GrInvariantOutput.h"
 #include "GrDefaultGeoProcFactory.h"
 
 static const GrGeometryProcessor* set_vertex_attributes(bool hasLocalCoords,
                                                         bool hasColors,
                                                         int* colorOffset,
                                                         int* texOffset,
                                                         GrColor color,
                                                         const SkMatrix& viewMatrix,
                                                         bool coverageIgnored) {
@@ skipping 79 matching lines @@
     }
     opt.getOverrideColorIfSet(&fGeoData[0].fColor);
 
     // setup batch properties
     fBatch.fColorIgnored = !opt.readsColor();
     fBatch.fColor = fGeoData[0].fColor;
     fBatch.fUsesLocalCoords = opt.readsLocalCoords();
     fBatch.fCoverageIgnored = !opt.readsCoverage();
 }
 
-void GrDrawVerticesBatch::generateGeometry(GrBatchTarget* batchTarget) {
+void GrDrawVerticesBatch::onPrepareDraws(Target* target) {
     int colorOffset = -1, texOffset = -1;
     SkAutoTUnref<const GrGeometryProcessor> gp(
             set_vertex_attributes(this->hasLocalCoords(), this->hasColors(), &colorOffset,
                                   &texOffset, this->color(), this->viewMatrix(),
                                   this->coverageIgnored()));
 
-    batchTarget->initDraw(gp, this->pipeline());
+    target->initDraw(gp, this->pipeline());
 
     size_t vertexStride = gp->getVertexStride();
 
     SkASSERT(vertexStride == sizeof(SkPoint) + (this->hasLocalCoords() ? sizeof(SkPoint) : 0)
                                              + (this->hasColors() ? sizeof(GrColor) : 0));
 
     int instanceCount = fGeoData.count();
 
     const GrVertexBuffer* vertexBuffer;
     int firstVertex;
 
-    void* verts = batchTarget->makeVertSpace(vertexStride, this->vertexCount(),
-                                             &vertexBuffer, &firstVertex);
+    void* verts = target->makeVertexSpace(vertexStride, this->vertexCount(),
+                                          &vertexBuffer, &firstVertex);
 
     if (!verts) {
         SkDebugf("Could not allocate vertices\n");
         return;
     }
 
     const GrIndexBuffer* indexBuffer = NULL;
     int firstIndex = 0;
 
     uint16_t* indices = NULL;
     if (this->hasIndices()) {
-        indices = batchTarget->makeIndexSpace(this->indexCount(), &indexBuffer, &firstIndex);
+        indices = target->makeIndexSpace(this->indexCount(), &indexBuffer, &firstIndex);
 
         if (!indices) {
             SkDebugf("Could not allocate indices\n");
             return;
         }
     }
 
     int indexOffset = 0;
     int vertexOffset = 0;
     for (int i = 0; i < instanceCount; i++) {
@@ skipping 20 matching lines @@
     }
 
     GrVertices vertices;
     if (this->hasIndices()) {
         vertices.initIndexed(this->primitiveType(), vertexBuffer, indexBuffer, firstVertex,
                              firstIndex, this->vertexCount(), this->indexCount());
 
     } else {
         vertices.init(this->primitiveType(), vertexBuffer, firstVertex, this->vertexCount());
     }
-    batchTarget->draw(vertices);
+    target->draw(vertices);
 }
 
 bool GrDrawVerticesBatch::onCombineIfPossible(GrBatch* t, const GrCaps& caps) {
     GrDrawVerticesBatch* that = t->cast<GrDrawVerticesBatch>();
 
     if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                 that->bounds(), caps)) {
         return false;
     }
 
@@ skipping 146 matching lines @@
     geometry.fColor = GrRandomColor(random);
     return GrDrawVerticesBatch::Create(geometry, type, viewMatrix,
                                        positions.begin(), vertexCount,
                                        indices.begin(), hasIndices ? vertexCount : 0,
                                        colors.begin(),
                                        texCoords.begin(),
                                        bounds);
 }
 
 #endif