Initial CL to move color / coverage off of drawstate

src/gpu/GrAADistanceFieldPathRenderer.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 "GrAADistanceFieldPathRenderer.h"
 
@@ skipping 87 matching lines @@
                                                    const GrDrawState*,
                                                    const SkPath&,
                                                    const SkStrokeRec&) const {
     return GrPathRenderer::kNoSupport_StencilSupport;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrAADistanceFieldPathRenderer::onDrawPath(GrDrawTarget* target,
                                                GrDrawState* drawState,
+                                               GrColor color,
                                                const SkPath& path,
                                                const SkStrokeRec& stroke,
                                                bool antiAlias) {
     // we've already bailed on inverse filled paths, so this is safe
     if (path.isEmpty()) {
         return true;
     }
 
     SkASSERT(fContext);
 
@@ skipping 18 matching lines @@
     PathData* pathData = fPathCache.find(key);
     if (NULL == pathData) {
         SkScalar scale = desiredDimension/maxDim;
         pathData = this->addPathToAtlas(path, stroke, antiAlias, desiredDimension, scale);
         if (NULL == pathData) {
             return false;
         }
     }
 
     // use signed distance field to render
-    return this->internalDrawPath(target, drawState, path, pathData);
+    return this->internalDrawPath(target, drawState, color, path, pathData);
 }
 
 // padding around path bounds to allow for antialiased pixels
 const SkScalar kAntiAliasPad = 1.0f;
 
 GrAADistanceFieldPathRenderer::PathData* GrAADistanceFieldPathRenderer::addPathToAtlas(
                                                                         const SkPath& path,
                                                                         const SkStrokeRec& stroke,
                                                                         bool antiAlias,
                                                                         uint32_t dimension,
@@ skipping 142 matching lines @@
     }
         
     // tell the atlas to free the plot
     GrAtlas::RemovePlot(&fPlotUsage, plot);
     
     return true;
 }
 
 bool GrAADistanceFieldPathRenderer::internalDrawPath(GrDrawTarget* target,
                                                      GrDrawState* drawState,
+                                                     GrColor color,
                                                      const SkPath& path,
                                                      const PathData* pathData) {
     GrTexture* texture = fAtlas->getTexture();
     GrDrawState::AutoRestoreEffects are(drawState);
     
     SkASSERT(pathData->fPlot);
     GrDrawTarget::DrawToken drawToken = target->getCurrentDrawToken();
     pathData->fPlot->setDrawToken(drawToken);
     
     // set up any flags
     uint32_t flags = 0;
     const SkMatrix& vm = drawState->getViewMatrix();
     flags |= vm.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
 
     GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode);
-    if (flags != fEffectFlags) {
-        fCachedGeometryProcessor.reset(GrDistanceFieldNoGammaTextureEffect::Create(texture,
+    if (flags != fEffectFlags || fCachedGeometryProcessor->getColor() != color) {
+        fCachedGeometryProcessor.reset(GrDistanceFieldNoGammaTextureEffect::Create(color,
+                                                                                   texture,
                                                                                    params,
                                                                                    flags));
         fEffectFlags = flags;
     }
     drawState->setGeometryProcessor(fCachedGeometryProcessor.get());
 
     void* vertices = NULL;
     bool success = target->reserveVertexAndIndexSpace(4,
                                                       fCachedGeometryProcessor->getVertexStride(),
                                                       0, &vertices, NULL);
@@ skipping 32 matching lines @@
                               vertSize);
     
     vm.mapRect(&r);
     target->setIndexSourceToBuffer(fContext->getQuadIndexBuffer());
     target->drawIndexedInstances(drawState, kTriangles_GrPrimitiveType, 1, 4, 6, &r);
     target->resetVertexSource();
     
     return true;
 }