Move loops that chain together effects into GrGLShaderBuilder from GrGLProgram.

src/gpu/gl/GrGLShaderBuilder.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
@@ skipping 53 matching lines @@
         void init(GrGLShaderBuilder* builder,
                   uint32_t configComponentMask,
                   const char* swizzle,
                   int idx) {
             GrAssert(!this->isInitialized());
             GrAssert(0 != configComponentMask);
             GrAssert(GrGLUniformManager::kInvalidUniformHandle == fSamplerUniform);
 
             GrAssert(NULL != builder);
             SkString name;
-            name.printf("Sampler%d_", idx);
+            name.printf("Sampler%d", idx);
             fSamplerUniform = builder->addUniform(GrGLShaderBuilder::kFragment_ShaderType,
                                                   kSampler2D_GrSLType,
                                                   name.c_str());
             GrAssert(GrGLUniformManager::kInvalidUniformHandle != fSamplerUniform);
 
             fConfigComponentMask = configComponentMask;
             memcpy(fSwizzle, swizzle, 4);
         }
 
         void init(GrGLShaderBuilder* builder, const GrTextureAccess* access, int idx) {
@@ skipping 183 matching lines @@
 
     /**
      * Interfaces used by GrGLProgram.
      * TODO: Hide these from the GrEffects using friend or splitting this into two related classes.
      * Also, GrGLProgram's shader string construction should be moved to this class.
      */
 
     /** Called after building is complete to get the final shader string. */
     void getShader(ShaderType, SkString*) const;
 
-    void setCurrentStage(int stageIdx) { fCurrentStageIdx = stageIdx; }
-    void setNonStage() { fCurrentStageIdx = kNonStageIdx; }
-    // TODO: move remainder of shader code generation to this class and call this privately
-    // Handles of sampler uniforms generated for the effect are appended to samplerHandles.
-    GrGLEffect* createAndEmitGLEffect(
-                                const GrEffectStage& stage,
-                                GrBackendEffectFactory::EffectKey key,
-                                const char* fsInColor, // NULL means no incoming color
-                                const char* fsOutColor,
-                                SkTArray<GrGLUniformManager::UniformHandle, true>* samplerHandles);
+    /**
+     * Adds code for effects. effectStages contains the effects to add. effectKeys[i] is the key
+     * generated from effectStages[i]. An entry in effectStages can be NULL, in which case it is
+     * skipped. Moreover, if the corresponding key is GrGLEffect::NoEffectKey then it is skipped.
+     * inOutFSColor specifies the input color to the first stage and is updated to be the
+     * output color of the last stage. fsInOutColorKnownValue specifies whether the input color
+     * has a known constant value and is updated to refer to the status of the output color.
+     * The handles to texture samplers for effectStage[i] are added to effectSamplerHandles[i]. The
+     * glEffects array is updated to contain the GrGLEffect generated for each entry in
+     * effectStages.
+     */
+    void emitEffects(const GrEffectStage* effectStages[],
+                     const GrBackendEffectFactory::EffectKey effectKeys[],
+                     int effectCnt,
+                     SkString*  inOutFSColor,
+                     GrSLConstantVec* fsInOutColorKnownValue,
+                     SkTArray<GrGLUniformManager::UniformHandle, true>* effectSamplerHandles[],
+                     GrGLEffect* glEffects[]);
 
     GrGLUniformManager::UniformHandle getRTHeightUniform() const { return fRTHeightUniform; }
     GrGLUniformManager::UniformHandle getDstCopyTopLeftUniform() const {
         return fDstCopyTopLeftUniform;
     }
     GrGLUniformManager::UniformHandle getDstCopyScaleUniform() const {
         return fDstCopyScaleUniform;
     }
     GrGLUniformManager::UniformHandle getDstCopySamplerUniform() const {
         return fDstCopySampler.fSamplerUniform;
@@ skipping 33 matching lines @@
 
     VarArray    fVSAttrs;
     VarArray    fVSOutputs;
     VarArray    fGSInputs;
     VarArray    fGSOutputs;
     VarArray    fFSInputs;
     SkString    fGSHeader; // layout qualifiers specific to GS
     VarArray    fFSOutputs;
 
 private:
-    enum {
-        kNonStageIdx = -1,
-    };
+    class CodeStage : GrNoncopyable {
+    public:
+        CodeStage() : fNextIndex(0), fCurrentIndex(-1), fEffectStage(NULL) {}
+
+        bool inStageCode() const {
+            this->validate();
+            return NULL != fEffectStage;
+        }
+
+        const GrEffectStage* effectStage() const {
+            this->validate();
+            return fEffectStage;
+        }
+
+        int stageIndex() const {
+            this->validate(); 
+            return fCurrentIndex;
+        }
+
+        class AutoStageRestore : GrNoncopyable {
+        public:
+            AutoStageRestore(CodeStage* codeStage, const GrEffectStage* newStage) {
+                GrAssert(NULL != codeStage);
+                fSavedIndex = codeStage->fCurrentIndex;
+                fSavedEffectStage = codeStage->fEffectStage;
+
+                if (NULL == newStage) {
+                    codeStage->fCurrentIndex = -1;
+                } else {
+                    codeStage->fCurrentIndex = codeStage->fNextIndex++;
+                }
+                codeStage->fEffectStage = newStage;
+
+                fCodeStage = codeStage;
+            }
+            ~AutoStageRestore() {
+                fCodeStage->fCurrentIndex = fSavedIndex;
+                fCodeStage->fEffectStage = fSavedEffectStage;
+            }
+        private:
+            CodeStage*              fCodeStage;
+            int                     fSavedIndex;
+            const GrEffectStage*    fSavedEffectStage;
+        };
+    private:
+        void validate() const { GrAssert((NULL == fEffectStage) == (-1 == fCurrentIndex)); }
+        int                     fNextIndex;
+        int                     fCurrentIndex;
+        const GrEffectStage*    fEffectStage;
+    } fCodeStage;
 
     /**
      * Features that should only be enabled by GrGLShaderBuilder itself.
      */
     enum GLSLPrivateFeature {
         kFragCoordConventions_GLSLPrivateFeature = kLastGLSLFeature + 1,
         kEXTShaderFramebufferFetch_GLSLPrivateFeature,
         kNVShaderFramebufferFetch_GLSLPrivateFeature,
     };
     bool enablePrivateFeature(GLSLPrivateFeature);
 
     // If we ever have VS/GS features we can expand this to take a bitmask of ShaderType and track
     // the enables separately for each shader.
     void addFSFeature(uint32_t featureBit, const char* extensionName);
 
+    // Generates a name for a variable. The generated string will be name prefixed by the prefix
+    // char (unless the prefix is '\0'). It also mangles the name to be stage-specific if we're
+    // generating stage code.
+    void nameVariable(SkString* out, char prefix, const char* name);
+
     // Interpretation of DstReadKey when generating code
     enum {
         kNoDstRead_DstReadKey         = 0,
         kYesDstRead_DstReadKeyBit     = 0x1, // Set if we do a dst-copy-read.
         kUseAlphaConfig_DstReadKeyBit = 0x2, // Set if dst-copy config is alpha only.
         kTopLeftOrigin_DstReadKeyBit  = 0x4, // Set if dst-copy origin is top-left.
     };
 
     const GrGLContextInfo&              fCtxInfo;
     GrGLUniformManager&                 fUniformManager;
-    int                                 fCurrentStageIdx;
     uint32_t                            fFSFeaturesAddedMask;
     SkString                            fFSFunctions;
     SkString                            fFSExtensions;
 
     bool                                fUsesGS;
 
     SkString                            fFSCode;
     SkString                            fVSCode;
     SkString                            fGSCode;
 
     bool                                fSetupFragPosition;
     TextureSampler                      fDstCopySampler;
 
     GrGLUniformManager::UniformHandle   fRTHeightUniform;
     GrGLUniformManager::UniformHandle   fDstCopyTopLeftUniform;
     GrGLUniformManager::UniformHandle   fDstCopyScaleUniform;
 
     SkSTArray<10, AttributePair, true>  fEffectAttributes;
 
     GrGLShaderVar*                      fPositionVar;
     GrGLShaderVar*                      fLocalCoordsVar;
 
 };
 
 #endif