Create GrOptDrawState before recording draw in GrInOrderDrawBuffer

src/gpu/GrDrawState.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 GrDrawState_DEFINED
 #define GrDrawState_DEFINED
 
 
 #include "GrBlend.h"
 #include "GrDrawTargetCaps.h"
 #include "GrGeometryProcessor.h"
 #include "GrGpuResourceRef.h"
-#include "GrProcessorStage.h"
+#include "GrFragmentStage.h"
 #include "GrProcOptInfo.h"
 #include "GrRenderTarget.h"
 #include "GrStencil.h"
 #include "SkMatrix.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 class GrDrawTargetCaps;
 class GrOptDrawState;
 class GrPaint;
 class GrTexture;
@@ skipping 506 matching lines @@
      *
      * @return    The currently set render target.
      */
     GrRenderTarget* getRenderTarget() const { return fRenderTarget.get(); }
 
     /**
      * Sets the render-target used at the next drawing call
      *
      * @param target  The render target to set.
      */
-    void setRenderTarget(GrRenderTarget* target) {
-        fRenderTarget.set(SkSafeRef(target), kWrite_GrIOType);
-    }
+    void setRenderTarget(GrRenderTarget* target) { fRenderTarget.reset(SkSafeRef(target)); }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Stencil
     ////
 
     const GrStencilSettings& getStencil() const { return fStencilSettings; }
 
     /**
@@ skipping 156 matching lines @@
     };
 
     void setHint(Hints hint, bool value) { fHints = value ? (fHints | hint) : (fHints & ~hint); }
 
     bool vertexColorsAreOpaque() const { return kVertexColorsAreOpaque_Hint & fHints; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
 
-    /** Return type for CombineIfPossible. */
-    enum CombinedState {
-        /** The GrDrawStates cannot be combined. */
-        kIncompatible_CombinedState,
-        /** Either draw state can be used in place of the other. */
-        kAOrB_CombinedState,
-        /** Use the first draw state. */
-        kA_CombinedState,
-        /** Use the second draw state. */
-        kB_CombinedState,
-    };
-
-    /** This function determines whether the GrDrawStates used for two draws can be combined into
-        a single GrDrawState. This is used to avoid storing redundant GrDrawStates and to determine
-        if draws can be batched. The return value indicates whether combining is possible and, if
-        so, which of the two inputs should be used. */
-    static CombinedState CombineIfPossible(const GrDrawState& a, const GrDrawState& b,
-                                           const GrDrawTargetCaps& caps);
-
     GrDrawState& operator= (const GrDrawState& that);
 
 private:
-    /**
-     * Converts refs on GrGpuResources owned directly or indirectly by this GrDrawState into
-     * pending reads and writes. This should be called when a GrDrawState is recorded into
-     * a GrDrawTarget for later execution. Subclasses of GrDrawState may add setters. However,
-     * once this call has been made the GrDrawState is immutable. It is also no longer copyable.
-     * In the future this conversion will automatically happen when converting a GrDrawState into
-     * an optimized draw state.
-     */
-    void convertToPendingExec();
-
-    friend class GrDrawTarget;
-
     bool isEqual(const GrDrawState& that) const;
 
     /**
      * Optimizations for blending / coverage to that can be applied based on the current state.
      */
     enum BlendOptFlags {
         /**
          * No optimization
          */
         kNone_BlendOpt                  = 0,
@@ skipping 63 matching lines @@
     void calcCoverageInvariantOutput() const;
 
     void onReset(const SkMatrix* initialViewMatrix);
 
     // Some of the auto restore objects assume that no effects are removed during their lifetime.
     // This is used to assert that this condition holds.
     SkDEBUGCODE(int fBlockEffectRemovalCnt;)
 
     void internalSetVertexAttribs(const GrVertexAttrib attribs[], int count, size_t stride);
 
-    typedef GrTGpuResourceRef<GrRenderTarget> ProgramRenderTarget;
-    // These fields are roughly sorted by decreasing likelihood of being different in op==
-    ProgramRenderTarget                 fRenderTarget;
-    GrColor                             fColor;
-    SkMatrix                            fViewMatrix;
-    GrColor                             fBlendConstant;
-    uint32_t                            fFlagBits;
-    const GrVertexAttrib*               fVAPtr;
-    int                                 fVACount;
-    size_t                              fVAStride;
-    GrStencilSettings                   fStencilSettings;
-    uint8_t                             fCoverage;
-    DrawFace                            fDrawFace;
-    GrBlendCoeff                        fSrcBlend;
-    GrBlendCoeff                        fDstBlend;
+    typedef SkSTArray<4, GrFragmentStage> FragmentStageArray;
 
-    typedef SkSTArray<4, GrFragmentStage> FragmentStageArray;
-    typedef GrProgramElementRef<const GrGeometryProcessor> ProgramGeometryProcessor;
-    ProgramGeometryProcessor            fGeometryProcessor;
-    FragmentStageArray                  fColorStages;
-    FragmentStageArray                  fCoverageStages;
-
-    uint32_t                            fHints;
+    SkAutoTUnref<GrRenderTarget>            fRenderTarget;
+    GrColor                                 fColor;
+    SkMatrix                                fViewMatrix;
+    GrColor                                 fBlendConstant;
+    uint32_t                                fFlagBits;
+    const GrVertexAttrib*                   fVAPtr;
+    int                                     fVACount;
+    size_t                                  fVAStride;
+    GrStencilSettings                       fStencilSettings;
+    uint8_t                                 fCoverage;
+    DrawFace                                fDrawFace;
+    GrBlendCoeff                            fSrcBlend;
+    GrBlendCoeff                            fDstBlend;
+    SkAutoTUnref<const GrGeometryProcessor> fGeometryProcessor;
+    FragmentStageArray                      fColorStages;
+    FragmentStageArray                      fCoverageStages;
+    uint32_t                                fHints;
 
     // This is simply a different representation of info in fVertexAttribs and thus does
     // not need to be compared in op==.
     int fFixedFunctionVertexAttribIndices[kGrFixedFunctionVertexAttribBindingCnt];
 
     mutable GrProcOptInfo fColorProcInfo;
     mutable GrProcOptInfo fCoverageProcInfo;
     mutable bool fColorProcInfoValid;
     mutable bool fCoverageProcInfoValid;
 
     friend class GrOptDrawState;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif