src/gpu/command_buffer/client/gles2_c_lib_autogen.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file is auto-generated from
   6 // gpu/command_buffer/build_gles2_cmd_buffer.py
   7 // It's formatted by clang-format using chromium coding style:
   8 //    clang-format -i -style=chromium filename
   9 // DO NOT EDIT!
  10
  11 // These functions emulate GLES2 over command buffers.
  12 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_C_LIB_AUTOGEN_H_
  13 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_C_LIB_AUTOGEN_H_
  14
  15 void GLES2ActiveTexture(GLenum texture) {
  16   gles2::GetGLContext()->ActiveTexture(texture);
  17 }
  18 void GLES2AttachShader(GLuint program, GLuint shader) {
  19   gles2::GetGLContext()->AttachShader(program, shader);
  20 }
  21 void GLES2BindAttribLocation(GLuint program, GLuint index, const char* name) {
  22   gles2::GetGLContext()->BindAttribLocation(program, index, name);
  23 }
  24 void GLES2BindBuffer(GLenum target, GLuint buffer) {
  25   gles2::GetGLContext()->BindBuffer(target, buffer);
  26 }
  27 void GLES2BindFramebuffer(GLenum target, GLuint framebuffer) {
  28   gles2::GetGLContext()->BindFramebuffer(target, framebuffer);
  29 }
  30 void GLES2BindRenderbuffer(GLenum target, GLuint renderbuffer) {
  31   gles2::GetGLContext()->BindRenderbuffer(target, renderbuffer);
  32 }
  33 void GLES2BindTexture(GLenum target, GLuint texture) {
  34   gles2::GetGLContext()->BindTexture(target, texture);
  35 }
  36 void GLES2BlendColor(GLclampf red,
  37                      GLclampf green,
  38                      GLclampf blue,
  39                      GLclampf alpha) {
  40   gles2::GetGLContext()->BlendColor(red, green, blue, alpha);
  41 }
  42 void GLES2BlendEquation(GLenum mode) {
  43   gles2::GetGLContext()->BlendEquation(mode);
  44 }
  45 void GLES2BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
  46   gles2::GetGLContext()->BlendEquationSeparate(modeRGB, modeAlpha);
  47 }
  48 void GLES2BlendFunc(GLenum sfactor, GLenum dfactor) {
  49   gles2::GetGLContext()->BlendFunc(sfactor, dfactor);
  50 }
  51 void GLES2BlendFuncSeparate(GLenum srcRGB,
  52                             GLenum dstRGB,
  53                             GLenum srcAlpha,
  54                             GLenum dstAlpha) {
  55   gles2::GetGLContext()->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
  56 }
  57 void GLES2BufferData(GLenum target,
  58                      GLsizeiptr size,
  59                      const void* data,
  60                      GLenum usage) {
  61   gles2::GetGLContext()->BufferData(target, size, data, usage);
  62 }
  63 void GLES2BufferSubData(GLenum target,
  64                         GLintptr offset,
  65                         GLsizeiptr size,
  66                         const void* data) {
  67   gles2::GetGLContext()->BufferSubData(target, offset, size, data);
  68 }
  69 GLenum GLES2CheckFramebufferStatus(GLenum target) {
  70   return gles2::GetGLContext()->CheckFramebufferStatus(target);
  71 }
  72 void GLES2Clear(GLbitfield mask) {
  73   gles2::GetGLContext()->Clear(mask);
  74 }
  75 void GLES2ClearColor(GLclampf red,
  76                      GLclampf green,
  77                      GLclampf blue,
  78                      GLclampf alpha) {
  79   gles2::GetGLContext()->ClearColor(red, green, blue, alpha);
  80 }
  81 void GLES2ClearDepthf(GLclampf depth) {
  82   gles2::GetGLContext()->ClearDepthf(depth);
  83 }
  84 void GLES2ClearStencil(GLint s) {
  85   gles2::GetGLContext()->ClearStencil(s);
  86 }
  87 void GLES2ColorMask(GLboolean red,
  88                     GLboolean green,
  89                     GLboolean blue,
  90                     GLboolean alpha) {
  91   gles2::GetGLContext()->ColorMask(red, green, blue, alpha);
  92 }
  93 void GLES2CompileShader(GLuint shader) {
  94   gles2::GetGLContext()->CompileShader(shader);
  95 }
  96 void GLES2CompressedTexImage2D(GLenum target,
  97                                GLint level,
  98                                GLenum internalformat,
  99                                GLsizei width,
 100                                GLsizei height,
 101                                GLint border,
 102                                GLsizei imageSize,
 103                                const void* data) {
 104   gles2::GetGLContext()->CompressedTexImage2D(
 105       target, level, internalformat, width, height, border, imageSize, data);
 106 }
 107 void GLES2CompressedTexSubImage2D(GLenum target,
 108                                   GLint level,
 109                                   GLint xoffset,
 110                                   GLint yoffset,
 111                                   GLsizei width,
 112                                   GLsizei height,
 113                                   GLenum format,
 114                                   GLsizei imageSize,
 115                                   const void* data) {
 116   gles2::GetGLContext()->CompressedTexSubImage2D(
 117       target, level, xoffset, yoffset, width, height, format, imageSize, data);
 118 }
 119 void GLES2CopyTexImage2D(GLenum target,
 120                          GLint level,
 121                          GLenum internalformat,
 122                          GLint x,
 123                          GLint y,
 124                          GLsizei width,
 125                          GLsizei height,
 126                          GLint border) {
 127   gles2::GetGLContext()->CopyTexImage2D(
 128       target, level, internalformat, x, y, width, height, border);
 129 }
 130 void GLES2CopyTexSubImage2D(GLenum target,
 131                             GLint level,
 132                             GLint xoffset,
 133                             GLint yoffset,
 134                             GLint x,
 135                             GLint y,
 136                             GLsizei width,
 137                             GLsizei height) {
 138   gles2::GetGLContext()->CopyTexSubImage2D(
 139       target, level, xoffset, yoffset, x, y, width, height);
 140 }
 141 GLuint GLES2CreateProgram() {
 142   return gles2::GetGLContext()->CreateProgram();
 143 }
 144 GLuint GLES2CreateShader(GLenum type) {
 145   return gles2::GetGLContext()->CreateShader(type);
 146 }
 147 void GLES2CullFace(GLenum mode) {
 148   gles2::GetGLContext()->CullFace(mode);
 149 }
 150 void GLES2DeleteBuffers(GLsizei n, const GLuint* buffers) {
 151   gles2::GetGLContext()->DeleteBuffers(n, buffers);
 152 }
 153 void GLES2DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
 154   gles2::GetGLContext()->DeleteFramebuffers(n, framebuffers);
 155 }
 156 void GLES2DeleteProgram(GLuint program) {
 157   gles2::GetGLContext()->DeleteProgram(program);
 158 }
 159 void GLES2DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
 160   gles2::GetGLContext()->DeleteRenderbuffers(n, renderbuffers);
 161 }
 162 void GLES2DeleteShader(GLuint shader) {
 163   gles2::GetGLContext()->DeleteShader(shader);
 164 }
 165 void GLES2DeleteTextures(GLsizei n, const GLuint* textures) {
 166   gles2::GetGLContext()->DeleteTextures(n, textures);
 167 }
 168 void GLES2DepthFunc(GLenum func) {
 169   gles2::GetGLContext()->DepthFunc(func);
 170 }
 171 void GLES2DepthMask(GLboolean flag) {
 172   gles2::GetGLContext()->DepthMask(flag);
 173 }
 174 void GLES2DepthRangef(GLclampf zNear, GLclampf zFar) {
 175   gles2::GetGLContext()->DepthRangef(zNear, zFar);
 176 }
 177 void GLES2DetachShader(GLuint program, GLuint shader) {
 178   gles2::GetGLContext()->DetachShader(program, shader);
 179 }
 180 void GLES2Disable(GLenum cap) {
 181   gles2::GetGLContext()->Disable(cap);
 182 }
 183 void GLES2DisableVertexAttribArray(GLuint index) {
 184   gles2::GetGLContext()->DisableVertexAttribArray(index);
 185 }
 186 void GLES2DrawArrays(GLenum mode, GLint first, GLsizei count) {
 187   gles2::GetGLContext()->DrawArrays(mode, first, count);
 188 }
 189 void GLES2DrawElements(GLenum mode,
 190                        GLsizei count,
 191                        GLenum type,
 192                        const void* indices) {
 193   gles2::GetGLContext()->DrawElements(mode, count, type, indices);
 194 }
 195 void GLES2Enable(GLenum cap) {
 196   gles2::GetGLContext()->Enable(cap);
 197 }
 198 void GLES2EnableVertexAttribArray(GLuint index) {
 199   gles2::GetGLContext()->EnableVertexAttribArray(index);
 200 }
 201 void GLES2Finish() {
 202   gles2::GetGLContext()->Finish();
 203 }
 204 void GLES2Flush() {
 205   gles2::GetGLContext()->Flush();
 206 }
 207 void GLES2FramebufferRenderbuffer(GLenum target,
 208                                   GLenum attachment,
 209                                   GLenum renderbuffertarget,
 210                                   GLuint renderbuffer) {
 211   gles2::GetGLContext()->FramebufferRenderbuffer(
 212       target, attachment, renderbuffertarget, renderbuffer);
 213 }
 214 void GLES2FramebufferTexture2D(GLenum target,
 215                                GLenum attachment,
 216                                GLenum textarget,
 217                                GLuint texture,
 218                                GLint level) {
 219   gles2::GetGLContext()->FramebufferTexture2D(
 220       target, attachment, textarget, texture, level);
 221 }
 222 void GLES2FrontFace(GLenum mode) {
 223   gles2::GetGLContext()->FrontFace(mode);
 224 }
 225 void GLES2GenBuffers(GLsizei n, GLuint* buffers) {
 226   gles2::GetGLContext()->GenBuffers(n, buffers);
 227 }
 228 void GLES2GenerateMipmap(GLenum target) {
 229   gles2::GetGLContext()->GenerateMipmap(target);
 230 }
 231 void GLES2GenFramebuffers(GLsizei n, GLuint* framebuffers) {
 232   gles2::GetGLContext()->GenFramebuffers(n, framebuffers);
 233 }
 234 void GLES2GenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
 235   gles2::GetGLContext()->GenRenderbuffers(n, renderbuffers);
 236 }
 237 void GLES2GenTextures(GLsizei n, GLuint* textures) {
 238   gles2::GetGLContext()->GenTextures(n, textures);
 239 }
 240 void GLES2GetActiveAttrib(GLuint program,
 241                           GLuint index,
 242                           GLsizei bufsize,
 243                           GLsizei* length,
 244                           GLint* size,
 245                           GLenum* type,
 246                           char* name) {
 247   gles2::GetGLContext()->GetActiveAttrib(
 248       program, index, bufsize, length, size, type, name);
 249 }
 250 void GLES2GetActiveUniform(GLuint program,
 251                            GLuint index,
 252                            GLsizei bufsize,
 253                            GLsizei* length,
 254                            GLint* size,
 255                            GLenum* type,
 256                            char* name) {
 257   gles2::GetGLContext()->GetActiveUniform(
 258       program, index, bufsize, length, size, type, name);
 259 }
 260 void GLES2GetAttachedShaders(GLuint program,
 261                              GLsizei maxcount,
 262                              GLsizei* count,
 263                              GLuint* shaders) {
 264   gles2::GetGLContext()->GetAttachedShaders(program, maxcount, count, shaders);
 265 }
 266 GLint GLES2GetAttribLocation(GLuint program, const char* name) {
 267   return gles2::GetGLContext()->GetAttribLocation(program, name);
 268 }
 269 void GLES2GetBooleanv(GLenum pname, GLboolean* params) {
 270   gles2::GetGLContext()->GetBooleanv(pname, params);
 271 }
 272 void GLES2GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
 273   gles2::GetGLContext()->GetBufferParameteriv(target, pname, params);
 274 }
 275 GLenum GLES2GetError() {
 276   return gles2::GetGLContext()->GetError();
 277 }
 278 void GLES2GetFloatv(GLenum pname, GLfloat* params) {
 279   gles2::GetGLContext()->GetFloatv(pname, params);
 280 }
 281 void GLES2GetFramebufferAttachmentParameteriv(GLenum target,
 282                                               GLenum attachment,
 283                                               GLenum pname,
 284                                               GLint* params) {
 285   gles2::GetGLContext()->GetFramebufferAttachmentParameteriv(
 286       target, attachment, pname, params);
 287 }
 288 void GLES2GetIntegerv(GLenum pname, GLint* params) {
 289   gles2::GetGLContext()->GetIntegerv(pname, params);
 290 }
 291 void GLES2GetProgramiv(GLuint program, GLenum pname, GLint* params) {
 292   gles2::GetGLContext()->GetProgramiv(program, pname, params);
 293 }
 294 void GLES2GetProgramInfoLog(GLuint program,
 295                             GLsizei bufsize,
 296                             GLsizei* length,
 297                             char* infolog) {
 298   gles2::GetGLContext()->GetProgramInfoLog(program, bufsize, length, infolog);
 299 }
 300 void GLES2GetRenderbufferParameteriv(GLenum target,
 301                                      GLenum pname,
 302                                      GLint* params) {
 303   gles2::GetGLContext()->GetRenderbufferParameteriv(target, pname, params);
 304 }
 305 void GLES2GetShaderiv(GLuint shader, GLenum pname, GLint* params) {
 306   gles2::GetGLContext()->GetShaderiv(shader, pname, params);
 307 }
 308 void GLES2GetShaderInfoLog(GLuint shader,
 309                            GLsizei bufsize,
 310                            GLsizei* length,
 311                            char* infolog) {
 312   gles2::GetGLContext()->GetShaderInfoLog(shader, bufsize, length, infolog);
 313 }
 314 void GLES2GetShaderPrecisionFormat(GLenum shadertype,
 315                                    GLenum precisiontype,
 316                                    GLint* range,
 317                                    GLint* precision) {
 318   gles2::GetGLContext()->GetShaderPrecisionFormat(
 319       shadertype, precisiontype, range, precision);
 320 }
 321 void GLES2GetShaderSource(GLuint shader,
 322                           GLsizei bufsize,
 323                           GLsizei* length,
 324                           char* source) {
 325   gles2::GetGLContext()->GetShaderSource(shader, bufsize, length, source);
 326 }
 327 const GLubyte* GLES2GetString(GLenum name) {
 328   return gles2::GetGLContext()->GetString(name);
 329 }
 330 void GLES2GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
 331   gles2::GetGLContext()->GetTexParameterfv(target, pname, params);
 332 }
 333 void GLES2GetTexParameteriv(GLenum target, GLenum pname, GLint* params) {
 334   gles2::GetGLContext()->GetTexParameteriv(target, pname, params);
 335 }
 336 void GLES2GetUniformfv(GLuint program, GLint location, GLfloat* params) {
 337   gles2::GetGLContext()->GetUniformfv(program, location, params);
 338 }
 339 void GLES2GetUniformiv(GLuint program, GLint location, GLint* params) {
 340   gles2::GetGLContext()->GetUniformiv(program, location, params);
 341 }
 342 GLint GLES2GetUniformLocation(GLuint program, const char* name) {
 343   return gles2::GetGLContext()->GetUniformLocation(program, name);
 344 }
 345 void GLES2GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) {
 346   gles2::GetGLContext()->GetVertexAttribfv(index, pname, params);
 347 }
 348 void GLES2GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) {
 349   gles2::GetGLContext()->GetVertexAttribiv(index, pname, params);
 350 }
 351 void GLES2GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) {
 352   gles2::GetGLContext()->GetVertexAttribPointerv(index, pname, pointer);
 353 }
 354 void GLES2Hint(GLenum target, GLenum mode) {
 355   gles2::GetGLContext()->Hint(target, mode);
 356 }
 357 GLboolean GLES2IsBuffer(GLuint buffer) {
 358   return gles2::GetGLContext()->IsBuffer(buffer);
 359 }
 360 GLboolean GLES2IsEnabled(GLenum cap) {
 361   return gles2::GetGLContext()->IsEnabled(cap);
 362 }
 363 GLboolean GLES2IsFramebuffer(GLuint framebuffer) {
 364   return gles2::GetGLContext()->IsFramebuffer(framebuffer);
 365 }
 366 GLboolean GLES2IsProgram(GLuint program) {
 367   return gles2::GetGLContext()->IsProgram(program);
 368 }
 369 GLboolean GLES2IsRenderbuffer(GLuint renderbuffer) {
 370   return gles2::GetGLContext()->IsRenderbuffer(renderbuffer);
 371 }
 372 GLboolean GLES2IsShader(GLuint shader) {
 373   return gles2::GetGLContext()->IsShader(shader);
 374 }
 375 GLboolean GLES2IsTexture(GLuint texture) {
 376   return gles2::GetGLContext()->IsTexture(texture);
 377 }
 378 void GLES2LineWidth(GLfloat width) {
 379   gles2::GetGLContext()->LineWidth(width);
 380 }
 381 void GLES2LinkProgram(GLuint program) {
 382   gles2::GetGLContext()->LinkProgram(program);
 383 }
 384 void GLES2PixelStorei(GLenum pname, GLint param) {
 385   gles2::GetGLContext()->PixelStorei(pname, param);
 386 }
 387 void GLES2PolygonOffset(GLfloat factor, GLfloat units) {
 388   gles2::GetGLContext()->PolygonOffset(factor, units);
 389 }
 390 void GLES2ReadPixels(GLint x,
 391                      GLint y,
 392                      GLsizei width,
 393                      GLsizei height,
 394                      GLenum format,
 395                      GLenum type,
 396                      void* pixels) {
 397   gles2::GetGLContext()->ReadPixels(x, y, width, height, format, type, pixels);
 398 }
 399 void GLES2ReleaseShaderCompiler() {
 400   gles2::GetGLContext()->ReleaseShaderCompiler();
 401 }
 402 void GLES2RenderbufferStorage(GLenum target,
 403                               GLenum internalformat,
 404                               GLsizei width,
 405                               GLsizei height) {
 406   gles2::GetGLContext()->RenderbufferStorage(
 407       target, internalformat, width, height);
 408 }
 409 void GLES2SampleCoverage(GLclampf value, GLboolean invert) {
 410   gles2::GetGLContext()->SampleCoverage(value, invert);
 411 }
 412 void GLES2Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
 413   gles2::GetGLContext()->Scissor(x, y, width, height);
 414 }
 415 void GLES2ShaderBinary(GLsizei n,
 416                        const GLuint* shaders,
 417                        GLenum binaryformat,
 418                        const void* binary,
 419                        GLsizei length) {
 420   gles2::GetGLContext()->ShaderBinary(n, shaders, binaryformat, binary, length);
 421 }
 422 void GLES2ShaderSource(GLuint shader,
 423                        GLsizei count,
 424                        const GLchar* const* str,
 425                        const GLint* length) {
 426   gles2::GetGLContext()->ShaderSource(shader, count, str, length);
 427 }
 428 void GLES2ShallowFinishCHROMIUM() {
 429   gles2::GetGLContext()->ShallowFinishCHROMIUM();
 430 }
 431 void GLES2ShallowFlushCHROMIUM() {
 432   gles2::GetGLContext()->ShallowFlushCHROMIUM();
 433 }
 434 void GLES2StencilFunc(GLenum func, GLint ref, GLuint mask) {
 435   gles2::GetGLContext()->StencilFunc(func, ref, mask);
 436 }
 437 void GLES2StencilFuncSeparate(GLenum face,
 438                               GLenum func,
 439                               GLint ref,
 440                               GLuint mask) {
 441   gles2::GetGLContext()->StencilFuncSeparate(face, func, ref, mask);
 442 }
 443 void GLES2StencilMask(GLuint mask) {
 444   gles2::GetGLContext()->StencilMask(mask);
 445 }
 446 void GLES2StencilMaskSeparate(GLenum face, GLuint mask) {
 447   gles2::GetGLContext()->StencilMaskSeparate(face, mask);
 448 }
 449 void GLES2StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
 450   gles2::GetGLContext()->StencilOp(fail, zfail, zpass);
 451 }
 452 void GLES2StencilOpSeparate(GLenum face,
 453                             GLenum fail,
 454                             GLenum zfail,
 455                             GLenum zpass) {
 456   gles2::GetGLContext()->StencilOpSeparate(face, fail, zfail, zpass);
 457 }
 458 void GLES2TexImage2D(GLenum target,
 459                      GLint level,
 460                      GLint internalformat,
 461                      GLsizei width,
 462                      GLsizei height,
 463                      GLint border,
 464                      GLenum format,
 465                      GLenum type,
 466                      const void* pixels) {
 467   gles2::GetGLContext()->TexImage2D(target,
 468                                     level,
 469                                     internalformat,
 470                                     width,
 471                                     height,
 472                                     border,
 473                                     format,
 474                                     type,
 475                                     pixels);
 476 }
 477 void GLES2TexParameterf(GLenum target, GLenum pname, GLfloat param) {
 478   gles2::GetGLContext()->TexParameterf(target, pname, param);
 479 }
 480 void GLES2TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) {
 481   gles2::GetGLContext()->TexParameterfv(target, pname, params);
 482 }
 483 void GLES2TexParameteri(GLenum target, GLenum pname, GLint param) {
 484   gles2::GetGLContext()->TexParameteri(target, pname, param);
 485 }
 486 void GLES2TexParameteriv(GLenum target, GLenum pname, const GLint* params) {
 487   gles2::GetGLContext()->TexParameteriv(target, pname, params);
 488 }
 489 void GLES2TexSubImage2D(GLenum target,
 490                         GLint level,
 491                         GLint xoffset,
 492                         GLint yoffset,
 493                         GLsizei width,
 494                         GLsizei height,
 495                         GLenum format,
 496                         GLenum type,
 497                         const void* pixels) {
 498   gles2::GetGLContext()->TexSubImage2D(
 499       target, level, xoffset, yoffset, width, height, format, type, pixels);
 500 }
 501 void GLES2Uniform1f(GLint location, GLfloat x) {
 502   gles2::GetGLContext()->Uniform1f(location, x);
 503 }
 504 void GLES2Uniform1fv(GLint location, GLsizei count, const GLfloat* v) {
 505   gles2::GetGLContext()->Uniform1fv(location, count, v);
 506 }
 507 void GLES2Uniform1i(GLint location, GLint x) {
 508   gles2::GetGLContext()->Uniform1i(location, x);
 509 }
 510 void GLES2Uniform1iv(GLint location, GLsizei count, const GLint* v) {
 511   gles2::GetGLContext()->Uniform1iv(location, count, v);
 512 }
 513 void GLES2Uniform2f(GLint location, GLfloat x, GLfloat y) {
 514   gles2::GetGLContext()->Uniform2f(location, x, y);
 515 }
 516 void GLES2Uniform2fv(GLint location, GLsizei count, const GLfloat* v) {
 517   gles2::GetGLContext()->Uniform2fv(location, count, v);
 518 }
 519 void GLES2Uniform2i(GLint location, GLint x, GLint y) {
 520   gles2::GetGLContext()->Uniform2i(location, x, y);
 521 }
 522 void GLES2Uniform2iv(GLint location, GLsizei count, const GLint* v) {
 523   gles2::GetGLContext()->Uniform2iv(location, count, v);
 524 }
 525 void GLES2Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
 526   gles2::GetGLContext()->Uniform3f(location, x, y, z);
 527 }
 528 void GLES2Uniform3fv(GLint location, GLsizei count, const GLfloat* v) {
 529   gles2::GetGLContext()->Uniform3fv(location, count, v);
 530 }
 531 void GLES2Uniform3i(GLint location, GLint x, GLint y, GLint z) {
 532   gles2::GetGLContext()->Uniform3i(location, x, y, z);
 533 }
 534 void GLES2Uniform3iv(GLint location, GLsizei count, const GLint* v) {
 535   gles2::GetGLContext()->Uniform3iv(location, count, v);
 536 }
 537 void GLES2Uniform4f(GLint location,
 538                     GLfloat x,
 539                     GLfloat y,
 540                     GLfloat z,
 541                     GLfloat w) {
 542   gles2::GetGLContext()->Uniform4f(location, x, y, z, w);
 543 }
 544 void GLES2Uniform4fv(GLint location, GLsizei count, const GLfloat* v) {
 545   gles2::GetGLContext()->Uniform4fv(location, count, v);
 546 }
 547 void GLES2Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
 548   gles2::GetGLContext()->Uniform4i(location, x, y, z, w);
 549 }
 550 void GLES2Uniform4iv(GLint location, GLsizei count, const GLint* v) {
 551   gles2::GetGLContext()->Uniform4iv(location, count, v);
 552 }
 553 void GLES2UniformMatrix2fv(GLint location,
 554                            GLsizei count,
 555                            GLboolean transpose,
 556                            const GLfloat* value) {
 557   gles2::GetGLContext()->UniformMatrix2fv(location, count, transpose, value);
 558 }
 559 void GLES2UniformMatrix3fv(GLint location,
 560                            GLsizei count,
 561                            GLboolean transpose,
 562                            const GLfloat* value) {
 563   gles2::GetGLContext()->UniformMatrix3fv(location, count, transpose, value);
 564 }
 565 void GLES2UniformMatrix4fv(GLint location,
 566                            GLsizei count,
 567                            GLboolean transpose,
 568                            const GLfloat* value) {
 569   gles2::GetGLContext()->UniformMatrix4fv(location, count, transpose, value);
 570 }
 571 void GLES2UseProgram(GLuint program) {
 572   gles2::GetGLContext()->UseProgram(program);
 573 }
 574 void GLES2ValidateProgram(GLuint program) {
 575   gles2::GetGLContext()->ValidateProgram(program);
 576 }
 577 void GLES2VertexAttrib1f(GLuint indx, GLfloat x) {
 578   gles2::GetGLContext()->VertexAttrib1f(indx, x);
 579 }
 580 void GLES2VertexAttrib1fv(GLuint indx, const GLfloat* values) {
 581   gles2::GetGLContext()->VertexAttrib1fv(indx, values);
 582 }
 583 void GLES2VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
 584   gles2::GetGLContext()->VertexAttrib2f(indx, x, y);
 585 }
 586 void GLES2VertexAttrib2fv(GLuint indx, const GLfloat* values) {
 587   gles2::GetGLContext()->VertexAttrib2fv(indx, values);
 588 }
 589 void GLES2VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
 590   gles2::GetGLContext()->VertexAttrib3f(indx, x, y, z);
 591 }
 592 void GLES2VertexAttrib3fv(GLuint indx, const GLfloat* values) {
 593   gles2::GetGLContext()->VertexAttrib3fv(indx, values);
 594 }
 595 void GLES2VertexAttrib4f(GLuint indx,
 596                          GLfloat x,
 597                          GLfloat y,
 598                          GLfloat z,
 599                          GLfloat w) {
 600   gles2::GetGLContext()->VertexAttrib4f(indx, x, y, z, w);
 601 }
 602 void GLES2VertexAttrib4fv(GLuint indx, const GLfloat* values) {
 603   gles2::GetGLContext()->VertexAttrib4fv(indx, values);
 604 }
 605 void GLES2VertexAttribPointer(GLuint indx,
 606                               GLint size,
 607                               GLenum type,
 608                               GLboolean normalized,
 609                               GLsizei stride,
 610                               const void* ptr) {
 611   gles2::GetGLContext()->VertexAttribPointer(
 612       indx, size, type, normalized, stride, ptr);
 613 }
 614 void GLES2Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
 615   gles2::GetGLContext()->Viewport(x, y, width, height);
 616 }
 617 void GLES2BlitFramebufferCHROMIUM(GLint srcX0,
 618                                   GLint srcY0,
 619                                   GLint srcX1,
 620                                   GLint srcY1,
 621                                   GLint dstX0,
 622                                   GLint dstY0,
 623                                   GLint dstX1,
 624                                   GLint dstY1,
 625                                   GLbitfield mask,
 626                                   GLenum filter) {
 627   gles2::GetGLContext()->BlitFramebufferCHROMIUM(
 628       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 629 }
 630 void GLES2RenderbufferStorageMultisampleCHROMIUM(GLenum target,
 631                                                  GLsizei samples,
 632                                                  GLenum internalformat,
 633                                                  GLsizei width,
 634                                                  GLsizei height) {
 635   gles2::GetGLContext()->RenderbufferStorageMultisampleCHROMIUM(
 636       target, samples, internalformat, width, height);
 637 }
 638 void GLES2RenderbufferStorageMultisampleEXT(GLenum target,
 639                                             GLsizei samples,
 640                                             GLenum internalformat,
 641                                             GLsizei width,
 642                                             GLsizei height) {
 643   gles2::GetGLContext()->RenderbufferStorageMultisampleEXT(
 644       target, samples, internalformat, width, height);
 645 }
 646 void GLES2FramebufferTexture2DMultisampleEXT(GLenum target,
 647                                              GLenum attachment,
 648                                              GLenum textarget,
 649                                              GLuint texture,
 650                                              GLint level,
 651                                              GLsizei samples) {
 652   gles2::GetGLContext()->FramebufferTexture2DMultisampleEXT(
 653       target, attachment, textarget, texture, level, samples);
 654 }
 655 void GLES2TexStorage2DEXT(GLenum target,
 656                           GLsizei levels,
 657                           GLenum internalFormat,
 658                           GLsizei width,
 659                           GLsizei height) {
 660   gles2::GetGLContext()->TexStorage2DEXT(
 661       target, levels, internalFormat, width, height);
 662 }
 663 void GLES2GenQueriesEXT(GLsizei n, GLuint* queries) {
 664   gles2::GetGLContext()->GenQueriesEXT(n, queries);
 665 }
 666 void GLES2DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
 667   gles2::GetGLContext()->DeleteQueriesEXT(n, queries);
 668 }
 669 GLboolean GLES2IsQueryEXT(GLuint id) {
 670   return gles2::GetGLContext()->IsQueryEXT(id);
 671 }
 672 void GLES2BeginQueryEXT(GLenum target, GLuint id) {
 673   gles2::GetGLContext()->BeginQueryEXT(target, id);
 674 }
 675 void GLES2EndQueryEXT(GLenum target) {
 676   gles2::GetGLContext()->EndQueryEXT(target);
 677 }
 678 void GLES2GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
 679   gles2::GetGLContext()->GetQueryivEXT(target, pname, params);
 680 }
 681 void GLES2GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint* params) {
 682   gles2::GetGLContext()->GetQueryObjectuivEXT(id, pname, params);
 683 }
 684 void GLES2InsertEventMarkerEXT(GLsizei length, const GLchar* marker) {
 685   gles2::GetGLContext()->InsertEventMarkerEXT(length, marker);
 686 }
 687 void GLES2PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
 688   gles2::GetGLContext()->PushGroupMarkerEXT(length, marker);
 689 }
 690 void GLES2PopGroupMarkerEXT() {
 691   gles2::GetGLContext()->PopGroupMarkerEXT();
 692 }
 693 void GLES2GenVertexArraysOES(GLsizei n, GLuint* arrays) {
 694   gles2::GetGLContext()->GenVertexArraysOES(n, arrays);
 695 }
 696 void GLES2DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
 697   gles2::GetGLContext()->DeleteVertexArraysOES(n, arrays);
 698 }
 699 GLboolean GLES2IsVertexArrayOES(GLuint array) {
 700   return gles2::GetGLContext()->IsVertexArrayOES(array);
 701 }
 702 void GLES2BindVertexArrayOES(GLuint array) {
 703   gles2::GetGLContext()->BindVertexArrayOES(array);
 704 }
 705 void GLES2SwapBuffers() {
 706   gles2::GetGLContext()->SwapBuffers();
 707 }
 708 GLuint GLES2GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
 709                                         GLsizei count,
 710                                         GLenum type,
 711                                         GLuint offset) {
 712   return gles2::GetGLContext()->GetMaxValueInBufferCHROMIUM(
 713       buffer_id, count, type, offset);
 714 }
 715 void GLES2GenSharedIdsCHROMIUM(GLuint namespace_id,
 716                                GLuint id_offset,
 717                                GLsizei n,
 718                                GLuint* ids) {
 719   gles2::GetGLContext()->GenSharedIdsCHROMIUM(namespace_id, id_offset, n, ids);
 720 }
 721 void GLES2DeleteSharedIdsCHROMIUM(GLuint namespace_id,
 722                                   GLsizei n,
 723                                   const GLuint* ids) {
 724   gles2::GetGLContext()->DeleteSharedIdsCHROMIUM(namespace_id, n, ids);
 725 }
 726 void GLES2RegisterSharedIdsCHROMIUM(GLuint namespace_id,
 727                                     GLsizei n,
 728                                     const GLuint* ids) {
 729   gles2::GetGLContext()->RegisterSharedIdsCHROMIUM(namespace_id, n, ids);
 730 }
 731 GLboolean GLES2EnableFeatureCHROMIUM(const char* feature) {
 732   return gles2::GetGLContext()->EnableFeatureCHROMIUM(feature);
 733 }
 734 void* GLES2MapBufferCHROMIUM(GLuint target, GLenum access) {
 735   return gles2::GetGLContext()->MapBufferCHROMIUM(target, access);
 736 }
 737 GLboolean GLES2UnmapBufferCHROMIUM(GLuint target) {
 738   return gles2::GetGLContext()->UnmapBufferCHROMIUM(target);
 739 }
 740 void* GLES2MapImageCHROMIUM(GLuint image_id) {
 741   return gles2::GetGLContext()->MapImageCHROMIUM(image_id);
 742 }
 743 void GLES2UnmapImageCHROMIUM(GLuint image_id) {
 744   gles2::GetGLContext()->UnmapImageCHROMIUM(image_id);
 745 }
 746 void* GLES2MapBufferSubDataCHROMIUM(GLuint target,
 747                                     GLintptr offset,
 748                                     GLsizeiptr size,
 749                                     GLenum access) {
 750   return gles2::GetGLContext()->MapBufferSubDataCHROMIUM(
 751       target, offset, size, access);
 752 }
 753 void GLES2UnmapBufferSubDataCHROMIUM(const void* mem) {
 754   gles2::GetGLContext()->UnmapBufferSubDataCHROMIUM(mem);
 755 }
 756 void* GLES2MapTexSubImage2DCHROMIUM(GLenum target,
 757                                     GLint level,
 758                                     GLint xoffset,
 759                                     GLint yoffset,
 760                                     GLsizei width,
 761                                     GLsizei height,
 762                                     GLenum format,
 763                                     GLenum type,
 764                                     GLenum access) {
 765   return gles2::GetGLContext()->MapTexSubImage2DCHROMIUM(
 766       target, level, xoffset, yoffset, width, height, format, type, access);
 767 }
 768 void GLES2UnmapTexSubImage2DCHROMIUM(const void* mem) {
 769   gles2::GetGLContext()->UnmapTexSubImage2DCHROMIUM(mem);
 770 }
 771 void GLES2ResizeCHROMIUM(GLuint width, GLuint height, GLfloat scale_factor) {
 772   gles2::GetGLContext()->ResizeCHROMIUM(width, height, scale_factor);
 773 }
 774 const GLchar* GLES2GetRequestableExtensionsCHROMIUM() {
 775   return gles2::GetGLContext()->GetRequestableExtensionsCHROMIUM();
 776 }
 777 void GLES2RequestExtensionCHROMIUM(const char* extension) {
 778   gles2::GetGLContext()->RequestExtensionCHROMIUM(extension);
 779 }
 780 void GLES2RateLimitOffscreenContextCHROMIUM() {
 781   gles2::GetGLContext()->RateLimitOffscreenContextCHROMIUM();
 782 }
 783 void GLES2GetMultipleIntegervCHROMIUM(const GLenum* pnames,
 784                                       GLuint count,
 785                                       GLint* results,
 786                                       GLsizeiptr size) {
 787   gles2::GetGLContext()->GetMultipleIntegervCHROMIUM(
 788       pnames, count, results, size);
 789 }
 790 void GLES2GetProgramInfoCHROMIUM(GLuint program,
 791                                  GLsizei bufsize,
 792                                  GLsizei* size,
 793                                  void* info) {
 794   gles2::GetGLContext()->GetProgramInfoCHROMIUM(program, bufsize, size, info);
 795 }
 796 GLuint GLES2CreateStreamTextureCHROMIUM(GLuint texture) {
 797   return gles2::GetGLContext()->CreateStreamTextureCHROMIUM(texture);
 798 }
 799 GLuint GLES2CreateImageCHROMIUM(GLsizei width,
 800                                 GLsizei height,
 801                                 GLenum internalformat,
 802                                 GLenum usage) {
 803   return gles2::GetGLContext()->CreateImageCHROMIUM(
 804       width, height, internalformat, usage);
 805 }
 806 void GLES2DestroyImageCHROMIUM(GLuint image_id) {
 807   gles2::GetGLContext()->DestroyImageCHROMIUM(image_id);
 808 }
 809 void GLES2GetImageParameterivCHROMIUM(GLuint image_id,
 810                                       GLenum pname,
 811                                       GLint* params) {
 812   gles2::GetGLContext()->GetImageParameterivCHROMIUM(image_id, pname, params);
 813 }
 814 void GLES2GetTranslatedShaderSourceANGLE(GLuint shader,
 815                                          GLsizei bufsize,
 816                                          GLsizei* length,
 817                                          char* source) {
 818   gles2::GetGLContext()->GetTranslatedShaderSourceANGLE(
 819       shader, bufsize, length, source);
 820 }
 821 void GLES2PostSubBufferCHROMIUM(GLint x, GLint y, GLint width, GLint height) {
 822   gles2::GetGLContext()->PostSubBufferCHROMIUM(x, y, width, height);
 823 }
 824 void GLES2TexImageIOSurface2DCHROMIUM(GLenum target,
 825                                       GLsizei width,
 826                                       GLsizei height,
 827                                       GLuint ioSurfaceId,
 828                                       GLuint plane) {
 829   gles2::GetGLContext()->TexImageIOSurface2DCHROMIUM(
 830       target, width, height, ioSurfaceId, plane);
 831 }
 832 void GLES2CopyTextureCHROMIUM(GLenum target,
 833                               GLenum source_id,
 834                               GLenum dest_id,
 835                               GLint level,
 836                               GLint internalformat,
 837                               GLenum dest_type) {
 838   gles2::GetGLContext()->CopyTextureCHROMIUM(
 839       target, source_id, dest_id, level, internalformat, dest_type);
 840 }
 841 void GLES2DrawArraysInstancedANGLE(GLenum mode,
 842                                    GLint first,
 843                                    GLsizei count,
 844                                    GLsizei primcount) {
 845   gles2::GetGLContext()->DrawArraysInstancedANGLE(
 846       mode, first, count, primcount);
 847 }
 848 void GLES2DrawElementsInstancedANGLE(GLenum mode,
 849                                      GLsizei count,
 850                                      GLenum type,
 851                                      const void* indices,
 852                                      GLsizei primcount) {
 853   gles2::GetGLContext()->DrawElementsInstancedANGLE(
 854       mode, count, type, indices, primcount);
 855 }
 856 void GLES2VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
 857   gles2::GetGLContext()->VertexAttribDivisorANGLE(index, divisor);
 858 }
 859 void GLES2GenMailboxCHROMIUM(GLbyte* mailbox) {
 860   gles2::GetGLContext()->GenMailboxCHROMIUM(mailbox);
 861 }
 862 void GLES2ProduceTextureCHROMIUM(GLenum target, const GLbyte* mailbox) {
 863   gles2::GetGLContext()->ProduceTextureCHROMIUM(target, mailbox);
 864 }
 865 void GLES2ProduceTextureDirectCHROMIUM(GLuint texture,
 866                                        GLenum target,
 867                                        const GLbyte* mailbox) {
 868   gles2::GetGLContext()->ProduceTextureDirectCHROMIUM(texture, target, mailbox);
 869 }
 870 void GLES2ConsumeTextureCHROMIUM(GLenum target, const GLbyte* mailbox) {
 871   gles2::GetGLContext()->ConsumeTextureCHROMIUM(target, mailbox);
 872 }
 873 GLuint GLES2CreateAndConsumeTextureCHROMIUM(GLenum target,
 874                                             const GLbyte* mailbox) {
 875   return gles2::GetGLContext()->CreateAndConsumeTextureCHROMIUM(target,
 876                                                                 mailbox);
 877 }
 878 void GLES2BindUniformLocationCHROMIUM(GLuint program,
 879                                       GLint location,
 880                                       const char* name) {
 881   gles2::GetGLContext()->BindUniformLocationCHROMIUM(program, location, name);
 882 }
 883 void GLES2BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
 884   gles2::GetGLContext()->BindTexImage2DCHROMIUM(target, imageId);
 885 }
 886 void GLES2ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
 887   gles2::GetGLContext()->ReleaseTexImage2DCHROMIUM(target, imageId);
 888 }
 889 void GLES2TraceBeginCHROMIUM(const char* name) {
 890   gles2::GetGLContext()->TraceBeginCHROMIUM(name);
 891 }
 892 void GLES2TraceEndCHROMIUM() {
 893   gles2::GetGLContext()->TraceEndCHROMIUM();
 894 }
 895 void GLES2AsyncTexSubImage2DCHROMIUM(GLenum target,
 896                                      GLint level,
 897                                      GLint xoffset,
 898                                      GLint yoffset,
 899                                      GLsizei width,
 900                                      GLsizei height,
 901                                      GLenum format,
 902                                      GLenum type,
 903                                      const void* data) {
 904   gles2::GetGLContext()->AsyncTexSubImage2DCHROMIUM(
 905       target, level, xoffset, yoffset, width, height, format, type, data);
 906 }
 907 void GLES2AsyncTexImage2DCHROMIUM(GLenum target,
 908                                   GLint level,
 909                                   GLenum internalformat,
 910                                   GLsizei width,
 911                                   GLsizei height,
 912                                   GLint border,
 913                                   GLenum format,
 914                                   GLenum type,
 915                                   const void* pixels) {
 916   gles2::GetGLContext()->AsyncTexImage2DCHROMIUM(target,
 917                                                  level,
 918                                                  internalformat,
 919                                                  width,
 920                                                  height,
 921                                                  border,
 922                                                  format,
 923                                                  type,
 924                                                  pixels);
 925 }
 926 void GLES2WaitAsyncTexImage2DCHROMIUM(GLenum target) {
 927   gles2::GetGLContext()->WaitAsyncTexImage2DCHROMIUM(target);
 928 }
 929 void GLES2WaitAllAsyncTexImage2DCHROMIUM() {
 930   gles2::GetGLContext()->WaitAllAsyncTexImage2DCHROMIUM();
 931 }
 932 void GLES2DiscardFramebufferEXT(GLenum target,
 933                                 GLsizei count,
 934                                 const GLenum* attachments) {
 935   gles2::GetGLContext()->DiscardFramebufferEXT(target, count, attachments);
 936 }
 937 void GLES2LoseContextCHROMIUM(GLenum current, GLenum other) {
 938   gles2::GetGLContext()->LoseContextCHROMIUM(current, other);
 939 }
 940 GLuint GLES2InsertSyncPointCHROMIUM() {
 941   return gles2::GetGLContext()->InsertSyncPointCHROMIUM();
 942 }
 943 void GLES2WaitSyncPointCHROMIUM(GLuint sync_point) {
 944   gles2::GetGLContext()->WaitSyncPointCHROMIUM(sync_point);
 945 }
 946 void GLES2DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
 947   gles2::GetGLContext()->DrawBuffersEXT(count, bufs);
 948 }
 949 void GLES2DiscardBackbufferCHROMIUM() {
 950   gles2::GetGLContext()->DiscardBackbufferCHROMIUM();
 951 }
 952 void GLES2ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
 953                                        GLenum plane_transform,
 954                                        GLuint overlay_texture_id,
 955                                        GLint bounds_x,
 956                                        GLint bounds_y,
 957                                        GLint bounds_width,
 958                                        GLint bounds_height,
 959                                        GLfloat uv_x,
 960                                        GLfloat uv_y,
 961                                        GLfloat uv_width,
 962                                        GLfloat uv_height) {
 963   gles2::GetGLContext()->ScheduleOverlayPlaneCHROMIUM(plane_z_order,
 964                                                       plane_transform,
 965                                                       overlay_texture_id,
 966                                                       bounds_x,
 967                                                       bounds_y,
 968                                                       bounds_width,
 969                                                       bounds_height,
 970                                                       uv_x,
 971                                                       uv_y,
 972                                                       uv_width,
 973                                                       uv_height);
 974 }
 975 void GLES2MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
 976   gles2::GetGLContext()->MatrixLoadfCHROMIUM(matrixMode, m);
 977 }
 978 void GLES2MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
 979   gles2::GetGLContext()->MatrixLoadIdentityCHROMIUM(matrixMode);
 980 }
 981
 982 namespace gles2 {
 983
 984 extern const NameToFunc g_gles2_function_table[] = {
 985     {
 986      "glActiveTexture", reinterpret_cast<GLES2FunctionPointer>(glActiveTexture),
 987     },
 988     {
 989      "glAttachShader", reinterpret_cast<GLES2FunctionPointer>(glAttachShader),
 990     },
 991     {
 992      "glBindAttribLocation",
 993      reinterpret_cast<GLES2FunctionPointer>(glBindAttribLocation),
 994     },
 995     {
 996      "glBindBuffer", reinterpret_cast<GLES2FunctionPointer>(glBindBuffer),
 997     },
 998     {
 999      "glBindFramebuffer",
1000      reinterpret_cast<GLES2FunctionPointer>(glBindFramebuffer),
1001     },
1002     {
1003      "glBindRenderbuffer",
1004      reinterpret_cast<GLES2FunctionPointer>(glBindRenderbuffer),
1005     },
1006     {
1007      "glBindTexture", reinterpret_cast<GLES2FunctionPointer>(glBindTexture),
1008     },
1009     {
1010      "glBlendColor", reinterpret_cast<GLES2FunctionPointer>(glBlendColor),
1011     },
1012     {
1013      "glBlendEquation", reinterpret_cast<GLES2FunctionPointer>(glBlendEquation),
1014     },
1015     {
1016      "glBlendEquationSeparate",
1017      reinterpret_cast<GLES2FunctionPointer>(glBlendEquationSeparate),
1018     },
1019     {
1020      "glBlendFunc", reinterpret_cast<GLES2FunctionPointer>(glBlendFunc),
1021     },
1022     {
1023      "glBlendFuncSeparate",
1024      reinterpret_cast<GLES2FunctionPointer>(glBlendFuncSeparate),
1025     },
1026     {
1027      "glBufferData", reinterpret_cast<GLES2FunctionPointer>(glBufferData),
1028     },
1029     {
1030      "glBufferSubData", reinterpret_cast<GLES2FunctionPointer>(glBufferSubData),
1031     },
1032     {
1033      "glCheckFramebufferStatus",
1034      reinterpret_cast<GLES2FunctionPointer>(glCheckFramebufferStatus),
1035     },
1036     {
1037      "glClear", reinterpret_cast<GLES2FunctionPointer>(glClear),
1038     },
1039     {
1040      "glClearColor", reinterpret_cast<GLES2FunctionPointer>(glClearColor),
1041     },
1042     {
1043      "glClearDepthf", reinterpret_cast<GLES2FunctionPointer>(glClearDepthf),
1044     },
1045     {
1046      "glClearStencil", reinterpret_cast<GLES2FunctionPointer>(glClearStencil),
1047     },
1048     {
1049      "glColorMask", reinterpret_cast<GLES2FunctionPointer>(glColorMask),
1050     },
1051     {
1052      "glCompileShader", reinterpret_cast<GLES2FunctionPointer>(glCompileShader),
1053     },
1054     {
1055      "glCompressedTexImage2D",
1056      reinterpret_cast<GLES2FunctionPointer>(glCompressedTexImage2D),
1057     },
1058     {
1059      "glCompressedTexSubImage2D",
1060      reinterpret_cast<GLES2FunctionPointer>(glCompressedTexSubImage2D),
1061     },
1062     {
1063      "glCopyTexImage2D",
1064      reinterpret_cast<GLES2FunctionPointer>(glCopyTexImage2D),
1065     },
1066     {
1067      "glCopyTexSubImage2D",
1068      reinterpret_cast<GLES2FunctionPointer>(glCopyTexSubImage2D),
1069     },
1070     {
1071      "glCreateProgram", reinterpret_cast<GLES2FunctionPointer>(glCreateProgram),
1072     },
1073     {
1074      "glCreateShader", reinterpret_cast<GLES2FunctionPointer>(glCreateShader),
1075     },
1076     {
1077      "glCullFace", reinterpret_cast<GLES2FunctionPointer>(glCullFace),
1078     },
1079     {
1080      "glDeleteBuffers", reinterpret_cast<GLES2FunctionPointer>(glDeleteBuffers),
1081     },
1082     {
1083      "glDeleteFramebuffers",
1084      reinterpret_cast<GLES2FunctionPointer>(glDeleteFramebuffers),
1085     },
1086     {
1087      "glDeleteProgram", reinterpret_cast<GLES2FunctionPointer>(glDeleteProgram),
1088     },
1089     {
1090      "glDeleteRenderbuffers",
1091      reinterpret_cast<GLES2FunctionPointer>(glDeleteRenderbuffers),
1092     },
1093     {
1094      "glDeleteShader", reinterpret_cast<GLES2FunctionPointer>(glDeleteShader),
1095     },
1096     {
1097      "glDeleteTextures",
1098      reinterpret_cast<GLES2FunctionPointer>(glDeleteTextures),
1099     },
1100     {
1101      "glDepthFunc", reinterpret_cast<GLES2FunctionPointer>(glDepthFunc),
1102     },
1103     {
1104      "glDepthMask", reinterpret_cast<GLES2FunctionPointer>(glDepthMask),
1105     },
1106     {
1107      "glDepthRangef", reinterpret_cast<GLES2FunctionPointer>(glDepthRangef),
1108     },
1109     {
1110      "glDetachShader", reinterpret_cast<GLES2FunctionPointer>(glDetachShader),
1111     },
1112     {
1113      "glDisable", reinterpret_cast<GLES2FunctionPointer>(glDisable),
1114     },
1115     {
1116      "glDisableVertexAttribArray",
1117      reinterpret_cast<GLES2FunctionPointer>(glDisableVertexAttribArray),
1118     },
1119     {
1120      "glDrawArrays", reinterpret_cast<GLES2FunctionPointer>(glDrawArrays),
1121     },
1122     {
1123      "glDrawElements", reinterpret_cast<GLES2FunctionPointer>(glDrawElements),
1124     },
1125     {
1126      "glEnable", reinterpret_cast<GLES2FunctionPointer>(glEnable),
1127     },
1128     {
1129      "glEnableVertexAttribArray",
1130      reinterpret_cast<GLES2FunctionPointer>(glEnableVertexAttribArray),
1131     },
1132     {
1133      "glFinish", reinterpret_cast<GLES2FunctionPointer>(glFinish),
1134     },
1135     {
1136      "glFlush", reinterpret_cast<GLES2FunctionPointer>(glFlush),
1137     },
1138     {
1139      "glFramebufferRenderbuffer",
1140      reinterpret_cast<GLES2FunctionPointer>(glFramebufferRenderbuffer),
1141     },
1142     {
1143      "glFramebufferTexture2D",
1144      reinterpret_cast<GLES2FunctionPointer>(glFramebufferTexture2D),
1145     },
1146     {
1147      "glFrontFace", reinterpret_cast<GLES2FunctionPointer>(glFrontFace),
1148     },
1149     {
1150      "glGenBuffers", reinterpret_cast<GLES2FunctionPointer>(glGenBuffers),
1151     },
1152     {
1153      "glGenerateMipmap",
1154      reinterpret_cast<GLES2FunctionPointer>(glGenerateMipmap),
1155     },
1156     {
1157      "glGenFramebuffers",
1158      reinterpret_cast<GLES2FunctionPointer>(glGenFramebuffers),
1159     },
1160     {
1161      "glGenRenderbuffers",
1162      reinterpret_cast<GLES2FunctionPointer>(glGenRenderbuffers),
1163     },
1164     {
1165      "glGenTextures", reinterpret_cast<GLES2FunctionPointer>(glGenTextures),
1166     },
1167     {
1168      "glGetActiveAttrib",
1169      reinterpret_cast<GLES2FunctionPointer>(glGetActiveAttrib),
1170     },
1171     {
1172      "glGetActiveUniform",
1173      reinterpret_cast<GLES2FunctionPointer>(glGetActiveUniform),
1174     },
1175     {
1176      "glGetAttachedShaders",
1177      reinterpret_cast<GLES2FunctionPointer>(glGetAttachedShaders),
1178     },
1179     {
1180      "glGetAttribLocation",
1181      reinterpret_cast<GLES2FunctionPointer>(glGetAttribLocation),
1182     },
1183     {
1184      "glGetBooleanv", reinterpret_cast<GLES2FunctionPointer>(glGetBooleanv),
1185     },
1186     {
1187      "glGetBufferParameteriv",
1188      reinterpret_cast<GLES2FunctionPointer>(glGetBufferParameteriv),
1189     },
1190     {
1191      "glGetError", reinterpret_cast<GLES2FunctionPointer>(glGetError),
1192     },
1193     {
1194      "glGetFloatv", reinterpret_cast<GLES2FunctionPointer>(glGetFloatv),
1195     },
1196     {
1197      "glGetFramebufferAttachmentParameteriv",
1198      reinterpret_cast<GLES2FunctionPointer>(
1199          glGetFramebufferAttachmentParameteriv),
1200     },
1201     {
1202      "glGetIntegerv", reinterpret_cast<GLES2FunctionPointer>(glGetIntegerv),
1203     },
1204     {
1205      "glGetProgramiv", reinterpret_cast<GLES2FunctionPointer>(glGetProgramiv),
1206     },
1207     {
1208      "glGetProgramInfoLog",
1209      reinterpret_cast<GLES2FunctionPointer>(glGetProgramInfoLog),
1210     },
1211     {
1212      "glGetRenderbufferParameteriv",
1213      reinterpret_cast<GLES2FunctionPointer>(glGetRenderbufferParameteriv),
1214     },
1215     {
1216      "glGetShaderiv", reinterpret_cast<GLES2FunctionPointer>(glGetShaderiv),
1217     },
1218     {
1219      "glGetShaderInfoLog",
1220      reinterpret_cast<GLES2FunctionPointer>(glGetShaderInfoLog),
1221     },
1222     {
1223      "glGetShaderPrecisionFormat",
1224      reinterpret_cast<GLES2FunctionPointer>(glGetShaderPrecisionFormat),
1225     },
1226     {
1227      "glGetShaderSource",
1228      reinterpret_cast<GLES2FunctionPointer>(glGetShaderSource),
1229     },
1230     {
1231      "glGetString", reinterpret_cast<GLES2FunctionPointer>(glGetString),
1232     },
1233     {
1234      "glGetTexParameterfv",
1235      reinterpret_cast<GLES2FunctionPointer>(glGetTexParameterfv),
1236     },
1237     {
1238      "glGetTexParameteriv",
1239      reinterpret_cast<GLES2FunctionPointer>(glGetTexParameteriv),
1240     },
1241     {
1242      "glGetUniformfv", reinterpret_cast<GLES2FunctionPointer>(glGetUniformfv),
1243     },
1244     {
1245      "glGetUniformiv", reinterpret_cast<GLES2FunctionPointer>(glGetUniformiv),
1246     },
1247     {
1248      "glGetUniformLocation",
1249      reinterpret_cast<GLES2FunctionPointer>(glGetUniformLocation),
1250     },
1251     {
1252      "glGetVertexAttribfv",
1253      reinterpret_cast<GLES2FunctionPointer>(glGetVertexAttribfv),
1254     },
1255     {
1256      "glGetVertexAttribiv",
1257      reinterpret_cast<GLES2FunctionPointer>(glGetVertexAttribiv),
1258     },
1259     {
1260      "glGetVertexAttribPointerv",
1261      reinterpret_cast<GLES2FunctionPointer>(glGetVertexAttribPointerv),
1262     },
1263     {
1264      "glHint", reinterpret_cast<GLES2FunctionPointer>(glHint),
1265     },
1266     {
1267      "glIsBuffer", reinterpret_cast<GLES2FunctionPointer>(glIsBuffer),
1268     },
1269     {
1270      "glIsEnabled", reinterpret_cast<GLES2FunctionPointer>(glIsEnabled),
1271     },
1272     {
1273      "glIsFramebuffer", reinterpret_cast<GLES2FunctionPointer>(glIsFramebuffer),
1274     },
1275     {
1276      "glIsProgram", reinterpret_cast<GLES2FunctionPointer>(glIsProgram),
1277     },
1278     {
1279      "glIsRenderbuffer",
1280      reinterpret_cast<GLES2FunctionPointer>(glIsRenderbuffer),
1281     },
1282     {
1283      "glIsShader", reinterpret_cast<GLES2FunctionPointer>(glIsShader),
1284     },
1285     {
1286      "glIsTexture", reinterpret_cast<GLES2FunctionPointer>(glIsTexture),
1287     },
1288     {
1289      "glLineWidth", reinterpret_cast<GLES2FunctionPointer>(glLineWidth),
1290     },
1291     {
1292      "glLinkProgram", reinterpret_cast<GLES2FunctionPointer>(glLinkProgram),
1293     },
1294     {
1295      "glPixelStorei", reinterpret_cast<GLES2FunctionPointer>(glPixelStorei),
1296     },
1297     {
1298      "glPolygonOffset", reinterpret_cast<GLES2FunctionPointer>(glPolygonOffset),
1299     },
1300     {
1301      "glReadPixels", reinterpret_cast<GLES2FunctionPointer>(glReadPixels),
1302     },
1303     {
1304      "glReleaseShaderCompiler",
1305      reinterpret_cast<GLES2FunctionPointer>(glReleaseShaderCompiler),
1306     },
1307     {
1308      "glRenderbufferStorage",
1309      reinterpret_cast<GLES2FunctionPointer>(glRenderbufferStorage),
1310     },
1311     {
1312      "glSampleCoverage",
1313      reinterpret_cast<GLES2FunctionPointer>(glSampleCoverage),
1314     },
1315     {
1316      "glScissor", reinterpret_cast<GLES2FunctionPointer>(glScissor),
1317     },
1318     {
1319      "glShaderBinary", reinterpret_cast<GLES2FunctionPointer>(glShaderBinary),
1320     },
1321     {
1322      "glShaderSource", reinterpret_cast<GLES2FunctionPointer>(glShaderSource),
1323     },
1324     {
1325      "glShallowFinishCHROMIUM",
1326      reinterpret_cast<GLES2FunctionPointer>(glShallowFinishCHROMIUM),
1327     },
1328     {
1329      "glShallowFlushCHROMIUM",
1330      reinterpret_cast<GLES2FunctionPointer>(glShallowFlushCHROMIUM),
1331     },
1332     {
1333      "glStencilFunc", reinterpret_cast<GLES2FunctionPointer>(glStencilFunc),
1334     },
1335     {
1336      "glStencilFuncSeparate",
1337      reinterpret_cast<GLES2FunctionPointer>(glStencilFuncSeparate),
1338     },
1339     {
1340      "glStencilMask", reinterpret_cast<GLES2FunctionPointer>(glStencilMask),
1341     },
1342     {
1343      "glStencilMaskSeparate",
1344      reinterpret_cast<GLES2FunctionPointer>(glStencilMaskSeparate),
1345     },
1346     {
1347      "glStencilOp", reinterpret_cast<GLES2FunctionPointer>(glStencilOp),
1348     },
1349     {
1350      "glStencilOpSeparate",
1351      reinterpret_cast<GLES2FunctionPointer>(glStencilOpSeparate),
1352     },
1353     {
1354      "glTexImage2D", reinterpret_cast<GLES2FunctionPointer>(glTexImage2D),
1355     },
1356     {
1357      "glTexParameterf", reinterpret_cast<GLES2FunctionPointer>(glTexParameterf),
1358     },
1359     {
1360      "glTexParameterfv",
1361      reinterpret_cast<GLES2FunctionPointer>(glTexParameterfv),
1362     },
1363     {
1364      "glTexParameteri", reinterpret_cast<GLES2FunctionPointer>(glTexParameteri),
1365     },
1366     {
1367      "glTexParameteriv",
1368      reinterpret_cast<GLES2FunctionPointer>(glTexParameteriv),
1369     },
1370     {
1371      "glTexSubImage2D", reinterpret_cast<GLES2FunctionPointer>(glTexSubImage2D),
1372     },
1373     {
1374      "glUniform1f", reinterpret_cast<GLES2FunctionPointer>(glUniform1f),
1375     },
1376     {
1377      "glUniform1fv", reinterpret_cast<GLES2FunctionPointer>(glUniform1fv),
1378     },
1379     {
1380      "glUniform1i", reinterpret_cast<GLES2FunctionPointer>(glUniform1i),
1381     },
1382     {
1383      "glUniform1iv", reinterpret_cast<GLES2FunctionPointer>(glUniform1iv),
1384     },
1385     {
1386      "glUniform2f", reinterpret_cast<GLES2FunctionPointer>(glUniform2f),
1387     },
1388     {
1389      "glUniform2fv", reinterpret_cast<GLES2FunctionPointer>(glUniform2fv),
1390     },
1391     {
1392      "glUniform2i", reinterpret_cast<GLES2FunctionPointer>(glUniform2i),
1393     },
1394     {
1395      "glUniform2iv", reinterpret_cast<GLES2FunctionPointer>(glUniform2iv),
1396     },
1397     {
1398      "glUniform3f", reinterpret_cast<GLES2FunctionPointer>(glUniform3f),
1399     },
1400     {
1401      "glUniform3fv", reinterpret_cast<GLES2FunctionPointer>(glUniform3fv),
1402     },
1403     {
1404      "glUniform3i", reinterpret_cast<GLES2FunctionPointer>(glUniform3i),
1405     },
1406     {
1407      "glUniform3iv", reinterpret_cast<GLES2FunctionPointer>(glUniform3iv),
1408     },
1409     {
1410      "glUniform4f", reinterpret_cast<GLES2FunctionPointer>(glUniform4f),
1411     },
1412     {
1413      "glUniform4fv", reinterpret_cast<GLES2FunctionPointer>(glUniform4fv),
1414     },
1415     {
1416      "glUniform4i", reinterpret_cast<GLES2FunctionPointer>(glUniform4i),
1417     },
1418     {
1419      "glUniform4iv", reinterpret_cast<GLES2FunctionPointer>(glUniform4iv),
1420     },
1421     {
1422      "glUniformMatrix2fv",
1423      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix2fv),
1424     },
1425     {
1426      "glUniformMatrix3fv",
1427      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix3fv),
1428     },
1429     {
1430      "glUniformMatrix4fv",
1431      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix4fv),
1432     },
1433     {
1434      "glUseProgram", reinterpret_cast<GLES2FunctionPointer>(glUseProgram),
1435     },
1436     {
1437      "glValidateProgram",
1438      reinterpret_cast<GLES2FunctionPointer>(glValidateProgram),
1439     },
1440     {
1441      "glVertexAttrib1f",
1442      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib1f),
1443     },
1444     {
1445      "glVertexAttrib1fv",
1446      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib1fv),
1447     },
1448     {
1449      "glVertexAttrib2f",
1450      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib2f),
1451     },
1452     {
1453      "glVertexAttrib2fv",
1454      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib2fv),
1455     },
1456     {
1457      "glVertexAttrib3f",
1458      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib3f),
1459     },
1460     {
1461      "glVertexAttrib3fv",
1462      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib3fv),
1463     },
1464     {
1465      "glVertexAttrib4f",
1466      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib4f),
1467     },
1468     {
1469      "glVertexAttrib4fv",
1470      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib4fv),
1471     },
1472     {
1473      "glVertexAttribPointer",
1474      reinterpret_cast<GLES2FunctionPointer>(glVertexAttribPointer),
1475     },
1476     {
1477      "glViewport", reinterpret_cast<GLES2FunctionPointer>(glViewport),
1478     },
1479     {
1480      "glBlitFramebufferCHROMIUM",
1481      reinterpret_cast<GLES2FunctionPointer>(glBlitFramebufferCHROMIUM),
1482     },
1483     {
1484      "glRenderbufferStorageMultisampleCHROMIUM",
1485      reinterpret_cast<GLES2FunctionPointer>(
1486          glRenderbufferStorageMultisampleCHROMIUM),
1487     },
1488     {
1489      "glRenderbufferStorageMultisampleEXT",
1490      reinterpret_cast<GLES2FunctionPointer>(
1491          glRenderbufferStorageMultisampleEXT),
1492     },
1493     {
1494      "glFramebufferTexture2DMultisampleEXT",
1495      reinterpret_cast<GLES2FunctionPointer>(
1496          glFramebufferTexture2DMultisampleEXT),
1497     },
1498     {
1499      "glTexStorage2DEXT",
1500      reinterpret_cast<GLES2FunctionPointer>(glTexStorage2DEXT),
1501     },
1502     {
1503      "glGenQueriesEXT", reinterpret_cast<GLES2FunctionPointer>(glGenQueriesEXT),
1504     },
1505     {
1506      "glDeleteQueriesEXT",
1507      reinterpret_cast<GLES2FunctionPointer>(glDeleteQueriesEXT),
1508     },
1509     {
1510      "glIsQueryEXT", reinterpret_cast<GLES2FunctionPointer>(glIsQueryEXT),
1511     },
1512     {
1513      "glBeginQueryEXT", reinterpret_cast<GLES2FunctionPointer>(glBeginQueryEXT),
1514     },
1515     {
1516      "glEndQueryEXT", reinterpret_cast<GLES2FunctionPointer>(glEndQueryEXT),
1517     },
1518     {
1519      "glGetQueryivEXT", reinterpret_cast<GLES2FunctionPointer>(glGetQueryivEXT),
1520     },
1521     {
1522      "glGetQueryObjectuivEXT",
1523      reinterpret_cast<GLES2FunctionPointer>(glGetQueryObjectuivEXT),
1524     },
1525     {
1526      "glInsertEventMarkerEXT",
1527      reinterpret_cast<GLES2FunctionPointer>(glInsertEventMarkerEXT),
1528     },
1529     {
1530      "glPushGroupMarkerEXT",
1531      reinterpret_cast<GLES2FunctionPointer>(glPushGroupMarkerEXT),
1532     },
1533     {
1534      "glPopGroupMarkerEXT",
1535      reinterpret_cast<GLES2FunctionPointer>(glPopGroupMarkerEXT),
1536     },
1537     {
1538      "glGenVertexArraysOES",
1539      reinterpret_cast<GLES2FunctionPointer>(glGenVertexArraysOES),
1540     },
1541     {
1542      "glDeleteVertexArraysOES",
1543      reinterpret_cast<GLES2FunctionPointer>(glDeleteVertexArraysOES),
1544     },
1545     {
1546      "glIsVertexArrayOES",
1547      reinterpret_cast<GLES2FunctionPointer>(glIsVertexArrayOES),
1548     },
1549     {
1550      "glBindVertexArrayOES",
1551      reinterpret_cast<GLES2FunctionPointer>(glBindVertexArrayOES),
1552     },
1553     {
1554      "glSwapBuffers", reinterpret_cast<GLES2FunctionPointer>(glSwapBuffers),
1555     },
1556     {
1557      "glGetMaxValueInBufferCHROMIUM",
1558      reinterpret_cast<GLES2FunctionPointer>(glGetMaxValueInBufferCHROMIUM),
1559     },
1560     {
1561      "glGenSharedIdsCHROMIUM",
1562      reinterpret_cast<GLES2FunctionPointer>(glGenSharedIdsCHROMIUM),
1563     },
1564     {
1565      "glDeleteSharedIdsCHROMIUM",
1566      reinterpret_cast<GLES2FunctionPointer>(glDeleteSharedIdsCHROMIUM),
1567     },
1568     {
1569      "glRegisterSharedIdsCHROMIUM",
1570      reinterpret_cast<GLES2FunctionPointer>(glRegisterSharedIdsCHROMIUM),
1571     },
1572     {
1573      "glEnableFeatureCHROMIUM",
1574      reinterpret_cast<GLES2FunctionPointer>(glEnableFeatureCHROMIUM),
1575     },
1576     {
1577      "glMapBufferCHROMIUM",
1578      reinterpret_cast<GLES2FunctionPointer>(glMapBufferCHROMIUM),
1579     },
1580     {
1581      "glUnmapBufferCHROMIUM",
1582      reinterpret_cast<GLES2FunctionPointer>(glUnmapBufferCHROMIUM),
1583     },
1584     {
1585      "glMapImageCHROMIUM",
1586      reinterpret_cast<GLES2FunctionPointer>(glMapImageCHROMIUM),
1587     },
1588     {
1589      "glUnmapImageCHROMIUM",
1590      reinterpret_cast<GLES2FunctionPointer>(glUnmapImageCHROMIUM),
1591     },
1592     {
1593      "glMapBufferSubDataCHROMIUM",
1594      reinterpret_cast<GLES2FunctionPointer>(glMapBufferSubDataCHROMIUM),
1595     },
1596     {
1597      "glUnmapBufferSubDataCHROMIUM",
1598      reinterpret_cast<GLES2FunctionPointer>(glUnmapBufferSubDataCHROMIUM),
1599     },
1600     {
1601      "glMapTexSubImage2DCHROMIUM",
1602      reinterpret_cast<GLES2FunctionPointer>(glMapTexSubImage2DCHROMIUM),
1603     },
1604     {
1605      "glUnmapTexSubImage2DCHROMIUM",
1606      reinterpret_cast<GLES2FunctionPointer>(glUnmapTexSubImage2DCHROMIUM),
1607     },
1608     {
1609      "glResizeCHROMIUM",
1610      reinterpret_cast<GLES2FunctionPointer>(glResizeCHROMIUM),
1611     },
1612     {
1613      "glGetRequestableExtensionsCHROMIUM",
1614      reinterpret_cast<GLES2FunctionPointer>(glGetRequestableExtensionsCHROMIUM),
1615     },
1616     {
1617      "glRequestExtensionCHROMIUM",
1618      reinterpret_cast<GLES2FunctionPointer>(glRequestExtensionCHROMIUM),
1619     },
1620     {
1621      "glRateLimitOffscreenContextCHROMIUM",
1622      reinterpret_cast<GLES2FunctionPointer>(
1623          glRateLimitOffscreenContextCHROMIUM),
1624     },
1625     {
1626      "glGetMultipleIntegervCHROMIUM",
1627      reinterpret_cast<GLES2FunctionPointer>(glGetMultipleIntegervCHROMIUM),
1628     },
1629     {
1630      "glGetProgramInfoCHROMIUM",
1631      reinterpret_cast<GLES2FunctionPointer>(glGetProgramInfoCHROMIUM),
1632     },
1633     {
1634      "glCreateStreamTextureCHROMIUM",
1635      reinterpret_cast<GLES2FunctionPointer>(glCreateStreamTextureCHROMIUM),
1636     },
1637     {
1638      "glCreateImageCHROMIUM",
1639      reinterpret_cast<GLES2FunctionPointer>(glCreateImageCHROMIUM),
1640     },
1641     {
1642      "glDestroyImageCHROMIUM",
1643      reinterpret_cast<GLES2FunctionPointer>(glDestroyImageCHROMIUM),
1644     },
1645     {
1646      "glGetImageParameterivCHROMIUM",
1647      reinterpret_cast<GLES2FunctionPointer>(glGetImageParameterivCHROMIUM),
1648     },
1649     {
1650      "glGetTranslatedShaderSourceANGLE",
1651      reinterpret_cast<GLES2FunctionPointer>(glGetTranslatedShaderSourceANGLE),
1652     },
1653     {
1654      "glPostSubBufferCHROMIUM",
1655      reinterpret_cast<GLES2FunctionPointer>(glPostSubBufferCHROMIUM),
1656     },
1657     {
1658      "glTexImageIOSurface2DCHROMIUM",
1659      reinterpret_cast<GLES2FunctionPointer>(glTexImageIOSurface2DCHROMIUM),
1660     },
1661     {
1662      "glCopyTextureCHROMIUM",
1663      reinterpret_cast<GLES2FunctionPointer>(glCopyTextureCHROMIUM),
1664     },
1665     {
1666      "glDrawArraysInstancedANGLE",
1667      reinterpret_cast<GLES2FunctionPointer>(glDrawArraysInstancedANGLE),
1668     },
1669     {
1670      "glDrawElementsInstancedANGLE",
1671      reinterpret_cast<GLES2FunctionPointer>(glDrawElementsInstancedANGLE),
1672     },
1673     {
1674      "glVertexAttribDivisorANGLE",
1675      reinterpret_cast<GLES2FunctionPointer>(glVertexAttribDivisorANGLE),
1676     },
1677     {
1678      "glGenMailboxCHROMIUM",
1679      reinterpret_cast<GLES2FunctionPointer>(glGenMailboxCHROMIUM),
1680     },
1681     {
1682      "glProduceTextureCHROMIUM",
1683      reinterpret_cast<GLES2FunctionPointer>(glProduceTextureCHROMIUM),
1684     },
1685     {
1686      "glProduceTextureDirectCHROMIUM",
1687      reinterpret_cast<GLES2FunctionPointer>(glProduceTextureDirectCHROMIUM),
1688     },
1689     {
1690      "glConsumeTextureCHROMIUM",
1691      reinterpret_cast<GLES2FunctionPointer>(glConsumeTextureCHROMIUM),
1692     },
1693     {
1694      "glCreateAndConsumeTextureCHROMIUM",
1695      reinterpret_cast<GLES2FunctionPointer>(glCreateAndConsumeTextureCHROMIUM),
1696     },
1697     {
1698      "glBindUniformLocationCHROMIUM",
1699      reinterpret_cast<GLES2FunctionPointer>(glBindUniformLocationCHROMIUM),
1700     },
1701     {
1702      "glBindTexImage2DCHROMIUM",
1703      reinterpret_cast<GLES2FunctionPointer>(glBindTexImage2DCHROMIUM),
1704     },
1705     {
1706      "glReleaseTexImage2DCHROMIUM",
1707      reinterpret_cast<GLES2FunctionPointer>(glReleaseTexImage2DCHROMIUM),
1708     },
1709     {
1710      "glTraceBeginCHROMIUM",
1711      reinterpret_cast<GLES2FunctionPointer>(glTraceBeginCHROMIUM),
1712     },
1713     {
1714      "glTraceEndCHROMIUM",
1715      reinterpret_cast<GLES2FunctionPointer>(glTraceEndCHROMIUM),
1716     },
1717     {
1718      "glAsyncTexSubImage2DCHROMIUM",
1719      reinterpret_cast<GLES2FunctionPointer>(glAsyncTexSubImage2DCHROMIUM),
1720     },
1721     {
1722      "glAsyncTexImage2DCHROMIUM",
1723      reinterpret_cast<GLES2FunctionPointer>(glAsyncTexImage2DCHROMIUM),
1724     },
1725     {
1726      "glWaitAsyncTexImage2DCHROMIUM",
1727      reinterpret_cast<GLES2FunctionPointer>(glWaitAsyncTexImage2DCHROMIUM),
1728     },
1729     {
1730      "glWaitAllAsyncTexImage2DCHROMIUM",
1731      reinterpret_cast<GLES2FunctionPointer>(glWaitAllAsyncTexImage2DCHROMIUM),
1732     },
1733     {
1734      "glDiscardFramebufferEXT",
1735      reinterpret_cast<GLES2FunctionPointer>(glDiscardFramebufferEXT),
1736     },
1737     {
1738      "glLoseContextCHROMIUM",
1739      reinterpret_cast<GLES2FunctionPointer>(glLoseContextCHROMIUM),
1740     },
1741     {
1742      "glInsertSyncPointCHROMIUM",
1743      reinterpret_cast<GLES2FunctionPointer>(glInsertSyncPointCHROMIUM),
1744     },
1745     {
1746      "glWaitSyncPointCHROMIUM",
1747      reinterpret_cast<GLES2FunctionPointer>(glWaitSyncPointCHROMIUM),
1748     },
1749     {
1750      "glDrawBuffersEXT",
1751      reinterpret_cast<GLES2FunctionPointer>(glDrawBuffersEXT),
1752     },
1753     {
1754      "glDiscardBackbufferCHROMIUM",
1755      reinterpret_cast<GLES2FunctionPointer>(glDiscardBackbufferCHROMIUM),
1756     },
1757     {
1758      "glScheduleOverlayPlaneCHROMIUM",
1759      reinterpret_cast<GLES2FunctionPointer>(glScheduleOverlayPlaneCHROMIUM),
1760     },
1761     {
1762      "glMatrixLoadfCHROMIUM",
1763      reinterpret_cast<GLES2FunctionPointer>(glMatrixLoadfCHROMIUM),
1764     },
1765     {
1766      "glMatrixLoadIdentityCHROMIUM",
1767      reinterpret_cast<GLES2FunctionPointer>(glMatrixLoadIdentityCHROMIUM),
1768     },
1769     {
1770      NULL, NULL,
1771     },
1772 };
1773
1774 }  // namespace gles2
1775 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_C_LIB_AUTOGEN_H_