Make GrVertexBatch objects hold their own draws during GrDrawTarget flush

src/gpu/batches/GrAAFillRectBatch.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 "GrAAFillRectBatch.h"
 
+#include "GrBatchFlushState.h"
 #include "GrColor.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrResourceKey.h"
 #include "GrResourceProvider.h"
 #include "GrTypes.h"
 #include "GrVertexBatch.h"
 #include "SkMatrix.h"
 #include "SkRect.h"
 
 GR_DECLARE_STATIC_UNIQUE_KEY(gAAFillRectIndexBufferKey);
@@ skipping 69 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();
         fBatch.fCanTweakAlphaForCoverage = opt.canTweakAlphaForCoverage();
     }
 
-    void generateGeometry(GrBatchTarget* batchTarget) override {
+    void onPrepareDraws(Target* target) override {
         bool canTweakAlphaForCoverage = this->canTweakAlphaForCoverage();
 
         SkAutoTUnref<const GrGeometryProcessor> gp(CreateFillRectGP(canTweakAlphaForCoverage,
                                                                     this->viewMatrix(),
                                                                     this->usesLocalCoords(),
                                                                     Base::LocalCoordsType(),
                                                                     this->coverageIgnored()));
         if (!gp) {
             SkDebugf("Couldn't create GrGeometryProcessor\n");
             return;
         }
 
-        batchTarget->initDraw(gp, this->pipeline());
+        target->initDraw(gp, this->pipeline());
 
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(Base::StrideCheck(vertexStride, canTweakAlphaForCoverage,
                                    this->usesLocalCoords()));
         int instanceCount = fGeoData.count();
 
-        SkAutoTUnref<const GrIndexBuffer> indexBuffer(get_index_buffer(
-            batchTarget->resourceProvider()));
+        SkAutoTUnref<const GrIndexBuffer> indexBuffer(get_index_buffer(target->resourceProvider()));
         InstancedHelper helper;
-        void* vertices = helper.init(batchTarget, kTriangles_GrPrimitiveType, vertexStride,
+        void* vertices = helper.init(target, kTriangles_GrPrimitiveType, vertexStride,
                                      indexBuffer, kVertsPerAAFillRect, kIndicesPerAAFillRect,
                                      instanceCount);
         if (!vertices || !indexBuffer) {
             SkDebugf("Could not allocate vertices\n");
             return;
         }
 
         for (int i = 0; i < instanceCount; i++) {
             this->generateAAFillRectGeometry(vertices,
                                              i * kVertsPerAAFillRect * vertexStride,
                                              vertexStride,
                                              fGeoData[i],
                                              canTweakAlphaForCoverage);
         }
-        helper.issueDraw(batchTarget);
+        helper.recordDraw(target);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
     // to avoid even the initial copy of the struct, we have a getter for the first item which
     // is used to seed the batch with its initial geometry.  After seeding, the client should call
     // init() so the Batch can initialize itself
     Geometry* geometry() { return &fGeoData[0]; }
     void init() {
         const Geometry& geo = fGeoData[0];
@@ skipping 306 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AAFillRectBatchLocalMatrix) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkMatrix localMatrix = GrTest::TestMatrix(random);
     SkRect rect = GrTest::TestRect(random);
     SkRect devRect = GrTest::TestRect(random);
     return GrAAFillRectBatch::Create(color, viewMatrix, localMatrix, rect, devRect);
 }
 
 #endif