Introduce GrBatch subclasses GrDrawBatch and GrVertexBatch to prepare for non-drawing batches

src/gpu/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 "GrBatchTarget.h"
@@ skipping 652 matching lines @@
             actualBounds.growToInclude(pos.fX, pos.fY);
         }
     }
     if (!first) {
         return tolDevBounds.contains(actualBounds);
     }
 
     return true;
 }
 
-class AAHairlineBatch : public GrBatch {
+class AAHairlineBatch : public GrVertexBatch {
 public:
     struct Geometry {
         GrColor fColor;
         uint8_t fCoverage;
         SkMatrix fViewMatrix;
         SkPath fPath;
         SkIRect fDevClipBounds;
     };
 
-    static GrBatch* Create(const Geometry& geometry) {
+    static GrDrawBatch* Create(const Geometry& geometry) {
         return SkNEW_ARGS(AAHairlineBatch, (geometry));
     }
 
     const char* name() const override { return "AAHairlineBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
         out->setKnownFourComponents(fGeoData[0].fColor);
     }
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
@@ skipping 31 matching lines @@
         // compute bounds
         fBounds = geometry.fPath.getBounds();
         geometry.fViewMatrix.mapRect(&fBounds);
 
         // This is b.c. hairlines are notionally infinitely thin so without expansion
         // two overlapping lines could be reordered even though they hit the same pixels.
         fBounds.outset(0.5f, 0.5f);
     }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
-        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *t->pipeline(), t->bounds(),
-                                    caps)) {
+        AAHairlineBatch* that = t->cast<AAHairlineBatch>();
+
+        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
+                                    that->bounds(), caps)) {
             return false;
         }
 
-        AAHairlineBatch* that = t->cast<AAHairlineBatch>();
-
         if (this->viewMatrix().hasPerspective() != that->viewMatrix().hasPerspective()) {
             return false;
         }
 
         // We go to identity if we don't have perspective
         if (this->viewMatrix().hasPerspective() &&
             !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
@@ skipping 191 matching lines @@
                 GrVertices verts;
                 verts.initInstanced(kTriangles_GrPrimitiveType, vertexBuffer, quadsIndexBuffer,
                                     firstVertex, kQuadNumVertices, kIdxsPerQuad, conicCount,
                                     kQuadsNumInIdxBuffer);
                 batchTarget->draw(verts);
             }
         }
     }
 }
 
-static GrBatch* create_hairline_batch(GrColor color,
-                                      const SkMatrix& viewMatrix,
-                                      const SkPath& path,
-                                      const GrStrokeInfo& stroke,
-                                      const SkIRect& devClipBounds) {
+static GrDrawBatch* create_hairline_batch(GrColor color,
+                                          const SkMatrix& viewMatrix,
+                                          const SkPath& path,
+                                          const GrStrokeInfo& stroke,
+                                          const SkIRect& devClipBounds) {
     SkScalar hairlineCoverage;
     uint8_t newCoverage = 0xff;
     if (GrPathRenderer::IsStrokeHairlineOrEquivalent(stroke, viewMatrix, &hairlineCoverage)) {
         newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
     }
 
     AAHairlineBatch::Geometry geometry;
     geometry.fColor = color;
     geometry.fCoverage = newCoverage;
     geometry.fViewMatrix = viewMatrix;
     geometry.fPath = path;
     geometry.fDevClipBounds = devClipBounds;
 
     return AAHairlineBatch::Create(geometry);
 }
 
 bool GrAAHairLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
     SkIRect devClipBounds;
     args.fPipelineBuilder->clip().getConservativeBounds(args.fPipelineBuilder->getRenderTarget(),
                                                         &devClipBounds);
 
-    SkAutoTUnref<GrBatch> batch(create_hairline_batch(args.fColor, *args.fViewMatrix, *args.fPath,
-                                                      *args.fStroke, devClipBounds));
+    SkAutoTUnref<GrDrawBatch> batch(create_hairline_batch(args.fColor, *args.fViewMatrix, *args.fPath,
+                                                          *args.fStroke, devClipBounds));
     args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
-BATCH_TEST_DEFINE(AAHairlineBatch) {
+DRAW_BATCH_TEST_DEFINE(AAHairlineBatch) {
     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