Remove cached OptDrawState from GrDrawState.

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
 
@@ skipping 10 matching lines @@
 
 class GrDrawTargetCaps;
 class GrOptDrawState;
 class GrPaint;
 class GrTexture;
 
 class GrDrawState : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrDrawState)
 
-    GrDrawState() : fCachedOptState(NULL) {
+    GrDrawState() {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         this->reset();
     }
 
-    GrDrawState(const SkMatrix& initialViewMatrix) : fCachedOptState(NULL) {
+    GrDrawState(const SkMatrix& initialViewMatrix) {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         this->reset(initialViewMatrix);
     }
 
     /**
      * Copies another draw state.
      **/
-    GrDrawState(const GrDrawState& state) : INHERITED(), fCachedOptState(NULL) {
+    GrDrawState(const GrDrawState& state) : INHERITED() {
         SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
         *this = state;
     }
 
     /**
      * Copies another draw state with a preconcat to the view matrix.
      **/
     GrDrawState(const GrDrawState& state, const SkMatrix& preConcatMatrix);
 
     virtual ~GrDrawState();
@@ skipping 113 matching lines @@
     GrColor getColor() const { return fColor; }
 
     /**
      *  Sets color for next draw to a premultiplied-alpha color.
      *
      *  @param color    the color to set.
      */
     void setColor(GrColor color) {
         if (color != fColor) {
             fColor = color;
-            this->invalidateOptState();
         }
     }
 
     /**
      *  Sets the color to be used for the next draw to be
      *  (r,g,b,a) = (alpha, alpha, alpha, alpha).
      *
      *  @param alpha The alpha value to set as the color.
      */
     void setAlpha(uint8_t a) { this->setColor((a << 24) | (a << 16) | (a << 8) | a); }
@@ skipping 11 matching lines @@
     }
 
     /**
      * Sets a constant fractional coverage to be applied to the draw. The
      * initial value (after construction or reset()) is 0xff. The constant
      * coverage is ignored when per-vertex coverage is provided.
      */
     void setCoverage(uint8_t coverage) {
         if (coverage != fCoverage) {
             fCoverage = coverage;
-            this->invalidateOptState();
         }
     }
 
     /// @}
 
     /**
      * The geometry processor is the sole element of the skia pipeline which can use the vertex,
      * geometry, and tesselation shaders.  The GP may also compute a coverage in its fragment shader
      * but is never put in the color processing pipeline.
      */
 
     const GrGeometryProcessor* setGeometryProcessor(const GrGeometryProcessor* geometryProcessor) {
         SkASSERT(geometryProcessor);
         SkASSERT(!this->hasGeometryProcessor());
         fGeometryProcessor.reset(SkRef(geometryProcessor));
-        this->invalidateOptState();
         return geometryProcessor;
     }
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Effect Stages
     /// Each stage hosts a GrProcessor. The effect produces an output color or coverage in the
     /// fragment shader. Its inputs are the output from the previous stage as well as some variables
     /// available to it in the fragment and vertex shader (e.g. the vertex position, the dst color,
     /// the fragment position, local coordinates).
     ///
@@ skipping 23 matching lines @@
     const GrFragmentStage& getCoverageStage(int idx) const { return fCoverageStages[idx]; }
 
     /**
      * Checks whether any of the effects will read the dst pixel color.
      */
     bool willEffectReadDstColor() const;
 
     const GrFragmentProcessor* addColorProcessor(const GrFragmentProcessor* effect) {
         SkASSERT(effect);
         SkNEW_APPEND_TO_TARRAY(&fColorStages, GrFragmentStage, (effect));
-        this->invalidateOptState();
         return effect;
     }
 
     const GrFragmentProcessor* addCoverageProcessor(const GrFragmentProcessor* effect) {
         SkASSERT(effect);
         SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrFragmentStage, (effect));
-        this->invalidateOptState();
         return effect;
     }
 
     /**
      * Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
      */
     void addColorTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
         this->addColorProcessor(GrSimpleTextureEffect::Create(texture, matrix))->unref();
     }
 
@@ skipping 120 matching lines @@
      *   color, and D' is the new destination color that will be written. sat()
      *   is the saturation function.
      *
      * @param srcCoef coefficient applied to the src color.
      * @param dstCoef coefficient applied to the dst color.
      */
     void setBlendFunc(GrBlendCoeff srcCoeff, GrBlendCoeff dstCoeff) {
         if (srcCoeff != fSrcBlend || dstCoeff != fDstBlend) {
             fSrcBlend = srcCoeff;
             fDstBlend = dstCoeff;
-            this->invalidateOptState();
         }
     #ifdef SK_DEBUG
         if (GrBlendCoeffRefsDst(dstCoeff)) {
             SkDebugf("Unexpected dst blend coeff. Won't work correctly with coverage stages.\n");
         }
         if (GrBlendCoeffRefsSrc(srcCoeff)) {
             SkDebugf("Unexpected src blend coeff. Won't work correctly with coverage stages.\n");
         }
     #endif
     }
 
     /**
      * Sets the blending function constant referenced by the following blending
      * coefficients:
      *      kConstC_GrBlendCoeff
      *      kIConstC_GrBlendCoeff
      *      kConstA_GrBlendCoeff
      *      kIConstA_GrBlendCoeff
      *
      * @param constant the constant to set
      */
     void setBlendConstant(GrColor constant) {
         if (constant != fBlendConstant) {
             fBlendConstant = constant;
-            this->invalidateOptState();
         }
     }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name View Matrix
     ////
 
     /**
@@ skipping 78 matching lines @@
      */
     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);
-        this->invalidateOptState();
     }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name Stencil
     ////
 
     const GrStencilSettings& getStencil() const { return fStencilSettings; }
 
     /**
      * Sets the stencil settings to use for the next draw.
      * Changing the clip has the side-effect of possibly zeroing
      * out the client settable stencil bits. So multipass algorithms
      * using stencil should not change the clip between passes.
      * @param settings  the stencil settings to use.
      */
     void setStencil(const GrStencilSettings& settings) {
         if (settings != fStencilSettings) {
             fStencilSettings = settings;
-            this->invalidateOptState();
         }
     }
 
     /**
      * Shortcut to disable stencil testing and ops.
      */
     void disableStencil() {
         if (!fStencilSettings.isDisabled()) {
             fStencilSettings.setDisabled();
-            this->invalidateOptState();
         }
     }
 
     GrStencilSettings* stencil() { return &fStencilSettings; }
 
     /// @}
 
     ///////////////////////////////////////////////////////////////////////////
     /// @name State Flags
     ////
@@ skipping 39 matching lines @@
 
     bool isStateFlagEnabled(uint32_t stateBit) const { return 0 != (stateBit & fFlagBits); }
 
     bool isClipState() const { return 0 != (fFlagBits & kClip_StateBit); }
     bool isColorWriteDisabled() const { return 0 != (fFlagBits & kNoColorWrites_StateBit); }
     bool isCoverageDrawing() const { return 0 != (fFlagBits & kCoverageDrawing_StateBit); }
 
     void resetStateFlags() {
         if (0 != fFlagBits) {
             fFlagBits = 0;
-            this->invalidateOptState();
         }
     }
 
     /**
      * Enable render state settings.
      *
      * @param stateBits bitfield of StateBits specifying the states to enable
      */
     void enableState(uint32_t stateBits) {
         if (stateBits & ~fFlagBits) {
             fFlagBits |= stateBits;
-            this->invalidateOptState();
         }
     }
 
     /**
      * Disable render state settings.
      *
      * @param stateBits bitfield of StateBits specifying the states to disable
      */
     void disableState(uint32_t stateBits) {
         if (stateBits & fFlagBits) {
             fFlagBits &= ~(stateBits);
-            this->invalidateOptState();
         }
     }
 
     /**
      * Enable or disable stateBits based on a boolean.
      *
      * @param stateBits bitfield of StateBits to enable or disable
      * @param enable    if true enable stateBits, otherwise disable
      */
     void setState(uint32_t stateBits, bool enable) {
@@ skipping 134 matching lines @@
      */
     BlendOptFlags getBlendOpts(bool forceCoverage = false,
                                GrBlendCoeff* srcCoeff = NULL,
                                GrBlendCoeff* dstCoeff = NULL) const;
 
     /**
      * Determines whether src alpha is guaranteed to be one for all src pixels
      */
     bool srcAlphaWillBeOne() const;
 
-    void invalidateOptState() 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==
@@ skipping 16 matching lines @@
     ProgramGeometryProcessor            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 GrOptDrawState* fCachedOptState;
-    mutable uint32_t fCachedCapsID;
-
     friend class GrOptDrawState;
 
     typedef SkRefCnt INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrDrawState::BlendOptFlags);
 
 #endif