Create GrGLSLVaryingHandler class for program building

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 "GrPipeline.h"
 #include "gl/GrGLProgramDataManager.h"
+#include "gl/GrGLVaryingHandler.h"
 #include "glsl/GrGLSLPrimitiveProcessor.h"
 #include "glsl/GrGLSLProgramBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLTextureSampler.h"
 #include "glsl/GrGLSLXferProcessor.h"
 
 class GrFragmentProcessor;
 class GrGLContextInfo;
 class GrGLSLShaderBuilder;
 class GrGLSLCaps;
@@ skipping 39 matching lines @@
     }
 
     const char* getUniformCStr(UniformHandle u) const override {
         return this->getUniformVariable(u).c_str();
     }
 
     const GrGLSLCaps* glslCaps() const override;
 
     GrGLGpu* gpu() const { return fGpu; }
 
-    void addVarying(
-            const char* name,
-            GrGLSLVarying*,
-            GrSLPrecision precision = kDefault_GrSLPrecision) override;
-
-    void addPassThroughAttribute(const GrPrimitiveProcessor::Attribute*,
-                                 const char* output) override;
-
-    SeparableVaryingHandle addSeparableVarying(
-        const char* name,
-        GrGLSLVertToFrag*,
-        GrSLPrecision fsPrecision = kDefault_GrSLPrecision) override;
-
 private:
     typedef GrGLProgramDataManager::UniformInfo UniformInfo;
     typedef GrGLProgramDataManager::UniformInfoArray UniformInfoArray;
-    typedef GrGLProgramDataManager::SeparableVaryingInfo SeparableVaryingInfo;
-    typedef GrGLProgramDataManager::SeparableVaryingInfoArray SeparableVaryingInfoArray;
 
     GrGLProgramBuilder(GrGLGpu*, const DrawArgs&);
 
     UniformHandle internalAddUniformArray(uint32_t visibility,
                                           GrSLType type,
                                           GrSLPrecision precision,
                                           const char* name,
                                           bool mangleName,
                                           int arrayCount,
                                           const char** outName) override;
@@ skipping 41 matching lines @@
     bool checkLinkStatus(GrGLuint programID);
     void resolveProgramResourceLocations(GrGLuint programID);
     void cleanupProgram(GrGLuint programID, const SkTDArray<GrGLuint>& shaderIDs);
     void cleanupShaders(const SkTDArray<GrGLuint>& shaderIDs);
 
     // Subclasses create different programs
     GrGLProgram* createProgram(GrGLuint programID);
 
     void onAppendUniformDecls(ShaderVisibility visibility, SkString* out) const override;
 
+    GrGLSLVaryingHandler* varyingHandler() override { return &fVaryingHandler; }
+
     // 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
     // fragment shader are cleared.
     void reset() {
         this->addStage();
         fFS.reset();
     }
     void addStage() { fStageIndex++; }
 
     class AutoStageAdvance {
@@ skipping 11 matching lines @@
 
     GrGLInstalledGeoProc* fGeometryProcessor;
     GrGLInstalledXferProc* fXferProcessor;
     SkAutoTUnref<GrGLInstalledFragProcs> fFragmentProcessors;
 
     GrGLGpu* fGpu;
     UniformInfoArray fUniforms;
     GrGLSLPrimitiveProcessor::TransformsIn fCoordTransforms;
     GrGLSLPrimitiveProcessor::TransformsOut fOutCoords;
     SkTArray<UniformHandle> fSamplerUniforms;
-    SeparableVaryingInfoArray fSeparableVaryingInfos;
 
-    friend class GrGLSLShaderBuilder;
-    friend class GrGLSLVertexBuilder;
-    friend class GrGLSLFragmentShaderBuilder;
-    friend class GrGLSLGeometryBuilder;
+    GrGLVaryingHandler        fVaryingHandler;
 
-   typedef GrGLSLProgramBuilder INHERITED; 
+    friend class GrGLVaryingHandler; 
+
+    typedef GrGLSLProgramBuilder INHERITED; 
 };
 #endif