Initial CL to move color / coverage off of drawstate

src/gpu/GrDefaultPathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDefaultPathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 215 matching lines @@
         }
     } else {
         if (indexed) {
             maxIdxs = 3 * maxPts;
             *primType = kTriangles_GrPrimitiveType;
         } else {
             *primType = kTriangleFan_GrPrimitiveType;
         }
     }
 
-    // TODO this is really wierd, I just need default vertex stride, can I think of a better way?
-    SkAutoTUnref<const GrGeometryProcessor> gp(GrDefaultGeoProcFactory::Create());
-    if (!arg->set(target, maxPts, gp->getVertexStride(), maxIdxs)) {
+    if (!arg->set(target, maxPts, GrDefaultGeoProcFactory::DefaultVertexStride(), maxIdxs)) {
         return false;
     }
-    SkASSERT(gp->getVertexStride() == sizeof(SkPoint));
+    SkASSERT(GrDefaultGeoProcFactory::DefaultVertexStride() == sizeof(SkPoint));
 
     uint16_t* idxBase = reinterpret_cast<uint16_t*>(arg->indices());
     uint16_t* idx = idxBase;
     uint16_t subpathIdxStart = 0;
 
     SkPoint* base = reinterpret_cast<SkPoint*>(arg->vertices());
     SkASSERT(base);
     SkPoint* vert = base;
 
     SkPoint pts[4];
@@ skipping 71 matching lines @@
 
     *vertexCnt = static_cast<int>(vert - base);
     *indexCnt = static_cast<int>(idx - idxBase);
 
     }
     return true;
 }
 
 bool GrDefaultPathRenderer::internalDrawPath(GrDrawTarget* target,
                                              GrDrawState* drawState,
+                                             GrColor color,
                                              const SkPath& path,
                                              const SkStrokeRec& origStroke,
                                              bool stencilOnly) {
     SkMatrix viewM = drawState->getViewMatrix();
     SkTCopyOnFirstWrite<SkStrokeRec> stroke(origStroke);
 
     SkScalar hairlineCoverage;
+    uint8_t newCoverage = 0xff;
     if (IsStrokeHairlineOrEquivalent(*stroke, drawState->getViewMatrix(),
                                      &hairlineCoverage)) {
-        uint8_t newCoverage = SkScalarRoundToInt(hairlineCoverage * drawState->getCoverage());
-        drawState->setCoverage(newCoverage);
+        newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
 
         if (!stroke->isHairlineStyle()) {
             stroke.writable()->setHairlineStyle();
         }
     }
 
     SkScalar tol = SK_Scalar1;
     tol = GrPathUtils::scaleToleranceToSrc(tol, viewM, path.getBounds());
 
     int vertexCnt;
@@ skipping 132 matching lines @@
                 if (!drawState->getViewMatrix().hasPerspective() &&
                     drawState->getViewInverse(&vmi)) {
                     vmi.mapRect(&bounds);
                 } else {
                     avmr.setIdentity(drawState);
                 }
             } else {
                 bounds = path.getBounds();
             }
             GrDrawTarget::AutoGeometryPush agp(target);
-            target->drawSimpleRect(drawState, bounds);
+            target->drawSimpleRect(drawState, color, bounds);
         } else {
             if (passCount > 1) {
                 drawState->enableState(GrDrawState::kNoColorWrites_StateBit);
             }
             GrDrawState::AutoRestoreEffects are(drawState);
-            drawState->setGeometryProcessor(GrDefaultGeoProcFactory::Create())->unref();
+            drawState->setGeometryProcessor(
+                    GrDefaultGeoProcFactory::Create(color,
+                                                    GrDefaultGeoProcFactory::kPosition_GPType,
+                                                    newCoverage))->unref();
             if (indexCnt) {
                 target->drawIndexed(drawState,
                                     primType,
                                     0,
                                     0,
                                     vertexCnt,
                                     indexCnt,
                                     &devBounds);
             } else {
                 target->drawNonIndexed(drawState, primType, 0, vertexCnt, &devBounds);
@@ skipping 10 matching lines @@
                                         bool antiAlias) const {
     // this class can draw any path with any fill but doesn't do any anti-aliasing.
 
     return !antiAlias && !(SkPath::kConic_SegmentMask & path.getSegmentMasks()) &&
         (stroke.isFillStyle() ||
          IsStrokeHairlineOrEquivalent(stroke, drawState->getViewMatrix(), NULL));
 }
 
 bool GrDefaultPathRenderer::onDrawPath(GrDrawTarget* target,
                                        GrDrawState* drawState,
+                                       GrColor color,
                                        const SkPath& path,
                                        const SkStrokeRec& stroke,
                                        bool antiAlias) {
     return this->internalDrawPath(target,
                                   drawState,
+                                  color,
                                   path,
                                   stroke,
                                   false);
 }
 
 void GrDefaultPathRenderer::onStencilPath(GrDrawTarget* target,
                                           GrDrawState* drawState,
                                           const SkPath& path,
                                           const SkStrokeRec& stroke) {
     SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
     SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
-    this->internalDrawPath(target, drawState, path, stroke, true);
+    this->internalDrawPath(target, drawState, GrColor_WHITE, path, stroke, true);
 }