Remove WGC3D::isContextLost references from cc

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))
 
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
 namespace {
 
 static void GetProgramUniformLocations(WebGraphicsContext3D* context,
                                        unsigned program,
                                        size_t count,
                                        const char** uniforms,
                                        int* locations,
-                                       bool using_bind_uniform,
                                        int* base_uniform_index) {
   for (size_t i = 0; i < count; i++) {
-    if (using_bind_uniform) {
-      locations[i] = (*base_uniform_index)++;
-      context->bindUniformLocationCHROMIUM(program, locations[i], uniforms[i]);
-    } else {
-      locations[i] = context->getUniformLocation(program, uniforms[i]);
-      DCHECK_NE(locations[i], -1);
-    }
+    locations[i] = (*base_uniform_index)++;
+    context->bindUniformLocationCHROMIUM(program, locations[i], uniforms[i]);
   }
 }
 
 static std::string SetFragTexCoordPrecision(
     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"
@@ skipping 64 matching lines @@
   return TexCoordPrecisionRequired(context,
                                    highp_threshold_cache, 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* uniforms[] = {
       "matrix",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   matrix_location_ = locations[0];
 }
 
 std::string VertexShaderPosTex::GetShaderString() const {
   return VERTEX_SHADER(
     attribute vec4 a_position;
     attribute TexCoordPrecision vec2 a_texCoord;
     uniform mat4 matrix;
     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) {}
 
 void VertexShaderPosTexYUVStretch::Init(WebGraphicsContext3D* context,
                                         unsigned program,
-                                        bool using_bind_uniform,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "texScale",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   matrix_location_ = locations[0];
   tex_scale_location_ = locations[1];
 }
 
 std::string VertexShaderPosTexYUVStretch::GetShaderString() const {
   return VERTEX_SHADER(
     precision mediump float;
     attribute vec4 a_position;
     attribute TexCoordPrecision vec2 a_texCoord;
     uniform mat4 matrix;
     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) {}
 
 void VertexShaderPos::Init(WebGraphicsContext3D* context,
                            unsigned program,
-                           bool using_bind_uniform,
                            int* base_uniform_index) {
   static const char* uniforms[] = {
       "matrix",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   matrix_location_ = locations[0];
 }
 
 std::string VertexShaderPos::GetShaderString() const {
   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),
       tex_transform_location_(-1),
       vertex_opacity_location_(-1) {}
 
 void VertexShaderPosTexTransform::Init(WebGraphicsContext3D* context,
                                        unsigned program,
-                                       bool using_bind_uniform,
                                        int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "texTransform",
     "opacity",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   matrix_location_ = locations[0];
   tex_transform_location_ = locations[1];
   vertex_opacity_location_ = locations[2];
 }
 
 std::string VertexShaderPosTexTransform::GetShaderString() const {
   return VERTEX_SHADER(
     attribute vec4 a_position;
     attribute TexCoordPrecision vec2 a_texCoord;
@@ skipping 23 matching lines @@
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderQuad::VertexShaderQuad()
     : matrix_location_(-1),
       quad_location_(-1) {}
 
 void VertexShaderQuad::Init(WebGraphicsContext3D* context,
                             unsigned program,
-                            bool using_bind_uniform,
                             int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "quad",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   matrix_location_ = locations[0];
   quad_location_ = locations[1];
 }
 
 std::string VertexShaderQuad::GetShaderString() const {
 #if defined(OS_ANDROID)
 // TODO(epenner): Find the cause of this 'quad' uniform
 // being missing if we don't add dummy variables.
 // http://crbug.com/240602
@@ skipping 25 matching lines @@
 }
 
 VertexShaderQuadAA::VertexShaderQuadAA()
     : matrix_location_(-1),
       viewport_location_(-1),
       quad_location_(-1),
       edge_location_(-1) {}
 
 void VertexShaderQuadAA::Init(WebGraphicsContext3D* context,
                             unsigned program,
-                            bool using_bind_uniform,
                             int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "viewport",
     "quad",
     "edge",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   matrix_location_ = locations[0];
   viewport_location_ = locations[1];
   quad_location_ = locations[2];
   edge_location_ = locations[3];
 }
 
 std::string VertexShaderQuadAA::GetShaderString() const {
   return VERTEX_SHADER(
     attribute TexCoordPrecision vec4 a_position;
@@ skipping 23 matching lines @@
 
 VertexShaderQuadTexTransformAA::VertexShaderQuadTexTransformAA()
     : matrix_location_(-1),
       viewport_location_(-1),
       quad_location_(-1),
       edge_location_(-1),
       tex_transform_location_(-1) {}
 
 void VertexShaderQuadTexTransformAA::Init(WebGraphicsContext3D* context,
                                         unsigned program,
-                                        bool using_bind_uniform,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "viewport",
     "quad",
     "edge",
     "texTrans",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   matrix_location_ = locations[0];
   viewport_location_ = locations[1];
   quad_location_ = locations[2];
   edge_location_ = locations[3];
   tex_transform_location_ = locations[4];
 }
 
 std::string VertexShaderQuadTexTransformAA::GetShaderString() const {
   return VERTEX_SHADER(
@@ skipping 25 matching lines @@
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderTile::VertexShaderTile()
     : matrix_location_(-1),
       quad_location_(-1),
       vertex_tex_transform_location_(-1) {}
 
 void VertexShaderTile::Init(WebGraphicsContext3D* context,
                             unsigned program,
-                            bool using_bind_uniform,
                             int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "quad",
     "vertexTexTransform",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   matrix_location_ = locations[0];
   quad_location_ = locations[1];
   vertex_tex_transform_location_ = locations[2];
 }
 
 std::string VertexShaderTile::GetShaderString() const {
   return VERTEX_SHADER(
     attribute TexCoordPrecision vec4 a_position;
     attribute float a_index;
@@ skipping 11 matching lines @@
 
 VertexShaderTileAA::VertexShaderTileAA()
     : matrix_location_(-1),
       viewport_location_(-1),
       quad_location_(-1),
       edge_location_(-1),
       vertex_tex_transform_location_(-1) {}
 
 void VertexShaderTileAA::Init(WebGraphicsContext3D* context,
                               unsigned program,
-                              bool using_bind_uniform,
                               int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "viewport",
     "quad",
     "edge",
     "vertexTexTransform",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   matrix_location_ = locations[0];
   viewport_location_ = locations[1];
   quad_location_ = locations[2];
   edge_location_ = locations[3];
   vertex_tex_transform_location_ = locations[4];
 }
 
 std::string VertexShaderTileAA::GetShaderString() const {
   return VERTEX_SHADER(
@@ skipping 24 matching lines @@
     }
   );  // NOLINT(whitespace/parens)
 }
 
 VertexShaderVideoTransform::VertexShaderVideoTransform()
     : matrix_location_(-1),
       tex_matrix_location_(-1) {}
 
 void VertexShaderVideoTransform::Init(WebGraphicsContext3D* context,
                                       unsigned program,
-                                      bool using_bind_uniform,
                                       int* base_uniform_index) {
   static const char* uniforms[] = {
     "matrix",
     "texMatrix",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   matrix_location_ = locations[0];
   tex_matrix_location_ = locations[1];
 }
 
 std::string VertexShaderVideoTransform::GetShaderString() const {
   return VERTEX_SHADER(
     attribute vec4 a_position;
     attribute TexCoordPrecision vec2 a_texCoord;
     uniform mat4 matrix;
     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),
       alpha_location_(-1) {}
 
 void FragmentTexAlphaBinding::Init(WebGraphicsContext3D* context,
                                    unsigned program,
-                                   bool using_bind_uniform,
                                    int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
 }
 
 FragmentTexColorMatrixAlphaBinding::FragmentTexColorMatrixAlphaBinding()
     : sampler_location_(-1),
       alpha_location_(-1),
       color_matrix_location_(-1),
       color_offset_location_(-1) {}
 
 void FragmentTexColorMatrixAlphaBinding::Init(WebGraphicsContext3D* context,
                                               unsigned program,
-                                              bool using_bind_uniform,
                                               int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
     "colorMatrix",
     "colorOffset",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   color_matrix_location_ = locations[2];
   color_offset_location_ = locations[3];
 }
 
 FragmentTexOpaqueBinding::FragmentTexOpaqueBinding()
     : sampler_location_(-1) {}
 
 void FragmentTexOpaqueBinding::Init(WebGraphicsContext3D* context,
                                     unsigned program,
-                                    bool using_bind_uniform,
                                     int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   sampler_location_ = locations[0];
 }
 
 FragmentShaderOESImageExternal::FragmentShaderOESImageExternal()
     : sampler_location_(-1) {}
 
 void FragmentShaderOESImageExternal::Init(WebGraphicsContext3D* context,
                                           unsigned program,
-                                          bool using_bind_uniform,
                                           int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              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;
@@ skipping 70 matching lines @@
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentTexBackgroundBinding::FragmentTexBackgroundBinding()
     : background_color_location_(-1),
       sampler_location_(-1) {
 }
 
 void FragmentTexBackgroundBinding::Init(WebGraphicsContext3D* context,
                                         unsigned program,
-                                        bool using_bind_uniform,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "background_color",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              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(
@@ skipping 96 matching lines @@
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
     : sampler_location_(-1),
       alpha_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaAA::Init(WebGraphicsContext3D* context,
                                         unsigned program,
-                                        bool using_bind_uniform,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
 }
 
 std::string FragmentShaderRGBATexAlphaAA::GetShaderString(
     TexCoordPrecision precision) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     uniform sampler2D s_texture;
@@ skipping 11 matching lines @@
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentTexClampAlphaAABinding::FragmentTexClampAlphaAABinding()
     : sampler_location_(-1),
       alpha_location_(-1),
       fragment_tex_transform_location_(-1) {}
 
 void FragmentTexClampAlphaAABinding::Init(WebGraphicsContext3D* context,
                                           unsigned program,
-                                          bool using_bind_uniform,
                                           int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
     "fragmentTexTransform",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   fragment_tex_transform_location_ = locations[2];
 }
 
 std::string FragmentShaderRGBATexClampAlphaAA::GetShaderString(
     TexCoordPrecision precision) const {
   return FRAGMENT_SHADER(
     precision mediump float;
@@ skipping 41 matching lines @@
 }
 
 FragmentShaderRGBATexAlphaMask::FragmentShaderRGBATexAlphaMask()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
       alpha_location_(-1),
       mask_tex_coord_scale_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaMask::Init(WebGraphicsContext3D* context,
                                           unsigned program,
-                                          bool using_bind_uniform,
                                           int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              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 {
@@ skipping 18 matching lines @@
 
 FragmentShaderRGBATexAlphaMaskAA::FragmentShaderRGBATexAlphaMaskAA()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
       alpha_location_(-1),
       mask_tex_coord_scale_location_(-1),
       mask_tex_coord_offset_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaMaskAA::Init(WebGraphicsContext3D* context,
                                             unsigned program,
-                                            bool using_bind_uniform,
                                             int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              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 {
@@ skipping 26 matching lines @@
         : sampler_location_(-1),
           mask_sampler_location_(-1),
           alpha_location_(-1),
           mask_tex_coord_scale_location_(-1),
           color_matrix_location_(-1),
           color_offset_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaMaskColorMatrixAA::Init(
     WebGraphicsContext3D* context,
     unsigned program,
-    bool using_bind_uniform,
     int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
     "colorMatrix",
     "colorOffset",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              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];
   color_matrix_location_ = locations[5];
   color_offset_location_ = locations[6];
 }
 
@@ skipping 33 matching lines @@
 FragmentShaderRGBATexAlphaColorMatrixAA::
     FragmentShaderRGBATexAlphaColorMatrixAA()
         : sampler_location_(-1),
           alpha_location_(-1),
           color_matrix_location_(-1),
           color_offset_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaColorMatrixAA::Init(
       WebGraphicsContext3D* context,
       unsigned program,
-      bool using_bind_uniform,
       int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
     "colorMatrix",
     "colorOffset",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              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 {
   return FRAGMENT_SHADER(
@@ skipping 23 matching lines @@
 FragmentShaderRGBATexAlphaMaskColorMatrix::
     FragmentShaderRGBATexAlphaMaskColorMatrix()
         : sampler_location_(-1),
           mask_sampler_location_(-1),
           alpha_location_(-1),
           mask_tex_coord_scale_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaMaskColorMatrix::Init(
     WebGraphicsContext3D* context,
     unsigned program,
-    bool using_bind_uniform,
     int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
     "colorMatrix",
     "colorOffset",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              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];
   color_matrix_location_ = locations[5];
   color_offset_location_ = locations[6];
 }
 
@@ skipping 28 matching lines @@
 FragmentShaderYUVVideo::FragmentShaderYUVVideo()
     : y_texture_location_(-1),
       u_texture_location_(-1),
       v_texture_location_(-1),
       alpha_location_(-1),
       yuv_matrix_location_(-1),
       yuv_adj_location_(-1) {}
 
 void FragmentShaderYUVVideo::Init(WebGraphicsContext3D* context,
                                   unsigned program,
-                                  bool using_bind_uniform,
                                   int* base_uniform_index) {
   static const char* uniforms[] = {
     "y_texture",
     "u_texture",
     "v_texture",
     "alpha",
     "yuv_matrix",
     "yuv_adj",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              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(
@@ skipping 24 matching lines @@
       u_texture_location_(-1),
       v_texture_location_(-1),
       a_texture_location_(-1),
       alpha_location_(-1),
       yuv_matrix_location_(-1),
       yuv_adj_location_(-1) {
 }
 
 void FragmentShaderYUVAVideo::Init(WebGraphicsContext3D* context,
                                    unsigned program,
-                                   bool using_bind_uniform,
                                    int* base_uniform_index) {
   static const char* uniforms[] = {
       "y_texture",
       "u_texture",
       "v_texture",
       "a_texture",
       "alpha",
       "cc_matrix",
       "yuv_adj",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   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];
 }
 
@@ skipping 20 matching lines @@
       gl_FragColor = vec4(rgb, 1.0) * (alpha * a_raw);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderColor::FragmentShaderColor()
     : color_location_(-1) {}
 
 void FragmentShaderColor::Init(WebGraphicsContext3D* context,
                                unsigned program,
-                               bool using_bind_uniform,
                                int* base_uniform_index) {
   static const char* uniforms[] = {
     "color",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   color_location_ = locations[0];
 }
 
 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()
     : color_location_(-1) {}
 
 void FragmentShaderColorAA::Init(WebGraphicsContext3D* context,
                                  unsigned program,
-                                 bool using_bind_uniform,
                                  int* base_uniform_index) {
   static const char* uniforms[] = {
     "color",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              base_uniform_index);
   color_location_ = locations[0];
 }
 
 std::string FragmentShaderColorAA::GetShaderString(
     TexCoordPrecision precision) 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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderCheckerboard::FragmentShaderCheckerboard()
     : alpha_location_(-1),
       tex_transform_location_(-1),
       frequency_location_(-1) {}
 
 void FragmentShaderCheckerboard::Init(WebGraphicsContext3D* context,
                                       unsigned program,
-                                      bool using_bind_uniform,
                                       int* base_uniform_index) {
   static const char* uniforms[] = {
     "alpha",
     "texTransform",
     "frequency",
     "color",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
-                             using_bind_uniform,
                              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 {
   // Shader based on Example 13-17 of "OpenGL ES 2.0 Programming Guide"
@@ skipping 12 matching lines @@
       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