Initial CL to move color / coverage off of drawstate

src/gpu/GrAAConvexPathRenderer.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAAConvexPathRenderer.h"
 
@@ skipping 487 matching lines @@
  * distance with negative being inside, positive outside. The edge is specified in
  * window space (y-down). If either the third or fourth component of the interpolated
  * vertex coord is > 0 then the pixel is considered outside the edge. This is used to
  * attempt to trim to a portion of the infinite quad.
  * Requires shader derivative instruction support.
  */
 
 class QuadEdgeEffect : public GrGeometryProcessor {
 public:
 
-    static GrGeometryProcessor* Create() {
-        return SkNEW(QuadEdgeEffect);
+    static GrGeometryProcessor* Create(GrColor color) {
+        return SkNEW_ARGS(QuadEdgeEffect, (color));
     }
 
     virtual ~QuadEdgeEffect() {}
 
     virtual const char* name() const SK_OVERRIDE { return "QuadEdge"; }
 
     const GrAttribute* inPosition() const { return fInPosition; }
     const GrAttribute* inQuadEdge() const { return fInQuadEdge; }
 
     class GLProcessor : public GrGLGeometryProcessor {
@@ skipping 59 matching lines @@
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const SK_OVERRIDE {
         GLProcessor::GenKey(*this, bt, caps, b);
     }
 
     virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) const SK_OVERRIDE {
         return SkNEW_ARGS(GLProcessor, (*this, bt));
     }
 
 private:
-    QuadEdgeEffect() {
+    QuadEdgeEffect(GrColor color) : INHERITED(color) {
         this->initClassID<QuadEdgeEffect>();
         fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_GrVertexAttribType));
         fInQuadEdge = &this->addVertexAttrib(GrAttribute("inQuadEdge", kVec4f_GrVertexAttribType));
     }
 
     virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE {
         return true;
     }
 
     virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE {
         inout->mulByUnknownAlpha();
     }
 
     const GrAttribute* fInPosition;
     const GrAttribute* fInQuadEdge;
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
-    typedef GrFragmentProcessor INHERITED;
+    typedef GrGeometryProcessor INHERITED;
 };
 
 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(QuadEdgeEffect);
 
 GrGeometryProcessor* QuadEdgeEffect::TestCreate(SkRandom* random,
                                                 GrContext*,
                                                 const GrDrawTargetCaps& caps,
                                                 GrTexture*[]) {
     // Doesn't work without derivative instructions.
-    return caps.shaderDerivativeSupport() ? QuadEdgeEffect::Create() : NULL;
+    return caps.shaderDerivativeSupport() ? QuadEdgeEffect::Create(GrRandomColor(random)) : NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrAAConvexPathRenderer::canDrawPath(const GrDrawTarget* target,
                                          const GrDrawState*,
                                          const SkPath& path,
                                          const SkStrokeRec& stroke,
                                          bool antiAlias) const {
     return (target->caps()->shaderDerivativeSupport() && antiAlias &&
             stroke.isFillStyle() && !path.isInverseFillType() && path.isConvex());
 }
 
 bool GrAAConvexPathRenderer::onDrawPath(GrDrawTarget* target,
                                         GrDrawState* drawState,
+                                        GrColor color,
                                         const SkPath& origPath,
                                         const SkStrokeRec&,
                                         bool antiAlias) {
 
     const SkPath* path = &origPath;
     if (path->isEmpty()) {
         return true;
     }
 
     SkMatrix viewMatrix = drawState->getViewMatrix();
@@ skipping 27 matching lines @@
     // We can't simply use the path bounds because we may degenerate cubics to quads which produces
     // new control points outside the original convex hull.
     SkRect devBounds;
     if (!get_segments(*path, viewMatrix, &segments, &fanPt, &vCount, &iCount, &devBounds)) {
         return false;
     }
 
     // Our computed verts should all be within one pixel of the segment control points.
     devBounds.outset(SK_Scalar1, SK_Scalar1);
 
-    GrGeometryProcessor* quadProcessor = QuadEdgeEffect::Create();
+    GrGeometryProcessor* quadProcessor = QuadEdgeEffect::Create(color);
     drawState->setGeometryProcessor(quadProcessor)->unref();
 
     GrDrawTarget::AutoReleaseGeometry arg(target, vCount, quadProcessor->getVertexStride(), iCount);
     SkASSERT(quadProcessor->getVertexStride() == sizeof(QuadVertex));
     if (!arg.succeeded()) {
         return false;
     }
     verts = reinterpret_cast<QuadVertex*>(arg.vertices());
     idxs = reinterpret_cast<uint16_t*>(arg.indices());
 
@@ skipping 20 matching lines @@
                             vOffset,  // start vertex
                             0,        // start index
                             draw.fVertexCnt,
                             draw.fIndexCnt,
                             &devBounds);
         vOffset += draw.fVertexCnt;
     }
 
     return true;
 }