Initial CL to move color / coverage off of drawstate

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
@@ skipping 251 matching lines @@
      * winding (not inverse or hairline). It will respect the HW antialias flag
      * on the draw state (if possible in the 3D API).  Note, we will never have an inverse fill
      * with stencil path
      */
     void stencilPath(GrDrawState*, const GrPath*, GrPathRendering::FillType fill);
 
     /**
      * Draws a path. Fill must not be a hairline. It will respect the HW
      * antialias flag on the draw state (if possible in the 3D API).
      */
-    void drawPath(GrDrawState*, const GrPath*, GrPathRendering::FillType fill);
+    void drawPath(GrDrawState*, GrColor, const GrPath*, GrPathRendering::FillType fill);
 
     /**
      * Draws the aggregate path from combining multiple. Note that this will not
      * always be equivalent to back-to-back calls to drawPath(). It will respect
      * the HW antialias flag on the draw state (if possible in the 3D API).
      *
      * @param pathRange       Source paths to draw from
      * @param indices         Array of path indices to draw
      * @param indexType       Data type of the array elements in indexBuffer
      * @param transformValues Array of transforms for the individual paths
      * @param transformType   Type of transforms in transformBuffer
      * @param count           Number of paths to draw
      * @param fill            Fill type for drawing all the paths
      */
-    void drawPaths(GrDrawState*, const GrPathRange* pathRange,
+    void drawPaths(GrDrawState*,
+                   GrColor,
+                   const GrPathRange* pathRange,
                    const void* indices,
                    PathIndexType indexType,
                    const float transformValues[],
                    PathTransformType transformType,
                    int count,
                    GrPathRendering::FillType fill);
 
     /**
      * Helper function for drawing rects. It performs a geometry src push and pop
      * and thus will finalize any reserved geometry.
      *
      * @param rect        the rect to draw
      * @param localRect   optional rect that specifies local coords to map onto
      *                    rect. If NULL then rect serves as the local coords.
      * @param localMatrix optional matrix applied to localRect. If
      *                    srcRect is non-NULL and srcMatrix is non-NULL
      *                    then srcRect will be transformed by srcMatrix.
      *                    srcMatrix can be NULL when no srcMatrix is desired.
      */
     void drawRect(GrDrawState* ds,
+                  GrColor color,
                   const SkRect& rect,
                   const SkRect* localRect,
                   const SkMatrix* localMatrix) {
         AutoGeometryPush agp(this);
-        this->onDrawRect(ds, rect, localRect, localMatrix);
+        this->onDrawRect(ds, color, rect, localRect, localMatrix);
     }
 
     /**
      * Helper for drawRect when the caller doesn't need separate local rects or matrices.
      */
-    void drawSimpleRect(GrDrawState* ds, const SkRect& rect) {
-        this->drawRect(ds, rect, NULL, NULL);
+    void drawSimpleRect(GrDrawState* ds, GrColor color, const SkRect& rect) {
+        this->drawRect(ds, color, rect, NULL, NULL);
     }
-    void drawSimpleRect(GrDrawState* ds, const SkIRect& irect) {
+    void drawSimpleRect(GrDrawState* ds, GrColor color, const SkIRect& irect) {
         SkRect rect = SkRect::Make(irect);
-        this->drawRect(ds, rect, NULL, NULL);
+        this->drawRect(ds, color, rect, NULL, NULL);
     }
 
     /**
      * This call is used to draw multiple instances of some geometry with a
      * given number of vertices (V) and indices (I) per-instance. The indices in
      * the index source must have the form i[k+I] == i[k] + V. Also, all indices
      * i[kI] ... i[(k+1)I-1] must be elements of the range kV ... (k+1)V-1. As a
      * concrete example, the following index buffer for drawing a series of
      * quads each as two triangles each satisfies these conditions with V=4 and
      * I=6:
@@ skipping 312 matching lines @@
 
     // Subclass must initialize this in its constructor.
     SkAutoTUnref<const GrDrawTargetCaps> fCaps;
 
     const GrTraceMarkerSet& getActiveTraceMarkers() { return fActiveTraceMarkers; }
 
     // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
     // but couldn't be made. Otherwise, returns true.  This method needs to be protected because it
     // needs to be accessed by GLPrograms to setup a correct drawstate
     bool setupDstReadIfNecessary(GrDrawState*,
+                                 GrColor,
+                                 uint8_t,
                                  GrDeviceCoordTexture* dstCopy,
                                  const SkRect* drawBounds);
 
 private:
     /**
      * This will be called before allocating a texture as a dst for copySurface. This function
      * populates the dstDesc's config, flags, and origin so as to maximize efficiency and guarantee
      * success of the copySurface call.
      */
     void initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* dstDesc) {
@@ skipping 25 matching lines @@
     // subclass overrides to be notified just before geo src state is pushed/popped.
     virtual void geometrySourceWillPush() = 0;
     virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0;
     // subclass called to perform drawing
     virtual void onDraw(const GrDrawState&,
                         const DrawInfo&,
                         const GrClipMaskManager::ScissorState&,
                         const GrDeviceCoordTexture* dstCopy) = 0;
     // TODO copy in order drawbuffer onDrawRect to here
     virtual void onDrawRect(GrDrawState*,
+                            GrColor color,
                             const SkRect& rect,
                             const SkRect* localRect,
                             const SkMatrix* localMatrix) = 0;
 
     virtual void onStencilPath(const GrDrawState&,
                                const GrPath*,
                                const GrClipMaskManager::ScissorState&,
                                const GrStencilSettings&) = 0;
     virtual void onDrawPath(const GrDrawState&,
+                            GrColor,
                             const GrPath*,
                             const GrClipMaskManager::ScissorState&,
                             const GrStencilSettings&,
                             const GrDeviceCoordTexture* dstCopy) = 0;
     virtual void onDrawPaths(const GrDrawState&,
+                             GrColor,
                              const GrPathRange*,
                              const void* indices,
                              PathIndexType,
                              const float transformValues[],
                              PathTransformType,
                              int count,
                              const GrClipMaskManager::ScissorState&,
                              const GrStencilSettings&,
                              const GrDeviceCoordTexture*) = 0;
 
@@ skipping 111 matching lines @@
     virtual bool setupClip(const SkRect* devBounds,
                            GrDrawState::AutoRestoreEffects* are,
                            GrDrawState::AutoRestoreStencil* ars,
                            GrDrawState*,
                            GrClipMaskManager::ScissorState* scissorState) SK_OVERRIDE;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif