move program descriptor generation to flush

src/gpu/GrGpu.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 GrGpu_DEFINED
 #define GrGpu_DEFINED
 
@@ skipping 297 matching lines @@
         kDrawPaths_DrawType,
     };
 
     static bool IsPathRenderingDrawType(DrawType type) {
         return kDrawPath_DrawType == type || kDrawPaths_DrawType == type;
     }
 
     GrContext::GPUStats* gpuStats() { return &fGPUStats; }
 
     virtual void buildProgramDesc(const GrOptDrawState&,
-                                  const GrProgramDesc::DescInfo&,
                                   GrGpu::DrawType,
                                   GrProgramDesc*) = 0;
 
     /**
      * Called at start and end of gpu trace marking
      * GR_CREATE_GPU_TRACE_MARKER(marker_str, target) will automatically call these at the start
      * and end of a code block respectively
      */
     void addGpuTraceMarker(const GrGpuTraceMarker* marker);
     void removeGpuTraceMarker(const GrGpuTraceMarker* marker);
@@ skipping 21 matching lines @@
 
     // Called to perform a surface to surface copy. Fallbacks to issuing a draw from the src to dst
     // take place at the GrDrawTarget level and this function implement faster copy paths. The rect
     // and point are pre-clipped. The src rect and implied dst rect are guaranteed to be within the
     // src/dst bounds and non-empty.
     virtual bool copySurface(GrSurface* dst,
                              GrSurface* src,
                              const SkIRect& srcRect,
                              const SkIPoint& dstPoint) = 0;
 
-    virtual void draw(const GrOptDrawState&, const GrDrawTarget::DrawInfo&);
+    virtual void draw(const GrOptDrawState&, const GrProgramDesc&, const GrDrawTarget::DrawInfo&);
     virtual void stencilPath(const GrOptDrawState&,
+                             const GrProgramDesc&,
                              const GrPath*,
                              const GrStencilSettings&);
     virtual void drawPath(const GrOptDrawState&,
+                          const GrProgramDesc&,
                           const GrPath*,
                           const GrStencilSettings&);
     virtual void drawPaths(const GrOptDrawState&,
+                           const GrProgramDesc&,
                            const GrPathRange*,
                            const void* indices,
                            GrDrawTarget::PathIndexType,
                            const float transformValues[],
                            GrDrawTarget::PathTransformType,
                            int count,
                            const GrStencilSettings&);
 
     static DrawType PrimTypeToDrawType(GrPrimitiveType type) {
         switch (type) {
@@ skipping 84 matching lines @@
     // not be created.
     virtual bool createStencilBufferForRenderTarget(GrRenderTarget*, int width, int height) = 0;
 
     // attaches an existing SB to an existing RT.
     virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*) = 0;
 
     // The GrGpu typically records the clients requested state and then flushes
     // deltas from previous state at draw time. This function does the
     // backend-specific flush of the state.
     // returns false if current state is unsupported.
-    virtual bool flushGraphicsState(const GrOptDrawState&, DrawType) = 0;
+    virtual bool flushGraphicsState(const GrOptDrawState&, const GrProgramDesc&, DrawType) = 0;
 
     // clears target's entire stencil buffer to 0
     virtual void clearStencil(GrRenderTarget* target) = 0;
 
     // Given a rt, find or create a stencil buffer and attach it
     bool attachStencilBufferToRenderTarget(GrRenderTarget* target);
 
     virtual void didAddGpuTraceMarker() = 0;
     virtual void didRemoveGpuTraceMarker() = 0;
 
@@ skipping 17 matching lines @@
     int                                                                 fGpuTraceMarkerCount;
     GrTraceMarkerSet                                                    fActiveTraceMarkers;
     GrTraceMarkerSet                                                    fStoredTraceMarkers;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
     GrContext*                                                          fContext;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif