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)

[joshualitt, 2015/08/12 17:14:53]

Braces

[wangyix, 2015/08/12 18:00:33]

Done.

+            return fSubstageIndices[fSubstageIndices.count() - 2];

[joshualitt, 2015/08/12 17:14:53]

Could you put a comment here for the '- 2'?
ie, the index of the child proc which is currently emitting code, or something
similar

[wangyix, 2015/08/12 18:00:33]

Done.

+        return -1;
+    }
+
+    const SkString& getMangleString() const { return fMangleString; }
+
+    SkString getMangleStringThisLevel() const {
+        SkString ret;
+        int childNumber = getChildNumberThisLevel();

[joshualitt, 2015/08/12 17:14:53]

this->

[wangyix, 2015/08/12 18:00:33]

Done.

+        if (childNumber >= 0)

[joshualitt, 2015/08/12 17:14:53]

braces

[wangyix, 2015/08/12 18:00:33]

Done.

+            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 manglestring, 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.
+     */
+    SkTArray<int> fSubstageIndices;
+    SkString fMangleString;

[joshualitt, 2015/08/12 17:14:53]

Please put an explanation of the what the mangle string looks like here

[wangyix, 2015/08/12 18:00:33]

Done.

+
     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