Refactor separable varying location info to be stored in GrGLProgram subclass

src/gpu/gl/builders/GrGLProgramBuilder.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 GrGLProgramBuilder_DEFINED
 #define GrGLProgramBuilder_DEFINED
 
 #include "GrGLFragmentShaderBuilder.h"
 #include "GrGLGeometryShaderBuilder.h"
 #include "GrGLVertexShaderBuilder.h"
 #include "../GrGLProgramDataManager.h"
+#include "../GrGLPathProgramDataManager.h"
 #include "../GrGLUniformHandle.h"
 #include "../GrGLPrimitiveProcessor.h"
 #include "../GrGLXferProcessor.h"
 #include "../../GrPendingFragmentStage.h"
 #include "../../GrPipeline.h"
 
 /*
  * This is the base class for a series of interfaces.  This base class *MUST* remain abstract with
  * NO data members because it is used in multiple interface inheritance.
  * Heirarchy:
  *                      GrGLUniformBuilder
  *                     /                  \
  *                GrGLFPBuilder       GrGLGPBuilder
  *                     \                  /
  *                     GrGLProgramBuilder(internal use only)
  */
 class GrGLUniformBuilder {
 public:
     enum ShaderVisibility {
         kVertex_Visibility   = 1 << kVertex_GrShaderType,
         kGeometry_Visibility = 1 << kGeometry_GrShaderType,
         kFragment_Visibility = 1 << kFragment_GrShaderType,
     };
 
     virtual ~GrGLUniformBuilder() {}
 
     typedef GrGLProgramDataManager::UniformHandle UniformHandle;
+    typedef GrGLPathProgramDataManager::SeparableVaryingHandle SeparableVaryingHandle;
 
     /** Add a uniform variable to the current program, that has visibility in one or more shaders.
         visibility is a bitfield of ShaderVisibility values indicating from which shaders the
         uniform should be accessible. At least one bit must be set. Geometry shader uniforms are not
         supported at this time. The actual uniform name will be mangled. If outName is not NULL then
         it will refer to the final uniform name after return. Use the addUniformArray variant to add
         an array of uniforms. */
     UniformHandle addUniform(uint32_t visibility,
                              GrSLType type,
                              GrSLPrecision precision,
@@ skipping 95 matching lines @@
 
     /*
      * This call can be used by GP to pass an attribute through all shaders directly to 'output' in
      * the fragment shader.  Though this call effects both the vertex shader and fragment shader,
      * it expects 'output' to be defined in the fragment shader before this call is made.
      * TODO it might be nicer behavior to have a flag to declare output inside this call
      */
     virtual void addPassThroughAttribute(const GrGeometryProcessor::Attribute*,
                                          const char* output) = 0;
 
+    /** Creates a fragment shader varying that can be referred to.
+     * Comparable to GrGLUniformBuilder::addUniform().
+     */
+    virtual SeparableVaryingHandle addSeparableVarying(
+        const char* name, GrGLVertToFrag*, GrSLPrecision fsPrecision = kDefault_GrSLPrecision) = 0;
+
     // TODO rename getFragmentBuilder
     virtual GrGLFragmentBuilder* getFragmentShaderBuilder() = 0;
     virtual GrGLVertexBuilder* getVertexShaderBuilder() = 0;
 
     /*
      * *NOTE* NO MEMBERS ALLOWED, MULTIPLE INHERITANCE
      */
 };
 
 /* a specializations for FPs. Lets the user add uniforms and FS code */
@@ skipping 85 matching lines @@
     GrGLVertexBuilder* getVertexShaderBuilder() override { return &fVS; }
 
     void addVarying(
             const char* name,
             GrGLVarying*,
             GrSLPrecision fsPrecision = kDefault_GrSLPrecision) override;
 
     void addPassThroughAttribute(const GrPrimitiveProcessor::Attribute*,
                                  const char* output) override;
 
+    SeparableVaryingHandle addSeparableVarying(
+        const char* name,
+        GrGLVertToFrag*,
+        GrSLPrecision fsPrecision = kDefault_GrSLPrecision) override;
 
     // Handles for program uniforms (other than per-effect uniforms)
     struct BuiltinUniformHandles {
         UniformHandle       fRTAdjustmentUni;
 
         // We use the render target height to provide a y-down frag coord when specifying
         // origin_upper_left is not supported.
         UniformHandle       fRTHeightUni;
     };
 
@@ skipping 43 matching lines @@
 
     void verify(const GrPrimitiveProcessor&);
     void verify(const GrXferProcessor&);
     void verify(const GrFragmentProcessor&);
     template <class Proc>
     void emitSamplers(const GrProcessor&,
                       GrGLProcessor::TextureSamplerArray* outSamplers,
                       GrGLInstalledProc<Proc>*);
 
     GrGLProgram* finalize();
-    void bindUniformLocations(GrGLuint programID);
+    void bindProgramResourceLocations(GrGLuint programID);
     bool checkLinkStatus(GrGLuint programID);
-    void resolveUniformLocations(GrGLuint programID);
+    virtual void resolveProgramResourceLocations(GrGLuint programID);
     void cleanupProgram(GrGLuint programID, const SkTDArray<GrGLuint>& shaderIDs);
     void cleanupShaders(const SkTDArray<GrGLuint>& shaderIDs);
 
     // Subclasses create different programs
     virtual GrGLProgram* createProgram(GrGLuint programID);
 
     void appendUniformDecls(ShaderVisibility, SkString*) const;
 
     // reset is called by program creator between each processor's emit code.  It increments the
     // stage offset for variable name mangling, and also ensures verfication variables in the
@@ skipping 52 matching lines @@
     UniformInfoArray fUniforms;
     GrGLPrimitiveProcessor::TransformsIn fCoordTransforms;
     GrGLPrimitiveProcessor::TransformsOut fOutCoords;
 
     friend class GrGLShaderBuilder;
     friend class GrGLVertexBuilder;
     friend class GrGLFragmentShaderBuilder;
     friend class GrGLGeometryBuilder;
 };
 #endif