cc: Use highp precision for texture coordinates if available

cc/shader.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/shader.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "cc/gl_renderer.h" // For the GLC() macro.
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
+#include "third_party/khronos/GLES2/gl2.h"
 
 #define SHADER0(Src) #Src
-#define SHADER(Src) SHADER0(Src)
+#define VERTEX_SHADER(Src) setVertexTexCoordPrecision(context, SHADER0(Src))
+#define FRAGMENT_SHADER(Src) setFragTexCoordPrecision(context, SHADER0(Src))
 
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
 namespace {
 
 static void getProgramUniformLocations(WebGraphicsContext3D* context, unsigned program, const char** shaderUniforms, size_t count, size_t maxLocations, int* locations, bool usingBindUniform, int* baseUniformIndex)
 {
     for (size_t uniformIndex = 0; uniformIndex < count; uniformIndex ++) {
         DCHECK(uniformIndex < maxLocations);
 
         if (usingBindUniform) {
             locations[uniformIndex] = (*baseUniformIndex)++;
             context->bindUniformLocationCHROMIUM(program, locations[uniformIndex], shaderUniforms[uniformIndex]);
         } else
             locations[uniformIndex] = context->getUniformLocation(program, shaderUniforms[uniformIndex]);
     }
 }
 
+static std::string setFragTexCoordPrecision(WebGraphicsContext3D* context,
+                                            const char* shaderString)
+{
+    // TexCoordPrecisionHigh is used for cases where we absolutely need high
+    // precision or where the texture coordinates are not mutated in the
+    // fragment shader.
+    // Some cases that benefit from high precision are:
+    //   * Sampling from textures with width or height > 1024.
+    //   * Linear filtering of scaled textures.
+    // texCoordPrecisionMedium is used for cases where we don't need the high
+    // precision and can use a lower precision to improve performance.
+
+    return "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
+           "  #define TexCoordPrecisionHigh highp\n"
+           "#else\n"
+           "  #define TexCoordPrecisionHigh mediump\n"
+           "#endif\n"
+           "#define TexCoordPrecisionMedium mediump\n" +
+           std::string(shaderString);
+}
+
+static std::string setVertexTexCoordPrecision(WebGraphicsContext3D* context,
+                                              const char* shaderString)
+{
+    return "#define TexCoordPrecisionHigh highp\n" +
+           std::string(shaderString);
+}
+
 }
 
 VertexShaderPosTex::VertexShaderPosTex()
     : m_matrixLocation(-1)
 {
 }
 
 void VertexShaderPosTex::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 {
     static const char* shaderUniforms[] = {
         "matrix",
     };
     int locations[1];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_matrixLocation = locations[0];
     DCHECK(m_matrixLocation != -1);
 }
 
-std::string VertexShaderPosTex::getShaderString() const
+std::string VertexShaderPosTex::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return VERTEX_SHADER(
         attribute vec4 a_position;
-        attribute vec2 a_texCoord;
+        attribute TexCoordPrecisionHigh vec2 a_texCoord;
         uniform mat4 matrix;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         void main()
         {
             gl_Position = matrix * a_position;
             v_texCoord = a_texCoord;
         }
     );
 }
 
 VertexShaderPosTexYUVStretch::VertexShaderPosTexYUVStretch()
     : m_matrixLocation(-1)
     , m_texScaleLocation(-1)
 {
 }
 
 void VertexShaderPosTexYUVStretch::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 {
     static const char* shaderUniforms[] = {
         "matrix",
         "texScale",
     };
     int locations[2];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_matrixLocation = locations[0];
     m_texScaleLocation = locations[1];
     DCHECK(m_matrixLocation != -1 && m_texScaleLocation != -1);
 }
 
-std::string VertexShaderPosTexYUVStretch::getShaderString() const
+std::string VertexShaderPosTexYUVStretch::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return VERTEX_SHADER(
         precision mediump float;
         attribute vec4 a_position;
-        attribute vec2 a_texCoord;
+        attribute TexCoordPrecisionHigh vec2 a_texCoord;
         uniform mat4 matrix;
-        varying vec2 v_texCoord;
-        uniform vec2 texScale;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
+        uniform TexCoordPrecisionHigh vec2 texScale;
         void main()
         {
             gl_Position = matrix * a_position;
             v_texCoord = a_texCoord * texScale;
         }
     );
 }
 
 VertexShaderPos::VertexShaderPos()
     : m_matrixLocation(-1)
 {
 }
 
 void VertexShaderPos::init(WebGraphicsContext3D* context, unsigned program, bool usingBindUniform, int* baseUniformIndex)
 {
     static const char* shaderUniforms[] = {
         "matrix",
     };
     int locations[1];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_matrixLocation = locations[0];
     DCHECK(m_matrixLocation != -1);
 }
 
-std::string VertexShaderPos::getShaderString() const
+std::string VertexShaderPos::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return VERTEX_SHADER(
         attribute vec4 a_position;
         uniform mat4 matrix;
         void main()
         {
             gl_Position = matrix * a_position;
         }
     );
 }
 
 VertexShaderPosTexTransform::VertexShaderPosTexTransform()
@@ skipping 13 matching lines @@
     int locations[3];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_matrixLocation = locations[0];
     m_texTransformLocation = locations[1];
     m_vertexOpacityLocation = locations[2];
     DCHECK(m_matrixLocation != -1 && m_texTransformLocation != -1 && m_vertexOpacityLocation != -1);
 }
 
-std::string VertexShaderPosTexTransform::getShaderString() const
+std::string VertexShaderPosTexTransform::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return VERTEX_SHADER(
         attribute vec4 a_position;
-        attribute vec2 a_texCoord;
+        attribute TexCoordPrecisionHigh vec2 a_texCoord;
         attribute float a_index;
         uniform mat4 matrix[8];
-        uniform vec4 texTransform[8];
+        uniform TexCoordPrecisionHigh vec4 texTransform[8];
         uniform float opacity[32];
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         varying float v_alpha;
         void main()
         {
             gl_Position = matrix[int(a_index * 0.25)] * a_position;
-            vec4 texTrans = texTransform[int(a_index * 0.25)];
+            TexCoordPrecisionHigh vec4 texTrans = texTransform[int(a_index * 0.25)];
             v_texCoord = a_texCoord * texTrans.zw + texTrans.xy;
             v_alpha = opacity[int(a_index)];
         }
     );
 }
 
-std::string VertexShaderPosTexTransformFlip::getShaderString() const
+std::string VertexShaderPosTexTransformFlip::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return VERTEX_SHADER(
         attribute vec4 a_position;
-        attribute vec2 a_texCoord;
+        attribute TexCoordPrecisionHigh vec2 a_texCoord;
         attribute float a_index;
         uniform mat4 matrix[8];
-        uniform vec4 texTransform[8];
+        uniform TexCoordPrecisionHigh vec4 texTransform[8];
         uniform float opacity[32];
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         varying float v_alpha;
         void main()
         {
             gl_Position = matrix[int(a_index * 0.25)] * a_position;
-            vec4 texTrans = texTransform[int(a_index * 0.25)];
+            TexCoordPrecisionHigh vec4 texTrans = texTransform[int(a_index * 0.25)];
             v_texCoord = a_texCoord * texTrans.zw + texTrans.xy;
             v_texCoord.y = 1.0 - v_texCoord.y;
             v_alpha = opacity[int(a_index)];
         }
     );
 }
 
-std::string VertexShaderPosTexIdentity::getShaderString() const
+std::string VertexShaderPosTexIdentity::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return VERTEX_SHADER(
         attribute vec4 a_position;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         void main()
         {
             gl_Position = a_position;
             v_texCoord = (a_position.xy + vec2(1.0)) * 0.5;
         }
     );
 }
 
 VertexShaderQuad::VertexShaderQuad()
     : m_matrixLocation(-1)
@@ skipping 14 matching lines @@
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_matrixLocation = locations[0];
     m_pointLocation = locations[1];
     m_texScaleLocation = locations[2];
     DCHECK_NE(m_matrixLocation, -1);
     DCHECK_NE(m_pointLocation, -1);
     DCHECK_NE(m_texScaleLocation, -1);
 }
 
-std::string VertexShaderQuad::getShaderString() const
+std::string VertexShaderQuad::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
-        attribute vec4 a_position;
-        attribute vec2 a_texCoord;
+    return VERTEX_SHADER(
+        attribute TexCoordPrecisionHigh vec4 a_position;
+        attribute TexCoordPrecisionHigh vec2 a_texCoord;
         uniform mat4 matrix;
-        uniform vec2 point[4];
-        uniform vec2 texScale;
-        varying vec2 v_texCoord;
+        uniform TexCoordPrecisionHigh vec2 point[4];
+        uniform TexCoordPrecisionHigh vec2 texScale;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         void main()
         {
-            vec2 complement = abs(a_texCoord - 1.0);
-            vec4 pos = vec4(0.0, 0.0, a_position.z, a_position.w);
+            TexCoordPrecisionHigh vec2 complement = abs(a_texCoord - 1.0);
+            TexCoordPrecisionHigh vec4 pos = vec4(0.0, 0.0, a_position.z, a_position.w);
             pos.xy += (complement.x * complement.y) * point[0];
             pos.xy += (a_texCoord.x * complement.y) * point[1];
             pos.xy += (a_texCoord.x * a_texCoord.y) * point[2];
             pos.xy += (complement.x * a_texCoord.y) * point[3];
             gl_Position = matrix * pos;
             v_texCoord = (pos.xy + vec2(0.5)) * texScale;
         }
     );
 }
 
@@ skipping 14 matching lines @@
     int locations[3];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_matrixLocation = locations[0];
     m_pointLocation = locations[1];
     m_vertexTexTransformLocation = locations[2];
     DCHECK(m_matrixLocation != -1 && m_pointLocation != -1 && m_vertexTexTransformLocation != -1);
 }
 
-std::string VertexShaderTile::getShaderString() const
+std::string VertexShaderTile::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
-        attribute vec4 a_position;
-        attribute vec2 a_texCoord;
+    return VERTEX_SHADER(
+        attribute TexCoordPrecisionHigh vec4 a_position;
+        attribute TexCoordPrecisionHigh vec2 a_texCoord;
         uniform mat4 matrix;
-        uniform vec2 point[4];
-        uniform vec4 vertexTexTransform;
-        varying vec2 v_texCoord;
+        uniform TexCoordPrecisionHigh vec2 point[4];
+        uniform TexCoordPrecisionHigh vec4 vertexTexTransform;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         void main()
         {
             vec2 complement = abs(a_texCoord - 1.0);
             vec4 pos = vec4(0.0, 0.0, a_position.z, a_position.w);
             pos.xy += (complement.x * complement.y) * point[0];
             pos.xy += (a_texCoord.x * complement.y) * point[1];
             pos.xy += (a_texCoord.x * a_texCoord.y) * point[2];
             pos.xy += (complement.x * a_texCoord.y) * point[3];
             gl_Position = matrix * pos;
             v_texCoord = pos.xy * vertexTexTransform.zw + vertexTexTransform.xy;
@@ skipping 15 matching lines @@
     };
     int locations[2];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_matrixLocation = locations[0];
     m_texMatrixLocation = locations[1];
     return m_matrixLocation != -1 && m_texMatrixLocation != -1;
 }
 
-std::string VertexShaderVideoTransform::getShaderString() const
+std::string VertexShaderVideoTransform::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return VERTEX_SHADER(
         attribute vec4 a_position;
-        attribute vec2 a_texCoord;
+        attribute TexCoordPrecisionHigh vec2 a_texCoord;
         uniform mat4 matrix;
-        uniform mat4 texMatrix;
-        varying vec2 v_texCoord;
+        uniform TexCoordPrecisionHigh mat4 texMatrix;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         void main()
         {
             gl_Position = matrix * a_position;
             v_texCoord = vec2(texMatrix * vec4(a_texCoord.x, 1.0 - a_texCoord.y, 0.0, 1.0));
         }
     );
 }
 
 FragmentTexAlphaBinding::FragmentTexAlphaBinding()
     : m_samplerLocation(-1)
@@ skipping 40 matching lines @@
         "s_texture",
     };
     int locations[1];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_samplerLocation = locations[0];
     return m_samplerLocation != -1;
 }
 
-std::string FragmentShaderOESImageExternal::getShaderString() const
+std::string FragmentShaderOESImageExternal::getShaderString(WebGraphicsContext3D* context) const
 {
-    // Cannot use the SHADER() macro because of the '#' char
-    return "#extension GL_OES_EGL_image_external : require \n"
+    // Cannot use the FRAGMENT_SHADER() macro because of the '#' char
+    return setFragTexCoordPrecision(context,
+           "#extension GL_OES_EGL_image_external : require \n"
            "precision mediump float;\n"
-           "varying vec2 v_texCoord;\n"
+           "varying TexCoordPrecisionHigh vec2 v_texCoord;\n"
            "uniform samplerExternalOES s_texture;\n"
            "void main()\n"
            "{\n"
            "    vec4 texColor = texture2D(s_texture, v_texCoord);\n"
            "    gl_FragColor = vec4(texColor.x, texColor.y, texColor.z, texColor.w);\n"
-           "}\n";
+           "}\n");
 }
 
-std::string FragmentShaderRGBATexAlpha::getShaderString() const
+std::string FragmentShaderRGBATexAlpha::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
             gl_FragColor = texColor * alpha;
         }
     );
 }
 
-std::string FragmentShaderRGBATexVaryingAlpha::getShaderString() const
+std::string FragmentShaderRGBATexVaryingAlpha::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         varying float v_alpha;
         uniform sampler2D s_texture;
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
             gl_FragColor = texColor * v_alpha;
         }
     );
 }
 
-std::string FragmentShaderRGBATexRectVaryingAlpha::getShaderString() const
+std::string FragmentShaderRGBATexRectVaryingAlpha::getShaderString(WebGraphicsContext3D* context) const
 {
-    return "#extension GL_ARB_texture_rectangle : require\n"
+    return setFragTexCoordPrecision(context,
+            "#extension GL_ARB_texture_rectangle : require\n"
             "precision mediump float;\n"
-            "varying vec2 v_texCoord;\n"
+            "varying TexCoordPrecisionHigh vec2 v_texCoord;\n"
             "varying float v_alpha;\n"
             "uniform sampler2DRect s_texture;\n"
             "void main()\n"
             "{\n"
             "    vec4 texColor = texture2DRect(s_texture, v_texCoord);\n"
             "    gl_FragColor = texColor * v_alpha;\n"
-            "}\n";
+            "}\n");
 }
 
-std::string FragmentShaderRGBATexOpaque::getShaderString() const
+std::string FragmentShaderRGBATexOpaque::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         uniform sampler2D s_texture;
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
             gl_FragColor = vec4(texColor.rgb, 1.0);
         }
     );
 }
 
-std::string FragmentShaderRGBATex::getShaderString() const
+std::string FragmentShaderRGBATex::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         uniform sampler2D s_texture;
         void main()
         {
             gl_FragColor = texture2D(s_texture, v_texCoord);
         }
     );
 }
 
-std::string FragmentShaderRGBATexSwizzleAlpha::getShaderString() const
+std::string FragmentShaderRGBATexSwizzleAlpha::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
             gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, texColor.w) * alpha;
         }
     );
 }
 
-std::string FragmentShaderRGBATexSwizzleOpaque::getShaderString() const
+std::string FragmentShaderRGBATexSwizzleOpaque::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         uniform sampler2D s_texture;
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
             gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, 1.0);
         }
     );
 }
 
 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
@@ skipping 13 matching lines @@
     int locations[3];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_samplerLocation = locations[0];
     m_alphaLocation = locations[1];
     m_edgeLocation = locations[2];
     DCHECK(m_samplerLocation != -1 && m_alphaLocation != -1 && m_edgeLocation != -1);
 }
 
-std::string FragmentShaderRGBATexAlphaAA::getShaderString() const
+std::string FragmentShaderRGBATexAlphaAA::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
         uniform vec3 edge[8];
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
             vec3 pos = vec3(gl_FragCoord.xy, 1);
             float a0 = clamp(dot(edge[0], pos), 0.0, 1.0);
             float a1 = clamp(dot(edge[1], pos), 0.0, 1.0);
             float a2 = clamp(dot(edge[2], pos), 0.0, 1.0);
@@ skipping 27 matching lines @@
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_samplerLocation = locations[0];
     m_alphaLocation = locations[1];
     m_fragmentTexTransformLocation = locations[2];
     m_edgeLocation = locations[3];
     DCHECK(m_samplerLocation != -1 && m_alphaLocation != -1 && m_fragmentTexTransformLocation != -1 && m_edgeLocation != -1);
 }
 
-std::string FragmentShaderRGBATexClampAlphaAA::getShaderString() const
+std::string FragmentShaderRGBATexClampAlphaAA::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionMedium vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
-        uniform vec4 fragmentTexTransform;
+        uniform TexCoordPrecisionMedium vec4 fragmentTexTransform;
         uniform vec3 edge[8];
         void main()
         {
-            vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw + fragmentTexTransform.xy;
+            TexCoordPrecisionMedium vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw + fragmentTexTransform.xy;
             vec4 texColor = texture2D(s_texture, texCoord);
             vec3 pos = vec3(gl_FragCoord.xy, 1);
             float a0 = clamp(dot(edge[0], pos), 0.0, 1.0);
             float a1 = clamp(dot(edge[1], pos), 0.0, 1.0);
             float a2 = clamp(dot(edge[2], pos), 0.0, 1.0);
             float a3 = clamp(dot(edge[3], pos), 0.0, 1.0);
             float a4 = clamp(dot(edge[4], pos), 0.0, 1.0);
             float a5 = clamp(dot(edge[5], pos), 0.0, 1.0);
             float a6 = clamp(dot(edge[6], pos), 0.0, 1.0);
             float a7 = clamp(dot(edge[7], pos), 0.0, 1.0);
             gl_FragColor = texColor * alpha * min(min(a0, a2) * min(a1, a3), min(a4, a6) * min(a5, a7));
         }
     );
 }
 
-std::string FragmentShaderRGBATexClampSwizzleAlphaAA::getShaderString() const
+std::string FragmentShaderRGBATexClampSwizzleAlphaAA::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionMedium vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
-        uniform vec4 fragmentTexTransform;
+        uniform TexCoordPrecisionMedium vec4 fragmentTexTransform;
         uniform vec3 edge[8];
         void main()
         {
-            vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw + fragmentTexTransform.xy;
+            TexCoordPrecisionMedium vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw + fragmentTexTransform.xy;
             vec4 texColor = texture2D(s_texture, texCoord);
             vec3 pos = vec3(gl_FragCoord.xy, 1);
             float a0 = clamp(dot(edge[0], pos), 0.0, 1.0);
             float a1 = clamp(dot(edge[1], pos), 0.0, 1.0);
             float a2 = clamp(dot(edge[2], pos), 0.0, 1.0);
             float a3 = clamp(dot(edge[3], pos), 0.0, 1.0);
             float a4 = clamp(dot(edge[4], pos), 0.0, 1.0);
             float a5 = clamp(dot(edge[5], pos), 0.0, 1.0);
             float a6 = clamp(dot(edge[6], pos), 0.0, 1.0);
             float a7 = clamp(dot(edge[7], pos), 0.0, 1.0);
@@ skipping 24 matching lines @@
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_samplerLocation = locations[0];
     m_maskSamplerLocation = locations[1];
     m_alphaLocation = locations[2];
     m_maskTexCoordScaleLocation = locations[3];
     m_maskTexCoordOffsetLocation = locations[4];
     DCHECK(m_samplerLocation != -1 && m_maskSamplerLocation != -1 && m_alphaLocation != -1);
 }
 
-std::string FragmentShaderRGBATexAlphaMask::getShaderString() const
+std::string FragmentShaderRGBATexAlphaMask::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionMedium vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform sampler2D s_mask;
-        uniform vec2 maskTexCoordScale;
-        uniform vec2 maskTexCoordOffset;
+        uniform TexCoordPrecisionMedium vec2 maskTexCoordScale;
+        uniform TexCoordPrecisionMedium vec2 maskTexCoordOffset;
         uniform float alpha;
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
-            vec2 maskTexCoord = vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x, maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
+            TexCoordPrecision vec2 maskTexCoord = vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x, maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
             vec4 maskColor = texture2D(s_mask, maskTexCoord);
             gl_FragColor = vec4(texColor.x, texColor.y, texColor.z, texColor.w) * alpha * maskColor.w;
         }
     );
 }
 
 FragmentShaderRGBATexAlphaMaskAA::FragmentShaderRGBATexAlphaMaskAA()
     : m_samplerLocation(-1)
     , m_maskSamplerLocation(-1)
     , m_alphaLocation(-1)
@@ skipping 18 matching lines @@
 
     m_samplerLocation = locations[0];
     m_maskSamplerLocation = locations[1];
     m_alphaLocation = locations[2];
     m_edgeLocation = locations[3];
     m_maskTexCoordScaleLocation = locations[4];
     m_maskTexCoordOffsetLocation = locations[5];
     DCHECK(m_samplerLocation != -1 && m_maskSamplerLocation != -1 && m_alphaLocation != -1 && m_edgeLocation != -1);
 }
 
-std::string FragmentShaderRGBATexAlphaMaskAA::getShaderString() const
+std::string FragmentShaderRGBATexAlphaMaskAA::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionMedium vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform sampler2D s_mask;
-        uniform vec2 maskTexCoordScale;
-        uniform vec2 maskTexCoordOffset;
+        uniform TexCoordPrecisionMedium vec2 maskTexCoordScale;
+        uniform TexCoordPrecisionMedium vec2 maskTexCoordOffset;
         uniform float alpha;
         uniform vec3 edge[8];
         void main()
         {
             vec4 texColor = texture2D(s_texture, v_texCoord);
-            vec2 maskTexCoord = vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x, maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
+            TexCoordPrecisionMedium vec2 maskTexCoord = vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x, maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
             vec4 maskColor = texture2D(s_mask, maskTexCoord);
             vec3 pos = vec3(gl_FragCoord.xy, 1);
             float a0 = clamp(dot(edge[0], pos), 0.0, 1.0);
             float a1 = clamp(dot(edge[1], pos), 0.0, 1.0);
             float a2 = clamp(dot(edge[2], pos), 0.0, 1.0);
             float a3 = clamp(dot(edge[3], pos), 0.0, 1.0);
             float a4 = clamp(dot(edge[4], pos), 0.0, 1.0);
             float a5 = clamp(dot(edge[5], pos), 0.0, 1.0);
             float a6 = clamp(dot(edge[6], pos), 0.0, 1.0);
             float a7 = clamp(dot(edge[7], pos), 0.0, 1.0);
@@ skipping 30 matching lines @@
     m_uTextureLocation = locations[1];
     m_vTextureLocation = locations[2];
     m_alphaLocation = locations[3];
     m_yuvMatrixLocation = locations[4];
     m_yuvAdjLocation = locations[5];
 
     DCHECK(m_yTextureLocation != -1 && m_uTextureLocation != -1 && m_vTextureLocation != -1
            && m_alphaLocation != -1 && m_yuvMatrixLocation != -1 && m_yuvAdjLocation != -1);
 }
 
-std::string FragmentShaderYUVVideo::getShaderString() const
+std::string FragmentShaderYUVVideo::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
         precision mediump int;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionHigh vec2 v_texCoord;
         uniform sampler2D y_texture;
         uniform sampler2D u_texture;
         uniform sampler2D v_texture;
         uniform float alpha;
         uniform vec3 yuv_adj;
         uniform mat3 yuv_matrix;
         void main()
         {
             float y_raw = texture2D(y_texture, v_texCoord).x;
             float u_unsigned = texture2D(u_texture, v_texCoord).x;
@@ skipping 16 matching lines @@
         "color",
     };
     int locations[1];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_colorLocation = locations[0];
     DCHECK(m_colorLocation != -1);
 }
 
-std::string FragmentShaderColor::getShaderString() const
+std::string FragmentShaderColor::getShaderString(WebGraphicsContext3D* context) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
         uniform vec4 color;
         void main()
         {
             gl_FragColor = color;
         }
     );
 }
 
 FragmentShaderCheckerboard::FragmentShaderCheckerboard()
@@ skipping 15 matching lines @@
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_alphaLocation = locations[0];
     m_texTransformLocation = locations[1];
     m_frequencyLocation = locations[2];
     m_colorLocation = locations[3];
     DCHECK(m_alphaLocation != -1 && m_texTransformLocation != -1 && m_frequencyLocation != -1 && m_colorLocation != -1);
 }
 
-std::string FragmentShaderCheckerboard::getShaderString() const
+std::string FragmentShaderCheckerboard::getShaderString(WebGraphicsContext3D* context) const
 {
     // Shader based on Example 13-17 of "OpenGL ES 2.0 Programming Guide"
     // by Munshi, Ginsburg, Shreiner.
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
         precision mediump int;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecisionMedium vec2 v_texCoord;
         uniform float alpha;
         uniform float frequency;
         uniform vec4 texTransform;
         uniform vec4 color;
         void main()
         {
             vec4 color1 = vec4(1.0, 1.0, 1.0, 1.0);
             vec4 color2 = color;
-            vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * texTransform.zw + texTransform.xy;
+            TexCoordPrecisionMedium vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * texTransform.zw + texTransform.xy;
             vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
             float picker = abs(coord.x - coord.y);
             gl_FragColor = mix(color1, color2, picker) * alpha;
         }
     );
 }
 
 }  // namespace cc