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

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 "GrBatch.h"
 #include "GrBatchTarget.h"
 #include "GrColor.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrPrimitiveProcessor.h"
 
 class GrBatchTarget;
 class SkMatrix;
 struct SkRect;
 
-class BWFillRectBatch : public GrBatch {
+class BWFillRectBatch : public GrVertexBatch {
 public:
     struct Geometry {
         SkMatrix fViewMatrix;
         SkRect fRect;
         SkRect fLocalRect;
         SkMatrix fLocalMatrix;
         GrColor fColor;
         bool fHasLocalRect;
         bool fHasLocalMatrix;
     };
 
-    static GrBatch* Create(const Geometry& geometry) {
+    static GrDrawBatch* Create(const Geometry& geometry) {
         return SkNEW_ARGS(BWFillRectBatch, (geometry));
     }
 
     const char* name() const override { return "RectBatch"; }
 
     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 84 matching lines @@
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     const SkMatrix& localMatrix() const { return fGeoData[0].fLocalMatrix; }
     bool hasLocalRect() const { return fGeoData[0].fHasLocalRect; }
     bool hasLocalMatrix() const { return fGeoData[0].fHasLocalMatrix; }
     bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
-        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *t->pipeline(), t->bounds(),
-                                    caps)) {
+        BWFillRectBatch* that = t->cast<BWFillRectBatch>();
+        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
+                                    that->bounds(), caps)) {
             return false;
         }
 
-        BWFillRectBatch* that = t->cast<BWFillRectBatch>();
-
         if (this->hasLocalRect() != that->hasLocalRect()) {
             return false;
         }
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         if (!this->hasLocalRect() && this->usesLocalCoords()) {
             if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
                 return false;
             }
 
@@ skipping 49 matching lines @@
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
     };
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
 namespace GrBWFillRectBatch {
-GrBatch* Create(GrColor color,
-                const SkMatrix& viewMatrix,
-                const SkRect& rect,
-                const SkRect* localRect,
-                const SkMatrix* localMatrix) {
+GrDrawBatch* Create(GrColor color,
+                    const SkMatrix& viewMatrix,
+                    const SkRect& rect,
+                    const SkRect* localRect,
+                    const SkMatrix* localMatrix) {
     BWFillRectBatch::Geometry geometry;
     geometry.fColor = color;
     geometry.fViewMatrix = viewMatrix;
     geometry.fRect = rect;
 
     if (localRect) {
         geometry.fHasLocalRect = true;
         geometry.fLocalRect = *localRect;
     } else {
         geometry.fHasLocalRect = false;
     }
 
     if (localMatrix) {
         geometry.fHasLocalMatrix = true;
         geometry.fLocalMatrix = *localMatrix;
     } else {
         geometry.fHasLocalMatrix = false;
     }
 
     return BWFillRectBatch::Create(geometry);
 }
 };
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 #include "GrBatchTest.h"
 
-BATCH_TEST_DEFINE(RectBatch) {
+DRAW_BATCH_TEST_DEFINE(RectBatch) {
     BWFillRectBatch::Geometry geometry;
     geometry.fColor = GrRandomColor(random);
 
     geometry.fRect = GrTest::TestRect(random);
     geometry.fHasLocalRect = random->nextBool();
 
     if (geometry.fHasLocalRect) {
         geometry.fViewMatrix = GrTest::TestMatrixInvertible(random);
         geometry.fLocalRect = GrTest::TestRect(random);
     } else {
         geometry.fViewMatrix = GrTest::TestMatrix(random);
     }
 
     geometry.fHasLocalMatrix = random->nextBool();
     if (geometry.fHasLocalMatrix) {
         geometry.fLocalMatrix = GrTest::TestMatrix(random);
     }
 
     return BWFillRectBatch::Create(geometry);
 }
 
 #endif