OptState owns program descriptor

src/gpu/GrOptDrawState.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrOptDrawState.h"
 
 #include "GrDrawState.h"
 #include "GrDrawTargetCaps.h"
+#include "gl/GrGpuGL.h"
 
 GrOptDrawState::GrOptDrawState(const GrDrawState& drawState,
                                BlendOptFlags blendOptFlags,
                                GrBlendCoeff optSrcCoeff,
                                GrBlendCoeff optDstCoeff,
-                               const GrDrawTargetCaps& caps) {
+                               GrGpu* gpu,
+                               const GrDeviceCoordTexture* dstCopy,
+                               GrGpu::DrawType drawType) {
     fRenderTarget.set(SkSafeRef(drawState.getRenderTarget()), kWrite_GrIOType);
     fColor = drawState.getColor();
     fCoverage = drawState.getCoverage();
     fViewMatrix = drawState.getViewMatrix();
     fBlendConstant = drawState.getBlendConstant();
     fFlagBits = drawState.getFlagBits();
     fVAPtr = drawState.getVertexAttribs();
     fVACount = drawState.getVertexAttribCount();
     fVAStride = drawState.getVertexStride();
     fStencilSettings = drawState.getStencil();
@@ skipping 17 matching lines @@
 
     this->computeEffectiveColorStages(drawState, &firstColorStageIdx, &fixedFunctionVAToRemove);
     this->computeEffectiveCoverageStages(drawState, &firstCoverageStageIdx);
     this->adjustFromBlendOpts(drawState, &firstColorStageIdx, &firstCoverageStageIdx,
                               &fixedFunctionVAToRemove);
     // Should not be setting any more FFVA to be removed at this point
     if (0 != fixedFunctionVAToRemove) {
         this->removeFixedFunctionVertexAttribs(fixedFunctionVAToRemove);
     }
     this->getStageStats(drawState, firstColorStageIdx, firstCoverageStageIdx);
-    this->setOutputStateInfo(drawState, caps, firstCoverageStageIdx, &separateCoverageFromColor);
+    this->setOutputStateInfo(drawState, *gpu->caps(), firstCoverageStageIdx,
+                             &separateCoverageFromColor);
 
     // Copy GeometryProcesssor from DS or ODS
     if (drawState.hasGeometryProcessor()) {
         fGeometryProcessor.initAndRef(drawState.fGeometryProcessor);
     } else {
         fGeometryProcessor.reset(NULL);
     }
 
     // Copy Color Stages from DS to ODS
     if (firstColorStageIdx < drawState.numColorStages()) {
         fFragmentStages.reset(&drawState.getColorStage(firstColorStageIdx),
                               drawState.numColorStages() - firstColorStageIdx);
     } else {
         fFragmentStages.reset();
     }
 
     fNumColorStages = fFragmentStages.count();
 
     // Copy Coverage Stages from DS to ODS
     if (firstCoverageStageIdx < drawState.numCoverageStages()) {
         fFragmentStages.push_back_n(drawState.numCoverageStages() - firstCoverageStageIdx,
                                     &drawState.getCoverageStage(firstCoverageStageIdx));
         if (!separateCoverageFromColor) {
             fNumColorStages = fFragmentStages.count();
         }
     }
+
+    // now create a key
+    gpu->buildKey(this, drawType, dstCopy, &fDesc);
 };
 
-GrOptDrawState* GrOptDrawState::Create(const GrDrawState& drawState, const GrDrawTargetCaps& caps,
+GrOptDrawState* GrOptDrawState::Create(const GrDrawState& drawState,
+                                       GrGpu* gpu,
+                                       const GrDeviceCoordTexture* dstCopy,
                                        GrGpu::DrawType drawType) {
+    const GrDrawTargetCaps& caps = *gpu->caps();
     if (NULL == drawState.fCachedOptState || caps.getUniqueID() != drawState.fCachedCapsID) {
         GrBlendCoeff srcCoeff;
         GrBlendCoeff dstCoeff;
         BlendOptFlags blendFlags = (BlendOptFlags) drawState.getBlendOpts(false,
                                                                           &srcCoeff,
                                                                           &dstCoeff);
 
         // If our blend coeffs are set to 0,1 we know we will not end up drawing unless we are
         // stenciling. When path rendering the stencil settings are not always set on the draw state
         // so we must check the draw type. In cases where we will skip drawing we simply return a
         // null GrOptDrawState.
         if (kZero_GrBlendCoeff == srcCoeff && kOne_GrBlendCoeff == dstCoeff &&
             !drawState.getStencil().doesWrite() && GrGpu::kStencilPath_DrawType != drawType) {
             return NULL;
         }
 
         drawState.fCachedOptState = SkNEW_ARGS(GrOptDrawState, (drawState, blendFlags, srcCoeff,
-                                                                dstCoeff, caps));
+                                                                dstCoeff, gpu, dstCopy, drawType));
         drawState.fCachedCapsID = caps.getUniqueID();
     } else {
 #ifdef SK_DEBUG
         GrBlendCoeff srcCoeff;
         GrBlendCoeff dstCoeff;
         BlendOptFlags blendFlags = (BlendOptFlags) drawState.getBlendOpts(false,
                                                                           &srcCoeff,
                                                                           &dstCoeff);
-        SkASSERT(GrOptDrawState(drawState, blendFlags, srcCoeff, dstCoeff, caps) ==
-                 *drawState.fCachedOptState);
+        SkASSERT(GrOptDrawState(drawState, blendFlags, srcCoeff, dstCoeff, gpu, dstCopy,
+                                drawType) == *drawState.fCachedOptState);
 #endif
     }
     drawState.fCachedOptState->ref();
     return drawState.fCachedOptState;
 }
 
 void GrOptDrawState::setOutputStateInfo(const GrDrawState& ds,
                                         const GrDrawTargetCaps& caps,
                                         int firstCoverageStageIdx,
                                         bool* separateCoverageFromColor) {
     // Set this default and then possibly change our mind if there is coverage.
-    fPrimaryOutputType = kModulate_PrimaryOutputType;
-    fSecondaryOutputType = kNone_SecondaryOutputType;
+    fPrimaryOutputType = GrProgramDesc::kModulate_PrimaryOutputType;
+    fSecondaryOutputType = GrProgramDesc::kNone_SecondaryOutputType;
 
     // If we do have coverage determine whether it matters.
     *separateCoverageFromColor = this->hasGeometryProcessor();
     if (!this->isCoverageDrawing() &&
         (ds.numCoverageStages() - firstCoverageStageIdx > 0 ||
          ds.hasGeometryProcessor() ||
          this->hasCoverageVertexAttribute())) {
 
         if (caps.dualSourceBlendingSupport()) {
             if (kZero_GrBlendCoeff == fDstBlend) {
                 // write the coverage value to second color
-                fSecondaryOutputType =  kCoverage_SecondaryOutputType;
+                fSecondaryOutputType = GrProgramDesc:: kCoverage_SecondaryOutputType;
                 *separateCoverageFromColor = true;
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             } else if (kSA_GrBlendCoeff == fDstBlend) {
                 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
-                fSecondaryOutputType = kCoverageISA_SecondaryOutputType;
+                fSecondaryOutputType = GrProgramDesc::kCoverageISA_SecondaryOutputType;
                 *separateCoverageFromColor = true;
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             } else if (kSC_GrBlendCoeff == fDstBlend) {
                 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially covered.
-                fSecondaryOutputType = kCoverageISC_SecondaryOutputType;
+                fSecondaryOutputType = GrProgramDesc::kCoverageISC_SecondaryOutputType;
                 *separateCoverageFromColor = true;
                 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff;
             }
         } else if (fReadsDst &&
                    kOne_GrBlendCoeff == fSrcBlend &&
                    kZero_GrBlendCoeff == fDstBlend) {
-            fPrimaryOutputType = kCombineWithDst_PrimaryOutputType;
+            fPrimaryOutputType = GrProgramDesc::kCombineWithDst_PrimaryOutputType;
             *separateCoverageFromColor = true;
         }
     }
 }
 
 void GrOptDrawState::adjustFromBlendOpts(const GrDrawState& ds,
                                          int* firstColorStageIdx,
                                          int* firstCoverageStageIdx,
                                          uint8_t* fixedFunctionVAToRemove) {
     switch (fBlendOptFlags) {
@@ skipping 209 matching lines @@
         }
     }
 
     SkASSERT(0 == memcmp(this->fFixedFunctionVertexAttribIndices,
                          that.fFixedFunctionVertexAttribIndices,
                          sizeof(this->fFixedFunctionVertexAttribIndices)));
 
     return true;
 }