Create GrOptDrawState before recording draw in GrInOrderDrawBuffer

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 "GrBlend.h"
@@ skipping 54 matching lines @@
         }
     }
 
     SkASSERT(0 == memcmp(this->fFixedFunctionVertexAttribIndices,
                          that.fFixedFunctionVertexAttribIndices,
                          sizeof(this->fFixedFunctionVertexAttribIndices)));
 
     return true;
 }
 
-GrDrawState::CombinedState GrDrawState::CombineIfPossible(
-    const GrDrawState& a, const GrDrawState& b, const GrDrawTargetCaps& caps) {
-
-    if (!a.isEqual(b)) {
-        return kIncompatible_CombinedState;
-    }
-
-    // If the general draw states are equal (from check above) we know hasColorVertexAttribute()
-    // is equivalent for both a and b
-    if (a.hasColorVertexAttribute()) {
-        // If one is opaque and the other is not then the combined state is not opaque. Moreover,
-        // if the opaqueness affects the ability to get color/coverage blending correct then we
-        // don't combine the draw states.
-        bool aIsOpaque = (kVertexColorsAreOpaque_Hint & a.fHints);
-        bool bIsOpaque = (kVertexColorsAreOpaque_Hint & b.fHints);
-        if (aIsOpaque != bIsOpaque) {
-            const GrDrawState* opaque;
-            const GrDrawState* nonOpaque;
-            if (aIsOpaque) {
-                opaque = &a;
-                nonOpaque = &b;
-            } else {
-                opaque = &b;
-                nonOpaque = &a;
-            }
-            if (!opaque->hasSolidCoverage() && opaque->couldApplyCoverage(caps)) {
-                SkASSERT(!nonOpaque->hasSolidCoverage());
-                if (!nonOpaque->couldApplyCoverage(caps)) {
-                    return kIncompatible_CombinedState;
-                }
-            }
-            return aIsOpaque ? kB_CombinedState : kA_CombinedState;
-        }
-    }
-    return kAOrB_CombinedState;
-}
-
 //////////////////////////////////////////////////////////////////////////////s
 
 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);
         }
     }
 }
 
 GrDrawState& GrDrawState::operator=(const GrDrawState& that) {
-    SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
-    SkASSERT(!that.fRenderTarget.ownsPendingIO());
-    SkASSERT(!this->fRenderTarget.ownsPendingIO());
-    this->setRenderTarget(that.getRenderTarget());
+    fRenderTarget.reset(SkSafeRef(that.fRenderTarget.get()));
     fColor = that.fColor;
     fViewMatrix = that.fViewMatrix;
     fSrcBlend = that.fSrcBlend;
     fDstBlend = that.fDstBlend;
     fBlendConstant = that.fBlendConstant;
     fFlagBits = that.fFlagBits;
     fVACount = that.fVACount;
     fVAPtr = that.fVAPtr;
     fVAStride = that.fVAStride;
     fStencilSettings = that.fStencilSettings;
     fCoverage = that.fCoverage;
     fDrawFace = that.fDrawFace;
-    if (that.hasGeometryProcessor()) {
-        fGeometryProcessor.initAndRef(that.fGeometryProcessor);
-    } else {
-        fGeometryProcessor.reset(NULL);
-    }
+    fGeometryProcessor.reset(SkSafeRef(that.fGeometryProcessor.get()));
     fColorStages = that.fColorStages;
     fCoverageStages = that.fCoverageStages;
 
     fHints = that.fHints;
 
     fColorProcInfoValid = that.fColorProcInfoValid;
     fCoverageProcInfoValid = that.fCoverageProcInfoValid;
     if (fColorProcInfoValid) {
         fColorProcInfo = that.fColorProcInfo;
     }
     if (fCoverageProcInfoValid) {
         fCoverageProcInfo = that.fCoverageProcInfo;
     }
 
     memcpy(fFixedFunctionVertexAttribIndices,
             that.fFixedFunctionVertexAttribIndices,
             sizeof(fFixedFunctionVertexAttribIndices));
     return *this;
 }
 
 void GrDrawState::onReset(const SkMatrix* initialViewMatrix) {
     SkASSERT(0 == fBlockEffectRemovalCnt || 0 == this->numTotalStages());
-    SkASSERT(!fRenderTarget.ownsPendingIO());
+    fRenderTarget.reset(NULL);
 
     fGeometryProcessor.reset(NULL);
     fColorStages.reset();
     fCoverageStages.reset();
 
-    fRenderTarget.reset();
 
     this->setDefaultVertexAttribs();
 
     fColor = 0xffffffff;
     if (NULL == initialViewMatrix) {
         fViewMatrix.reset();
     } else {
         fViewMatrix = *initialViewMatrix;
     }
     fSrcBlend = kOne_GrBlendCoeff;
@@ skipping 382 matching lines @@
 
     int numCoverageStages = fDrawState->numCoverageStages();
     for (int s = 0; s < numCoverageStages; ++s, ++i) {
         fDrawState->getCoverageStage(s).saveCoordChange(&fSavedCoordChanges[i]);
         fDrawState->fCoverageStages[s].localCoordChange(coordChangeMatrix);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-void GrDrawState::convertToPendingExec() {
-    fRenderTarget.markPendingIO();
-    fRenderTarget.removeRef();
-    for (int i = 0; i < fColorStages.count(); ++i) {
-        fColorStages[i].convertToPendingExec();
-    }
-    if (fGeometryProcessor) {
-        fGeometryProcessor.convertToPendingExec();
-    }
-    for (int i = 0; i < fCoverageStages.count(); ++i) {
-        fCoverageStages[i].convertToPendingExec();
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
 GrDrawState::~GrDrawState() {
     SkASSERT(0 == fBlockEffectRemovalCnt);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrDrawState::BlendOptFlags GrDrawState::getBlendOpts(bool forceCoverage,
                                                      GrBlendCoeff* srcCoeff,
                                                      GrBlendCoeff* dstCoeff) const {
     GrBlendCoeff bogusSrcCoeff, bogusDstCoeff;
@@ skipping 148 matching lines @@
         } else {
             flags = kRGBA_GrColorComponentFlags;
             color = this->getCoverageColor();
         }
         fCoverageProcInfo.calcWithInitialValues(fCoverageStages.begin(), this->numCoverageStages(),
                                                 color, flags, true, fGeometryProcessor.get());
         fCoverageProcInfoValid = true;
     }
 }