Opt state takes a GP instead of a GeometryStage

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"
@@ skipping 36 matching lines @@
     this->computeEffectiveCoverageStages(drawState, &firstCoverageStageIdx);
     this->adjustFromBlendOpts(drawState, &firstColorStageIdx, &firstCoverageStageIdx,
                               &fixedFunctionVAToRemove);
     // Should not be setting any more FFVA to be removed at this point
     this->removeFixedFunctionVertexAttribs(fixedFunctionVAToRemove);
     this->getStageStats(drawState, firstColorStageIdx, firstCoverageStageIdx);
     this->setOutputStateInfo(drawState, caps, firstCoverageStageIdx, &separateCoverageFromColor);
 
     // Copy GeometryProcesssor from DS or ODS
     if (drawState.hasGeometryProcessor()) {
-        fGeometryProcessor.reset(SkNEW_ARGS(GrGeometryStage, (*drawState.getGeometryProcessor())));
+        fGeometryProcessor.initAndRef(drawState.fGeometryProcessor);
     } else {
         fGeometryProcessor.reset(NULL);
     }
 
     // Copy Color Stages from DS to ODS
     if (firstColorStageIdx < drawState.numColorStages()) {
         fColorStages.reset(&drawState.getColorStage(firstColorStageIdx),
                            drawState.numColorStages() - firstColorStageIdx);
     } else {
         fColorStages.reset();
@@ skipping 233 matching lines @@
 
     for (int s = firstColorStageIdx; s < ds.numColorStages(); ++s) {
         const GrFragmentStage& stage = ds.getColorStage(s);
         get_stage_stats(stage, &fReadsDst, &fReadsFragPosition);
     }
     for (int s = firstCoverageStageIdx; s < ds.numCoverageStages(); ++s) {
         const GrFragmentStage& stage = ds.getCoverageStage(s);
         get_stage_stats(stage, &fReadsDst, &fReadsFragPosition);
     }
     if (ds.hasGeometryProcessor()) {
-        const GrGeometryStage& stage = *ds.getGeometryProcessor();
-        fReadsFragPosition = fReadsFragPosition || stage.getProcessor()->willReadFragmentPosition();
+        const GrGeometryProcessor& gp = *ds.getGeometryProcessor();
+        fReadsFragPosition = fReadsFragPosition || gp.willReadFragmentPosition();
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 bool GrOptDrawState::operator== (const GrOptDrawState& that) const {
     return this->isEqual(that);
 }
 
 bool GrOptDrawState::isEqual(const GrOptDrawState& that) const {
@@ skipping 27 matching lines @@
 
     bool usingVertexCoverage = this->hasCoverageVertexAttribute();
     if (!usingVertexCoverage && this->fCoverage != that.fCoverage) {
         return false;
     }
 
     bool explicitLocalCoords = this->hasLocalCoordAttribute();
     if (this->hasGeometryProcessor()) {
         if (!that.hasGeometryProcessor()) {
             return false;
-        } else if (!GrProcessorStage::AreCompatible(*this->getGeometryProcessor(),
-                                                    *that.getGeometryProcessor(),
-                                                    explicitLocalCoords)) {
+        } else if (!this->getGeometryProcessor()->isEqual(*that.getGeometryProcessor())) {
             return false;
         }
     } else if (that.hasGeometryProcessor()) {
         return false;
     }
 
     for (int i = 0; i < this->numColorStages(); i++) {
-        if (!GrProcessorStage::AreCompatible(this->getColorStage(i), that.getColorStage(i),
+        if (!GrFragmentStage::AreCompatible(this->getColorStage(i), that.getColorStage(i),
                                              explicitLocalCoords)) {
             return false;
         }
     }
     for (int i = 0; i < this->numCoverageStages(); i++) {
-        if (!GrProcessorStage::AreCompatible(this->getCoverageStage(i), that.getCoverageStage(i),
+        if (!GrFragmentStage::AreCompatible(this->getCoverageStage(i), that.getCoverageStage(i),
                                              explicitLocalCoords)) {
             return false;
         }
     }
 
     SkASSERT(0 == memcmp(this->fFixedFunctionVertexAttribIndices,
                          that.fFixedFunctionVertexAttribIndices,
                          sizeof(this->fFixedFunctionVertexAttribIndices)));
 
     return true;
 }