move program descriptor generation to flush

src/gpu/GrOptDrawState.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrOptDrawState_DEFINED
 #define GrOptDrawState_DEFINED
 
@@ skipping 12 matching lines @@
 /**
  * Class that holds an optimized version of a GrDrawState. It is meant to be an immutable class,
  * and contains all data needed to set the state for a gpu draw.
  */
 class GrOptDrawState {
 public:
     SK_DECLARE_INST_COUNT(GrOptDrawState)
 
     typedef GrClipMaskManager::ScissorState ScissorState;
 
-    GrOptDrawState(const GrDrawState& drawState, GrGpu*, const ScissorState&,
+    GrOptDrawState(const GrDrawState& drawState, const GrDrawTargetCaps&, const ScissorState&,
                    const GrDeviceCoordTexture* dstCopy, GrGpu::DrawType);
 
     bool operator== (const GrOptDrawState& that) const;
     bool operator!= (const GrOptDrawState& that) const { return !(*this == that); }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Color
     ////
@@ skipping 129 matching lines @@
      * Gets whether the target is drawing clockwise, counterclockwise,
      * or both faces.
      * @return the current draw face(s).
      */
     GrDrawState::DrawFace getDrawFace() const { return fDrawFace; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
 
+    GrGpu::DrawType drawType() const { return fDrawType; }
+
     const GrDeviceCoordTexture* getDstCopy() const { return fDstCopy.texture() ? &fDstCopy : NULL; }
 
-    const GrProgramDesc& programDesc() const { return fDesc; }
+    // Finalize *MUST* be called before programDesc()
+    void finalize(GrGpu*);
+
+    const GrProgramDesc& programDesc() const { SkASSERT(fFinalized); return fDesc; }
 
 private:
     /**
-     * Loops through all the color stage effects to check if the stage will ignore color input or
-     * always output a constant color. In the ignore color input case we can ignore all previous
-     * stages. In the constant color case, we can ignore all previous stages and
-     * the current one and set the state color to the constant color.
-     */
-    void computeEffectiveColorStages(const GrDrawState& ds, GrProgramDesc::DescInfo*,
-                                     int* firstColorStageIdx, uint8_t* fixFunctionVAToRemove);
-
-    /**
-     * Loops through all the coverage stage effects to check if the stage will ignore color input.
-     * If a coverage stage will ignore input, then we can ignore all coverage stages before it. We
-     * loop to determine the first effective coverage stage.
-     */
-    void computeEffectiveCoverageStages(const GrDrawState& ds, GrProgramDesc::DescInfo* descInfo,
-                                        int* firstCoverageStageIdx);
-
-    /**
      * Alter the program desc and inputs (attribs and processors) based on the blend optimization.
      */
     void adjustProgramForBlendOpt(const GrDrawState& ds, GrDrawState::BlendOpt,
-                                  GrProgramDesc::DescInfo*,
                                   int* firstColorStageIdx, int* firstCoverageStageIdx);
 
     /**
      * Loop over the effect stages to determine various info like what data they will read and what
      * shaders they require.
      */
     void getStageStats(const GrDrawState& ds, int firstColorStageIdx, int firstCoverageStageIdx,
-                       bool hasLocalCoords, GrProgramDesc::DescInfo*);
+                       bool hasLocalCoords);
 
     /**
      * Calculates the primary and secondary output types of the shader. For certain output types
      * the function may adjust the blend coefficients. After this function is called the src and dst
      * blend coeffs will represent those used by backend API.
      */
-    void setOutputStateInfo(const GrDrawState& ds, GrDrawState::BlendOpt, const GrDrawTargetCaps&,
-                            GrProgramDesc::DescInfo*);
+    void setOutputStateInfo(const GrDrawState& ds, GrDrawState::BlendOpt, const GrDrawTargetCaps&);
 
     enum Flags {
         kDither_Flag            = 0x1,
         kHWAA_Flag              = 0x2,
         kDisableColorWrite_Flag = 0x4,
     };
 
     typedef GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> RenderTarget;
     typedef SkSTArray<8, GrPendingFragmentStage> FragmentStageArray;
     typedef GrPendingProgramElement<const GrGeometryProcessor> ProgramGeometryProcessor;
     typedef GrPendingProgramElement<const GrXferProcessor> ProgramXferProcessor;
     RenderTarget                        fRenderTarget;
     ScissorState                        fScissorState;
     GrColor                             fColor;
     SkMatrix                            fViewMatrix;
     GrColor                             fBlendConstant;
     GrStencilSettings                   fStencilSettings;
     uint8_t                             fCoverage;
     GrDrawState::DrawFace               fDrawFace;
     GrDeviceCoordTexture                fDstCopy;
     GrBlendCoeff                        fSrcBlend;
     GrBlendCoeff                        fDstBlend;
     uint32_t                            fFlags;
     ProgramGeometryProcessor            fGeometryProcessor;
     ProgramXferProcessor                fXferProcessor;
     FragmentStageArray                  fFragmentStages;
+    GrGpu::DrawType                     fDrawType;
+    GrProgramDesc::DescInfo             fDescInfo;
+    bool                                fFinalized;
 
     // This function is equivalent to the offset into fFragmentStages where coverage stages begin.
     int                                 fNumColorStages;
 
     GrProgramDesc fDesc;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif