Remove GP from drawstate, revision of invariant output for GP

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 "../GrAARectRenderer.h"
@@ skipping 317 matching lines @@
 
         SkPoint devicePts[2];
         vm.mapPoints(devicePts, ptsRot, 2);
         SkScalar lineLength = SkPoint::Distance(devicePts[0], devicePts[1]);
         if (hasCap) {
             lineLength += 2.f * halfDevStroke;
         }
         devIntervals[0] = lineLength;
     }
 
-    const GrGeometryProcessor* gp;
+    SkAutoTUnref<const GrGeometryProcessor> gp;
     bool fullDash = devIntervals[1] > 0.f || useAA;
     if (fullDash) {
         SkPathEffect::DashInfo devInfo;
         devInfo.fPhase = devPhase;
         devInfo.fCount = 2;
         devInfo.fIntervals = devIntervals;
         GrPrimitiveEdgeType edgeType= useAA ? kFillAA_GrProcessorEdgeType :
             kFillBW_GrProcessorEdgeType;
         bool isRoundCap = SkPaint::kRound_Cap == cap;
         GrDashingEffect::DashCap capType = isRoundCap ? GrDashingEffect::kRound_DashCap :
                                                         GrDashingEffect::kNonRound_DashCap;
-        gp = GrDashingEffect::Create(color, edgeType, devInfo, strokeWidth, capType);
+        gp.reset(GrDashingEffect::Create(color, edgeType, devInfo, strokeWidth, capType));
     } else {
         // Set up the vertex data for the line and start/end dashes
-        gp = GrDefaultGeoProcFactory::Create(color, GrDefaultGeoProcFactory::kPosition_GPType);
+        gp.reset(GrDefaultGeoProcFactory::Create(color, GrDefaultGeoProcFactory::kPosition_GPType));
     }
 
-    drawState->setGeometryProcessor(gp)->unref();
-
     int totalRectCnt = 0;
 
     totalRectCnt += !lineDone ? 1 : 0;
     totalRectCnt += hasStartRect ? 1 : 0;
     totalRectCnt += hasEndRect ? 1 : 0;
 
     GrDrawTarget::AutoReleaseGeometry geo(target,
                                           totalRectCnt * 4,
                                           gp->getVertexStride(), 0);
     if (!geo.succeeded()) {
@@ skipping 60 matching lines @@
                               devIntervals[0], halfDevStroke);
         } else {
             SkPoint* verts = reinterpret_cast<SkPoint*>(geo.vertices());
             SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
             setup_dashed_rect_pos(endRect, curVIdx, combinedMatrix, verts);
         }
 
     }
 
     target->setIndexSourceToBuffer(gpu->getContext()->getQuadIndexBuffer());
-    target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, totalRectCnt, 4, 6);
+    target->drawIndexedInstances(drawState, gp, kTriangles_GrPrimitiveType, totalRectCnt, 4, 6);
     target->resetIndexSource();
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 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.
@@ skipping 33 matching lines @@
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE;
 
     virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker&) const SK_OVERRIDE;
 
 private:
     DashingCircleEffect(GrColor, GrPrimitiveEdgeType edgeType, const DashInfo& info,
                         SkScalar radius);
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
-    virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+    virtual void onComputeOutputCoverage(GrInitInvariantOutput*) const SK_OVERRIDE;
 
     GrPrimitiveEdgeType fEdgeType;
     const GrAttribute*  fInPosition;
     const GrAttribute*  fInCoord;
     SkScalar            fIntervalLength;
     SkScalar            fRadius;
     SkScalar            fCenterX;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
@@ skipping 104 matching lines @@
                                                  SkScalar radius) {
     if (info.fCount != 2 || info.fIntervals[0] != 0) {
         return NULL;
     }
 
     return SkNEW_ARGS(DashingCircleEffect, (color, edgeType, info, radius));
 }
 
 DashingCircleEffect::~DashingCircleEffect() {}
 
-void DashingCircleEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
-    inout->mulByUnknownAlpha();
+void DashingCircleEffect::onComputeOutputCoverage(GrInitInvariantOutput* out) const {
+    out->setIsUnknownSingleComponent();
 }
 
 void DashingCircleEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                             const GrGLCaps& caps,
                                             GrProcessorKeyBuilder* b) const {
     GLDashingCircleEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLGeometryProcessor* DashingCircleEffect::createGLInstance(const GrBatchTracker& bt) const {
     return SkNEW_ARGS(GLDashingCircleEffect, (*this, bt));
@@ skipping 83 matching lines @@
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE;
 
     virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE;
 
 private:
     DashingLineEffect(GrColor, GrPrimitiveEdgeType edgeType, const DashInfo& info,
                       SkScalar strokeWidth);
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE;
 
-    virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE;
+    virtual void onComputeOutputCoverage(GrInitInvariantOutput*) const SK_OVERRIDE;
 
     GrPrimitiveEdgeType fEdgeType;
     const GrAttribute*  fInPosition;
     const GrAttribute*  fInCoord;
     SkRect              fRect;
     SkScalar            fIntervalLength;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
@@ skipping 117 matching lines @@
                                                SkScalar strokeWidth) {
     if (info.fCount != 2) {
         return NULL;
     }
 
     return SkNEW_ARGS(DashingLineEffect, (color, edgeType, info, strokeWidth));
 }
 
 DashingLineEffect::~DashingLineEffect() {}
 
-void DashingLineEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
-    inout->mulByUnknownAlpha();
+void DashingLineEffect::onComputeOutputCoverage(GrInitInvariantOutput* out) const {
+    out->setIsUnknownSingleComponent();
 }
 
 void DashingLineEffect::getGLProcessorKey(const GrBatchTracker& bt,
                                           const GrGLCaps& caps,
                                           GrProcessorKeyBuilder* b) const {
     GLDashingLineEffect::GenKey(*this, bt, caps, b);
 }
 
 GrGLGeometryProcessor* DashingLineEffect::createGLInstance(const GrBatchTracker& bt) const {
     return SkNEW_ARGS(GLDashingLineEffect, (*this, bt));
@@ skipping 52 matching lines @@
     switch (cap) {
         case GrDashingEffect::kRound_DashCap:
             return DashingCircleEffect::Create(color, edgeType, info, SkScalarHalf(strokeWidth));
         case GrDashingEffect::kNonRound_DashCap:
             return DashingLineEffect::Create(color, edgeType, info, strokeWidth);
         default:
             SkFAIL("Unexpected dashed cap.");
     }
     return NULL;
 }