Make GrVertexBatch objects hold their own draws during GrDrawTarget flush

src/gpu/batches/GrBWFillRectBatch.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 "GrBWFillRectBatch.h"
 
-#include "GrBatchTarget.h"
+#include "GrBatchFlushState.h"
 #include "GrColor.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrPrimitiveProcessor.h"
 #include "GrVertexBatch.h"
 
-class GrBatchTarget;
+class GrBatchFlushState;
 class SkMatrix;
 struct SkRect;
 
 class BWFillRectBatch : public GrVertexBatch {
 public:
     struct Geometry {
         SkMatrix fViewMatrix;
         SkRect fRect;
         SkRect fLocalRect;
         SkMatrix fLocalMatrix;
@@ skipping 24 matching lines @@
         }
         init.getOverrideColorIfSet(&fGeoData[0].fColor);
 
         // setup batch properties
         fBatch.fColorIgnored = !init.readsColor();
         fBatch.fColor = fGeoData[0].fColor;
         fBatch.fUsesLocalCoords = init.readsLocalCoords();
         fBatch.fCoverageIgnored = !init.readsCoverage();
     }
 
-    void generateGeometry(GrBatchTarget* batchTarget) override {
+    void onPrepareDraws(Target* target) override {
         SkAutoTUnref<const GrGeometryProcessor> gp(this->createRectGP());
         if (!gp) {
             SkDebugf("Could not create GrGeometryProcessor\n");
             return;
         }
 
-        batchTarget->initDraw(gp, this->pipeline());
+        target->initDraw(gp, this->pipeline());
 
         int instanceCount = fGeoData.count();
         size_t vertexStride = gp->getVertexStride();
         SkASSERT(this->hasLocalRect() ?
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) :
                  vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr));
         QuadHelper helper;
-        void* vertices = helper.init(batchTarget, vertexStride, instanceCount);
+        void* vertices = helper.init(target, vertexStride, instanceCount);
 
         if (!vertices) {
             return;
         }
 
         for (int i = 0; i < instanceCount; i++) {
             const Geometry& geom = fGeoData[i];
 
             intptr_t offset = reinterpret_cast<intptr_t>(vertices) +
                               kVerticesPerQuad * i * vertexStride;
@@ skipping 16 matching lines @@
             }
 
             static const int kColorOffset = sizeof(SkPoint);
             GrColor* vertColor = reinterpret_cast<GrColor*>(offset + kColorOffset);
             for (int j = 0; j < 4; ++j) {
                 *vertColor = geom.fColor;
                 vertColor = (GrColor*) ((intptr_t) vertColor + vertexStride);
             }
         }
 
-        helper.issueDraw(batchTarget);
+        helper.recordDraw(target);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     BWFillRectBatch(const Geometry& geometry) {
         this->initClassID<BWFillRectBatch>();
         fGeoData.push_back(geometry);
 
         fBounds = geometry.fRect;
@@ skipping 135 matching lines @@
 
     geometry.fHasLocalMatrix = random->nextBool();
     if (geometry.fHasLocalMatrix) {
         geometry.fLocalMatrix = GrTest::TestMatrix(random);
     }
 
     return BWFillRectBatch::Create(geometry);
 }
 
 #endif