Revert of Preliminary attempt to remove batch tracker

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 "GrBatch.h"
@@ skipping 223 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,
                                            DashCap cap,
-                                           const SkMatrix& localMatrix,
-                                           bool usesLocalCoords);
+                                           const SkMatrix& localMatrix);
 
 class DashBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkMatrix fSrcRotInv;
         SkPoint fPtsRot[2];
         SkScalar fSrcStrokeWidth;
         SkScalar fPhase;
@@ skipping 53 matching lines @@
             return;
         }
 
         SkPaint::Cap cap = this->cap();
 
         SkAutoTUnref<const GrGeometryProcessor> gp;
 
         bool isRoundCap = SkPaint::kRound_Cap == cap;
         DashCap capType = isRoundCap ? kRound_DashCap : kNonRound_DashCap;
         if (this->fullDash()) {
-            gp.reset(create_dash_gp(this->color(), this->aaMode(), capType, invert,
-                                    this->usesLocalCoords()));
+            gp.reset(create_dash_gp(this->color(), this->aaMode(), capType, invert));
         } else {
             // Set up the vertex data for the line and start/end dashes
             gp.reset(GrDefaultGeoProcFactory::Create(GrDefaultGeoProcFactory::kPosition_GPType,
                                                      this->color(),
-                                                     this->usesLocalCoords(),
-                                                     this->coverageIgnored(),
                                                      SkMatrix::I(),
                                                      invert));
         }
 
         batchTarget->initDraw(gp, pipeline);
 
+        // TODO remove this when batch is everywhere
+        GrPipelineInfo init;
+        init.fColorIgnored = fBatch.fColorIgnored;
+        init.fOverrideColor = GrColor_ILLEGAL;
+        init.fCoverageIgnored = fBatch.fCoverageIgnored;
+        init.fUsesLocalCoords = this->usesLocalCoords();
+        gp->initBatchTracker(batchTarget->currentBatchTracker(), init);
+
         // useAA here means Edge AA or MSAA
         bool useAA = this->aaMode() != kBW_DashAAMode;
         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
         SkSTArray<128, SkRect, true> rects;
         SkSTArray<128, DashDraw, true> draws;
 
@@ skipping 307 matching lines @@
         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; }
     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;
         bool fFullDash;
     };
@@ skipping 69 matching lines @@
     }
 
     target->drawBatch(pipelineBuilder, batch);
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingCircleEffect;
 
+struct DashingCircleBatchTracker {
+    GrGPInput fInputColorType;
+    GrColor fColor;
+    bool fUsesLocalCoords;
+};
+
 /*
  * 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,
-                                       const SkMatrix& localMatrix,
-                                       bool usesLocalCoords);
+                                       const SkMatrix& localMatrix);
 
     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; }
 
     GrColor color() const { return fColor; }
 
-    bool colorIgnored() const { return GrColor_ILLEGAL == fColor; }
-
     const SkMatrix& localMatrix() const { return fLocalMatrix; }
 
-    bool usesLocalCoords() const { return fUsesLocalCoords; }
-
     virtual void getGLProcessorKey(const GrBatchTracker&,
                                    const GrGLSLCaps&,
                                    GrProcessorKeyBuilder* b) const override;
 
     virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker&,
                                                      const GrGLSLCaps&) const override;
 
+    void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
+
 private:
-    DashingCircleEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix,
-                        bool usesLocalCoords);
+    DashingCircleEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix);
 
     GrColor             fColor;
     SkMatrix            fLocalMatrix;
-    bool                fUsesLocalCoords;
     DashAAMode          fAAMode;
     const Attribute*    fInPosition;
     const Attribute*    fInDashParams;
     const Attribute*    fInCircleParams;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
@@ skipping 34 matching lines @@
 GLDashingCircleEffect::GLDashingCircleEffect(const GrGeometryProcessor&,
                                              const GrBatchTracker&) {
     fColor = GrColor_ILLEGAL;
     fPrevRadius = SK_ScalarMin;
     fPrevCenterX = SK_ScalarMin;
     fPrevIntervalLength = SK_ScalarMax;
 }
 
 void GLDashingCircleEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
     const DashingCircleEffect& dce = args.fGP.cast<DashingCircleEffect>();
+    const DashingCircleBatchTracker local = args.fBT.cast<DashingCircleBatchTracker>();
     GrGLGPBuilder* pb = args.fPB;
     GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
 
     // emit attributes
     vsBuilder->emitAttributes(dce);
 
     // XY are dashPos, Z is dashInterval
     GrGLVertToFrag dashParams(kVec3f_GrSLType);
     args.fPB->addVarying("DashParam", &dashParams);
     vsBuilder->codeAppendf("%s = %s;", dashParams.vsOut(), dce.inDashParams()->fName);
 
     // x refers to circle radius - 0.5, y refers to cicle's center x coord
     GrGLVertToFrag circleParams(kVec2f_GrSLType);
     args.fPB->addVarying("CircleParams", &circleParams);
     vsBuilder->codeAppendf("%s = %s;", circleParams.vsOut(), dce.inCircleParams()->fName);
 
     // Setup pass through color
-    if (!dce.colorIgnored()) {
-        this->setupUniformColor(pb, args.fOutputColor, &fColorUniform);
-    }
+    this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, &fColorUniform);
 
     // Setup position
     this->setupPosition(pb, gpArgs, dce.inPosition()->fName);
 
     // emit transforms
     this->emitTransforms(args.fPB, gpArgs->fPositionVar, dce.inPosition()->fName, dce.localMatrix(),
                          args.fTransformsIn, args.fTransformsOut);
 
     // transforms all points so that we can compare them to our test circle
     GrGLFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
@@ skipping 10 matching lines @@
     } else {
         fsBuilder->codeAppendf("float alpha = 1.0;");
         fsBuilder->codeAppendf("alpha *=  dist < %s.x + 0.5 ? 1.0 : 0.0;", circleParams.fsIn());
     }
     fsBuilder->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
 }
 
 void GLDashingCircleEffect::setData(const GrGLProgramDataManager& pdman,
                                     const GrPrimitiveProcessor& processor,
                                     const GrBatchTracker& bt) {
-    const DashingCircleEffect& dce = processor.cast<DashingCircleEffect>();
-    if (dce.color() != fColor) {
+    const DashingCircleBatchTracker& local = bt.cast<DashingCircleBatchTracker>();
+    if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
         GrGLfloat c[4];
-        GrColorToRGBAFloat(dce.color(), c);
+        GrColorToRGBAFloat(local.fColor, c);
         pdman.set4fv(fColorUniform, 1, c);
-        fColor = dce.color();
+        fColor = local.fColor;
     }
 }
 
 void GLDashingCircleEffect::GenKey(const GrGeometryProcessor& gp,
                                    const GrBatchTracker& bt,
                                    const GrGLSLCaps&,
                                    GrProcessorKeyBuilder* b) {
+    const DashingCircleBatchTracker& local = bt.cast<DashingCircleBatchTracker>();
     const DashingCircleEffect& dce = gp.cast<DashingCircleEffect>();
     uint32_t key = 0;
-    key |= dce.usesLocalCoords() && dce.localMatrix().hasPerspective() ? 0x1 : 0x0;
-    key |= dce.colorIgnored() ? 0x2 : 0x0;
+    key |= local.fUsesLocalCoords && dce.localMatrix().hasPerspective() ? 0x1 : 0x0;
     key |= dce.aaMode() << 8;
-    b->add32(key);
+    b->add32(key << 16 | local.fInputColorType);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGeometryProcessor* DashingCircleEffect::Create(GrColor color,
                                                  DashAAMode aaMode,
-                                                 const SkMatrix& localMatrix,
-                                                 bool usesLocalCoords) {
-    return SkNEW_ARGS(DashingCircleEffect, (color, aaMode, localMatrix, usesLocalCoords));
+                                                 const SkMatrix& localMatrix) {
+    return SkNEW_ARGS(DashingCircleEffect, (color, aaMode, localMatrix));
 }
 
 void DashingCircleEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                             const GrGLSLCaps& caps,
                                             GrProcessorKeyBuilder* b) const {
     GLDashingCircleEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLPrimitiveProcessor* DashingCircleEffect::createGLInstance(const GrBatchTracker& bt,
                                                               const GrGLSLCaps&) const {
     return SkNEW_ARGS(GLDashingCircleEffect, (*this, bt));
 }
 
 DashingCircleEffect::DashingCircleEffect(GrColor color,
                                          DashAAMode aaMode,
-                                         const SkMatrix& localMatrix,
-                                         bool usesLocalCoords)
+                                         const SkMatrix& localMatrix)
     : 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));
 }
 
+void DashingCircleEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
+    DashingCircleBatchTracker* local = bt->cast<DashingCircleBatchTracker>();
+    local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
+    local->fUsesLocalCoords = init.fUsesLocalCoords;
+}
+
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingCircleEffect);
 
 GrGeometryProcessor* DashingCircleEffect::TestCreate(SkRandom* random,
                                                      GrContext*,
                                                      const GrDrawTargetCaps& caps,
                                                      GrTexture*[]) {
     DashAAMode aaMode = static_cast<DashAAMode>(random->nextULessThan(kDashAAModeCount));
     return DashingCircleEffect::Create(GrRandomColor(random),
-                                      aaMode, GrTest::TestMatrix(random),
-                                      random->nextBool());
+                                      aaMode, GrTest::TestMatrix(random));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 class GLDashingLineEffect;
 
+struct DashingLineBatchTracker {
+    GrGPInput fInputColorType;
+    GrColor  fColor;
+    bool fUsesLocalCoords;
+};
+
 /*
  * 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,
-                                       const SkMatrix& localMatrix,
-                                       bool usesLocalCoords);
+                                       const SkMatrix& localMatrix);
 
     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; }
 
     GrColor color() const { return fColor; }
 
-    bool colorIgnored() const { return GrColor_ILLEGAL == fColor; }
-
     const SkMatrix& localMatrix() const { return fLocalMatrix; }
 
-    bool usesLocalCoords() const { return fUsesLocalCoords; }
-
     virtual void getGLProcessorKey(const GrBatchTracker& bt,
                                    const GrGLSLCaps& caps,
                                    GrProcessorKeyBuilder* b) const override;
 
     virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
                                                      const GrGLSLCaps&) const override;
 
+    void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override;
+
 private:
-    DashingLineEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix,
-                      bool usesLocalCoords);
+    DashingLineEffect(GrColor, DashAAMode aaMode, const SkMatrix& localMatrix);
 
     GrColor             fColor;
     SkMatrix            fLocalMatrix;
-    bool                fUsesLocalCoords;
     DashAAMode          fAAMode;
     const Attribute*    fInPosition;
     const Attribute*    fInDashParams;
     const Attribute*    fInRectParams;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
@@ skipping 27 matching lines @@
     typedef GrGLGeometryProcessor INHERITED;
 };
 
 GLDashingLineEffect::GLDashingLineEffect(const GrGeometryProcessor&,
                                          const GrBatchTracker&) {
     fColor = GrColor_ILLEGAL;
 }
 
 void GLDashingLineEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) {
     const DashingLineEffect& de = args.fGP.cast<DashingLineEffect>();
+    const DashingLineBatchTracker& local = args.fBT.cast<DashingLineBatchTracker>();
     GrGLGPBuilder* pb = args.fPB;
 
     GrGLVertexBuilder* vsBuilder = args.fPB->getVertexShaderBuilder();
 
     // emit attributes
     vsBuilder->emitAttributes(de);
 
     // XY refers to dashPos, Z is the dash interval length
     GrGLVertToFrag inDashParams(kVec3f_GrSLType);
     args.fPB->addVarying("DashParams", &inDashParams);
     vsBuilder->codeAppendf("%s = %s;", inDashParams.vsOut(), de.inDashParams()->fName);
 
     // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5),
     // respectively.
     GrGLVertToFrag inRectParams(kVec4f_GrSLType);
     args.fPB->addVarying("RectParams", &inRectParams);
     vsBuilder->codeAppendf("%s = %s;", inRectParams.vsOut(), de.inRectParams()->fName);
 
     // Setup pass through color
-    if (!de.colorIgnored()) {
-        this->setupUniformColor(pb, args.fOutputColor, &fColorUniform);
-    }
-
+    this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, NULL, &fColorUniform);
 
     // Setup position
     this->setupPosition(pb, gpArgs, de.inPosition()->fName);
 
     // emit transforms
     this->emitTransforms(args.fPB, gpArgs->fPositionVar, de.inPosition()->fName, de.localMatrix(),
                          args.fTransformsIn, args.fTransformsOut);
 
     // transforms all points so that we can compare them to our test rect
     GrGLFragmentBuilder* fsBuilder = args.fPB->getFragmentShaderBuilder();
@@ skipping 27 matching lines @@
                                inRectParams.fsIn());
         fsBuilder->codeAppendf("alpha *= (%s.z - fragPosShifted.x) >= -0.5 ? 1.0 : 0.0;",
                                inRectParams.fsIn());
     }
     fsBuilder->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
 }
 
 void GLDashingLineEffect::setData(const GrGLProgramDataManager& pdman,
                                   const GrPrimitiveProcessor& processor,
                                   const GrBatchTracker& bt) {
-    const DashingLineEffect& de = processor.cast<DashingLineEffect>();
-    if (de.color() != fColor) {
+    const DashingLineBatchTracker& local = bt.cast<DashingLineBatchTracker>();
+    if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
         GrGLfloat c[4];
-        GrColorToRGBAFloat(de.color(), c);
+        GrColorToRGBAFloat(local.fColor, c);
         pdman.set4fv(fColorUniform, 1, c);
-        fColor = de.color();
+        fColor = local.fColor;
     }
 }
 
 void GLDashingLineEffect::GenKey(const GrGeometryProcessor& gp,
                                  const GrBatchTracker& bt,
                                  const GrGLSLCaps&,
                                  GrProcessorKeyBuilder* b) {
+    const DashingLineBatchTracker& local = bt.cast<DashingLineBatchTracker>();
     const DashingLineEffect& de = gp.cast<DashingLineEffect>();
     uint32_t key = 0;
-    key |= de.usesLocalCoords() && de.localMatrix().hasPerspective() ? 0x1 : 0x0;
-    key |= de.colorIgnored() ? 0x2 : 0x0;
+    key |= local.fUsesLocalCoords && de.localMatrix().hasPerspective() ? 0x1 : 0x0;
     key |= de.aaMode() << 8;
-    b->add32(key);
+    b->add32(key << 16 | local.fInputColorType);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGeometryProcessor* DashingLineEffect::Create(GrColor color,
                                                DashAAMode aaMode,
-                                               const SkMatrix& localMatrix,
-                                               bool usesLocalCoords) {
-    return SkNEW_ARGS(DashingLineEffect, (color, aaMode, localMatrix, usesLocalCoords));
+                                               const SkMatrix& localMatrix) {
+    return SkNEW_ARGS(DashingLineEffect, (color, aaMode, localMatrix));
 }
 
 void DashingLineEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                           const GrGLSLCaps& caps,
                                           GrProcessorKeyBuilder* b) const {
     GLDashingLineEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLPrimitiveProcessor* DashingLineEffect::createGLInstance(const GrBatchTracker& bt,
                                                             const GrGLSLCaps&) const {
     return SkNEW_ARGS(GLDashingLineEffect, (*this, bt));
 }
 
 DashingLineEffect::DashingLineEffect(GrColor color,
                                      DashAAMode aaMode,
-                                     const SkMatrix& localMatrix,
-                                     bool usesLocalCoords)
+                                     const SkMatrix& localMatrix)
     : 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));
 }
 
+void DashingLineEffect::initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const {
+    DashingLineBatchTracker* local = bt->cast<DashingLineBatchTracker>();
+    local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init, false);
+    local->fUsesLocalCoords = init.fUsesLocalCoords;
+}
+
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingLineEffect);
 
 GrGeometryProcessor* DashingLineEffect::TestCreate(SkRandom* random,
                                                    GrContext*,
                                                    const GrDrawTargetCaps& caps,
                                                    GrTexture*[]) {
     DashAAMode aaMode = static_cast<DashAAMode>(random->nextULessThan(kDashAAModeCount));
     return DashingLineEffect::Create(GrRandomColor(random),
-                                     aaMode, GrTest::TestMatrix(random), random->nextBool());
+                                     aaMode, GrTest::TestMatrix(random));
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 static GrGeometryProcessor* create_dash_gp(GrColor color,
                                            DashAAMode dashAAMode,
                                            DashCap cap,
-                                           const SkMatrix& localMatrix,
-                                           bool usesLocalCoords) {
+                                           const SkMatrix& localMatrix) {
     switch (cap) {
         case kRound_DashCap:
-            return DashingCircleEffect::Create(color, dashAAMode, localMatrix, usesLocalCoords);
+            return DashingCircleEffect::Create(color, dashAAMode, localMatrix);
         case kNonRound_DashCap:
-            return DashingLineEffect::Create(color, dashAAMode, localMatrix, usesLocalCoords);
+            return DashingLineEffect::Create(color, dashAAMode, localMatrix);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
@@ skipping 66 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