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 <algorithm>
 
 #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(SHADER0(Src))
+#define FRAGMENT_SHADER(Src) setFragTexCoordPrecision(precision, SHADER0(Src))
 
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
 namespace {
 
 static void GetProgramUniformLocations(WebGraphicsContext3D* context,
                                        unsigned program,
                                        const char** shader_uniforms,
@@ skipping 10 matching lines @@
       context->bindUniformLocationCHROMIUM(program,
                                            locations[uniform_index],
                                            shader_uniforms[uniform_index]);
     } else {
       locations[uniform_index] =
           context->getUniformLocation(program, shader_uniforms[uniform_index]);
     }
   }
 }
 
-}  // namespace
+static std::string setFragTexCoordPrecision(
+    TexCoordPrecision requestedPrecision, std::string shaderString)
+{
+    switch (requestedPrecision) {
+    case TexCoordPrecisionHigh:
+      DCHECK_NE(shaderString.find("TexCoordPrecision"), std::string::npos);
+      return "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
+               "  #define TexCoordPrecision highp\n"
+               "#else\n"
+               "  #define TexCoordPrecision mediump\n"
+               "#endif\n" +
+               shaderString;
+    case TexCoordPrecisionMedium:
+      DCHECK_NE(shaderString.find("TexCoordPrecision"), std::string::npos);
+      return "#define TexCoordPrecision mediump\n" +
+               shaderString;
+    case TexCoordPrecisionNA:
+      DCHECK_EQ(shaderString.find("TexCoordPrecision"), std::string::npos);
+      DCHECK_EQ(shaderString.find("texture2D"), std::string::npos);
+      return shaderString;
+    }
+    return shaderString;
+}
+
+static std::string setVertexTexCoordPrecision(const char* shaderString)
+{
+    // We unconditionally use highp in the vertex shader since
+    // we are unlikely to be vertex shader bound when drawing large quads.
+    // Also, some vertex shaders mutate the texture coordinate in such a
+    // way that the effective precision might be lower than expected.
+    return "#define TexCoordPrecision highp\n" +
+           std::string(shaderString);
+}
+
+TexCoordPrecision TexCoordPrecisionRequired(WebGraphicsContext3D* context,
+                                            int highp_threshold_min,
+                                            int x, int y) {
+  // Initialize range and precision with minimum spec values for when
+  // getShaderPrecisionFormat is a test stub.
+  // TODO: Implement better stubs of getShaderPrecisionFormat everywhere.
+  GLint range[2] = { 14, 14 };
+  GLint precision = 10;
+  GLC(context, context->getShaderPrecisionFormat(GL_FRAGMENT_SHADER,
+                                                 GL_MEDIUM_FLOAT,
+                                                 range, &precision));
+  int highp_threshold = std::max(1 << precision, highp_threshold_min);
+  if (x > highp_threshold || y > highp_threshold)
+    return TexCoordPrecisionHigh;
+  return TexCoordPrecisionMedium;
+}
+
+} // namespace
+
+TexCoordPrecision TexCoordPrecisionRequired(WebGraphicsContext3D* context,
+                                            int highp_threshold_min,
+                                            const gfx::Point& max_coordinate) {
+  return TexCoordPrecisionRequired(context, highp_threshold_min,
+                                   max_coordinate.x(), max_coordinate.y());
+}
+
+TexCoordPrecision TexCoordPrecisionRequired(WebGraphicsContext3D* context,
+                                            int highp_threshold_min,
+                                            const gfx::Size& max_size) {
+  return TexCoordPrecisionRequired(context, highp_threshold_min,
+                                   max_size.width(), max_size.height());
+}
 
 VertexShaderPosTex::VertexShaderPosTex()
       : matrix_location_(-1) {}
 
 void VertexShaderPosTex::Init(WebGraphicsContext3D* context,
                               unsigned program,
                               bool using_bind_uniform,
                               int* base_uniform_index) {
   static const char* shader_uniforms[] = {
       "matrix",
   };
   int locations[1];
 
   GetProgramUniformLocations(context,
                              program,
                              shader_uniforms,
                              arraysize(shader_uniforms),
                              arraysize(locations),
                              locations,
                              using_bind_uniform,
                              base_uniform_index);
 
   matrix_location_ = locations[0];
   DCHECK_NE(matrix_location_, -1);
 }
 
 std::string VertexShaderPosTex::GetShaderString() 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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderPosTexYUVStretch::VertexShaderPosTexYUVStretch()
     : matrix_location_(-1),
       tex_scale_location_(-1) {}
@@ skipping 16 matching lines @@
                              locations,
                              using_bind_uniform,
                              base_uniform_index);
 
   matrix_location_ = locations[0];
   tex_scale_location_ = locations[1];
   DCHECK(matrix_location_ != -1 && tex_scale_location_ != -1);
 }
 
 std::string VertexShaderPosTexYUVStretch::GetShaderString() 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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderPos::VertexShaderPos()
     : matrix_location_(-1) {}
 
@@ skipping 13 matching lines @@
                              arraysize(locations),
                              locations,
                              using_bind_uniform,
                              base_uniform_index);
 
   matrix_location_ = locations[0];
   DCHECK_NE(matrix_location_, -1);
 }
 
 std::string VertexShaderPos::GetShaderString() const {
-  return SHADER(
+  return VERTEX_SHADER(
     attribute vec4 a_position;
     uniform mat4 matrix;
     void main() {
         gl_Position = matrix * a_position;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderPosTexTransform::VertexShaderPosTexTransform()
     : matrix_location_(-1),
@@ skipping 21 matching lines @@
                              base_uniform_index);
 
   matrix_location_ = locations[0];
   tex_transform_location_ = locations[1];
   vertex_opacity_location_ = locations[2];
   DCHECK(matrix_location_ != -1 && tex_transform_location_ != -1 &&
          vertex_opacity_location_ != -1);
 }
 
 std::string VertexShaderPosTexTransform::GetShaderString() 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;  // NOLINT
-      vec4 texTrans = texTransform[int(a_index * 0.25)];  // NOLINT
+      TexCoordPrecision vec4 texTrans =
+          texTransform[int(a_index * 0.25)];  // NOLINT
       v_texCoord = a_texCoord * texTrans.zw + texTrans.xy;
       v_alpha = opacity[int(a_index)]; // NOLINT
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string VertexShaderPosTexTransformFlip::GetShaderString() 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;  // NOLINT
-      vec4 texTrans = texTransform[int(a_index * 0.25)];  // NOLINT
+      TexCoordPrecision vec4 texTrans =
+          texTransform[int(a_index * 0.25)];  // NOLINT
       v_texCoord = a_texCoord * texTrans.zw + texTrans.xy;
       v_texCoord.y = 1.0 - v_texCoord.y;
       v_alpha = opacity[int(a_index)];  // NOLINT
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string VertexShaderPosTexIdentity::GetShaderString() 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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderQuad::VertexShaderQuad()
     : matrix_location_(-1),
       point_location_(-1),
@@ skipping 21 matching lines @@
 
   matrix_location_ = locations[0];
   point_location_ = locations[1];
   tex_scale_location_ = locations[2];
   DCHECK_NE(matrix_location_, -1);
   DCHECK_NE(point_location_, -1);
   DCHECK_NE(tex_scale_location_, -1);
 }
 
 std::string VertexShaderQuad::GetShaderString() 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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
@@ skipping 23 matching lines @@
                              base_uniform_index);
 
   matrix_location_ = locations[0];
   point_location_ = locations[1];
   vertex_tex_transform_location_ = locations[2];
   DCHECK(matrix_location_ != -1 && point_location_ != -1 &&
          vertex_tex_transform_location_ != -1);
 }
 
 std::string VertexShaderTile::GetShaderString() 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);
+      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 * vertexTexTransform.zw + vertexTexTransform.xy;
     }
   );  // NOLINT(whitespace/parens)
 }
 
@@ skipping 19 matching lines @@
                              locations,
                              using_bind_uniform,
                              base_uniform_index);
 
   matrix_location_ = locations[0];
   tex_matrix_location_ = locations[1];
   return matrix_location_ != -1 && tex_matrix_location_ != -1;
 }
 
 std::string VertexShaderVideoTransform::GetShaderString() 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));
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentTexAlphaBinding::FragmentTexAlphaBinding()
     : sampler_location_(-1),
@@ skipping 101 matching lines @@
                              arraysize(shader_uniforms),
                              arraysize(locations),
                              locations,
                              using_bind_uniform,
                              base_uniform_index);
 
   sampler_location_ = locations[0];
   return sampler_location_ != -1;
 }
 
-std::string FragmentShaderOESImageExternal::GetShaderString() const {
+std::string FragmentShaderOESImageExternal::GetShaderString(
+    TexCoordPrecision precision) const {
   // Cannot use the SHADER() macro because of the '#' char
-  return "#extension GL_OES_EGL_image_external : require\n"
-      SHADER(
+  return "#extension GL_OES_EGL_image_external : require\n" +
+      FRAGMENT_SHADER(
          precision mediump float;
-         varying vec2 v_texCoord;
+         varying TexCoordPrecision vec2 v_texCoord;
          uniform samplerExternalOES s_texture;
          void main() {
            vec4 texColor = texture2D(s_texture, v_texCoord);
            gl_FragColor = vec4(texColor.x, texColor.y, texColor.z, texColor.w);
          }
       );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexAlpha::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexAlpha::GetShaderString(
+    TexCoordPrecision precision) const {
+  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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderString(
+    TexCoordPrecision precision) const {
+  return FRAGMENT_SHADER(
     precision mediump float;
-    varying vec2 v_texCoord;
+    varying TexCoordPrecision vec2 v_texCoord;
     uniform sampler2D s_texture;
     uniform float alpha;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     void main() {
       vec4 texColor = texture2D(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
       gl_FragColor = texColor * alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexVaryingAlpha::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexVaryingAlpha::GetShaderString(
+    TexCoordPrecision precision) const {
+  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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexRectVaryingAlpha::GetShaderString() const {
-  return "#extension GL_ARB_texture_rectangle : require\n"
-      SHADER(
+std::string FragmentShaderRGBATexRectVaryingAlpha::GetShaderString(
+    TexCoordPrecision precision) const {
+  return "#extension GL_ARB_texture_rectangle : require\n" +
+      FRAGMENT_SHADER(
         precision mediump float;
-        varying vec2 v_texCoord;
+        varying TexCoordPrecision vec2 v_texCoord;
         varying float v_alpha;
         uniform sampler2DRect s_texture;
         void main() {
           vec4 texColor = texture2DRect(s_texture, v_texCoord);
           gl_FragColor = texColor * v_alpha;
         }
       );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexOpaque::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexOpaque::GetShaderString(
+    TexCoordPrecision precision) const {
+  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);
     }
   );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATex::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATex::GetShaderString(
+    TexCoordPrecision precision) const {
+  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);
     }
   );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderString(
+    TexCoordPrecision precision) const {
+  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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderString(
+    TexCoordPrecision precision) const {
+  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);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
     : sampler_location_(-1),
@@ skipping 20 matching lines @@
                              using_bind_uniform,
                              base_uniform_index);
 
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   edge_location_ = locations[2];
   DCHECK(sampler_location_ != -1 && alpha_location_ != -1 &&
          edge_location_ != -1);
 }
 
-std::string FragmentShaderRGBATexAlphaAA::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexAlphaAA::GetShaderString(
+    TexCoordPrecision precision) const {
+  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);
       float a3 = clamp(dot(edge[3], pos), 0.0, 1.0);
@@ skipping 35 matching lines @@
                              base_uniform_index);
 
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   fragment_tex_transform_location_ = locations[2];
   edge_location_ = locations[3];
   DCHECK(sampler_location_ != -1 && alpha_location_ != -1 &&
          fragment_tex_transform_location_ != -1 && edge_location_ != -1);
 }
 
-std::string FragmentShaderRGBATexClampAlphaAA::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexClampAlphaAA::GetShaderString(
+    TexCoordPrecision precision) const {
+  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 +
+      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));
     }
   );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexClampSwizzleAlphaAA::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexClampSwizzleAlphaAA::GetShaderString(
+    TexCoordPrecision precision) const {
+  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 +
+      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);
@@ skipping 34 matching lines @@
 
   sampler_location_ = locations[0];
   mask_sampler_location_ = locations[1];
   alpha_location_ = locations[2];
   mask_tex_coord_scale_location_ = locations[3];
   mask_tex_coord_offset_location_ = locations[4];
   DCHECK(sampler_location_ != -1 && mask_sampler_location_ != -1 &&
          alpha_location_ != -1);
 }
 
-std::string FragmentShaderRGBATexAlphaMask::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexAlphaMask::GetShaderString(
+    TexCoordPrecision precision) const {
+  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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaMaskAA::FragmentShaderRGBATexAlphaMaskAA()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
@@ skipping 27 matching lines @@
   sampler_location_ = locations[0];
   mask_sampler_location_ = locations[1];
   alpha_location_ = locations[2];
   edge_location_ = locations[3];
   mask_tex_coord_scale_location_ = locations[4];
   mask_tex_coord_offset_location_ = locations[5];
   DCHECK(sampler_location_ != -1 && mask_sampler_location_ != -1 &&
          alpha_location_ != -1 && edge_location_ != -1);
 }
 
-std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderString(
+    TexCoordPrecision precision) const {
+  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 46 matching lines @@
   edge_location_ = locations[3];
   mask_tex_coord_scale_location_ = locations[4];
   mask_tex_coord_offset_location_ = locations[5];
   color_matrix_location_ = locations[6];
   color_offset_location_ = locations[7];
   DCHECK(sampler_location_ != -1 && mask_sampler_location_ != -1 &&
          alpha_location_ != -1 && edge_location_ != -1 &&
          color_matrix_location_ != -1 && color_offset_location_ != -1);
 }
 
-std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderString()
-    const {
-  return SHADER(
+std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderString(
+    TexCoordPrecision precision) const {
+  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 mat4 colorMatrix;
     uniform vec4 colorOffset;
     uniform float alpha;
     uniform vec3 edge[8];
     void main() {
       vec4 texColor = texture2D(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
-      vec2 maskTexCoord =
+      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);
@@ skipping 39 matching lines @@
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   edge_location_ = locations[2];
   color_matrix_location_ = locations[3];
   color_offset_location_ = locations[4];
   DCHECK(sampler_location_ != -1 && alpha_location_ != -1 &&
          edge_location_ != -1 && color_matrix_location_ != -1 &&
          color_offset_location_ != -1);
 }
 
-std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderString(
+    TexCoordPrecision precision) const {
+  return FRAGMENT_SHADER(
     precision mediump float;
-    varying vec2 v_texCoord;
+    varying TexCoordPrecision vec2 v_texCoord;
     uniform sampler2D s_texture;
     uniform float alpha;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     uniform vec3 edge[8];
     void main() {
       vec4 texColor = texture2D(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
@@ skipping 49 matching lines @@
   alpha_location_ = locations[2];
   mask_tex_coord_scale_location_ = locations[3];
   mask_tex_coord_offset_location_ = locations[4];
   color_matrix_location_ = locations[5];
   color_offset_location_ = locations[6];
   DCHECK(sampler_location_ != -1 && mask_sampler_location_ != -1 &&
       alpha_location_ != -1 && color_matrix_location_ != -1 &&
       color_offset_location_ != -1);
 }
 
-std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderString(
+    TexCoordPrecision precision) const {
+  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 mat4 colorMatrix;
     uniform vec4 colorOffset;
     uniform float alpha;
     void main() {
       vec4 texColor = texture2D(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
-      vec2 maskTexCoord =
+      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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderYUVVideo::FragmentShaderYUVVideo()
@@ skipping 32 matching lines @@
   v_texture_location_ = locations[2];
   alpha_location_ = locations[3];
   yuv_matrix_location_ = locations[4];
   yuv_adj_location_ = locations[5];
 
   DCHECK(y_texture_location_ != -1 && u_texture_location_ != -1 &&
          v_texture_location_ != -1 && alpha_location_ != -1 &&
          yuv_matrix_location_ != -1 && yuv_adj_location_ != -1);
 }
 
-std::string FragmentShaderYUVVideo::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderYUVVideo::GetShaderString(
+    TexCoordPrecision precision) const {
+  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;
       float v_unsigned = texture2D(v_texture, v_texCoord).x;
@@ skipping 22 matching lines @@
                              arraysize(shader_uniforms),
                              arraysize(locations),
                              locations,
                              using_bind_uniform,
                              base_uniform_index);
 
   color_location_ = locations[0];
   DCHECK_NE(color_location_, -1);
 }
 
-std::string FragmentShaderColor::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderColor::GetShaderString(
+    TexCoordPrecision precision) const {
+  return FRAGMENT_SHADER(
     precision mediump float;
     uniform vec4 color;
     void main() {
       gl_FragColor = color;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderColorAA::FragmentShaderColorAA()
     : edge_location_(-1),
@@ skipping 16 matching lines @@
                              arraysize(locations),
                              locations,
                              using_bind_uniform,
                              base_uniform_index);
 
   edge_location_ = locations[0];
   color_location_ = locations[1];
   DCHECK(edge_location_ != -1 && color_location_ != -1);
 }
 
-std::string FragmentShaderColorAA::GetShaderString() const {
-  return SHADER(
+std::string FragmentShaderColorAA::GetShaderString(
+    TexCoordPrecision precision) const {
+  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);
       float a4 = clamp(dot(edge[4], pos), 0.0, 1.0);
@@ skipping 33 matching lines @@
                              base_uniform_index);
 
   alpha_location_ = locations[0];
   tex_transform_location_ = locations[1];
   frequency_location_ = locations[2];
   color_location_ = locations[3];
   DCHECK(alpha_location_ != -1 && tex_transform_location_ != -1 &&
          frequency_location_ != -1 && color_location_ != -1);
 }
 
-std::string FragmentShaderCheckerboard::GetShaderString() const {
+std::string FragmentShaderCheckerboard::GetShaderString(
+    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;
     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;
+      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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 }  // namespace cc