cc: Allow TEXTURE_RECTANGLE_ARB to be used for tile textures.

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/public/platform/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 
 #define SHADER0(Src) #Src
 #define VERTEX_SHADER(Src) SetVertexTexCoordPrecision(SHADER0(Src))
-#define FRAGMENT_SHADER(Src) SetFragTexCoordPrecision(precision, SHADER0(Src))
+#define FRAGMENT_SHADER(Src) SetFragmentTexCoordPrecision( \
+    precision, SetFragmentSamplerType(sampler, SHADER0(Src)))
 
 using blink::WebGraphicsContext3D;
 
 namespace cc {
 
 namespace {
 
 static void GetProgramUniformLocations(WebGraphicsContext3D* context,
                                        unsigned program,
                                        size_t count,
                                        const char** uniforms,
                                        int* locations,
                                        int* base_uniform_index) {
   for (size_t i = 0; i < count; i++) {
     locations[i] = (*base_uniform_index)++;
     context->bindUniformLocationCHROMIUM(program, locations[i], uniforms[i]);
   }
 }
 
-static std::string SetFragTexCoordPrecision(
+static std::string SetFragmentTexCoordPrecision(
     TexCoordPrecision requested_precision, std::string shader_string) {
   switch (requested_precision) {
     case TexCoordPrecisionHigh:
       DCHECK_NE(shader_string.find("TexCoordPrecision"), std::string::npos);
       return
           "#ifdef GL_FRAGMENT_PRECISION_HIGH\n"
           "  #define TexCoordPrecision highp\n"
           "#else\n"
           "  #define TexCoordPrecision mediump\n"
           "#endif\n" +
           shader_string;
     case TexCoordPrecisionMedium:
       DCHECK_NE(shader_string.find("TexCoordPrecision"), std::string::npos);
       return "#define TexCoordPrecision mediump\n" +
           shader_string;
     case TexCoordPrecisionNA:
       DCHECK_EQ(shader_string.find("TexCoordPrecision"), std::string::npos);
       DCHECK_EQ(shader_string.find("texture2D"), std::string::npos);
+      DCHECK_EQ(shader_string.find("texture2DRect"), std::string::npos);
       return shader_string;
+    default:
+      NOTREACHED();
+      break;
   }
   return shader_string;
 }
 
 static std::string SetVertexTexCoordPrecision(const char* shader_string) {
   // 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" +
@@ skipping 16 matching lines @@
                                                    range, &precision));
     *highp_threshold_cache = 1 << precision;
   }
 
   int highp_threshold = std::max(*highp_threshold_cache, highp_threshold_min);
   if (x > highp_threshold || y > highp_threshold)
     return TexCoordPrecisionHigh;
   return TexCoordPrecisionMedium;
 }
 
+static std::string SetFragmentSamplerType(
+    SamplerType requested_type, std::string shader_string) {
+  switch (requested_type) {
+    case SamplerType2D:
+      DCHECK_NE(shader_string.find("SamplerType"), std::string::npos);
+      DCHECK_NE(shader_string.find("TextureLookup"), std::string::npos);
+      return
+          "#define SamplerType sampler2D\n"
+          "#define TextureLookup texture2D\n" +
+          shader_string;
+    case SamplerType2DRect:
+      DCHECK_NE(shader_string.find("SamplerType"), std::string::npos);
+      DCHECK_NE(shader_string.find("TextureLookup"), std::string::npos);
+      return
+          "#extension GL_ARB_texture_rectangle : require\n"
+          "#define SamplerType sampler2DRect\n"
+          "#define TextureLookup texture2DRect\n" +
+          shader_string;
+    case SamplerTypeExternalOES:
+      DCHECK_NE(shader_string.find("SamplerType"), std::string::npos);
+      DCHECK_NE(shader_string.find("TextureLookup"), std::string::npos);
+      return
+          "#extension GL_OES_EGL_image_external : require\n"
+          "#define SamplerType samplerExternalOES\n"
+          "#define TextureLookup texture2D\n" +
+          shader_string;
+    case SamplerTypeNA:
+      DCHECK_EQ(shader_string.find("SamplerType"), std::string::npos);
+      DCHECK_EQ(shader_string.find("TextureLookup"), std::string::npos);
+      return shader_string;
+    default:
+      NOTREACHED();
+      break;
+  }
+  return shader_string;
+}
+
 }  // namespace
 
 TexCoordPrecision TexCoordPrecisionRequired(WebGraphicsContext3D* context,
                                             int *highp_threshold_cache,
                                             int highp_threshold_min,
                                             gfx::Point max_coordinate) {
   return TexCoordPrecisionRequired(context,
                                    highp_threshold_cache, highp_threshold_min,
                                    max_coordinate.x(), max_coordinate.y());
 }
@@ skipping 545 matching lines @@
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
 }
 
-FragmentShaderOESImageExternal::FragmentShaderOESImageExternal()
-    : sampler_location_(-1) {}
-
-void FragmentShaderOESImageExternal::Init(WebGraphicsContext3D* context,
-                                          unsigned program,
-                                          int* base_uniform_index) {
-  static const char* uniforms[] = {
-    "s_texture",
-  };
-  int locations[arraysize(uniforms)];
-
-  GetProgramUniformLocations(context,
-                             program,
-                             arraysize(uniforms),
-                             uniforms,
-                             locations,
-                             base_uniform_index);
-  sampler_location_ = locations[0];
-}
-
-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" +
-      FRAGMENT_SHADER(
-         precision mediump float;
-         varying TexCoordPrecision vec2 v_texCoord;
-         uniform samplerExternalOES s_texture;
-         void main() {
-           vec4 texColor = texture2D(s_texture, v_texCoord);
-           gl_FragColor = texColor;
-         }
-      );  // NOLINT(whitespace/parens)
-}
-
 std::string FragmentShaderRGBATexAlpha::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     uniform float alpha;
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = texColor * alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     uniform float alpha;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(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(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = texColor * v_alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(s_texture, v_texCoord);
       texColor.rgb *= texColor.a;
       gl_FragColor = texColor * v_alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentTexBackgroundBinding::FragmentTexBackgroundBinding()
     : background_color_location_(-1),
       sampler_location_(-1) {
 }
@@ skipping 15 matching lines @@
                              base_uniform_index);
 
   sampler_location_ = locations[0];
   DCHECK_NE(sampler_location_, -1);
 
   background_color_location_ = locations[1];
   DCHECK_NE(background_color_location_, -1);
 }
 
 std::string FragmentShaderTexBackgroundVaryingAlpha::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform vec4 background_color;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(s_texture, v_texCoord);
       texColor += background_color * (1.0 - texColor.a);
       gl_FragColor = texColor * v_alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderTexBackgroundPremultiplyAlpha::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform vec4 background_color;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(s_texture, v_texCoord);
       texColor.rgb *= texColor.a;
       texColor += background_color * (1.0 - texColor.a);
       gl_FragColor = texColor * v_alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexRectVaryingAlpha::GetShaderString(
-    TexCoordPrecision precision) const {
-  return "#extension GL_ARB_texture_rectangle : require\n" +
-      FRAGMENT_SHADER(
-        precision mediump float;
-        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(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = vec4(texColor.rgb, 1.0);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderRGBATex::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     void main() {
-      gl_FragColor = texture2D(s_texture, v_texCoord);
+      gl_FragColor = TextureLookup(s_texture, v_texCoord);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     uniform float alpha;
     void main() {
-        vec4 texColor = texture2D(s_texture, v_texCoord);
+        vec4 texColor = TextureLookup(s_texture, v_texCoord);
         gl_FragColor =
             vec4(texColor.z, texColor.y, texColor.x, texColor.w) * alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(s_texture, v_texCoord);
       gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, 1.0);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
     : sampler_location_(-1),
       alpha_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaAA::Init(WebGraphicsContext3D* context,
                                         unsigned program,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
 }
 
 std::string FragmentShaderRGBATexAlphaAA::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     uniform float alpha;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(s_texture, v_texCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = texColor * alpha * aa;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentTexClampAlphaAABinding::FragmentTexClampAlphaAABinding()
     : sampler_location_(-1),
@@ skipping 15 matching lines @@
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   fragment_tex_transform_location_ = locations[2];
 }
 
 std::string FragmentShaderRGBATexClampAlphaAA::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     uniform float alpha;
     uniform TexCoordPrecision vec4 fragmentTexTransform;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
     void main() {
       TexCoordPrecision vec2 texCoord =
           clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw +
           fragmentTexTransform.xy;
-      vec4 texColor = texture2D(s_texture, texCoord);
+      vec4 texColor = TextureLookup(s_texture, texCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = texColor * alpha * aa;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderRGBATexClampSwizzleAlphaAA::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     uniform float alpha;
     uniform TexCoordPrecision vec4 fragmentTexTransform;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
     void main() {
       TexCoordPrecision vec2 texCoord =
           clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw +
           fragmentTexTransform.xy;
-      vec4 texColor = texture2D(s_texture, texCoord);
+      vec4 texColor = TextureLookup(s_texture, texCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, texColor.w) *
           alpha * aa;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaMask::FragmentShaderRGBATexAlphaMask()
@@ skipping 21 matching lines @@
                              locations,
                              base_uniform_index);
   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];
 }
 
 std::string FragmentShaderRGBATexAlphaMask::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
-    uniform sampler2D s_texture;
-    uniform sampler2D s_mask;
+    uniform SamplerType s_texture;
+    uniform SamplerType s_mask;
     uniform TexCoordPrecision vec2 maskTexCoordScale;
     uniform TexCoordPrecision vec2 maskTexCoordOffset;
     uniform float alpha;
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(s_texture, v_texCoord);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
-      vec4 maskColor = texture2D(s_mask, maskTexCoord);
+      vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
       gl_FragColor = texColor * alpha * maskColor.w;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaMaskAA::FragmentShaderRGBATexAlphaMaskAA()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
       alpha_location_(-1),
       mask_tex_coord_scale_location_(-1),
@@ skipping 18 matching lines @@
                              locations,
                              base_uniform_index);
   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];
 }
 
 std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
-    uniform sampler2D s_texture;
-    uniform sampler2D s_mask;
+    uniform SamplerType s_texture;
+    uniform SamplerType s_mask;
     uniform TexCoordPrecision vec2 maskTexCoordScale;
     uniform TexCoordPrecision vec2 maskTexCoordOffset;
     uniform float alpha;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(s_texture, v_texCoord);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
-      vec4 maskColor = texture2D(s_mask, maskTexCoord);
+      vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = texColor * alpha * maskColor.w * aa;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaMaskColorMatrixAA::
     FragmentShaderRGBATexAlphaMaskColorMatrixAA()
@@ skipping 28 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];
   color_matrix_location_ = locations[5];
   color_offset_location_ = locations[6];
 }
 
 std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
-    uniform sampler2D s_texture;
-    uniform sampler2D s_mask;
+    uniform SamplerType s_texture;
+    uniform SamplerType s_mask;
     uniform vec2 maskTexCoordScale;
     uniform vec2 maskTexCoordOffset;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     uniform float alpha;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(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);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
-      vec4 maskColor = texture2D(s_mask, maskTexCoord);
+      vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = texColor * alpha * maskColor.w * aa;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaColorMatrixAA::
     FragmentShaderRGBATexAlphaColorMatrixAA()
@@ skipping 20 matching lines @@
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   color_matrix_location_ = locations[2];
   color_offset_location_ = locations[3];
 }
 
 std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
-    uniform sampler2D s_texture;
+    uniform SamplerType s_texture;
     uniform float alpha;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
     void main() {
-      vec4 texColor = texture2D(s_texture, v_texCoord);
+      vec4 texColor = TextureLookup(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);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = texColor * alpha * aa;
     }
@@ skipping 31 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];
   color_matrix_location_ = locations[5];
   color_offset_location_ = locations[6];
 }
 
 std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
-    uniform sampler2D s_texture;
-    uniform sampler2D s_mask;
+    uniform SamplerType s_texture;
+    uniform SamplerType 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);
+      vec4 texColor = TextureLookup(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);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
-      vec4 maskColor = texture2D(s_mask, maskTexCoord);
+      vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
       gl_FragColor = texColor * alpha * maskColor.w;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderYUVVideo::FragmentShaderYUVVideo()
     : y_texture_location_(-1),
       u_texture_location_(-1),
       v_texture_location_(-1),
       alpha_location_(-1),
@@ skipping 21 matching lines @@
                              base_uniform_index);
   y_texture_location_ = locations[0];
   u_texture_location_ = locations[1];
   v_texture_location_ = locations[2];
   alpha_location_ = locations[3];
   yuv_matrix_location_ = locations[4];
   yuv_adj_location_ = locations[5];
 }
 
 std::string FragmentShaderYUVVideo::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     precision mediump int;
     varying TexCoordPrecision vec2 v_texCoord;
-    uniform sampler2D y_texture;
-    uniform sampler2D u_texture;
-    uniform sampler2D v_texture;
+    uniform SamplerType y_texture;
+    uniform SamplerType u_texture;
+    uniform SamplerType 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;
+      float y_raw = TextureLookup(y_texture, v_texCoord).x;
+      float u_unsigned = TextureLookup(u_texture, v_texCoord).x;
+      float v_unsigned = TextureLookup(v_texture, v_texCoord).x;
       vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
       vec3 rgb = yuv_matrix * yuv;
       gl_FragColor = vec4(rgb, 1.0) * alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderYUVAVideo::FragmentShaderYUVAVideo()
     : y_texture_location_(-1),
       u_texture_location_(-1),
@@ skipping 27 matching lines @@
   y_texture_location_ = locations[0];
   u_texture_location_ = locations[1];
   v_texture_location_ = locations[2];
   a_texture_location_ = locations[3];
   alpha_location_ = locations[4];
   yuv_matrix_location_ = locations[5];
   yuv_adj_location_ = locations[6];
 }
 
 std::string FragmentShaderYUVAVideo::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     precision mediump int;
     varying TexCoordPrecision vec2 v_texCoord;
-    uniform sampler2D y_texture;
-    uniform sampler2D u_texture;
-    uniform sampler2D v_texture;
-    uniform sampler2D a_texture;
+    uniform SamplerType y_texture;
+    uniform SamplerType u_texture;
+    uniform SamplerType v_texture;
+    uniform SamplerType a_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;
-      float a_raw = texture2D(a_texture, v_texCoord).x;
+      float y_raw = TextureLookup(y_texture, v_texCoord).x;
+      float u_unsigned = TextureLookup(u_texture, v_texCoord).x;
+      float v_unsigned = TextureLookup(v_texture, v_texCoord).x;
+      float a_raw = TextureLookup(a_texture, v_texCoord).x;
       vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
       vec3 rgb = yuv_matrix * yuv;
       gl_FragColor = vec4(rgb, 1.0) * (alpha * a_raw);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderColor::FragmentShaderColor()
     : color_location_(-1) {}
 
 void FragmentShaderColor::Init(WebGraphicsContext3D* context,
                                unsigned program,
                                int* base_uniform_index) {
   static const char* uniforms[] = {
     "color",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   color_location_ = locations[0];
 }
 
 std::string FragmentShaderColor::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     uniform vec4 color;
     void main() {
       gl_FragColor = color;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderColorAA::FragmentShaderColorAA()
@@ skipping 10 matching lines @@
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   color_location_ = locations[0];
 }
 
 std::string FragmentShaderColorAA::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     uniform vec4 color;
     varying vec4 edge_dist[2];  // 8 edge distances.
 
     void main() {
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = color * aa;
@@ skipping 23 matching lines @@
                              uniforms,
                              locations,
                              base_uniform_index);
   alpha_location_ = locations[0];
   tex_transform_location_ = locations[1];
   frequency_location_ = locations[2];
   color_location_ = locations[3];
 }
 
 std::string FragmentShaderCheckerboard::GetShaderString(
-    TexCoordPrecision precision) const {
+    TexCoordPrecision precision, SamplerType sampler) const {
   // Shader based on Example 13-17 of "OpenGL ES 2.0 Programming Guide"
   // by Munshi, Ginsburg, Shreiner.
   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 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
       float picker = abs(coord.x - coord.y);  // NOLINT
       gl_FragColor = mix(color1, color2, picker) * alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 }  // namespace cc