Move program descriptor and primitive processor off of optstate

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 "GrGpu.h"
 #include "GrProcOptInfo.h"
 #include "GrXferProcessor.h"
 
 GrOptDrawState::GrOptDrawState(const GrDrawState& drawState,
                                const GrPrimitiveProcessor* primProc,
                                const GrDrawTargetCaps& caps,
                                const GrScissorState& scissorState,
                                const GrDeviceCoordTexture* dstCopy,
-                               GrGpu::DrawType drawType)
-    : fFinalized(false) {
+                               GrGpu::DrawType drawType) {
     fDrawType = drawType;
 
-    fPrimitiveProcessor.reset(primProc);
-
-
-    const GrProcOptInfo& colorPOI = drawState.colorProcInfo(fPrimitiveProcessor);
-    const GrProcOptInfo& coveragePOI = drawState.coverageProcInfo(fPrimitiveProcessor);
+    const GrProcOptInfo& colorPOI = drawState.colorProcInfo(primProc);
+    const GrProcOptInfo& coveragePOI = drawState.coverageProcInfo(primProc);
 
     // Create XferProcessor from DS's XPFactory
     SkAutoTUnref<GrXferProcessor> xferProcessor(
         drawState.getXPFactory()->createXferProcessor(colorPOI, coveragePOI));
 
     GrColor overrideColor = GrColor_ILLEGAL;
     if (colorPOI.firstEffectiveStageIndex() != 0) {
         overrideColor = colorPOI.inputColorToEffectiveStage();
     }
 
@@ skipping 65 matching lines @@
     fNumColorStages = fFragmentStages.count();
     for (int i = firstCoverageStageIdx; i < drawState.numCoverageStages(); ++i) {
         SkNEW_APPEND_TO_TARRAY(&fFragmentStages,
                                GrPendingFragmentStage,
                                (drawState.fCoverageStages[i]));
         usesLocalCoords = usesLocalCoords ||
                           drawState.fCoverageStages[i].processor()->usesLocalCoords();
     }
 
     // let the GP init the batch tracker
-    GrGeometryProcessor::InitBT init;
-    init.fColorIgnored = SkToBool(optFlags & GrXferProcessor::kIgnoreColor_OptFlag);
-    init.fOverrideColor = init.fColorIgnored ? GrColor_ILLEGAL : overrideColor;
-    init.fCoverageIgnored = SkToBool(optFlags & GrXferProcessor::kIgnoreCoverage_OptFlag);
-    init.fUsesLocalCoords = usesLocalCoords;
-    fPrimitiveProcessor->initBatchTracker(&fBatchTracker, init);
+    fInitBT.fColorIgnored = SkToBool(optFlags & GrXferProcessor::kIgnoreColor_OptFlag);
+    fInitBT.fOverrideColor = fInitBT.fColorIgnored ? GrColor_ILLEGAL : overrideColor;
+    fInitBT.fCoverageIgnored = SkToBool(optFlags & GrXferProcessor::kIgnoreCoverage_OptFlag);
+    fInitBT.fUsesLocalCoords = usesLocalCoords;
 }
 
 void GrOptDrawState::adjustProgramFromOptimizations(const GrDrawState& ds,
                                                     GrXferProcessor::OptFlags flags,
                                                     const GrProcOptInfo& colorPOI,
                                                     const GrProcOptInfo& coveragePOI,
                                                     int* firstColorStageIdx,
                                                     int* firstCoverageStageIdx) {
     fDescInfo.fReadsFragPosition = false;
 
     if ((flags & GrXferProcessor::kIgnoreColor_OptFlag) ||
         (flags & GrXferProcessor::kOverrideColor_OptFlag)) {
         *firstColorStageIdx = ds.numColorStages();
     } else {
         fDescInfo.fReadsFragPosition = colorPOI.readsFragPosition();
     }
 
     if (flags & GrXferProcessor::kIgnoreCoverage_OptFlag) {
         *firstCoverageStageIdx = ds.numCoverageStages();
     } else {
         if (coveragePOI.readsFragPosition()) {
             fDescInfo.fReadsFragPosition = true;
         }
     }
 }
 
-void GrOptDrawState::finalize(GrGpu* gpu) {
-    gpu->buildProgramDesc(*this, fDescInfo, fDrawType, &fDesc);
-    fFinalized = true;
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
-bool GrOptDrawState::combineIfPossible(const GrOptDrawState& that) {
-    if (fDescInfo != that.fDescInfo) {
-        return false;
-    }
-
+bool GrOptDrawState::isEqual(const GrOptDrawState& that) const {
     if (this->getRenderTarget() != that.getRenderTarget() ||
         this->fFragmentStages.count() != that.fFragmentStages.count() ||
         this->fNumColorStages != that.fNumColorStages ||
         this->fScissorState != that.fScissorState ||
         this->fDrawType != that.fDrawType ||
         this->fFlags != that.fFlags ||
         this->fStencilSettings != that.fStencilSettings ||
         this->fDrawFace != that.fDrawFace ||
         this->fDstCopy.texture() != that.fDstCopy.texture()) {
         return false;
     }
 
-    if (!this->getPrimitiveProcessor()->canMakeEqual(fBatchTracker,
-                                                     *that.getPrimitiveProcessor(),
-                                                     that.getBatchTracker())) {
-        return false;
-    }
-
     if (!this->getXferProcessor()->isEqual(*that.getXferProcessor())) {
         return false;
     }
 
     // The program desc comparison should have already assured that the stage counts match.
     SkASSERT(this->numFragmentStages() == that.numFragmentStages());
     for (int i = 0; i < this->numFragmentStages(); i++) {
 
         if (this->getFragmentStage(i) != that.getFragmentStage(i)) {
             return false;
         }
     }
-
-    // Now update the GrPrimitiveProcessor's batch tracker
-    fPrimitiveProcessor->makeEqual(&fBatchTracker, that.getBatchTracker());
     return true;
 }