Revert of Cleanup of shader building system

src/gpu/gl/builders/GrGLShaderBuilder.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 GrGLShaderBuilder_DEFINED
 #define GrGLShaderBuilder_DEFINED
 
 #include "gl/GrGLProgramDesc.h"
+#include "gl/GrGLProgramEffects.h"
+#include "gl/GrGLSL.h"
 #include "gl/GrGLProgramDataManager.h"
+#include "GrBackendProcessorFactory.h"
+#include "GrColor.h"
+#include "GrProcessor.h"
+#include "SkTypes.h"
 
 #include <stdarg.h>
 
 class GrGLContextInfo;
+class GrProcessorStage;
+class GrGLProgramDesc;
 class GrGLProgramBuilder;
+class GrGLFullProgramBuilder;
 
 /**
   base class for all shaders builders
 */
 class GrGLShaderBuilder {
 public:
     typedef GrGLProcessor::TransformedCoordsArray TransformedCoordsArray;
     typedef GrGLProcessor::TextureSampler TextureSampler;
-
     GrGLShaderBuilder(GrGLProgramBuilder* program);
 
     void addInput(GrGLShaderVar i) { fInputs.push_back(i); }
     void addOutput(GrGLShaderVar i) { fOutputs.push_back(i); }
 
     /*
      * We put texture lookups in the base class because it is TECHNICALLY possible to do texture
      * lookups in any kind of shader.  However, for the time being using these calls on non-fragment
      * shaders will result in a shader compilation error as texture sampler uniforms are only
      * visible to the fragment shader.  It would not be hard to change this behavior, if someone
@@ skipping 60 matching lines @@
                       const GrGLShaderVar* args,
                       const char* body,
                       SkString* outName);
 
     /*
      * Get parent builder for adding uniforms
      */
     GrGLProgramBuilder* getProgramBuilder() { return fProgramBuilder; }
 
     /**
-     * Helper for begining and ending a block in the shader code.
+     * Helper for begining and ending a block in the fragment code.
      */
     class ShaderBlock {
     public:
         ShaderBlock(GrGLShaderBuilder* builder) : fBuilder(builder) {
             SkASSERT(builder);
             fBuilder->codeAppend("{");
         }
 
         ~ShaderBlock() {
             fBuilder->codeAppend("}");
         }
     private:
         GrGLShaderBuilder* fBuilder;
     };
-
 protected:
-    typedef GrTAllocator<GrGLShaderVar> VarArray;
-    void appendDecls(const VarArray& vars, SkString* out) const;
 
     /*
      * this super low level function is just for use internally to builders
      */
     void appendTextureLookup(const char* samplerName,
                              const char* coordName,
                              uint32_t configComponentMask,
                              const char* swizzle);
 
     /*
      * A general function which enables an extension in a shader if the feature bit is not present
      */
     void addFeature(uint32_t featureBit, const char* extensionName);
 
+    typedef GrTAllocator<GrGLShaderVar> VarArray;
+
     GrGLProgramBuilder* fProgramBuilder;
 
     SkString fCode;
     SkString fFunctions;
     SkString fExtensions;
 
     VarArray fInputs;
     VarArray fOutputs;
     uint32_t fFeaturesAddedMask;
 };
+
+
+/*
+ * Full Shader builder is the base class for shaders which are only accessible through full program
+ * builder, ie vertex, geometry, and later TCU / TES.  Using this base class, they can access the
+ * full program builder functionality through the full program pointer
+ */
+class GrGLFullShaderBuilder : public GrGLShaderBuilder {
+public:
+    GrGLFullShaderBuilder(GrGLFullProgramBuilder* program);
+
+    GrGLFullProgramBuilder* fullProgramBuilder() { return fFullProgramBuilder; }
+protected:
+    GrGLFullProgramBuilder* fFullProgramBuilder;
+private:
+    typedef GrGLShaderBuilder INHERITED;
+};
 #endif