Make GrGLProgram be available to GrGLProgramDataManager

src/gpu/gl/GrGLShaderBuilder.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 "gl/GrGLShaderBuilder.h"
 #include "gl/GrGLProgram.h"
 #include "gl/GrGLUniformHandle.h"
@@ skipping 71 matching lines @@
         out->appendf(".%s", swizzle);
     }
 }
 
 }
 
 static const char kDstCopyColorName[] = "_dstColor";
 
 ///////////////////////////////////////////////////////////////////////////////
 
-bool GrGLShaderBuilder::GenProgram(GrGpuGL* gpu,
-                                   GrGLProgramDataManager* pdman,
-                                   const GrGLProgramDesc& desc,
-                                   const GrEffectStage* inColorStages[],
-                                   const GrEffectStage* inCoverageStages[],
-                                   GenProgramOutput* output) {
-    SkAutoTDelete<GrGLShaderBuilder> builder;
-    if (desc.getHeader().fHasVertexCode ||!gpu->shouldUseFixedFunctionTexturing()) {
-        builder.reset(SkNEW_ARGS(GrGLFullShaderBuilder, (gpu, pdman, desc)));
-    } else {
-        builder.reset(SkNEW_ARGS(GrGLFragmentOnlyShaderBuilder, (gpu, pdman, desc)));
-    }
-    if (builder->genProgram(inColorStages, inCoverageStages)) {
-        *output = builder->getOutput();
-        return true;
-    }
-    return false;
-}
-
 bool GrGLShaderBuilder::genProgram(const GrEffectStage* colorStages[],
                                    const GrEffectStage* coverageStages[]) {
     const GrGLProgramDesc::KeyHeader& header = this->desc().getHeader();
 
     ///////////////////////////////////////////////////////////////////////////
     // emit code to read the dst copy texture, if necessary
     if (kNoDstRead_DstReadKey != header.fDstReadKey &&
         GrGLCaps::kNone_FBFetchType == fGpu->glCaps().fbFetchType()) {
         bool topDown = SkToBool(kTopLeftOrigin_DstReadKeyBit & header.fDstReadKey);
         const char* dstCopyTopLeftName;
         const char* dstCopyCoordScaleName;
         const char* dstCopySamplerName;
         uint32_t configMask;
         if (SkToBool(kUseAlphaConfig_DstReadKeyBit & header.fDstReadKey)) {
             configMask = kA_GrColorComponentFlag;
         } else {
             configMask = kRGBA_GrColorComponentFlags;
         }
-        fOutput.fUniformHandles.fDstCopySamplerUni =
+        fUniformHandles.fDstCopySamplerUni =
             this->addUniform(kFragment_Visibility, kSampler2D_GrSLType, "DstCopySampler",
                              &dstCopySamplerName);
-        fOutput.fUniformHandles.fDstCopyTopLeftUni =
+        fUniformHandles.fDstCopyTopLeftUni =
             this->addUniform(kFragment_Visibility, kVec2f_GrSLType, "DstCopyUpperLeft",
                              &dstCopyTopLeftName);
-        fOutput.fUniformHandles.fDstCopyScaleUni =
+        fUniformHandles.fDstCopyScaleUni =
             this->addUniform(kFragment_Visibility, kVec2f_GrSLType, "DstCopyCoordScale",
                              &dstCopyCoordScaleName);
         const char* fragPos = this->fragmentPosition();
         this->fsCodeAppend("\t// Read color from copy of the destination.\n");
         this->fsCodeAppendf("\tvec2 _dstTexCoord = (%s.xy - %s) * %s;\n",
                             fragPos, dstCopyTopLeftName, dstCopyCoordScaleName);
         if (!topDown) {
             this->fsCodeAppend("\t_dstTexCoord.y = 1.0 - _dstTexCoord.y;\n");
         }
         this->fsCodeAppendf("\tvec4 %s = ", kDstCopyColorName);
         append_texture_lookup(&fFSCode,
                               fGpu,
                               dstCopySamplerName,
                               "_dstTexCoord",
                               configMask,
                               "rgba");
         this->fsCodeAppend(";\n\n");
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // get the initial color and coverage to feed into the first effect in each effect chain
 
     GrGLSLExpr4 inputColor;
     GrGLSLExpr4 inputCoverage;
 
     if (GrGLProgramDesc::kUniform_ColorInput == header.fColorInput) {
         const char* name;
-        fOutput.fUniformHandles.fColorUni =
+        fUniformHandles.fColorUni =
             this->addUniform(GrGLShaderBuilder::kFragment_Visibility, kVec4f_GrSLType, "Color",
                              &name);
         inputColor = GrGLSLExpr4(name);
     }
 
     if (GrGLProgramDesc::kUniform_ColorInput == header.fCoverageInput) {
         const char* name;
-        fOutput.fUniformHandles.fCoverageUni =
+        fUniformHandles.fCoverageUni =
             this->addUniform(GrGLShaderBuilder::kFragment_Visibility, kVec4f_GrSLType, "Coverage",
                              &name);
         inputCoverage = GrGLSLExpr4(name);
     } else if (GrGLProgramDesc::kSolidWhite_ColorInput == header.fCoverageInput) {
         inputCoverage = GrGLSLExpr4(1);
     }
 
     if (k110_GrGLSLGeneration != fGpu->glslGeneration()) {
         fFSOutputs.push_back().set(kVec4f_GrSLType,
                                    GrGLShaderVar::kOut_TypeModifier,
                                    declared_color_output_name());
         fHasCustomColorOutput = true;
     }
 
     this->emitCodeBeforeEffects(&inputColor, &inputCoverage);
 
     ///////////////////////////////////////////////////////////////////////////
     // emit the per-effect code for both color and coverage effects
 
     GrGLProgramDesc::EffectKeyProvider colorKeyProvider(
         &this->desc(), GrGLProgramDesc::EffectKeyProvider::kColor_EffectType);
-    fOutput.fColorEffects.reset(this->createAndEmitEffects(colorStages,
-                                                           this->desc().numColorEffects(),
-                                                           colorKeyProvider,
-                                                           &inputColor));
+    fColorEffects.reset(this->createAndEmitEffects(colorStages,
+                                                   this->desc().numColorEffects(),
+                                                   colorKeyProvider,
+                                                   &inputColor));
 
     GrGLProgramDesc::EffectKeyProvider coverageKeyProvider(
         &this->desc(), GrGLProgramDesc::EffectKeyProvider::kCoverage_EffectType);
-    fOutput.fCoverageEffects.reset(this->createAndEmitEffects(coverageStages,
-                                   this->desc().numCoverageEffects(),
-                                   coverageKeyProvider,
-                                   &inputCoverage));
+    fCoverageEffects.reset(this->createAndEmitEffects(coverageStages,
+                                                      this->desc().numCoverageEffects(),
+                                                      coverageKeyProvider,
+                                                      &inputCoverage));
 
     this->emitCodeAfterEffects();
 
     ///////////////////////////////////////////////////////////////////////////
     // write the secondary color output if necessary
     if (GrGLProgramDesc::CoverageOutputUsesSecondaryOutput(header.fCoverageOutput)) {
         const char* secondaryOutputName = this->enableSecondaryOutput();
 
         // default coeff to ones for kCoverage_DualSrcOutput
         GrGLSLExpr4 coeff(1);
@@ skipping 27 matching lines @@
     if (!this->finish()) {
         return false;
     }
 
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGLShaderBuilder::GrGLShaderBuilder(GrGpuGL* gpu,
-                                     GrGLProgramDataManager* programResourceManager,
                                      const GrGLProgramDesc& desc)
-    : fDesc(desc)
+    : fHasVertexShader(false)
+    , fTexCoordSetCnt(0)
+    , fProgramID(0)
+    , fDesc(desc)
     , fGpu(gpu)
-    , fProgramDataManager(SkRef(programResourceManager))
     , fFSFeaturesAddedMask(0)
     , fFSInputs(kVarsPerBlock)
     , fFSOutputs(kMaxFSOutputs)
     , fUniforms(kVarsPerBlock)
     , fSetupFragPosition(false)
     , fTopLeftFragPosRead(kTopLeftFragPosRead_FragPosKey == desc.getHeader().fFragPosKey)
     , fHasCustomColorOutput(false)
     , fHasSecondaryOutput(false) {
 }
 
@@ skipping 77 matching lines @@
         }
     }
     static const char kFBFetchColorName[] = "gl_LastFragData[0]";
     GrGLCaps::FBFetchType fetchType = fGpu->glCaps().fbFetchType();
     if (GrGLCaps::kEXT_FBFetchType == fetchType) {
         SkAssertResult(this->enablePrivateFeature(kEXTShaderFramebufferFetch_GLSLPrivateFeature));
         return kFBFetchColorName;
     } else if (GrGLCaps::kNV_FBFetchType == fetchType) {
         SkAssertResult(this->enablePrivateFeature(kNVShaderFramebufferFetch_GLSLPrivateFeature));
         return kFBFetchColorName;
-    } else if (fOutput.fUniformHandles.fDstCopySamplerUni.isValid()) {
+    } else if (fUniformHandles.fDstCopySamplerUni.isValid()) {
         return kDstCopyColorName;
     } else {
         return "";
     }
 }
 
 void GrGLShaderBuilder::appendTextureLookup(SkString* out,
                                             const GrGLShaderBuilder::TextureSampler& sampler,
                                             const char* coordName,
                                             GrSLType varyingType) const {
@@ skipping 69 matching lines @@
 GrGLProgramDataManager::UniformHandle GrGLShaderBuilder::addUniformArray(uint32_t visibility,
                                                                          GrSLType type,
                                                                          const char* name,
                                                                          int count,
                                                                          const char** outName) {
     SkASSERT(name && strlen(name));
     SkDEBUGCODE(static const uint32_t kVisibilityMask = kVertex_Visibility | kFragment_Visibility);
     SkASSERT(0 == (~kVisibilityMask & visibility));
     SkASSERT(0 != visibility);
 
-    BuilderUniform& uni = fUniforms.push_back();
-    UniformHandle h = GrGLProgramDataManager::UniformHandle::CreateFromUniformIndex(fUniforms.count() - 1);
-    SkDEBUGCODE(UniformHandle h2 =)
-    fProgramDataManager->appendUniform(type, count);
-    // We expect the uniform manager to initially have no uniforms and that all uniforms are added
-    // by this function. Therefore, the handles should match.
-    SkASSERT(h2 == h);
+    UniformInfo& uni = fUniforms.push_back();
     uni.fVariable.setType(type);
     uni.fVariable.setTypeModifier(GrGLShaderVar::kUniform_TypeModifier);
     this->nameVariable(uni.fVariable.accessName(), 'u', name);
     uni.fVariable.setArrayCount(count);
     uni.fVisibility = visibility;
 
     // If it is visible in both the VS and FS, the precision must match.
     // We declare a default FS precision, but not a default VS. So set the var
     // to use the default FS precision.
     if ((kVertex_Visibility | kFragment_Visibility) == visibility) {
         // the fragment and vertex precisions must match
         uni.fVariable.setPrecision(kDefaultFragmentPrecision);
     }
 
     if (NULL != outName) {
         *outName = uni.fVariable.c_str();
     }
-
-    return h;
+    return GrGLProgramDataManager::UniformHandle::CreateFromUniformIndex(fUniforms.count() - 1);
 }
 
 SkString GrGLShaderBuilder::ensureFSCoords2D(const TransformedCoordsArray& coords, int index) {
     if (kVec3f_GrSLType != coords[index].type()) {
         SkASSERT(kVec2f_GrSLType == coords[index].type());
         return coords[index].getName();
     }
 
     SkString coords2D("coords2D");
     if (0 != index) {
@@ skipping 29 matching lines @@
                                       GrGLShaderVar::kUpperLeft_Origin);
             fSetupFragPosition = true;
         }
         return "gl_FragCoord";
     } else {
         static const char* kCoordName = "fragCoordYDown";
         if (!fSetupFragPosition) {
             // temporarily change the stage index because we're inserting non-stage code.
             CodeStage::AutoStageRestore csar(&fCodeStage, NULL);
 
-            SkASSERT(!fOutput.fUniformHandles.fRTHeightUni.isValid());
+            SkASSERT(!fUniformHandles.fRTHeightUni.isValid());
             const char* rtHeightName;
 
-            fOutput.fUniformHandles.fRTHeightUni =
+            fUniformHandles.fRTHeightUni =
                 this->addUniform(kFragment_Visibility, kFloat_GrSLType, "RTHeight", &rtHeightName);
 
             // Using glFragCoord.zw for the last two components tickles an Adreno driver bug that
             // causes programs to fail to link. Making this function return a vec2() didn't fix the
             // problem but using 1.0 for the last two components does.
             this->fFSCode.prependf("\tvec4 %s = vec4(gl_FragCoord.x, %s - gl_FragCoord.y, 1.0, "
                                    "1.0);\n", kCoordName, rtHeightName);
             fSetupFragPosition = true;
         }
-        SkASSERT(fOutput.fUniformHandles.fRTHeightUni.isValid());
+        SkASSERT(fUniformHandles.fRTHeightUni.isValid());
         return kCoordName;
     }
 }
 
 void GrGLShaderBuilder::fsEmitFunction(GrSLType returnType,
                                        const char* name,
                                        int argCnt,
                                        const GrGLShaderVar* args,
                                        const char* body,
                                        SkString* outName) {
@@ skipping 110 matching lines @@
     if (!fHasSecondaryOutput) {
         fFSOutputs.push_back().set(kVec4f_GrSLType,
                                    GrGLShaderVar::kOut_TypeModifier,
                                    dual_source_output_name());
         fHasSecondaryOutput = true;
     }
     return dual_source_output_name();
 }
 
 bool GrGLShaderBuilder::finish() {
-    SkASSERT(0 == fOutput.fProgramID);
-    GL_CALL_RET(fOutput.fProgramID, CreateProgram());
-    if (!fOutput.fProgramID) {
+    SkASSERT(0 == fProgramID);
+    GL_CALL_RET(fProgramID, CreateProgram());
+    if (!fProgramID) {
         return false;
     }
 
     SkTDArray<GrGLuint> shadersToDelete;
 
-    if (!this->compileAndAttachShaders(fOutput.fProgramID, &shadersToDelete)) {
-        GL_CALL(DeleteProgram(fOutput.fProgramID));
+    if (!this->compileAndAttachShaders(fProgramID, &shadersToDelete)) {
+        GL_CALL(DeleteProgram(fProgramID));
         return false;
     }
 
-    this->bindProgramLocations(fOutput.fProgramID);
-    if (fProgramDataManager->isUsingBindUniform()) {
-        fProgramDataManager->getUniformLocations(fOutput.fProgramID, fUniforms);
-    }
+    this->bindProgramLocations(fProgramID);
 
-    GL_CALL(LinkProgram(fOutput.fProgramID));
+    GL_CALL(LinkProgram(fProgramID));
 
     // Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
     bool checkLinked = !fGpu->ctxInfo().isChromium();
 #ifdef SK_DEBUG
     checkLinked = true;
 #endif
     if (checkLinked) {
         GrGLint linked = GR_GL_INIT_ZERO;
-        GL_CALL(GetProgramiv(fOutput.fProgramID, GR_GL_LINK_STATUS, &linked));
+        GL_CALL(GetProgramiv(fProgramID, GR_GL_LINK_STATUS, &linked));
         if (!linked) {
             GrGLint infoLen = GR_GL_INIT_ZERO;
-            GL_CALL(GetProgramiv(fOutput.fProgramID, GR_GL_INFO_LOG_LENGTH, &infoLen));
+            GL_CALL(GetProgramiv(fProgramID, GR_GL_INFO_LOG_LENGTH, &infoLen));
             SkAutoMalloc log(sizeof(char)*(infoLen+1));  // outside if for debugger
             if (infoLen > 0) {
                 // retrieve length even though we don't need it to workaround
                 // bug in chrome cmd buffer param validation.
                 GrGLsizei length = GR_GL_INIT_ZERO;
-                GL_CALL(GetProgramInfoLog(fOutput.fProgramID,
+                GL_CALL(GetProgramInfoLog(fProgramID,
                                           infoLen+1,
                                           &length,
                                           (char*)log.get()));
                 GrPrintf((char*)log.get());
             }
             SkDEBUGFAIL("Error linking program");
-            GL_CALL(DeleteProgram(fOutput.fProgramID));
-            fOutput.fProgramID = 0;
+            GL_CALL(DeleteProgram(fProgramID));
+            fProgramID = 0;
             return false;
         }
     }
 
-    if (!fProgramDataManager->isUsingBindUniform()) {
-        fProgramDataManager->getUniformLocations(fOutput.fProgramID, fUniforms);
-    }
+    this->resolveProgramLocations(fProgramID);
 
     for (int i = 0; i < shadersToDelete.count(); ++i) {
       GL_CALL(DeleteShader(shadersToDelete[i]));
     }
 
     return true;
 }
 
 // Compiles a GL shader and attaches it to a program. Returns the shader ID if
 // successful, or 0 if not.
@@ skipping 77 matching lines @@
     GrGLuint fragShaderId = attach_shader(fGpu->glContext(), programId, GR_GL_FRAGMENT_SHADER, fragShaderSrc);
     if (!fragShaderId) {
         return false;
     }
 
     *shaderIds->append() = fragShaderId;
 
     return true;
 }
 
-void GrGLShaderBuilder::bindProgramLocations(GrGLuint programId) const {
+void GrGLShaderBuilder::bindProgramLocations(GrGLuint programId) {
     if (fHasCustomColorOutput) {
         GL_CALL(BindFragDataLocation(programId, 0, declared_color_output_name()));
     }
     if (fHasSecondaryOutput) {
         GL_CALL(BindFragDataLocationIndexed(programId, 0, 1, dual_source_output_name()));
     }
+    // skbug.com/2056
+    bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
+    if (usingBindUniform) {
+        int count = fUniforms.count();
+        for (int i = 0; i < count; ++i) {
+            GL_CALL(BindUniformLocation(programId, i, fUniforms[i].fVariable.c_str()));
+            fUniforms[i].fLocation = i;
+        }
+    }
+}
+
+void GrGLShaderBuilder::resolveProgramLocations(GrGLuint programId) {
+    bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
+    if (!usingBindUniform) {
+        int count = fUniforms.count();
+        for (int i = 0; i < count; ++i) {
+            GrGLint location;
+            GL_CALL_RET(location,
+                        GetUniformLocation(programId, fUniforms[i].fVariable.c_str()));
+            fUniforms[i].fLocation = location;
+        }
+    }
 }
 
 const GrGLContextInfo& GrGLShaderBuilder::ctxInfo() const {
     return fGpu->ctxInfo();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrGLFullShaderBuilder::GrGLFullShaderBuilder(GrGpuGL* gpu,
-                                             GrGLProgramDataManager* programResourceManager,
                                              const GrGLProgramDesc& desc)
-    : INHERITED(gpu, programResourceManager, desc)
+    : INHERITED(gpu, desc)
     , fVSAttrs(kVarsPerBlock)
     , fVSOutputs(kVarsPerBlock)
     , fGSInputs(kVarsPerBlock)
     , fGSOutputs(kVarsPerBlock) {
 }
 
 void GrGLFullShaderBuilder::emitCodeBeforeEffects(GrGLSLExpr4* color, GrGLSLExpr4* coverage) {
     const GrGLProgramDesc::KeyHeader& header = this->desc().getHeader();
 
-    fOutput.fHasVertexShader = true;
+    fHasVertexShader = true;
 
     fPositionVar = &fVSAttrs.push_back();
     fPositionVar->set(kVec2f_GrSLType, GrGLShaderVar::kAttribute_TypeModifier, "aPosition");
     if (-1 != header.fLocalCoordAttributeIndex) {
         fLocalCoordsVar = &fVSAttrs.push_back();
         fLocalCoordsVar->set(kVec2f_GrSLType,
                              GrGLShaderVar::kAttribute_TypeModifier,
                              "aLocalCoords");
     } else {
         fLocalCoordsVar = fPositionVar;
     }
 
     const char* viewMName;
-    fOutput.fUniformHandles.fViewMatrixUni =
+    fUniformHandles.fViewMatrixUni =
         this->addUniform(GrGLShaderBuilder::kVertex_Visibility, kMat33f_GrSLType, "ViewM",
                           &viewMName);
 
     // Transform the position into Skia's device coords.
     this->vsCodeAppendf("\tvec3 pos3 = %s * vec3(%s, 1);\n",
                         viewMName, fPositionVar->c_str());
 
     // we output point size in the GS if present
     if (header.fEmitsPointSize
 #if GR_GL_EXPERIMENTAL_GS
@@ skipping 15 matching lines @@
         this->addAttribute(kVec4f_GrSLType, coverage_attribute_name());
         const char *vsName, *fsName;
         this->addVarying(kVec4f_GrSLType, "Coverage", &vsName, &fsName);
         this->vsCodeAppendf("\t%s = %s;\n", vsName, coverage_attribute_name());
         *coverage = fsName;
     }
 }
 
 void GrGLFullShaderBuilder::emitCodeAfterEffects() {
     const char* rtAdjustName;
-    fOutput.fUniformHandles.fRTAdjustmentUni =
+    fUniformHandles.fRTAdjustmentUni =
         this->addUniform(GrGLShaderBuilder::kVertex_Visibility, kVec4f_GrSLType, "rtAdjustment",
                          &rtAdjustName);
 
     // Transform from Skia's device coords to GL's normalized device coords.
     this->vsCodeAppendf(
         "\tgl_Position = vec4(dot(pos3.xz, %s.xy), dot(pos3.yz, %s.zw), 0, pos3.z);\n",
         rtAdjustName, rtAdjustName);
 }
 
 bool GrGLFullShaderBuilder::addAttribute(GrSLType type, const char* name) {
@@ skipping 131 matching lines @@
         if (!geomShaderId) {
             return false;
         }
         *shaderIds->append() = geomShaderId;
     }
 #endif
 
     return this->INHERITED::compileAndAttachShaders(programId, shaderIds);
 }
 
-void GrGLFullShaderBuilder::bindProgramLocations(GrGLuint programId) const {
+void GrGLFullShaderBuilder::bindProgramLocations(GrGLuint programId) {
     this->INHERITED::bindProgramLocations(programId);
 
     const GrGLProgramDesc::KeyHeader& header = this->desc().getHeader();
 
     // Bind the attrib locations to same values for all shaders
     SkASSERT(-1 != header.fPositionAttributeIndex);
     GL_CALL(BindAttribLocation(programId,
                                header.fPositionAttributeIndex,
                                fPositionVar->c_str()));
     if (-1 != header.fLocalCoordAttributeIndex) {
@@ skipping 14 matching lines @@
 
     const AttributePair* attribEnd = fEffectAttributes.end();
     for (const AttributePair* attrib = fEffectAttributes.begin(); attrib != attribEnd; ++attrib) {
          GL_CALL(BindAttribLocation(programId, attrib->fIndex, attrib->fName.c_str()));
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrGLFragmentOnlyShaderBuilder::GrGLFragmentOnlyShaderBuilder(GrGpuGL* gpu,
-                                                             GrGLProgramDataManager* programResourceManager,
                                                              const GrGLProgramDesc& desc)
-    : INHERITED(gpu, programResourceManager, desc) {
+    : INHERITED(gpu, desc) {
     SkASSERT(!desc.getHeader().fHasVertexCode);
     SkASSERT(gpu->glCaps().pathRenderingSupport());
     SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fColorInput);
     SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fCoverageInput);
 }
 
 int GrGLFragmentOnlyShaderBuilder::addTexCoordSets(int count) {
-    int firstFreeCoordSet = fOutput.fTexCoordSetCnt;
-    fOutput.fTexCoordSetCnt += count;
-    SkASSERT(gpu()->glCaps().maxFixedFunctionTextureCoords() >= fOutput.fTexCoordSetCnt);
+    int firstFreeCoordSet = fTexCoordSetCnt;
+    fTexCoordSetCnt += count;
+    SkASSERT(gpu()->glCaps().maxFixedFunctionTextureCoords() >= fTexCoordSetCnt);
     return firstFreeCoordSet;
 }
 
 GrGLProgramEffects* GrGLFragmentOnlyShaderBuilder::createAndEmitEffects(
         const GrEffectStage* effectStages[],
         int effectCnt,
         const GrGLProgramDesc::EffectKeyProvider& keyProvider,
         GrGLSLExpr4* inOutFSColor) {
 
     GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,
                                                                  effectCnt);
     this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,
                                           effectStages,
                                           effectCnt,
                                           keyProvider,
                                           inOutFSColor);
     return pathTexGenEffectsBuilder.finish();
 }