Add addFragPosUniform to GrGLrogramBuilder

BUG=skia:

Review URL: https://codereview.chromium.org/1434483002

src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp

@@ -143,17 +143,15 @@ const char* GrGLFragmentShaderBuilder::fragmentPosition() {
         static const char* kTempName = "tmpXYFragCoord";
         static const char* kCoordName = "fragCoordYDown";
         if (!fSetupFragPosition) {
-            // temporarily change the stage index because we're inserting non-stage code.
-            GrGLProgramBuilder::AutoStageRestore asr(fProgramBuilder);
             SkASSERT(!fProgramBuilder->fUniformHandles.fRTHeightUni.isValid());
             const char* rtHeightName;
 
             fProgramBuilder->fUniformHandles.fRTHeightUni =
-                    fProgramBuilder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
+                    fProgramBuilder->addFragPosUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                                kFloat_GrSLType,
+                                                       kFloat_GrSLType,
-                                                kDefault_GrSLPrecision,
+                                                       kDefault_GrSLPrecision,
-                                                "RTHeight",
+                                                       "RTHeight",
-                                                &rtHeightName);
+                                                       &rtHeightName);
 
             // The Adreno compiler seems to be very touchy about access to "gl_FragCoord".
             // Accessing glFragCoord.zw can cause a program to fail to link. Additionally,

src/gpu/gl/builders/GrGLProgramBuilder.cpp

@@ -56,7 +56,6 @@ GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu, const DrawArgs& args)
     : fVS(this)
     , fGS(this)
     , fFS(this, args.fDesc->header().fFragPosKey)
-    , fOutOfStage(true)
     , fStageIndex(-1)
     , fGeometryProcessor(nullptr)
     , fXferProcessor(nullptr)
@@ -107,13 +106,13 @@ GrGLProgramBuilder::SeparableVaryingHandle GrGLProgramBuilder::addSeparableVaryi
     return SeparableVaryingHandle(varyingInfo.fLocation);
 }
 
-void GrGLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name) {
+void GrGLProgramBuilder::nameVariable(SkString* out, char prefix, const char* name, bool mangle) {
     if ('\0' == prefix) {
         *out = name;
     } else {
         out->printf("%c%s", prefix, name);
     }
-    if (!fOutOfStage) {
+    if (mangle) {
         if (out->endsWith('_')) {
             // Names containing "__" are reserved.
             out->append("x");
@@ -122,11 +121,12 @@ void GrGLProgramBuilder::nameVariable(SkString* out, char prefix, const char* na
     }
 }
 
-GrGLSLProgramDataManager::UniformHandle GrGLProgramBuilder::addUniformArray(
+GrGLSLProgramDataManager::UniformHandle GrGLProgramBuilder::internalAddUniformArray(
                                                                 uint32_t visibility,
                                                                 GrSLType type,
                                                                 GrSLPrecision precision,
                                                                 const char* name,
+                                                                bool mangleName,
                                                                 int count,
                                                                 const char** outName) {
     SkASSERT(name && strlen(name));
@@ -148,7 +148,7 @@ GrGLSLProgramDataManager::UniformHandle GrGLProgramBuilder::addUniformArray(
     if ('u' == name[0]) {
         prefix = '\0';
     }
-    this->nameVariable(uni.fVariable.accessName(), prefix, name);
+    this->nameVariable(uni.fVariable.accessName(), prefix, name, mangleName);
     uni.fVariable.setArrayCount(count);
     uni.fVisibility = visibility;
     uni.fVariable.setPrecision(precision);

src/gpu/gl/builders/GrGLProgramBuilder.h

@@ -68,7 +68,11 @@ public:
         GrSLPrecision precision,
         const char* name,
         int arrayCount,
-        const char** outName = nullptr) = 0;
+        const char** outName = nullptr) {
+        return this->internalAddUniformArray(visibility, type, precision, name, true, arrayCount,
+                                             outName);
+    }
+
 
     virtual const GrGLSLShaderVar& getUniformVariable(UniformHandle u) const = 0;
 
@@ -86,6 +90,15 @@ public:
     /*
      * *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
      */
+private:
+    virtual UniformHandle internalAddUniformArray(
+        uint32_t visibility,
+        GrSLType type,
+        GrSLPrecision precision,
+        const char* name,
+        bool mangleName,
+        int arrayCount,
+        const char** outName) = 0;
 };
 
 // TODO move this into GrGLGPBuilder and move them both out of this file
@@ -239,13 +252,6 @@ public:
      */
     static GrGLProgram* CreateProgram(const DrawArgs&, GrGLGpu*);
 
-    UniformHandle addUniformArray(uint32_t visibility,
-                                  GrSLType type,
-                                  GrSLPrecision precision,
-                                  const char* name,
-                                  int arrayCount,
-                                  const char** outName) override;
-
     const GrGLSLShaderVar& getUniformVariable(UniformHandle u) const override {
         return fUniforms[u.toIndex()].fVariable;
     }
@@ -298,10 +304,29 @@ protected:
     const GrProgramDesc& desc() const { return *fArgs.fDesc; }
     const GrProgramDesc::KeyHeader& header() const { return fArgs.fDesc->header(); }
 
+    UniformHandle internalAddUniformArray(uint32_t visibility,
+                                          GrSLType type,
+                                          GrSLPrecision precision,
+                                          const char* name,
+                                          bool mangleName,
+                                          int arrayCount,
+                                          const char** outName) override;
+
+    // Used to add a uniform for frag position without mangling the name of the uniform inside of a
+    // stage.
+    UniformHandle addFragPosUniform(uint32_t visibility,
+                                    GrSLType type,
+                                    GrSLPrecision precision,
+                                    const char* name,
+                                    const char** outName) {
+        SkDebugf("in my frag pos thing\n");
+        return this->internalAddUniformArray(visibility, type, precision, name, false, 0, outName);
+    }
+
     // 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
+    // char (unless the prefix is '\0'). It also will mangle the name to be stage-specific unless
-    // generating stage code.
+    // explicitly asked not to.
-    void nameVariable(SkString* out, char prefix, const char* name);
+    void nameVariable(SkString* out, char prefix, const char* name, bool mangle = true);
     // Generates a possibly mangled name for a stage variable and writes it to the fragment shader.
     // If GrGLSLExpr4 has a valid name then it will use that instead
     void nameExpression(GrGLSLExpr4*, const char* baseName);
@@ -356,22 +381,11 @@ protected:
     // stage offset for variable name mangling, and also ensures verfication variables in the
     // fragment shader are cleared.
     void reset() {
-        this->enterStage();
         this->addStage();
         fFS.reset();
     }
     void addStage() { fStageIndex++; }
 
-    // This simple class exits the stage and then restores the stage when it goes out of scope
-    class AutoStageRestore {
-    public:
-        AutoStageRestore(GrGLProgramBuilder* pb)
-            : fPB(pb), fOutOfStage(pb->fOutOfStage) { pb->exitStage(); }
-        ~AutoStageRestore() { fPB->fOutOfStage = fOutOfStage; }
-    private:
-        GrGLProgramBuilder* fPB;
-        bool fOutOfStage;
-    };
     class AutoStageAdvance {
     public:
         AutoStageAdvance(GrGLProgramBuilder* pb)
@@ -380,12 +394,10 @@ protected:
             // Each output to the fragment processor gets its own code section
             fPB->fFS.nextStage();
         }
-        ~AutoStageAdvance() { fPB->exitStage(); }
+        ~AutoStageAdvance() {}
     private:
         GrGLProgramBuilder* fPB;
     };
-    void exitStage() { fOutOfStage = true; }
-    void enterStage() { fOutOfStage = false; }
     int stageIndex() const { return fStageIndex; }
 
     const char* rtAdjustment() const { return "rtAdjustment"; }
@@ -397,7 +409,6 @@ protected:
     GrGLVertexBuilder fVS;
     GrGLGeometryBuilder fGS;
     GrGLFragmentShaderBuilder fFS;
-    bool fOutOfStage;
     int fStageIndex;
 
     GrGLInstalledGeoProc* fGeometryProcessor;