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

src/gpu/effects/GrDashingEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDashingEffect.h"
 
 #include "GrBatchTarget.h"
@@ skipping 225 matching lines @@
  * This GrGeometryProcessor is meant for dashed lines that only have a single on/off interval pair.
  * Bounding geometry is rendered and the effect computes coverage based on the fragment's
  * position relative to the dashed line.
  */
 static GrGeometryProcessor* create_dash_gp(GrColor,
                                            DashAAMode aaMode,
                                            DashCap cap,
                                            const SkMatrix& localMatrix,
                                            bool usesLocalCoords);
 
-class DashBatch : public GrBatch {
+class DashBatch : public GrVertexBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkMatrix fSrcRotInv;
         SkPoint fPtsRot[2];
         SkScalar fSrcStrokeWidth;
         SkScalar fPhase;
         SkScalar fIntervals[2];
         SkScalar fParallelScale;
         SkScalar fPerpendicularScale;
     };
 
-    static GrBatch* Create(const Geometry& geometry, SkPaint::Cap cap, DashAAMode aaMode,
-                           bool fullDash) {
+    static GrDrawBatch* Create(const Geometry& geometry, SkPaint::Cap cap, DashAAMode aaMode,
+                               bool fullDash) {
         return SkNEW_ARGS(DashBatch, (geometry, cap, aaMode, fullDash));
     }
 
     const char* name() const override { return "DashBatch"; }
 
     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 339 matching lines @@
         fBounds.set(geometry.fPtsRot[0], geometry.fPtsRot[1]);
         fBounds.outset(xBloat, halfStrokeWidth);
 
         // Note, we actually create the combined matrix here, and save the work
         SkMatrix& combinedMatrix = fGeoData[0].fSrcRotInv;
         combinedMatrix.postConcat(geometry.fViewMatrix);
         combinedMatrix.mapRect(&fBounds);
     }
 
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
-        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *t->pipeline(), t->bounds(),
-                                    caps)) {
+        DashBatch* that = t->cast<DashBatch>();
+        if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
+                                    that->bounds(), caps)) {
             return false;
         }
 
-        DashBatch* that = t->cast<DashBatch>();
-
         if (this->aaMode() != that->aaMode()) {
             return false;
         }
 
         if (this->fullDash() != that->fullDash()) {
             return false;
         }
 
         if (this->cap() != that->cap()) {
             return false;
@@ skipping 32 matching lines @@
         bool fFullDash;
     };
 
     static const int kVertsPerDash = 4;
     static const int kIndicesPerDash = 6;
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
-static GrBatch* create_batch(GrColor color, const SkMatrix& viewMatrix, const SkPoint pts[2],
-                             bool useAA, const GrStrokeInfo& strokeInfo, bool msaaRT) {
+static GrDrawBatch* create_batch(GrColor color, const SkMatrix& viewMatrix, const SkPoint pts[2],
+                                 bool useAA, const GrStrokeInfo& strokeInfo, bool msaaRT) {
     const SkScalar* intervals = strokeInfo.getDashIntervals();
     SkScalar phase = strokeInfo.getDashPhase();
 
     SkPaint::Cap cap = strokeInfo.getCap();
 
     DashBatch::Geometry geometry;
     geometry.fSrcStrokeWidth = strokeInfo.getWidth();
 
     // the phase should be normalized to be [0, sum of all intervals)
     SkASSERT(phase >= 0 && phase < intervals[0] + intervals[1]);
@@ skipping 35 matching lines @@
     geometry.fIntervals[0] = intervals[0];
     geometry.fIntervals[1] = intervals[1];
 
     return DashBatch::Create(geometry, cap, aaMode, fullDash);
 }
 
 bool GrDashingEffect::DrawDashLine(GrDrawTarget* target,
                                    const GrPipelineBuilder& pipelineBuilder, GrColor color,
                                    const SkMatrix& viewMatrix, const SkPoint pts[2],
                                    bool useAA, const GrStrokeInfo& strokeInfo) {
-    SkAutoTUnref<GrBatch> batch(
+    SkAutoTUnref<GrDrawBatch> batch(
             create_batch(color, viewMatrix, pts, useAA, strokeInfo,
                          pipelineBuilder.getRenderTarget()->isUnifiedMultisampled()));
     if (!batch) {
         return false;
     }
 
     target->drawBatch(pipelineBuilder, batch);
     return true;
 }
 
@@ skipping 474 matching lines @@
         case kNonRound_DashCap:
             return DashingLineEffect::Create(color, dashAAMode, invert, usesLocalCoords);
     }
     return NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
-BATCH_TEST_DEFINE(DashBatch) {
+DRAW_BATCH_TEST_DEFINE(DashBatch) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixPreservesRightAngles(random);
     bool useAA = random->nextBool();
     bool msaaRT = random->nextBool();
 
     // We can only dash either horizontal or vertical lines
     SkPoint pts[2];
     if (random->nextBool()) {
         // vertical
         pts[0].fX = 1.f;
@@ skipping 55 matching lines @@
     info.fIntervals = intervals;
     info.fCount = 2;
     info.fPhase = phase;
     SkDEBUGCODE(bool success = ) strokeInfo.setDashInfo(info);
     SkASSERT(success);
 
     return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaRT);
 }
 
 #endif