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

src/gpu/GrTessellatingPathRenderer.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 "GrTessellatingPathRenderer.h"
 
 #include "GrBatchTarget.h"
@@ skipping 1366 matching lines @@
 }  // namespace
 
 bool GrTessellatingPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
     // This path renderer can draw all fill styles, all stroke styles except hairlines, but does
     // not do antialiasing. It can do convex and concave paths, but we'll leave the convex ones to
     // simpler algorithms.
     return !IsStrokeHairlineOrEquivalent(*args.fStroke, *args.fViewMatrix, NULL) &&
            !args.fAntiAlias && !args.fPath->isConvex();
 }
 
-class TessellatingPathBatch : public GrBatch {
+class TessellatingPathBatch : public GrVertexBatch {
 public:
 
-    static GrBatch* Create(const GrColor& color,
-                           const SkPath& path,
-                           const GrStrokeInfo& stroke,
-                           const SkMatrix& viewMatrix,
-                           SkRect clipBounds) {
+    static GrDrawBatch* Create(const GrColor& color,
+                               const SkPath& path,
+                               const GrStrokeInfo& stroke,
+                               const SkMatrix& viewMatrix,
+                               SkRect clipBounds) {
         return SkNEW_ARGS(TessellatingPathBatch, (color, path, stroke, viewMatrix, clipBounds));
     }
 
     const char* name() const override { return "TessellatingPathBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         out->setKnownFourComponents(fColor);
     }
 
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
@@ skipping 208 matching lines @@
     }
 
     SkIRect clipBoundsI;
     args.fPipelineBuilder->clip().getConservativeBounds(rt, &clipBoundsI);
     SkRect clipBounds = SkRect::Make(clipBoundsI);
     SkMatrix vmi;
     if (!args.fViewMatrix->invert(&vmi)) {
         return false;
     }
     vmi.mapRect(&clipBounds);
-    SkAutoTUnref<GrBatch> batch(TessellatingPathBatch::Create(args.fColor, *args.fPath,
-                                                              *args.fStroke, *args.fViewMatrix,
-                                                              clipBounds));
+    SkAutoTUnref<GrDrawBatch> batch(TessellatingPathBatch::Create(args.fColor, *args.fPath,
+                                                                  *args.fStroke, *args.fViewMatrix,
+                                                                  clipBounds));
     args.fTarget->drawBatch(*args.fPipelineBuilder, batch);
 
     return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
-BATCH_TEST_DEFINE(TesselatingPathBatch) {
+DRAW_BATCH_TEST_DEFINE(TesselatingPathBatch) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
     SkPath path = GrTest::TestPath(random);
     SkRect clipBounds = GrTest::TestRect(random);
     SkMatrix vmi;
     bool result = viewMatrix.invert(&vmi);
     if (!result) {
         SkFAIL("Cannot invert matrix\n");
     }
     vmi.mapRect(&clipBounds);
     GrStrokeInfo strokeInfo = GrTest::TestStrokeInfo(random);
     return TessellatingPathBatch::Create(color, path, strokeInfo, viewMatrix, clipBounds);
 }
 
 #endif