Added mangleString member and onBefore*, onAfter* functions to GrGLFragmentShaderBuilder

src/gpu/gl/builders/GrGLFragmentShaderBuilder.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLFragmentShaderBuilder_DEFINED
 #define GrGLFragmentShaderBuilder_DEFINED
 
 #include "GrGLShaderBuilder.h"
 
 class GrGLVarying;
 
 /*
  * This base class encapsulates the functionality which the GP uses to build fragment shaders
  */
 class GrGLFragmentBuilder : public GrGLShaderBuilder {
 public:
-    GrGLFragmentBuilder(GrGLProgramBuilder* program) : INHERITED(program) {}
+    GrGLFragmentBuilder(GrGLProgramBuilder* program)
+        : INHERITED(program) {
+        fSubstageIndices.push_back(0);
+    }
     virtual ~GrGLFragmentBuilder() {}
     /**
      * Use of these features may require a GLSL extension to be enabled. Shaders may not compile
      * if code is added that uses one of these features without calling enableFeature()
      */
     enum GLSLFeature {
         kStandardDerivatives_GLSLFeature = 0,
         kLastGLSLFeature = kStandardDerivatives_GLSLFeature
     };
 
     /**
      * If the feature is supported then true is returned and any necessary #extension declarations
      * are added to the shaders. If the feature is not supported then false will be returned.
      */
     virtual bool enableFeature(GLSLFeature) = 0;
 
     /**
      * This returns a variable name to access the 2D, perspective correct version of the coords in
      * the fragment shader. If the coordinates at index are 3-dimensional, it immediately emits a
      * perspective divide into the fragment shader (xy / z) to convert them to 2D.
      */
     virtual SkString ensureFSCoords2D(const GrGLProcessor::TransformedCoordsArray& coords,
                                       int index) = 0;
 
 
     /** Returns a variable name that represents the position of the fragment in the FS. The position
         is in device space (e.g. 0,0 is the top left and pixel centers are at half-integers). */
     virtual const char* fragmentPosition() = 0;
 
+    /**
+     * Fragment procs with child procs should call these functions before/after calling emitCode
+     * on a child proc.
+     */
+    void onBeforeChildProcEmitCode();
+    void onAfterChildProcEmitCode();
+
+    int getChildNumberThisLevel() const {
+        if (fSubstageIndices.count() > 1) {
+            // second-to-last value in the fSubstageIndices stack is the index of the child proc
+            // at that level which is currently emitting code.
+            return fSubstageIndices[fSubstageIndices.count() - 2];
+        }
+        return -1;
+    }
+
+    const SkString& getMangleString() const { return fMangleString; }
+
+    SkString getMangleStringThisLevel() const {
+        SkString ret;
+        int childNumber = this->getChildNumberThisLevel();
+        if (childNumber >= 0) {
+            ret.printf("_c%d", childNumber);
+        }
+        return ret;
+    }
+
 private:
+    /*
+     * State that tracks which child proc in the proc tree is currently emitting code.  This is
+     * used to update the fMangleString, which is used to mangle the names of uniforms and functions
+     * emitted by the proc.  fSubstageIndices is a stack: its count indicates how many levels deep
+     * we are in the tree, and its second-to-last value is the index of the child proc at that
+     * level which is currently emitting code. For example, if fSubstageIndices = [3, 1, 2, 0], that
+     * means we're currently emitting code for the base proc's 3rd child's 1st child's 2nd child.
+     */
+    SkTArray<int> fSubstageIndices;
+
+    /*
+     * The mangle string is used to mangle the names of uniforms/functions emitted by the child
+     * procs so no duplicate uniforms/functions appear in the generated shader program. The mangle
+     * string is simply based on fSubstageIndices. For example, if fSubstageIndices = [3, 1, 2, 0],
+     * then the manglestring will be "_c3_c1_c2", and any uniform/function emitted by that proc will
+     * have "_c3_c1_c2" appended to its name, which can be interpreted as "base proc's 3rd child's
+     * 1st child's 2nd child".
+     */
+    SkString fMangleString;
+
     friend class GrGLPathProcessor;
 
     typedef GrGLShaderBuilder INHERITED;
 };
 
 /*
  * Fragment processor's, in addition to all of the above, may need to use dst color so they use
  * this builder to create their shader.  Because this is the only shader builder the FP sees, we
  * just call it FPShaderBuilder
  */
@@ skipping 101 matching lines @@
     // the program creator
     bool fHasReadDstColor;
     bool fHasReadFragmentPosition;
 
     friend class GrGLProgramBuilder;
 
     typedef GrGLXPFragmentBuilder INHERITED;
 };
 
 #endif