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

src/gpu/GrDefaultPathRenderer.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 "GrDefaultPathRenderer.h"
 
 #include "GrBatchTarget.h"
@@ skipping 191 matching lines @@
             srcSpaceTolSqd, vert,
             GrPathUtils::quadraticPointCount(pts, srcSpaceTol));
     if (indexed) {
         for (uint16_t i = 0; i < numPts; ++i) {
             append_countour_edge_indices(isHairline, subpathIdxStart,
                                          firstQPtIdx + i, idx);
         }
     }
 }
 
-class DefaultPathBatch : public GrBatch {
+class DefaultPathBatch : public GrVertexBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkPath fPath;
         SkScalar fTolerance;
     };
 
-    static GrBatch* Create(const Geometry& geometry, uint8_t coverage, const SkMatrix& viewMatrix,
-                           bool isHairline, const SkRect& devBounds) {
+    static GrDrawBatch* Create(const Geometry& geometry, uint8_t coverage,
+                               const SkMatrix& viewMatrix, bool isHairline,
+                               const SkRect& devBounds) {
         return SkNEW_ARGS(DefaultPathBatch, (geometry, coverage, viewMatrix, isHairline,
                                              devBounds));
     }
 
     const char* name() const override { return "DefaultPathBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
         out->setKnownFourComponents(fGeoData[0].fColor);
     }
@@ skipping 148 matching lines @@
         this->initClassID<DefaultPathBatch>();
         fBatch.fCoverage = coverage;
         fBatch.fIsHairline = isHairline;
         fBatch.fViewMatrix = viewMatrix;
         fGeoData.push_back(geometry);
 
         this->setBounds(devBounds);
     }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
-        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *t->pipeline(), t->bounds(),
-                                    caps)) {
+        DefaultPathBatch* that = t->cast<DefaultPathBatch>();
+        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
+                                     that->bounds(), caps)) {
             return false;
         }
 
-        DefaultPathBatch* that = t->cast<DefaultPathBatch>();
-
         if (this->color() != that->color()) {
             return false;
         }
 
         if (this->coverage() != that->coverage()) {
             return false;
         }
 
         if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
@@ skipping 283 matching lines @@
         } else {
             if (passCount > 1) {
                 pipelineBuilder->setDisableColorXPFactory();
             }
 
             DefaultPathBatch::Geometry geometry;
             geometry.fColor = color;
             geometry.fPath = path;
             geometry.fTolerance = srcSpaceTol;
 
-            SkAutoTUnref<GrBatch> batch(DefaultPathBatch::Create(geometry, newCoverage, viewMatrix,
-                                                                 isHairline, devBounds));
+            SkAutoTUnref<GrDrawBatch> batch(DefaultPathBatch::Create(geometry, newCoverage,
+                                                                     viewMatrix, isHairline,
+                                                                     devBounds));
 
             target->drawBatch(*pipelineBuilder, batch);
         }
     }
     return true;
 }
 
 bool GrDefaultPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // this class can draw any path with any fill but doesn't do any anti-aliasing.
     return !args.fAntiAlias && (args.fStroke->isFillStyle() ||
@@ skipping 15 matching lines @@
     SkASSERT(SkPath::kInverseEvenOdd_FillType != args.fPath->getFillType());
     SkASSERT(SkPath::kInverseWinding_FillType != args.fPath->getFillType());
     this->internalDrawPath(args.fTarget, args.fPipelineBuilder, GrColor_WHITE, *args.fViewMatrix,
                            *args.fPath, *args.fStroke, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
-BATCH_TEST_DEFINE(DefaultPathBatch) {
+DRAW_BATCH_TEST_DEFINE(DefaultPathBatch) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
 
     // For now just hairlines because the other types of draws require two batches.
     // TODO we should figure out a way to combine the stencil and cover steps into one batch
     GrStrokeInfo stroke(SkStrokeRec::kHairline_InitStyle);
     SkPath path = GrTest::TestPath(random);
 
     // Compute srcSpaceTol
     SkRect bounds = path.getBounds();
     SkScalar tol = GrPathUtils::kDefaultTolerance;
     SkScalar srcSpaceTol = GrPathUtils::scaleToleranceToSrc(tol, viewMatrix, bounds);
 
     DefaultPathBatch::Geometry geometry;
     geometry.fColor = color;
     geometry.fPath = path;
     geometry.fTolerance = srcSpaceTol;
 
     viewMatrix.mapRect(&bounds);
     uint8_t coverage = GrRandomCoverage(random);
     return DefaultPathBatch::Create(geometry, coverage, viewMatrix, true, bounds);
 }
 
 #endif