Move shader precision modifier check onto GLSLCaps

src/gpu/gl/builders/GrGLShaderBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLShaderBuilder.h"
 #include "GrGLProgramBuilder.h"
 #include "GrGLShaderStringBuilder.h"
-#include "../GrGLGpu.h"
-#include "../GrGLShaderVar.h"
+#include "gl/GrGLCaps.h"
+#include "gl/GrGLContext.h"
+#include "gl/GrGLGpu.h"
+#include "gl/GrGLShaderVar.h"
 #include "glsl/GrGLSLCaps.h"
 
 namespace {
 void append_texture_lookup(SkString* out,
                            GrGLGpu* gpu,
                            const char* samplerName,
                            const char* coordName,
                            uint32_t configComponentMask,
                            const char* swizzle,
                            GrSLType varyingType = kVec2f_GrSLType) {
@@ skipping 37 matching lines @@
         fShaderStrings.push_back();
         fCompilerStrings.push_back(nullptr);
         fCompilerStringLengths.push_back(0);
     }
 
     this->main() = "void main() {";
 }
 
 void GrGLShaderBuilder::declAppend(const GrGLShaderVar& var) {
     SkString tempDecl;
-    var.appendDecl(fProgramBuilder->ctxInfo(), &tempDecl);
+    var.appendDecl(fProgramBuilder->glslCaps(), &tempDecl);
     this->codeAppendf("%s;", tempDecl.c_str());
 }
 
 void GrGLShaderBuilder::emitFunction(GrSLType returnType,
                                      const char* name,
                                      int argCnt,
                                      const GrGLShaderVar* args,
                                      const char* body,
                                      SkString* outName) {
     this->functions().append(GrGLSLTypeString(returnType));
     fProgramBuilder->nameVariable(outName, '\0', name);
     this->functions().appendf(" %s", outName->c_str());
     this->functions().append("(");
-    const GrGLContextInfo& ctxInfo = fProgramBuilder->gpu()->ctxInfo();
     for (int i = 0; i < argCnt; ++i) {
-        args[i].appendDecl(ctxInfo, &this->functions());
+        args[i].appendDecl(fProgramBuilder->glslCaps(), &this->functions());
         if (i < argCnt - 1) {
             this->functions().append(", ");
         }
     }
     this->functions().append(") {\n");
     this->functions().append(body);
     this->functions().append("}\n\n");
 }
 
 void GrGLShaderBuilder::appendTextureLookup(SkString* out,
@@ skipping 43 matching lines @@
 
 void GrGLShaderBuilder::addFeature(uint32_t featureBit, const char* extensionName) {
     if (!(featureBit & fFeaturesAddedMask)) {
         this->extensions().appendf("#extension %s: require\n", extensionName);
         fFeaturesAddedMask |= featureBit;
     }
 }
 
 void GrGLShaderBuilder::appendDecls(const VarArray& vars, SkString* out) const {
     for (int i = 0; i < vars.count(); ++i) {
-        vars[i].appendDecl(fProgramBuilder->ctxInfo(), out);
+        vars[i].appendDecl(fProgramBuilder->glslCaps(), out);
         out->append(";\n");
     }
 }
 
 void GrGLShaderBuilder::appendTextureLookup(const char* samplerName,
                                             const char* coordName,
                                             uint32_t configComponentMask,
                                             const char* swizzle) {
     append_texture_lookup(&this->code(),
                           fProgramBuilder->gpu(),
@@ skipping 54 matching lines @@
     fFinalized = true;
 
     if (!shaderId) {
         return false;
     }
 
     *shaderIds->append() = shaderId;
 
     return true;
 }