Make addUniform take a precision

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 27 matching lines @@
     virtual ~GrGLUniformBuilder() {}
 
     typedef GrGLProgramDataManager::UniformHandle UniformHandle;
 
     /** 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. */
-    virtual UniformHandle addUniform(uint32_t visibility,
-                                     GrSLType type,
-                                     const char* name,
-                                     const char** outName = NULL) = 0;
-    virtual UniformHandle addUniformArray(uint32_t visibility,
-                                          GrSLType type,
-                                          const char* name,
-                                          int arrayCount,
-                                          const char** outName = NULL) = 0;
+    UniformHandle addUniform(uint32_t visibility,
+                             GrSLType type,
+                             GrSLPrecision precision,
+                             const char* name,
+                             const char** outName = NULL) {
+        return this->addUniformArray(visibility, type, precision, name, 0, outName);
+    }
+
+    virtual UniformHandle addUniformArray(
+        uint32_t visibility,
+        GrSLType type,
+        GrSLPrecision precision,
+        const char* name,
+        int arrayCount,
+        const char** outName = NULL) = 0;
 
     virtual const GrGLShaderVar& getUniformVariable(UniformHandle u) const = 0;
 
     /**
      * Shortcut for getUniformVariable(u).c_str()
      */
     virtual const char* getUniformCStr(UniformHandle u) const = 0;
 
     virtual const GrGLContextInfo& ctxInfo() const = 0;
 
@@ skipping 114 matching lines @@
 public:
     /** Generates a shader program.
      *
      * The program implements what is specified in the stages given as input.
      * After successful generation, the builder result objects are available
      * to be used.
      * @return true if generation was successful.
      */
     static GrGLProgram* CreateProgram(const GrOptDrawState&, GrGpuGL*);
 
-    virtual UniformHandle addUniform(uint32_t visibility,
-                                     GrSLType type,
-                                     const char* name,
-                                     const char** outName = NULL) SK_OVERRIDE {
-        return this->addUniformArray(visibility, type, name, GrGLShaderVar::kNonArray, outName);
-    }
-    virtual UniformHandle addUniformArray(uint32_t visibility,
-                                          GrSLType type,
-                                          const char* name,
-                                          int arrayCount,
-                                          const char** outName = NULL) SK_OVERRIDE;
+    UniformHandle addUniformArray(uint32_t visibility,
+                                  GrSLType type,
+                                  GrSLPrecision precision,
+                                  const char* name,
+                                  int arrayCount,
+                                  const char** outName) SK_OVERRIDE;
 
-    virtual const GrGLShaderVar& getUniformVariable(UniformHandle u) const SK_OVERRIDE {
+    const GrGLShaderVar& getUniformVariable(UniformHandle u) const SK_OVERRIDE {
         return fUniforms[u.toShaderBuilderIndex()].fVariable;
     }
 
-    virtual const char* getUniformCStr(UniformHandle u) const SK_OVERRIDE {
+    const char* getUniformCStr(UniformHandle u) const SK_OVERRIDE {
         return this->getUniformVariable(u).c_str();
     }
 
-    virtual const GrGLContextInfo& ctxInfo() const SK_OVERRIDE;
+    const GrGLContextInfo& ctxInfo() const SK_OVERRIDE;
 
-    virtual GrGpuGL* gpu() const SK_OVERRIDE { return fGpu; }
+    GrGpuGL* gpu() const SK_OVERRIDE { return fGpu; }
 
-    virtual GrGLFPFragmentBuilder* getFragmentShaderBuilder() SK_OVERRIDE { return &fFS; }
-    virtual GrGLVertexBuilder* getVertexShaderBuilder() SK_OVERRIDE { return &fVS; }
+    GrGLFPFragmentBuilder* getFragmentShaderBuilder() SK_OVERRIDE { return &fFS; }
+    GrGLVertexBuilder* getVertexShaderBuilder() SK_OVERRIDE { return &fVS; }
 
-    virtual void addVarying(
+    void addVarying(
             const char* name,
             GrGLVarying*,
             GrSLPrecision fsPrecision = kDefault_GrSLPrecision) SK_OVERRIDE;
 
-    virtual void addPassThroughAttribute(const GrGeometryProcessor::GrAttribute*,
+    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;
 
@@ skipping 183 matching lines @@
     SkAutoTDelete<GrGLFragmentProcessor> fGLProc;
     SkSTArray<2, Transform, true>        fTransforms;
 };
 
 struct GrGLInstalledFragProcs : public SkRefCnt {
     virtual ~GrGLInstalledFragProcs();
     SkSTArray<8, GrGLInstalledFragProc*, true> fProcs;
 };
 
 #endif