Draft change to start pulling uniform color into GP

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
 
@@ skipping 224 matching lines @@
             GrSLPrecision fsPrecision = kDefault_GrSLPrecision) SK_OVERRIDE;
 
     void addPassThroughAttribute(const GrGeometryProcessor::GrAttribute*,
                                          const char* output) SK_OVERRIDE;
 
 
     // Handles for program uniforms (other than per-effect uniforms)
     struct BuiltinUniformHandles {
         UniformHandle       fViewMatrixUni;
         UniformHandle       fRTAdjustmentUni;
-        UniformHandle       fColorUni;
-        UniformHandle       fCoverageUni;
 
         // We use the render target height to provide a y-down frag coord when specifying
         // origin_upper_left is not supported.
         UniformHandle       fRTHeightUni;
 
         // Uniforms for computing texture coords to do the dst-copy lookup
         UniformHandle       fDstCopyTopLeftUni;
         UniformHandle       fDstCopyScaleUni;
         UniformHandle       fDstCopySamplerUni;
     };
 
 protected:
     typedef GrGLProgramDataManager::UniformInfo UniformInfo;
     typedef GrGLProgramDataManager::UniformInfoArray UniformInfoArray;
 
     static GrGLProgramBuilder* CreateProgramBuilder(const GrOptDrawState&,
                                                     bool hasGeometryProcessor,
                                                     GrGpuGL*);
 
     GrGLProgramBuilder(GrGpuGL*, const GrOptDrawState&);
 
     const GrOptDrawState& optState() const { return fOptState; }
     const GrProgramDesc& desc() const { return fDesc; }
     const GrProgramDesc::KeyHeader& header() const { return fDesc.header(); }
 
     // 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
     // generating stage code.
     void nameVariable(SkString* out, char prefix, const char* name);
-    void setupUniformColorAndCoverageIfNeeded(GrGLSLExpr4* inputColor, GrGLSLExpr1* inputCoverage);
     // 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);
     void emitAndInstallProcs(GrGLSLExpr4* inputColor,
                              GrGLSLExpr4* inputCoverage);
     void emitAndInstallFragProcs(int procOffset, int numProcs, GrGLSLExpr4* inOut);
     void emitAndInstallProc(const GrPendingFragmentStage&,
                             int index,
                             const GrGLSLExpr4& input,
                             GrGLSLExpr4* output);
 
-    void emitAndInstallProc(const GrGeometryProcessor&,
+    void emitAndInstallProc(const GrPrimitiveProcessor&,
                             GrGLSLExpr4* outputColor,
                             GrGLSLExpr4* outputCoverage);
 
     // these emit functions help to keep the createAndEmitProcessors template general
     void emitAndInstallProc(const GrPendingFragmentStage&,
                             const char* outColor,
                             const char* inColor);
-    void emitAndInstallProc(const GrGeometryProcessor&,
+    void emitAndInstallProc(const GrPrimitiveProcessor&,
                             const char* outColor,
                             const char* outCoverage);
     void emitAndInstallXferProc(const GrXferProcessor&,
                                 const GrGLSLExpr4& colorIn,
                                 const GrGLSLExpr4& coverageIn);
 
-    void verify(const GrGeometryProcessor&);
+    void verify(const GrPrimitiveProcessor&);
     void verify(const GrXferProcessor&);
     void verify(const GrFragmentProcessor&);
     void emitSamplers(const GrProcessor&,
                       GrGLProcessor::TextureSamplerArray* outSamplers,
                       GrGLInstalledProc*);
 
     // each specific program builder has a distinct transform and must override this function
     virtual void emitTransforms(const GrPendingFragmentStage&,
                                 GrGLProcessor::TransformedCoordsArray* outCoords,
                                 GrGLInstalledFragProc*);
@@ skipping 126 matching lines @@
     SkAutoTDelete<GrGLFragmentProcessor> fGLProc;
     SkSTArray<2, Transform, true>        fTransforms;
 };
 
 struct GrGLInstalledFragProcs : public SkRefCnt {
     virtual ~GrGLInstalledFragProcs();
     SkSTArray<8, GrGLInstalledFragProc*, true> fProcs;
 };
 
 #endif