Incremental refactoring of GrGLProgram and GrGLShaderBuilder

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 72 matching lines @@
     }
 }
 
 }
 
 static const char kDstCopyColorName[] = "_dstColor";
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool GrGLShaderBuilder::GenProgram(GrGpuGL* gpu,
-                                   GrGLUniformManager& uman,
+                                   GrGLUniformManager* uman,
                                    const GrGLProgramDesc& desc,
                                    const GrEffectStage* inColorStages[],
                                    const GrEffectStage* inCoverageStages[],
                                    GenProgramOutput* output) {
     if (desc.getHeader().fHasVertexCode ||!gpu->shouldUseFixedFunctionTexturing()) {
         GrGLFullShaderBuilder fullBuilder(gpu, uman, desc);
         if (fullBuilder.genProgram(inColorStages, inCoverageStages, output)) {
             output->fHasVS = true;
             output->fUniformHandles.fViewMatrixUni = fullBuilder.getViewMatrixUniform();
             output->fUniformHandles.fRTAdjustmentUni = fullBuilder.getRTAdjustmentVecUniform();
@@ skipping 63 matching lines @@
         GrGLSLExpr4 dstContribution = dstCoeff * GrGLSLExpr4(this->dstColor());
 
         fragColor = fragColor + dstContribution;
     }
     this->fsCodeAppendf("\t%s = %s;\n", this->getColorOutputName(), fragColor.c_str());
 
     if (!this->finish(&output->fProgramID)) {
         return false;
     }
 
-    output->fUniformHandles.fRTHeightUni = this->getRTHeightUniform();
-    output->fUniformHandles.fDstCopyTopLeftUni = this->getDstCopyTopLeftUniform();
-    output->fUniformHandles.fDstCopyScaleUni = this->getDstCopyScaleUniform();
-    output->fUniformHandles.fColorUni = this->getColorUniform();
-    output->fUniformHandles.fCoverageUni = this->getCoverageUniform();
-    output->fUniformHandles.fDstCopySamplerUni = this->getDstCopySamplerUniform();
+    output->fUniformHandles.fRTHeightUni = fRTHeightUniform;
+    output->fUniformHandles.fColorUni = fColorUniform;
+    output->fUniformHandles.fCoverageUni = fCoverageUniform;
+    output->fUniformHandles.fDstCopyTopLeftUni = fDstCopyTopLeftUniform;
+    output->fUniformHandles.fDstCopyScaleUni = fDstCopyScaleUniform;
+    output->fUniformHandles.fDstCopySamplerUni = fDstCopySamplerUniform;
 
     return true;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 GrGLShaderBuilder::GrGLShaderBuilder(GrGpuGL* gpu,
-                                     GrGLUniformManager& uniformManager,
+                                     GrGLUniformManager* uniformManager,
                                      const GrGLProgramDesc& desc)
     : fDesc(desc)
     , fGpu(gpu)
-    , fUniformManager(uniformManager)
+    , fUniformManager(SkRef(uniformManager))
     , fFSFeaturesAddedMask(0)
     , fFSInputs(kVarsPerBlock)
     , fFSOutputs(kMaxFSOutputs)
     , fUniforms(kVarsPerBlock)
     , fSetupFragPosition(false)
     , fHasCustomColorOutput(false)
     , fHasSecondaryOutput(false)
     , fTopLeftFragPosRead(kTopLeftFragPosRead_FragPosKey == desc.getHeader().fFragPosKey) {
 
     const GrGLProgramDesc::KeyHeader& header = desc.getHeader();
@@ skipping 241 matching lines @@
                                                                      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 = GrGLUniformManager::UniformHandle::CreateFromUniformIndex(fUniforms.count() - 1);
     SkDEBUGCODE(UniformHandle h2 =)
-    fUniformManager.appendUniform(type, count);
+    fUniformManager->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);
     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.
@@ skipping 208 matching lines @@
     }
 
     SkTDArray<GrGLuint> shadersToDelete;
 
     if (!this->compileAndAttachShaders(programId, &shadersToDelete)) {
         GL_CALL(DeleteProgram(programId));
         return false;
     }
 
     this->bindProgramLocations(programId);
-    if (fUniformManager.isUsingBindUniform()) {
-      fUniformManager.getUniformLocations(programId, fUniforms);
+    if (fUniformManager->isUsingBindUniform()) {
+      fUniformManager->getUniformLocations(programId, fUniforms);
     }
 
     GL_CALL(LinkProgram(programId));
 
     // Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
     bool checkLinked = !fGpu->ctxInfo().isChromium();
 #ifdef SK_DEBUG
     checkLinked = true;
 #endif
     if (checkLinked) {
@@ skipping 12 matching lines @@
                                           &length,
                                           (char*)log.get()));
                 GrPrintf((char*)log.get());
             }
             SkDEBUGFAIL("Error linking program");
             GL_CALL(DeleteProgram(programId));
             return false;
         }
     }
 
-    if (!fUniformManager.isUsingBindUniform()) {
-      fUniformManager.getUniformLocations(programId, fUniforms);
+    if (!fUniformManager->isUsingBindUniform()) {
+      fUniformManager->getUniformLocations(programId, fUniforms);
     }
 
     for (int i = 0; i < shadersToDelete.count(); ++i) {
       GL_CALL(DeleteShader(shadersToDelete[i]));
     }
 
     *outProgramId = programId;
     return true;
 }
 
@@ skipping 92 matching lines @@
     }
 }
 
 const GrGLContextInfo& GrGLShaderBuilder::ctxInfo() const {
     return fGpu->ctxInfo();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrGLFullShaderBuilder::GrGLFullShaderBuilder(GrGpuGL* gpu,
-                                             GrGLUniformManager& uniformManager,
+                                             GrGLUniformManager* uniformManager,
                                              const GrGLProgramDesc& desc)
     : INHERITED(gpu, uniformManager, desc)
     , fVSAttrs(kVarsPerBlock)
     , fVSOutputs(kVarsPerBlock)
     , fGSInputs(kVarsPerBlock)
     , fGSOutputs(kVarsPerBlock) {
 
     const GrGLProgramDesc::KeyHeader& header = this->desc().getHeader();
 
     fPositionVar = &fVSAttrs.push_back();
@@ skipping 219 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,
-                                                             GrGLUniformManager& uniformManager,
+                                                             GrGLUniformManager* uniformManager,
                                                              const GrGLProgramDesc& desc)
     : INHERITED(gpu, uniformManager, desc)
     , fNumTexCoordSets(0) {
 
     SkASSERT(!desc.getHeader().fHasVertexCode);
     SkASSERT(gpu->glCaps().pathRenderingSupport());
     SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fColorInput);
     SkASSERT(GrGLProgramDesc::kAttribute_ColorInput != desc.getHeader().fCoverageInput);
 }
 
@@ skipping 12 matching lines @@
 
     GrGLPathTexGenProgramEffectsBuilder pathTexGenEffectsBuilder(this,
                                                                  effectCnt);
     this->INHERITED::createAndEmitEffects(&pathTexGenEffectsBuilder,
                                           effectStages,
                                           effectKeys,
                                           effectCnt,
                                           inOutFSColor);
     return pathTexGenEffectsBuilder.finish();
 }