Remove GP from drawstate, revision of invariant output for GP

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 215 matching lines @@
      *                     to index 0
      * @param startIndex   first index to read from index src.
      * @param vertexCount  one greater than the max index.
      * @param indexCount   the number of index elements to read. The index count
      *                     is effectively trimmed to the last completely
      *                     specified primitive.
      * @param devBounds    optional bounds hint. This is a promise from the caller,
      *                     not a request for clipping.
      */
     void drawIndexed(GrDrawState*,
+                     const GrGeometryProcessor*,
                      GrPrimitiveType type,
                      int startVertex,
                      int startIndex,
                      int vertexCount,
                      int indexCount,
                      const SkRect* devBounds = NULL);
 
     /**
      * Draws non-indexed geometry using the current state and current vertex
      * sources.
      *
      * @param type         The type of primitives to draw.
      * @param startVertex  the vertex in the vertex array/buffer corresponding
      *                     to index 0
      * @param vertexCount  one greater than the max index.
      * @param devBounds    optional bounds hint. This is a promise from the caller,
      *                     not a request for clipping.
      */
     void drawNonIndexed(GrDrawState*,
+                        const GrGeometryProcessor*,
                         GrPrimitiveType type,
                         int startVertex,
                         int vertexCount,
                         const SkRect* devBounds = NULL);
 
     /**
      * Draws path into the stencil buffer. The fill must be either even/odd or
      * 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
@@ skipping 85 matching lines @@
      *                      indicesPerInstance indices drawn as the primitive
      *                      type specified by type.
      * @param verticesPerInstance   The number of vertices in each instance (V
      *                              in the above description).
      * @param indicesPerInstance    The number of indices in each instance (I
      *                              in the above description).
      * @param devBounds    optional bounds hint. This is a promise from the caller,
      *                     not a request for clipping.
      */
     void drawIndexedInstances(GrDrawState*,
+                              const GrGeometryProcessor*,
                               GrPrimitiveType type,
                               int instanceCount,
                               int verticesPerInstance,
                               int indicesPerInstance,
                               const SkRect* devBounds = NULL);
 
     /**
      * Clear the passed in render target. Ignores the draw state and clip. Clears the whole thing if
      * rect is NULL, otherwise just the rect. If canIgnoreRect is set then the entire render target
      * can be optionally cleared.
@@ skipping 279 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*,
+                                 const GrPrimitiveProcessor*,
                                  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.
@@ skipping 22 matching lines @@
     virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) = 0;
     virtual bool onReserveIndexSpace(int indexCount, void** indices) = 0;
     // implemented by subclass to handle release of reserved geom space
     virtual void releaseReservedVertexSpace() = 0;
     virtual void releaseReservedIndexSpace() = 0;
     // 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 GrGeometryProcessor*,
                         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;
 
@@ skipping 48 matching lines @@
 
     // helpers for reserving vertex and index space.
     bool reserveVertexSpace(size_t vertexSize,
                             int vertexCount,
                             void** vertices);
     bool reserveIndexSpace(int indexCount, void** indices);
 
     // called by drawIndexed and drawNonIndexed. Use a negative indexCount to
     // indicate non-indexed drawing.
     bool checkDraw(const GrDrawState&,
+                   const GrGeometryProcessor*,
                    GrPrimitiveType type,
                    int startVertex,
                    int startIndex,
                    int vertexCount,
                    int indexCount) const;
     // called when setting a new vert/idx source to unref prev vb/ib
     void releasePreviousVertexSource();
     void releasePreviousIndexSource();
 
     // Check to see if this set of draw commands has been sent out
@@ skipping 65 matching lines @@
     virtual bool setupClip(const SkRect* devBounds,
                            GrDrawState::AutoRestoreEffects* are,
                            GrDrawState::AutoRestoreStencil* ars,
                            GrDrawState*,
                            GrClipMaskManager::ScissorState* scissorState) SK_OVERRIDE;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif