Move shader precision out of GrShaderVar

src/gpu/gl/GrGLCaps.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLCaps.h"
 
@@ skipping 758 matching lines @@
             fStencilFormats.push_back() = gD24S8;
         }
         if (ctxInfo.hasExtension("GL_OES_stencil4")) {
             fStencilFormats.push_back() = gS4;
         }
     }
     SkASSERT(0 == fStencilVerifiedColorConfigs.count());
     fStencilVerifiedColorConfigs.push_back_n(fStencilFormats.count());
 }
 
-static GrGLenum precision_to_gl_float_type(GrShaderVar::Precision p) {
+static GrGLenum precision_to_gl_float_type(GrSLPrecision p) {
     switch (p) {
-        case GrShaderVar::kLow_Precision:
+        case kLow_GrSLPrecision:
             return GR_GL_LOW_FLOAT;
-        case GrShaderVar::kMedium_Precision:
+        case kMedium_GrSLPrecision:
             return GR_GL_MEDIUM_FLOAT;
-        case GrShaderVar::kHigh_Precision:
+        case kHigh_GrSLPrecision:
             return GR_GL_HIGH_FLOAT;
     }
     SkFAIL("Unknown precision.");
     return -1;
 }
 
 static GrGLenum shader_type_to_gl_shader(GrShaderType type) {
     switch (type) {
         case kVertex_GrShaderType:
             return GR_GL_VERTEX_SHADER;
         case kGeometry_GrShaderType:
             return GR_GL_GEOMETRY_SHADER;
         case kFragment_GrShaderType:
             return GR_GL_FRAGMENT_SHADER;
     }
     SkFAIL("Unknown shader type.");
     return -1;
 }
 
 void GrGLCaps::initShaderPrecisionTable(const GrGLContextInfo& ctxInfo, const GrGLInterface* intf) {
     if (kGLES_GrGLStandard == ctxInfo.standard() || ctxInfo.version() >= GR_GL_VER(4,1) ||
         ctxInfo.hasExtension("GL_ARB_ES2_compatibility")) {
         for (int s = 0; s < kGrShaderTypeCount; ++s) {
             if (kGeometry_GrShaderType != s || fGeometryShaderSupport) {
                 GrShaderType shaderType = static_cast<GrShaderType>(s);
                 GrGLenum glShader = shader_type_to_gl_shader(shaderType);
                 PrecisionInfo* first = NULL;
                 fShaderPrecisionVaries = false;
-                for (int p = 0; p < GrShaderVar::kPrecisionCount; ++p) {
-                    GrShaderVar::Precision precision = static_cast<GrShaderVar::Precision>(p);
+                for (int p = 0; p < kGrSLPrecisionCount; ++p) {
+                    GrSLPrecision precision = static_cast<GrSLPrecision>(p);
                     GrGLenum glPrecision = precision_to_gl_float_type(precision);
                     GrGLint range[2];
                     GrGLint bits;
                     GR_GL_GetShaderPrecisionFormat(intf, glShader, glPrecision, range, &bits);
                     if (bits) {
                         fFloatPrecisions[s][p].fLogRangeLow = range[0];
                         fFloatPrecisions[s][p].fLogRangeHigh = range[1];
                         fFloatPrecisions[s][p].fBits = bits;
                         if (!first) {
                             first = &fFloatPrecisions[s][p];
                         } else if (!fShaderPrecisionVaries) {
                             fShaderPrecisionVaries = (*first != fFloatPrecisions[s][p]);
                         }
                     }
                 }
             }
         }
     } else {
         // We're on a desktop GL that doesn't have precision info. Assume they're all 32bit float.
         fShaderPrecisionVaries = false;
         for (int s = 0; s < kGrShaderTypeCount; ++s) {
             if (kGeometry_GrShaderType != s || fGeometryShaderSupport) {
-                for (int p = 0; p < GrShaderVar::kPrecisionCount; ++p) {
+                for (int p = 0; p < kGrSLPrecisionCount; ++p) {
                     fFloatPrecisions[s][p].fLogRangeLow = 127;
                     fFloatPrecisions[s][p].fLogRangeHigh = 127;
                     fFloatPrecisions[s][p].fBits = 23;
                 }
             }
         }
     }
 }
 
 
@@ skipping 120 matching lines @@
     r.appendf("Two Format Limit: %s\n", (fTwoFormatLimit ? "YES": "NO"));
     r.appendf("Fragment coord conventions support: %s\n",
              (fFragCoordsConventionSupport ? "YES": "NO"));
     r.appendf("Vertex array object support: %s\n", (fVertexArrayObjectSupport ? "YES": "NO"));
     r.appendf("Use non-VBO for dynamic data: %s\n",
              (fUseNonVBOVertexAndIndexDynamicData ? "YES" : "NO"));
     r.appendf("Full screen clear is free: %s\n", (fFullClearIsFree ? "YES" : "NO"));
     r.appendf("Drops tile on zero divide: %s\n", (fDropsTileOnZeroDivide ? "YES" : "NO"));
     return r;
 }