Make GrDashEffect take a AA mode enum.

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 "GrBatchFlushState.h"
 #include "GrBatchTest.h"
 #include "GrCaps.h"
 #include "GrGeometryProcessor.h"
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrInvariantOutput.h"
 #include "GrProcessor.h"
 #include "GrStyle.h"
 #include "SkGr.h"
 #include "batches/GrVertexBatch.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "glsl/GrGLSLVarying.h"
 #include "glsl/GrGLSLVertexShaderBuilder.h"
 
+using AAMode = GrDashingEffect::AAMode;
+
 ///////////////////////////////////////////////////////////////////////////////
 
 // Returns whether or not the gpu can fast path the dash line effect.
 bool GrDashingEffect::CanDrawDashLine(const SkPoint pts[2], const GrStyle& style,
                                       const SkMatrix& viewMatrix) {
     // Pts must be either horizontal or vertical in src space
     if (pts[0].fX != pts[1].fX && pts[0].fY != pts[1].fY) {
         return false;
     }
 
@@ skipping 28 matching lines @@
     SkScalar fIntervalLength;
     SkRect fRect;
 };
 struct DashCircleVertex {
     SkPoint fPos;
     SkPoint fDashPos;
     SkScalar fIntervalLength;
     SkScalar fRadius;
     SkScalar fCenterX;
 };
-
-enum DashAAMode {
-    kBW_DashAAMode,
-    kEdgeAA_DashAAMode,
-    kMSAA_DashAAMode,
-
-    kDashAAModeCount,
-};
 };
 
 static void calc_dash_scaling(SkScalar* parallelScale, SkScalar* perpScale,
                             const SkMatrix& viewMatrix, const SkPoint pts[2]) {
     SkVector vecSrc = pts[1] - pts[0];
     SkScalar magSrc = vecSrc.length();
     SkScalar invSrc = magSrc ? SkScalarInvert(magSrc) : 0;
     vecSrc.scale(invSrc);
 
     SkVector vecSrcPerp;
@@ skipping 137 matching lines @@
 }
 
 
 /**
  * An GrGeometryProcessor that renders a dashed line.
  * 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,
+                                           AAMode aaMode,
                                            DashCap cap,
                                            const SkMatrix& localMatrix,
                                            bool usesLocalCoords);
 
 class DashBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
-
     struct Geometry {
         SkMatrix fViewMatrix;
         SkMatrix fSrcRotInv;
         SkPoint fPtsRot[2];
         SkScalar fSrcStrokeWidth;
         SkScalar fPhase;
         SkScalar fIntervals[2];
         SkScalar fParallelScale;
         SkScalar fPerpendicularScale;
         GrColor fColor;
     };
 
-    static GrDrawBatch* Create(const Geometry& geometry, SkPaint::Cap cap, DashAAMode aaMode,
+    static GrDrawBatch* Create(const Geometry& geometry, SkPaint::Cap cap, AAMode aaMode,
                                bool fullDash) {
         return new DashBatch(geometry, cap, aaMode, fullDash);
     }
 
     const char* name() const override { return "DashBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
         // When this is called on a batch, there is only one geometry bundle
         color->setKnownFourComponents(fGeoData[0].fColor);
         coverage->setUnknownSingleComponent();
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
-    DashBatch(const Geometry& geometry, SkPaint::Cap cap, DashAAMode aaMode, bool fullDash)
+    DashBatch(const Geometry& geometry, SkPaint::Cap cap, AAMode aaMode, bool fullDash)
         : INHERITED(ClassID()) {
         fGeoData.push_back(geometry);
 
         fBatch.fAAMode = aaMode;
         fBatch.fCap = cap;
         fBatch.fFullDash = fullDash;
 
         // compute bounds
         SkScalar halfStrokeWidth = 0.5f * geometry.fSrcStrokeWidth;
         SkScalar xBloat = SkPaint::kButt_Cap == cap ? 0 : halfStrokeWidth;
@@ skipping 60 matching lines @@
                                                               LocalCoords::kUnused_Type);
             gp.reset(CreateForDeviceSpace(color, coverage, localCoords, this->viewMatrix()));
         }
 
         if (!gp) {
             SkDebugf("Could not create GrGeometryProcessor\n");
             return;
         }
 
         // useAA here means Edge AA or MSAA
-        bool useAA = this->aaMode() != kBW_DashAAMode;
+        bool useAA = this->aaMode() != AAMode::kNone;
         bool fullDash = this->fullDash();
 
         // We do two passes over all of the dashes.  First we setup the start, end, and bounds,
         // rectangles.  We preserve all of this work in the rects / draws arrays below.  Then we
         // iterate again over these decomposed dashes to generate vertices
         static const int kNumStackDashes = 128;
         SkSTArray<kNumStackDashes, SkRect, true> rects;
         SkSTArray<kNumStackDashes, DashDraw, true> draws;
 
         int totalRectCount = 0;
@@ skipping 106 matching lines @@
 
             if (SkPaint::kSquare_Cap == cap && 0 != args.fSrcStrokeWidth) {
                 // add cap to on interval and remove from off interval
                 devIntervals[0] += strokeWidth;
                 devIntervals[1] -= strokeWidth;
             }
             SkScalar startOffset = devIntervals[1] * 0.5f + devPhase;
 
             // For EdgeAA, we bloat in X & Y for both square and round caps.
             // For MSAA, we don't bloat at all for square caps, and bloat in Y only for round caps.
-            SkScalar devBloatX = this->aaMode() == kEdgeAA_DashAAMode ? 0.5f : 0.0f;
-            SkScalar devBloatY = (SkPaint::kRound_Cap == cap && this->aaMode() == kMSAA_DashAAMode)
-                                 ? 0.5f : devBloatX;
+            SkScalar devBloatX = this->aaMode() == AAMode::kCoverage ? 0.5f : 0.0f;
+            SkScalar devBloatY;
+            if (SkPaint::kRound_Cap == cap && this->aaMode() == AAMode::kCoverageWithMSAA) {
+                devBloatY = 0.5f;
+            } else {
+                devBloatY = devBloatX;
+            }
 
             SkScalar bloatX = devBloatX / args.fParallelScale;
             SkScalar bloatY = devBloatY / args.fPerpendicularScale;
 
             if (devIntervals[1] <= 0.f && useAA) {
                 // Case when we end up drawing a solid AA rect
                 // Reset the start rect to draw this single solid rect
                 // but it requires to upload a new intervals uniform so we can mimic
                 // one giant dash
                 draw.fPtsRot[0].fX -= hasStartRect ? startAdj : 0;
@@ skipping 156 matching lines @@
         }
 
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
-    DashAAMode aaMode() const { return fBatch.fAAMode; }
+    AAMode aaMode() const { return fBatch.fAAMode; }
     bool fullDash() const { return fBatch.fFullDash; }
     SkPaint::Cap cap() const { return fBatch.fCap; }
     bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
     struct BatchTracker {
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
         SkPaint::Cap fCap;
-        DashAAMode fAAMode;
+        AAMode fAAMode;
         bool fFullDash;
     };
 
     static const int kVertsPerDash = 4;
     static const int kIndicesPerDash = 6;
 
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 
     typedef GrVertexBatch INHERITED;
 };
 
-static GrDrawBatch* create_batch(GrColor color, const SkMatrix& viewMatrix, const SkPoint pts[2],
-                                 bool useAA, const GrStyle& style, bool msaaRT) {
+GrDrawBatch* GrDashingEffect::CreateDashLineBatch(GrColor color,
+                                                  const SkMatrix& viewMatrix,
+                                                  const SkPoint pts[2],
+                                                  AAMode aaMode,
+                                                  const GrStyle& style) {
     SkASSERT(GrDashingEffect::CanDrawDashLine(pts, style, viewMatrix));
     const SkScalar* intervals = style.dashIntervals();
     SkScalar phase = style.dashPhase();
 
     SkPaint::Cap cap = style.strokeRec().getCap();
 
     DashBatch::Geometry geometry;
     geometry.fSrcStrokeWidth = style.strokeRec().getWidth();
 
     // the phase should be normalized to be [0, sum of all intervals)
@@ skipping 17 matching lines @@
                       geometry.fPtsRot);
 
     SkScalar offInterval = intervals[1] * geometry.fParallelScale;
     SkScalar strokeWidth = geometry.fSrcStrokeWidth * geometry.fPerpendicularScale;
 
     if (SkPaint::kSquare_Cap == cap && 0 != geometry.fSrcStrokeWidth) {
         // add cap to on interveal and remove from off interval
         offInterval -= strokeWidth;
     }
 
-    DashAAMode aaMode = msaaRT ? kMSAA_DashAAMode :
-                                 useAA ? kEdgeAA_DashAAMode : kBW_DashAAMode;
-
     // TODO we can do a real rect call if not using fulldash(ie no off interval, not using AA)
-    bool fullDash = offInterval > 0.f || aaMode != kBW_DashAAMode;
+    bool fullDash = offInterval > 0.f || aaMode != AAMode::kNone;
 
     geometry.fColor = color;
     geometry.fViewMatrix = viewMatrix;
     geometry.fPhase = phase;
     geometry.fIntervals[0] = intervals[0];
     geometry.fIntervals[1] = intervals[1];
 
     return DashBatch::Create(geometry, cap, aaMode, fullDash);
 }
 
-GrDrawBatch* GrDashingEffect::CreateDashLineBatch(GrColor color,
-                                                  const SkMatrix& viewMatrix,
-                                                  const SkPoint pts[2],
-                                                  bool useAA,
-                                                  bool msaaIsEnabled,
-                                                  const GrStyle& style) {
-    return create_batch(color, viewMatrix, pts, useAA, style, msaaIsEnabled);
-}
-
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingCircleEffect;
 
 /*
  * This effect will draw a dotted line (defined as a dashed lined with round caps and no on
  * interval). The radius of the dots is given by the strokeWidth and the spacing by the DashInfo.
  * Both of the previous two parameters are in device space. This effect also requires the setting of
  * a vec2 vertex attribute for the the four corners of the bounding rect. This attribute is the
  * "dash position" of each vertex. In other words it is the vertex coords (in device space) if we
  * transform the line to be horizontal, with the start of line at the origin then shifted to the
  * right by half the off interval. The line then goes in the positive x direction.
  */
 class DashingCircleEffect : public GrGeometryProcessor {
 public:
     typedef SkPathEffect::DashInfo DashInfo;
 
     static GrGeometryProcessor* Create(GrColor,
-                                       DashAAMode aaMode,
+                                       AAMode aaMode,
                                        const SkMatrix& localMatrix,
                                        bool usesLocalCoords);
 
     const char* name() const override { return "DashingCircleEffect"; }
 
     const Attribute* inPosition() const { return fInPosition; }
 
     const Attribute* inDashParams() const { return fInDashParams; }
 
     const Attribute* inCircleParams() const { return fInCircleParams; }
 
-    DashAAMode aaMode() const { return fAAMode; }
+    AAMode aaMode() const { return fAAMode; }
 
     GrColor color() const { return fColor; }
 
     bool colorIgnored() const { return GrColor_ILLEGAL == fColor; }
 
     const SkMatrix& localMatrix() const { return fLocalMatrix; }
 
     bool usesLocalCoords() const { return fUsesLocalCoords; }
 
     void getGLSLProcessorKey(const GrGLSLCaps&, GrProcessorKeyBuilder* b) const override;
 
     GrGLSLPrimitiveProcessor* createGLSLInstance(const GrGLSLCaps&) const override;
 
 private:
-    DashingCircleEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix,
+    DashingCircleEffect(GrColor, AAMode aaMode, const SkMatrix& localMatrix,
                         bool usesLocalCoords);
 
     GrColor             fColor;
     SkMatrix            fLocalMatrix;
     bool                fUsesLocalCoords;
-    DashAAMode          fAAMode;
+    AAMode              fAAMode;
     const Attribute*    fInPosition;
     const Attribute*    fInDashParams;
     const Attribute*    fInCircleParams;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
@@ skipping 72 matching lines @@
                          args.fTransformsIn,
                          args.fTransformsOut);
 
     // transforms all points so that we can compare them to our test circle
     fragBuilder->codeAppendf("float xShifted = %s.x - floor(%s.x / %s.z) * %s.z;",
                              dashParams.fsIn(), dashParams.fsIn(), dashParams.fsIn(),
                              dashParams.fsIn());
     fragBuilder->codeAppendf("vec2 fragPosShifted = vec2(xShifted, %s.y);", dashParams.fsIn());
     fragBuilder->codeAppendf("vec2 center = vec2(%s.y, 0.0);", circleParams.fsIn());
     fragBuilder->codeAppend("float dist = length(center - fragPosShifted);");
-    if (dce.aaMode() != kBW_DashAAMode) {
+    if (dce.aaMode() != AAMode::kNone) {
         fragBuilder->codeAppendf("float diff = dist - %s.x;", circleParams.fsIn());
         fragBuilder->codeAppend("diff = 1.0 - diff;");
         fragBuilder->codeAppend("float alpha = clamp(diff, 0.0, 1.0);");
     } else {
         fragBuilder->codeAppendf("float alpha = 1.0;");
         fragBuilder->codeAppendf("alpha *=  dist < %s.x + 0.5 ? 1.0 : 0.0;", circleParams.fsIn());
     }
     fragBuilder->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
 }
 
 void GLDashingCircleEffect::setData(const GrGLSLProgramDataManager& pdman,
                                     const GrPrimitiveProcessor& processor) {
     const DashingCircleEffect& dce = processor.cast<DashingCircleEffect>();
     if (dce.color() != fColor) {
         float c[4];
         GrColorToRGBAFloat(dce.color(), c);
         pdman.set4fv(fColorUniform, 1, c);
         fColor = dce.color();
     }
 }
 
 void GLDashingCircleEffect::GenKey(const GrGeometryProcessor& gp,
                                    const GrGLSLCaps&,
                                    GrProcessorKeyBuilder* b) {
     const DashingCircleEffect& dce = gp.cast<DashingCircleEffect>();
     uint32_t key = 0;
     key |= dce.usesLocalCoords() && dce.localMatrix().hasPerspective() ? 0x1 : 0x0;
     key |= dce.colorIgnored() ? 0x2 : 0x0;
-    key |= dce.aaMode() << 8;
+    key |= static_cast<uint32_t>(dce.aaMode()) << 8;
     b->add32(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGeometryProcessor* DashingCircleEffect::Create(GrColor color,
-                                                 DashAAMode aaMode,
+                                                 AAMode aaMode,
                                                  const SkMatrix& localMatrix,
                                                  bool usesLocalCoords) {
     return new DashingCircleEffect(color, aaMode, localMatrix, usesLocalCoords);
 }
 
 void DashingCircleEffect::getGLSLProcessorKey(const GrGLSLCaps& caps,
                                               GrProcessorKeyBuilder* b) const {
     GLDashingCircleEffect::GenKey(*this, caps, b);
 }
 
 GrGLSLPrimitiveProcessor* DashingCircleEffect::createGLSLInstance(const GrGLSLCaps&) const {
     return new GLDashingCircleEffect();
 }
 
 DashingCircleEffect::DashingCircleEffect(GrColor color,
-                                         DashAAMode aaMode,
+                                         AAMode aaMode,
                                          const SkMatrix& localMatrix,
                                          bool usesLocalCoords)
     : fColor(color)
     , fLocalMatrix(localMatrix)
     , fUsesLocalCoords(usesLocalCoords)
     , fAAMode(aaMode) {
     this->initClassID<DashingCircleEffect>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     fInDashParams = &this->addVertexAttrib(Attribute("inDashParams", kVec3f_GrVertexAttribType));
     fInCircleParams = &this->addVertexAttrib(Attribute("inCircleParams",
                                                        kVec2f_GrVertexAttribType));
 }
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingCircleEffect);
 
 const GrGeometryProcessor* DashingCircleEffect::TestCreate(GrProcessorTestData* d) {
-    DashAAMode aaMode = static_cast<DashAAMode>(d->fRandom->nextULessThan(kDashAAModeCount));
+    AAMode aaMode = static_cast<AAMode>(d->fRandom->nextULessThan(GrDashingEffect::kAAModeCnt));
     return DashingCircleEffect::Create(GrRandomColor(d->fRandom),
                                       aaMode, GrTest::TestMatrix(d->fRandom),
                                       d->fRandom->nextBool());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingLineEffect;
 
 /*
  * This effect will draw a dashed line. The width of the dash is given by the strokeWidth and the
  * length and spacing by the DashInfo. Both of the previous two parameters are in device space.
  * This effect also requires the setting of a vec2 vertex attribute for the the four corners of the
  * bounding rect. This attribute is the "dash position" of each vertex. In other words it is the
  * vertex coords (in device space) if we transform the line to be horizontal, with the start of
  * line at the origin then shifted to the right by half the off interval. The line then goes in the
  * positive x direction.
  */
 class DashingLineEffect : public GrGeometryProcessor {
 public:
     typedef SkPathEffect::DashInfo DashInfo;
 
     static GrGeometryProcessor* Create(GrColor,
-                                       DashAAMode aaMode,
+                                       AAMode aaMode,
                                        const SkMatrix& localMatrix,
                                        bool usesLocalCoords);
 
     const char* name() const override { return "DashingEffect"; }
 
     const Attribute* inPosition() const { return fInPosition; }
 
     const Attribute* inDashParams() const { return fInDashParams; }
 
     const Attribute* inRectParams() const { return fInRectParams; }
 
-    DashAAMode aaMode() const { return fAAMode; }
+    AAMode aaMode() const { return fAAMode; }
 
     GrColor color() const { return fColor; }
 
     bool colorIgnored() const { return GrColor_ILLEGAL == fColor; }
 
     const SkMatrix& localMatrix() const { return fLocalMatrix; }
 
     bool usesLocalCoords() const { return fUsesLocalCoords; }
 
     void getGLSLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     GrGLSLPrimitiveProcessor* createGLSLInstance(const GrGLSLCaps&) const override;
 
 private:
-    DashingLineEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix,
+    DashingLineEffect(GrColor, AAMode aaMode, const SkMatrix& localMatrix,
                       bool usesLocalCoords);
 
     GrColor             fColor;
     SkMatrix            fLocalMatrix;
     bool                fUsesLocalCoords;
-    DashAAMode          fAAMode;
+    AAMode              fAAMode;
     const Attribute*    fInPosition;
     const Attribute*    fInDashParams;
     const Attribute*    fInRectParams;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
@@ skipping 65 matching lines @@
                          de.inPosition()->fName,
                          de.localMatrix(),
                          args.fTransformsIn,
                          args.fTransformsOut);
 
     // transforms all points so that we can compare them to our test rect
     fragBuilder->codeAppendf("float xShifted = %s.x - floor(%s.x / %s.z) * %s.z;",
                              inDashParams.fsIn(), inDashParams.fsIn(), inDashParams.fsIn(),
                              inDashParams.fsIn());
     fragBuilder->codeAppendf("vec2 fragPosShifted = vec2(xShifted, %s.y);", inDashParams.fsIn());
-    if (de.aaMode() == kEdgeAA_DashAAMode) {
+    if (de.aaMode() == AAMode::kCoverage) {
         // The amount of coverage removed in x and y by the edges is computed as a pair of negative
         // numbers, xSub and ySub.
         fragBuilder->codeAppend("float xSub, ySub;");
         fragBuilder->codeAppendf("xSub = min(fragPosShifted.x - %s.x, 0.0);", inRectParams.fsIn());
         fragBuilder->codeAppendf("xSub += min(%s.z - fragPosShifted.x, 0.0);", inRectParams.fsIn());
         fragBuilder->codeAppendf("ySub = min(fragPosShifted.y - %s.y, 0.0);", inRectParams.fsIn());
         fragBuilder->codeAppendf("ySub += min(%s.w - fragPosShifted.y, 0.0);", inRectParams.fsIn());
         // Now compute coverage in x and y and multiply them to get the fraction of the pixel
         // covered.
         fragBuilder->codeAppendf(
             "float alpha = (1.0 + max(xSub, -1.0)) * (1.0 + max(ySub, -1.0));");
-    } else if (de.aaMode() == kMSAA_DashAAMode) {
+    } else if (de.aaMode() == AAMode::kCoverageWithMSAA) {
         // For MSAA, we don't modulate the alpha by the Y distance, since MSAA coverage will handle
         // AA on the the top and bottom edges. The shader is only responsible for intra-dash alpha.
         fragBuilder->codeAppend("float xSub;");
         fragBuilder->codeAppendf("xSub = min(fragPosShifted.x - %s.x, 0.0);", inRectParams.fsIn());
         fragBuilder->codeAppendf("xSub += min(%s.z - fragPosShifted.x, 0.0);", inRectParams.fsIn());
         // Now compute coverage in x to get the fraction of the pixel covered.
         fragBuilder->codeAppendf("float alpha = (1.0 + max(xSub, -1.0));");
     } else {
         // Assuming the bounding geometry is tight so no need to check y values
         fragBuilder->codeAppendf("float alpha = 1.0;");
@@ skipping 16 matching lines @@
     }
 }
 
 void GLDashingLineEffect::GenKey(const GrGeometryProcessor& gp,
                                  const GrGLSLCaps&,
                                  GrProcessorKeyBuilder* b) {
     const DashingLineEffect& de = gp.cast<DashingLineEffect>();
     uint32_t key = 0;
     key |= de.usesLocalCoords() && de.localMatrix().hasPerspective() ? 0x1 : 0x0;
     key |= de.colorIgnored() ? 0x2 : 0x0;
-    key |= de.aaMode() << 8;
+    key |= static_cast<int>(de.aaMode()) << 8;
     b->add32(key);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGeometryProcessor* DashingLineEffect::Create(GrColor color,
-                                               DashAAMode aaMode,
+                                               AAMode aaMode,
                                                const SkMatrix& localMatrix,
                                                bool usesLocalCoords) {
     return new DashingLineEffect(color, aaMode, localMatrix, usesLocalCoords);
 }
 
 void DashingLineEffect::getGLSLProcessorKey(const GrGLSLCaps& caps,
                                             GrProcessorKeyBuilder* b) const {
     GLDashingLineEffect::GenKey(*this, caps, b);
 }
 
 GrGLSLPrimitiveProcessor* DashingLineEffect::createGLSLInstance(const GrGLSLCaps&) const {
     return new GLDashingLineEffect();
 }
 
 DashingLineEffect::DashingLineEffect(GrColor color,
-                                     DashAAMode aaMode,
+                                     AAMode aaMode,
                                      const SkMatrix& localMatrix,
                                      bool usesLocalCoords)
     : fColor(color)
     , fLocalMatrix(localMatrix)
     , fUsesLocalCoords(usesLocalCoords)
     , fAAMode(aaMode) {
     this->initClassID<DashingLineEffect>();
     fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
     fInDashParams = &this->addVertexAttrib(Attribute("inDashParams", kVec3f_GrVertexAttribType));
     fInRectParams = &this->addVertexAttrib(Attribute("inRect", kVec4f_GrVertexAttribType));
 }
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingLineEffect);
 
 const GrGeometryProcessor* DashingLineEffect::TestCreate(GrProcessorTestData* d) {
-    DashAAMode aaMode = static_cast<DashAAMode>(d->fRandom->nextULessThan(kDashAAModeCount));
+    AAMode aaMode = static_cast<AAMode>(d->fRandom->nextULessThan(GrDashingEffect::kAAModeCnt));
     return DashingLineEffect::Create(GrRandomColor(d->fRandom),
                                      aaMode, GrTest::TestMatrix(d->fRandom),
                                      d->fRandom->nextBool());
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 static GrGeometryProcessor* create_dash_gp(GrColor color,
-                                           DashAAMode dashAAMode,
+                                           AAMode aaMode,
                                            DashCap cap,
                                            const SkMatrix& viewMatrix,
                                            bool usesLocalCoords) {
     SkMatrix invert;
     if (usesLocalCoords && !viewMatrix.invert(&invert)) {
         SkDebugf("Failed to invert\n");
         return nullptr;
     }
 
     switch (cap) {
         case kRound_DashCap:
-            return DashingCircleEffect::Create(color, dashAAMode, invert, usesLocalCoords);
+            return DashingCircleEffect::Create(color, aaMode, invert, usesLocalCoords);
         case kNonRound_DashCap:
-            return DashingLineEffect::Create(color, dashAAMode, invert, usesLocalCoords);
+            return DashingLineEffect::Create(color, aaMode, invert, usesLocalCoords);
     }
     return nullptr;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 DRAW_BATCH_TEST_DEFINE(DashBatch) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrixPreservesRightAngles(random);
-    bool useAA = random->nextBool();
-    bool msaaRT = random->nextBool();
+    AAMode aaMode = static_cast<AAMode>(random->nextULessThan(GrDashingEffect::kAAModeCnt));
 
     // We can only dash either horizontal or vertical lines
     SkPoint pts[2];
     if (random->nextBool()) {
         // vertical
         pts[0].fX = 1.f;
         pts[0].fY = random->nextF() * 10.f;
         pts[1].fX = 1.f;
         pts[1].fY = random->nextF() * 10.f;
     } else {
@@ skipping 41 matching lines @@
     SkScalar phase = random->nextRangeScalar(0, intervals[0] + intervals[1]);
 
     SkPaint p;
     p.setStyle(SkPaint::kStroke_Style);
     p.setStrokeWidth(SkIntToScalar(1));
     p.setStrokeCap(cap);
     p.setPathEffect(GrTest::TestDashPathEffect::Make(intervals, 2, phase));
 
     GrStyle style(p);
 
-    return create_batch(color, viewMatrix, pts, useAA, style, msaaRT);
+    return GrDashingEffect::CreateDashLineBatch(color, viewMatrix, pts, aaMode, style);
 }
 
 #endif