Add some backend flexibility for shader declarations in ProgramBuilding.

src/gpu/glsl/GrGLSLVarying.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrGLSLVarying_DEFINED
 #define GrGLSLVarying_DEFINED
 
@@ skipping 61 matching lines @@
 public:
     explicit GrGLSLVaryingHandler(GrGLSLProgramBuilder* program)
         : fVertexInputs(kVaryingsPerBlock)
         , fVertexOutputs(kVaryingsPerBlock)
         , fGeomInputs(kVaryingsPerBlock)
         , fGeomOutputs(kVaryingsPerBlock)
         , fFragInputs(kVaryingsPerBlock)
         , fFragOutputs(kVaryingsPerBlock)
         , fProgramBuilder(program) {}
 
+    virtual ~GrGLSLVaryingHandler() {}
+
     typedef GrTAllocator<GrGLSLShaderVar> VarArray;
     typedef GrGLSLProgramDataManager::VaryingHandle VaryingHandle;
 
     /*
      * addVarying allows fine grained control for setting up varyings between stages. Calling this
      * functions will make sure all necessary decls are setup for the client. The client however is
      * responsible for setting up all shader code (e.g "vOut = vIn;") If you just need to take an
      * attribute and pass it through to an output value in a fragment shader, use
      * addPassThroughAttribute.
      * TODO convert most uses of addVarying to addPassThroughAttribute
      */
     void addVarying(const char* name,
                     GrGLSLVarying*,
                     GrSLPrecision precision = kDefault_GrSLPrecision);
 
     /*
      * 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. If there
      * is a geometry shader, we will simply take the value of the varying from the first vertex and
      * that will be set as the output varying for all emitted vertices.
      * TODO it might be nicer behavior to have a flag to declare output inside this call
      */
     void addPassThroughAttribute(const GrGeometryProcessor::Attribute*, const char* output);
 
     void emitAttributes(const GrGeometryProcessor& gp);
 
+    // This should be called once all attributes and varyings have been added to the
+    // GrGLSLVaryingHanlder and before getting/adding any of the declarations to the shaders.
+    void finalize();
+
     void getVertexDecls(SkString* inputDecls, SkString* outputDecls) const;
     void getGeomDecls(SkString* inputDecls, SkString* outputDecls) const;
     void getFragDecls(SkString* inputDecls, SkString* outputDecls) const;
 protected:
     VarArray fVertexInputs;
     VarArray fVertexOutputs;
     VarArray fGeomInputs;
     VarArray fGeomOutputs;
     VarArray fFragInputs;
     VarArray fFragOutputs;
 
     // This is not owned by the class
     GrGLSLProgramBuilder* fProgramBuilder;
 
 private:
     void addVertexVarying(const char* name, GrSLPrecision precision, GrGLSLVarying* v);
     void addGeomVarying(const char* name, GrSLPrecision precision, GrGLSLVarying* v);
     void addFragVarying(GrSLPrecision precision, GrGLSLVarying* v);
 
     void addAttribute(const GrShaderVar& var);
 
+    virtual void onFinalize() = 0;
+
     // helper function for get*Decls
     void appendDecls(const VarArray& vars, SkString* out) const;
 
     friend class GrGLSLProgramBuilder;
 };
 
 #endif