cc: Use highp precision for texture coords if available and needed

cc/output/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/output/shader.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "cc/output/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, precision, 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,
+                                            TexCoordPrecision requestedPrecision,
+                                            const char* shaderString)
+{
+    if (requestedPrecision == TexCoordPrecisionHigh) {

[vangelis, 2013/03/20 19:20:44]

The context is no longer needed here, is it? 

[brianderson, 2013/03/20 20:57:15]

Context is no longer needed. Will remove it.

+        return "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
+               "  #define TexCoordPrecision highp\n"
+               "#else\n"
+               "  #define TexCoordPrecision mediump\n"
+               "#endif\n"+
+               std::string(shaderString);
+    } else {
+        return "#define TexCoordPrecision mediump\n" +
+               std::string(shaderString);
+    }
+}
+
+static std::string setVertexTexCoordPrecision(WebGraphicsContext3D* context,
+                                              const char* shaderString)
+{
+    return "#define TexCoordPrecision highp\n" +

[vangelis, 2013/03/20 19:20:44]

Not sure I understand why for the vertex shaders we blindly use highp but for
fragment shader we're passing the precision in as an argument.

[brianderson, 2013/03/20 20:57:15]

My thinking was that we're not likely to be vertex shader bound and should just
use highp blindly to avoid any unexpected corner cases. Some of the vertex
shaders use math that can reduce the final effective precision.

+           std::string(shaderString);
+}
+
 }
 
+TexCoordPrecision TexCoordPrecisionRequired(const gfx::Point &max_coordinate)
+{
+    if (max_coordinate.x() > 1024 || max_coordinate.y() > 1024)

[aelias_OOO_until_Jul13, 2013/03/20 19:55:01]

1280 is a common height on mid-end phones like the Galaxy Nexus so this
threshold would activate highp on their fbo copy.  My understanding is really
want highp for very high resolutions like 2560, so could we bump it up to 2048?

[brianderson, 2013/03/20 20:57:15]

mediump is only guaranteed to provide 10 bits of precision, so we can represent
exact integer coordinates up to 2^10 = 1024.  Beyond that, an FBO copy will not
be perfect with mediump precision.

Are we even doing large FBO copies in the common case at ToT? We were not able
to reproduce the same mediump corruption at ToT as we were with the M18 branch,
(presumably because a large copy had been removed). Also, at ToT, the
SurfaceFlinger dump seems to indicate that the Renderer's output gets its own
overlay.

+        return TexCoordPrecisionHigh;
+    return TexCoordPrecisionMedium;
+}
+
 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 TexCoordPrecision vec2 a_texCoord;
         uniform mat4 matrix;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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 TexCoordPrecision vec2 a_texCoord;
         uniform mat4 matrix;
-        varying vec2 v_texCoord;
-        uniform vec2 texScale;
+        varying TexCoordPrecision vec2 v_texCoord;
+        uniform TexCoordPrecision 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 TexCoordPrecision vec2 a_texCoord;
         attribute float a_index;
         uniform mat4 matrix[8];
-        uniform vec4 texTransform[8];
+        uniform TexCoordPrecision vec4 texTransform[8];
         uniform float opacity[32];
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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)];
+            TexCoordPrecision 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 TexCoordPrecision vec2 a_texCoord;
         attribute float a_index;
         uniform mat4 matrix[8];
-        uniform vec4 texTransform[8];
+        uniform TexCoordPrecision vec4 texTransform[8];
         uniform float opacity[32];
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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)];
+            TexCoordPrecision 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 TexCoordPrecision 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 TexCoordPrecision vec4 a_position;
+        attribute TexCoordPrecision vec2 a_texCoord;
         uniform mat4 matrix;
-        uniform vec2 point[4];
-        uniform vec2 texScale;
-        varying vec2 v_texCoord;
+        uniform TexCoordPrecision vec2 point[4];
+        uniform TexCoordPrecision vec2 texScale;
+        varying TexCoordPrecision 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);
+            TexCoordPrecision vec2 complement = abs(a_texCoord - 1.0);
+            TexCoordPrecision 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 TexCoordPrecision vec4 a_position;
+        attribute TexCoordPrecision vec2 a_texCoord;
         uniform mat4 matrix;
-        uniform vec2 point[4];
-        uniform vec4 vertexTexTransform;
-        varying vec2 v_texCoord;
+        uniform TexCoordPrecision vec2 point[4];
+        uniform TexCoordPrecision vec4 vertexTexTransform;
+        varying TexCoordPrecision 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 TexCoordPrecision vec2 a_texCoord;
         uniform mat4 matrix;
-        uniform mat4 texMatrix;
-        varying vec2 v_texCoord;
+        uniform TexCoordPrecision mat4 texMatrix;
+        varying TexCoordPrecision 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,
+                                                            TexCoordPrecision precision) 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, precision,
+           "#extension GL_OES_EGL_image_external : require \n"
            "precision mediump float;\n"
-           "varying vec2 v_texCoord;\n"
+           "varying TexCoordPrecision 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,
+                                                        TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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,
+                                                               TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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,
+                                                                   TexCoordPrecision precision) const
 {
-    return "#extension GL_ARB_texture_rectangle : require\n"
+    return setFragTexCoordPrecision(context, precision,
+            "#extension GL_ARB_texture_rectangle : require\n"
             "precision mediump float;\n"
-            "varying vec2 v_texCoord;\n"
+            "varying TexCoordPrecision 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,
+                                                         TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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,
+                                                   TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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,
+                                                               TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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,
+                                                                TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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,
+                                                          TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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,
+                                                               TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
-        uniform vec4 fragmentTexTransform;
+        uniform TexCoordPrecision vec4 fragmentTexTransform;
         uniform vec3 edge[8];
         void main()
         {
-            vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw + fragmentTexTransform.xy;
+            TexCoordPrecision 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,
+                                                                      TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform float alpha;
-        uniform vec4 fragmentTexTransform;
+        uniform TexCoordPrecision vec4 fragmentTexTransform;
         uniform vec3 edge[8];
         void main()
         {
-            vec2 texCoord = clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw + fragmentTexTransform.xy;
+            TexCoordPrecision 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,
+                                                            TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform sampler2D s_mask;
-        uniform vec2 maskTexCoordScale;
-        uniform vec2 maskTexCoordOffset;
+        uniform TexCoordPrecision vec2 maskTexCoordScale;
+        uniform TexCoordPrecision 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,
+                                                              TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision vec2 v_texCoord;
         uniform sampler2D s_texture;
         uniform sampler2D s_mask;
-        uniform vec2 maskTexCoordScale;
-        uniform vec2 maskTexCoordOffset;
+        uniform TexCoordPrecision vec2 maskTexCoordScale;
+        uniform TexCoordPrecision 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);
+            TexCoordPrecision 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,
+                                                    TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
         precision mediump int;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision 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,
+                                                 TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
         uniform vec4 color;
         void main()
         {
             gl_FragColor = color;
         }
     );
 }
 
 FragmentShaderColorAA::FragmentShaderColorAA()
@@ skipping 10 matching lines @@
     };
     int locations[2];
 
     getProgramUniformLocations(context, program, shaderUniforms, arraysize(shaderUniforms), arraysize(locations), locations, usingBindUniform, baseUniformIndex);
 
     m_edgeLocation = locations[0];
     m_colorLocation = locations[1];
     DCHECK(m_edgeLocation != -1 && m_colorLocation != -1);
 }
 
-std::string FragmentShaderColorAA::getShaderString() const
+std::string FragmentShaderColorAA::getShaderString(WebGraphicsContext3D* context,
+                                                   TexCoordPrecision precision) const
 {
-    return SHADER(
+    return FRAGMENT_SHADER(
         precision mediump float;
         uniform vec4 color;
         uniform vec3 edge[8];
         void main()
         {
             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);
@@ skipping 25 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,
+                                                        TexCoordPrecision precision) 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 TexCoordPrecision 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;
+            TexCoordPrecision 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