Opt state takes a GP instead of a GeometryStage

src/gpu/gl/GrGLProgramDesc.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLProgramDesc_DEFINED
 #define GrGLProgramDesc_DEFINED
 
@@ skipping 25 matching lines @@
     uint32_t getChecksum() const { return *this->atOffset<uint32_t, kChecksumOffset>(); }
 
     /**
      * Builds a program descriptor from a GrOptDrawState. Whether the primitive type is points, and
      * the caps of the GrGpuGL are also inputs. It also outputs the color and coverage stages
      * referenced by the generated descriptor. Coverage stages from the drawState may be treated as
      * color stages in the output.
      */
     static bool Build(const GrOptDrawState&,
                       GrGpu::DrawType,
-                      GrBlendCoeff srcCoeff,
-                      GrBlendCoeff dstCoeff,
                       GrGpuGL*,
-                      const GrDeviceCoordTexture* dstCopy,
-                      const GrGeometryStage** geometryProcessor,
-                      SkTArray<const GrFragmentStage*, true>* colorStages,
-                      SkTArray<const GrFragmentStage*, true>* coverageStages,
+                      const GrDeviceCoordTexture*,
                       GrGLProgramDesc*);
 
     bool hasGeometryProcessor() const {
         return SkToBool(this->getHeader().fHasGeometryProcessor);
     }
 
     int numColorEffects() const {
         return this->getHeader().fColorEffectCnt;
     }
 
@@ skipping 90 matching lines @@
     static bool BuildStagedProcessorKey(const typename ProcessorKeyBuilder::StagedProcessor& stage,
                                         const GrGLCaps& caps,
                                         bool requiresLocalCoordAttrib,
                                         GrGLProgramDesc* desc,
                                         int* offsetAndSizeIndex);
     void finalize();
 
     const KeyHeader& getHeader() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); }
 
     /** Used to provide effects' keys to their emitCode() function. */
-    class EffectKeyProvider {
+    class ProcKeyProvider {
     public:
-        enum EffectType {
-            kGeometryProcessor_EffectType,
-            kColor_EffectType,
-            kCoverage_EffectType,
+        enum ProcessorType {
+            kGeometry_ProcessorType,
+            kFragment_ProcessorType,
         };
 
-        EffectKeyProvider(const GrGLProgramDesc* desc, EffectType type) : fDesc(desc) {
+        ProcKeyProvider(const GrGLProgramDesc* desc, ProcessorType type)
+            : fDesc(desc), fBaseIndex(0) {
             switch (type) {
-                case kGeometryProcessor_EffectType:
+                case kGeometry_ProcessorType:
                     // there can be only one
                     fBaseIndex = 0;
                     break;
-                case kColor_EffectType:
+                case kFragment_ProcessorType:
                     fBaseIndex = desc->hasGeometryProcessor() ? 1 : 0;
                     break;
-                case kCoverage_EffectType:
-                    fBaseIndex = desc->numColorEffects() + (desc->hasGeometryProcessor() ? 1 : 0);
-                    break;
             }
         }
 
         GrProcessorKey get(int index) const {
             const uint16_t* offsetsAndLengths = reinterpret_cast<const uint16_t*>(
                 fDesc->fKey.begin() + kEffectKeyOffsetsAndLengthOffset);
             // We store two uint16_ts per effect, one for the offset to the effect's key and one for
             // its length. Here we just need the offset.
             uint16_t offset = offsetsAndLengths[2 * (fBaseIndex + index) + 0];
             uint16_t length = offsetsAndLengths[2 * (fBaseIndex + index) + 1];
@@ skipping 21 matching lines @@
     // visible to GrGLProcessors. Then make public accessors as necessary and remove friends.
     friend class GrGLProgram;
     friend class GrGLProgramBuilder;
     friend class GrGLLegacyNvprProgramBuilder;
     friend class GrGLVertexBuilder;
     friend class GrGLFragmentShaderBuilder;
     friend class GrGLGeometryBuilder;
 };
 
 #endif