Initial CL to move color / coverage off of drawstate

src/gpu/GrPathRenderer.h

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrPathRenderer_DEFINED
 #define GrPathRenderer_DEFINED
@@ skipping 99 matching lines @@
      * Draws the path into the draw target. If getStencilSupport() would return kNoRestriction then
      * the subclass must respect the stencil settings of the target's draw state.
      *
      * @param path                  the path to draw.
      * @param stroke                the stroke information (width, join, cap)
      * @param target                target that the path will be rendered to
      * @param antiAlias             true if anti-aliasing is required.
      */
     bool drawPath(GrDrawTarget* target,
                   GrDrawState* ds,
+                  GrColor color,
                   const SkPath& path,
                   const SkStrokeRec& stroke,
                   bool antiAlias) {
         SkASSERT(!path.isEmpty());
         SkASSERT(this->canDrawPath(target, ds, path, stroke, antiAlias));
         SkASSERT(ds->getStencil().isDisabled() ||
                  kNoRestriction_StencilSupport == this->getStencilSupport(target, ds, path,
                                                                           stroke));
-        return this->onDrawPath(target, ds, path, stroke, antiAlias);
+        return this->onDrawPath(target, ds, color, path, stroke, antiAlias);
     }
 
     /**
      * Draws the path to the stencil buffer. Assume the writable stencil bits are already
      * initialized to zero. The pixels inside the path will have non-zero stencil values afterwards.
      *
      * @param path                  the path to draw.
      * @param stroke                the stroke information (width, join, cap)
      * @param target                target that the path will be rendered to
      */
@@ skipping 29 matching lines @@
                                                const SkPath&,
                                                const SkStrokeRec&) const {
         return kNoRestriction_StencilSupport;
     }
 
     /**
      * Subclass implementation of drawPath()
      */
     virtual bool onDrawPath(GrDrawTarget*,
                             GrDrawState*,
+                            GrColor,
                             const SkPath&,
                             const SkStrokeRec&,
                             bool antiAlias) = 0;
 
     /**
      * Subclass implementation of stencilPath(). Subclass must override iff it ever returns
      * kStencilOnly in onGetStencilSupport().
      */
     virtual void onStencilPath(GrDrawTarget* target,
                                GrDrawState* drawState,
                                const SkPath& path,
                                const SkStrokeRec& stroke) {
         GR_STATIC_CONST_SAME_STENCIL(kIncrementStencil,
                                      kReplace_StencilOp,
                                      kReplace_StencilOp,
                                      kAlways_StencilFunc,
                                      0xffff,
                                      0xffff,
                                      0xffff);
         drawState->setStencil(kIncrementStencil);
         drawState->enableState(GrDrawState::kNoColorWrites_StateBit);
-        this->drawPath(target, drawState, path, stroke, false);
+        this->drawPath(target, drawState, GrColor_WHITE,  path, stroke, false);
     }
 
     // Helper for getting the device bounds of a path. Inverse filled paths will have bounds set
     // by devSize. Non-inverse path bounds will not necessarily be clipped to devSize.
     static void GetPathDevBounds(const SkPath& path,
                                  int devW,
                                  int devH,
                                  const SkMatrix& matrix,
                                  SkRect* bounds);
 
     // Helper version that gets the dev width and height from a GrSurface.
     static void GetPathDevBounds(const SkPath& path,
                                  const GrSurface* device,
                                  const SkMatrix& matrix,
                                  SkRect* bounds) {
         GetPathDevBounds(path, device->width(), device->height(), matrix, bounds);
     }
 
 private:
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif