Remove cached OptDrawState from GrDrawState.

src/gpu/GrDrawState.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawState.h"
 
 #include "GrOptDrawState.h"
@@ skipping 91 matching lines @@
                 }
             }
             return aIsOpaque ? kB_CombinedState : kA_CombinedState;
         }
     }
     return kAOrB_CombinedState;
 }
 
 //////////////////////////////////////////////////////////////////////////////s
 
-GrDrawState::GrDrawState(const GrDrawState& state, const SkMatrix& preConcatMatrix)
-    : fCachedOptState(NULL) {
+GrDrawState::GrDrawState(const GrDrawState& state, const SkMatrix& preConcatMatrix) {
     SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
     *this = state;
     if (!preConcatMatrix.isIdentity()) {
         for (int i = 0; i < this->numColorStages(); ++i) {
             fColorStages[i].localCoordChange(preConcatMatrix);
         }
         for (int i = 0; i < this->numCoverageStages(); ++i) {
             fCoverageStages[i].localCoordChange(preConcatMatrix);
         }
-        this->invalidateOptState();
     }
 }
 
 GrDrawState& GrDrawState::operator=(const GrDrawState& that) {
     SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
     SkASSERT(!that.fRenderTarget.ownsPendingIO());
     SkASSERT(!this->fRenderTarget.ownsPendingIO());
     this->setRenderTarget(that.getRenderTarget());
     fColor = that.fColor;
     fViewMatrix = that.fViewMatrix;
@@ skipping 10 matching lines @@
     if (that.hasGeometryProcessor()) {
         fGeometryProcessor.initAndRef(that.fGeometryProcessor);
     } else {
         fGeometryProcessor.reset(NULL);
     }
     fColorStages = that.fColorStages;
     fCoverageStages = that.fCoverageStages;
 
     fHints = that.fHints;
 
-    SkRefCnt_SafeAssign(fCachedOptState, that.fCachedOptState);
-
     memcpy(fFixedFunctionVertexAttribIndices,
             that.fFixedFunctionVertexAttribIndices,
             sizeof(fFixedFunctionVertexAttribIndices));
     return *this;
 }
 
 void GrDrawState::onReset(const SkMatrix* initialViewMatrix) {
     SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
     SkASSERT(!fRenderTarget.ownsPendingIO());
 
@@ skipping 13 matching lines @@
     }
     fSrcBlend = kOne_GrBlendCoeff;
     fDstBlend = kZero_GrBlendCoeff;
     fBlendConstant = 0x0;
     fFlagBits = 0x0;
     fStencilSettings.setDisabled();
     fCoverage = 0xff;
     fDrawFace = kBoth_DrawFace;
 
     fHints = 0;
-
-    this->invalidateOptState();
 }
 
 bool GrDrawState::setIdentityViewMatrix()  {
     if (this->numTotalStages()) {
         SkMatrix invVM;
         if (!fViewMatrix.invert(&invVM)) {
             // sad trombone sound
             return false;
         }
         for (int s = 0; s < this->numColorStages(); ++s) {
             fColorStages[s].localCoordChange(invVM);
         }
         for (int s = 0; s < this->numCoverageStages(); ++s) {
             fCoverageStages[s].localCoordChange(invVM);
         }
     }
-    this->invalidateOptState();
     fViewMatrix.reset();
     return true;
 }
 
 void GrDrawState::setFromPaint(const GrPaint& paint, const SkMatrix& vm, GrRenderTarget* rt) {
     SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
 
     fGeometryProcessor.reset(NULL);
     fColorStages.reset();
     fCoverageStages.reset();
@@ skipping 19 matching lines @@
 
     // Enable the clip bit
     this->enableState(GrDrawState::kClip_StateBit);
 
     this->setColor(paint.getColor());
     this->setState(GrDrawState::kDither_StateBit, paint.isDither());
     this->setState(GrDrawState::kHWAntialias_StateBit, paint.isAntiAlias());
 
     this->setBlendFunc(paint.getSrcBlendCoeff(), paint.getDstBlendCoeff());
     this->setCoverage(paint.getCoverage());
-    this->invalidateOptState();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawState::validateVertexAttribs() const {
     // check consistency of effects and attributes
     GrSLType slTypes[kMaxVertexAttribCnt];
     for (int i = 0; i < kMaxVertexAttribCnt; ++i) {
         slTypes[i] = static_cast<GrSLType>(-1);
     }
@@ skipping 77 matching lines @@
             fFixedFunctionVertexAttribIndices[attribs[i].fBinding] = i;
         }
 #ifdef SK_DEBUG
         size_t dwordCount = GrVertexAttribTypeSize(attribs[i].fType) >> 2;
         uint32_t mask = (1 << dwordCount)-1;
         size_t offsetShift = attribs[i].fOffset >> 2;
         SkASSERT(!(overlapCheck & (mask << offsetShift)));
         overlapCheck |= (mask << offsetShift);
 #endif
     }
-    this->invalidateOptState();
     // Positions must be specified.
     SkASSERT(-1 != fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding]);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrDrawState::setDefaultVertexAttribs() {
     static const GrVertexAttrib kPositionAttrib =
         {kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding};
 
     fVAPtr = &kPositionAttrib;
     fVACount = 1;
     fVAStride = GrVertexAttribTypeSize(kVec2f_GrVertexAttribType);
 
     // set all the fixed function indices to -1 except position.
     memset(fFixedFunctionVertexAttribIndices,
            0xff,
            sizeof(fFixedFunctionVertexAttribIndices));
     fFixedFunctionVertexAttribIndices[kPosition_GrVertexAttribBinding] = 0;
-    this->invalidateOptState();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrDrawState::couldApplyCoverage(const GrDrawTargetCaps& caps) const {
     if (caps.dualSourceBlendingSupport()) {
         return true;
     }
     // we can correctly apply coverage if a) we have dual source blending
     // or b) one of our blend optimizations applies
@@ skipping 74 matching lines @@
             fOriginalGPID = SK_InvalidUniqueID;
         }
 
         int m = fDrawState->numColorStages() - fColorEffectCnt;
         SkASSERT(m >= 0);
         fDrawState->fColorStages.pop_back_n(m);
 
         int n = fDrawState->numCoverageStages() - fCoverageEffectCnt;
         SkASSERT(n >= 0);
         fDrawState->fCoverageStages.pop_back_n(n);
-        if (m + n > 0) {
-            fDrawState->invalidateOptState();
-        }
         SkDEBUGCODE(--fDrawState->fBlockEffectRemovalCnt;)
     }
     fDrawState = ds;
     if (NULL != ds) {
         SkASSERT(SK_InvalidUniqueID == fOriginalGPID);
         if (NULL != ds->getGeometryProcessor()) {
             fOriginalGPID = ds->getGeometryProcessor()->getUniqueID();
         }
         fColorEffectCnt = ds->numColorStages();
         fCoverageEffectCnt = ds->numCoverageStages();
@@ skipping 33 matching lines @@
         int numCoverageStages = fSavedCoordChanges.count() - fNumColorStages;
         SkASSERT(fDrawState->numCoverageStages() >= numCoverageStages);
 
         int i = 0;
         for (int s = 0; s < fNumColorStages; ++s, ++i) {
             fDrawState->fColorStages[s].restoreCoordChange(fSavedCoordChanges[i]);
         }
         for (int s = 0; s < numCoverageStages; ++s, ++i) {
             fDrawState->fCoverageStages[s].restoreCoordChange(fSavedCoordChanges[i]);
         }
-        fDrawState->invalidateOptState();
         fDrawState = NULL;
     }
 }
 
 void GrDrawState::AutoViewMatrixRestore::set(GrDrawState* drawState,
                                              const SkMatrix& preconcatMatrix) {
     this->restore();
 
     SkASSERT(NULL == fDrawState);
     if (NULL == drawState || preconcatMatrix.isIdentity()) {
         return;
     }
     fDrawState = drawState;
 
     fViewMatrix = drawState->getViewMatrix();
     drawState->fViewMatrix.preConcat(preconcatMatrix);
 
     this->doEffectCoordChanges(preconcatMatrix);
     SkDEBUGCODE(++fDrawState->fBlockEffectRemovalCnt;)
-    drawState->invalidateOptState();
 }
 
 bool GrDrawState::AutoViewMatrixRestore::setIdentity(GrDrawState* drawState) {
     this->restore();
 
     if (NULL == drawState) {
         return false;
     }
 
     if (drawState->getViewMatrix().isIdentity()) {
         return true;
     }
 
-    drawState->invalidateOptState();
     fViewMatrix = drawState->getViewMatrix();
     if (0 == drawState->numTotalStages()) {
         drawState->fViewMatrix.reset();
         fDrawState = drawState;
         fNumColorStages = 0;
         fSavedCoordChanges.reset(0);
         SkDEBUGCODE(++fDrawState->fBlockEffectRemovalCnt;)
         return true;
     } else {
         SkMatrix inv;
@@ skipping 36 matching lines @@
     if (fGeometryProcessor) {
         fGeometryProcessor.convertToPendingExec();
     }
     for (int i = 0; i < fCoverageStages.count(); ++i) {
         fCoverageStages[i].convertToPendingExec();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void GrDrawState::invalidateOptState() const {
-    SkSafeSetNull(fCachedOptState);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 GrDrawState::~GrDrawState() {
-    SkSafeUnref(fCachedOptState);
     SkASSERT(0 == fBlockEffectRemovalCnt);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrDrawState::BlendOptFlags GrDrawState::getBlendOpts(bool forceCoverage,
                                                      GrBlendCoeff* srcCoeff,
                                                      GrBlendCoeff* dstCoeff) const {
     GrBlendCoeff bogusSrcCoeff, bogusDstCoeff;
     if (NULL == srcCoeff) {
@@ skipping 133 matching lines @@
         }
 
         // Since the shader will multiply coverage and color, the only way the final A==1 is if
         // coverage and color both have A==1.
         return (inoutColor.isOpaque() && inoutCoverage.isOpaque());
     }
 
     return inoutColor.isOpaque();
 }