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 GLES2BindBufferBase(GLenum target, GLuint index, GLuint buffer) {
  28   gles2::GetGLContext()->BindBufferBase(target, index, buffer);
  29 }
  30 void GLES2BindBufferRange(GLenum target,
  31                           GLuint index,
  32                           GLuint buffer,
  33                           GLintptr offset,
  34                           GLsizeiptr size) {
  35   gles2::GetGLContext()->BindBufferRange(target, index, buffer, offset, size);
  36 }
  37 void GLES2BindFramebuffer(GLenum target, GLuint framebuffer) {
  38   gles2::GetGLContext()->BindFramebuffer(target, framebuffer);
  39 }
  40 void GLES2BindRenderbuffer(GLenum target, GLuint renderbuffer) {
  41   gles2::GetGLContext()->BindRenderbuffer(target, renderbuffer);
  42 }
  43 void GLES2BindSampler(GLuint unit, GLuint sampler) {
  44   gles2::GetGLContext()->BindSampler(unit, sampler);
  45 }
  46 void GLES2BindTexture(GLenum target, GLuint texture) {
  47   gles2::GetGLContext()->BindTexture(target, texture);
  48 }
  49 void GLES2BindTransformFeedback(GLenum target, GLuint transformfeedback) {
  50   gles2::GetGLContext()->BindTransformFeedback(target, transformfeedback);
  51 }
  52 void GLES2BlendColor(GLclampf red,
  53                      GLclampf green,
  54                      GLclampf blue,
  55                      GLclampf alpha) {
  56   gles2::GetGLContext()->BlendColor(red, green, blue, alpha);
  57 }
  58 void GLES2BlendEquation(GLenum mode) {
  59   gles2::GetGLContext()->BlendEquation(mode);
  60 }
  61 void GLES2BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
  62   gles2::GetGLContext()->BlendEquationSeparate(modeRGB, modeAlpha);
  63 }
  64 void GLES2BlendFunc(GLenum sfactor, GLenum dfactor) {
  65   gles2::GetGLContext()->BlendFunc(sfactor, dfactor);
  66 }
  67 void GLES2BlendFuncSeparate(GLenum srcRGB,
  68                             GLenum dstRGB,
  69                             GLenum srcAlpha,
  70                             GLenum dstAlpha) {
  71   gles2::GetGLContext()->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
  72 }
  73 void GLES2BufferData(GLenum target,
  74                      GLsizeiptr size,
  75                      const void* data,
  76                      GLenum usage) {
  77   gles2::GetGLContext()->BufferData(target, size, data, usage);
  78 }
  79 void GLES2BufferSubData(GLenum target,
  80                         GLintptr offset,
  81                         GLsizeiptr size,
  82                         const void* data) {
  83   gles2::GetGLContext()->BufferSubData(target, offset, size, data);
  84 }
  85 GLenum GLES2CheckFramebufferStatus(GLenum target) {
  86   return gles2::GetGLContext()->CheckFramebufferStatus(target);
  87 }
  88 void GLES2Clear(GLbitfield mask) {
  89   gles2::GetGLContext()->Clear(mask);
  90 }
  91 void GLES2ClearBufferfi(GLenum buffer,
  92                         GLint drawbuffers,
  93                         GLfloat depth,
  94                         GLint stencil) {
  95   gles2::GetGLContext()->ClearBufferfi(buffer, drawbuffers, depth, stencil);
  96 }
  97 void GLES2ClearBufferfv(GLenum buffer,
  98                         GLint drawbuffers,
  99                         const GLfloat* value) {
 100   gles2::GetGLContext()->ClearBufferfv(buffer, drawbuffers, value);
 101 }
 102 void GLES2ClearBufferiv(GLenum buffer, GLint drawbuffers, const GLint* value) {
 103   gles2::GetGLContext()->ClearBufferiv(buffer, drawbuffers, value);
 104 }
 105 void GLES2ClearBufferuiv(GLenum buffer,
 106                          GLint drawbuffers,
 107                          const GLuint* value) {
 108   gles2::GetGLContext()->ClearBufferuiv(buffer, drawbuffers, value);
 109 }
 110 void GLES2ClearColor(GLclampf red,
 111                      GLclampf green,
 112                      GLclampf blue,
 113                      GLclampf alpha) {
 114   gles2::GetGLContext()->ClearColor(red, green, blue, alpha);
 115 }
 116 void GLES2ClearDepthf(GLclampf depth) {
 117   gles2::GetGLContext()->ClearDepthf(depth);
 118 }
 119 void GLES2ClearStencil(GLint s) {
 120   gles2::GetGLContext()->ClearStencil(s);
 121 }
 122 GLenum GLES2ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
 123   return gles2::GetGLContext()->ClientWaitSync(sync, flags, timeout);
 124 }
 125 void GLES2ColorMask(GLboolean red,
 126                     GLboolean green,
 127                     GLboolean blue,
 128                     GLboolean alpha) {
 129   gles2::GetGLContext()->ColorMask(red, green, blue, alpha);
 130 }
 131 void GLES2CompileShader(GLuint shader) {
 132   gles2::GetGLContext()->CompileShader(shader);
 133 }
 134 void GLES2CompressedTexImage2D(GLenum target,
 135                                GLint level,
 136                                GLenum internalformat,
 137                                GLsizei width,
 138                                GLsizei height,
 139                                GLint border,
 140                                GLsizei imageSize,
 141                                const void* data) {
 142   gles2::GetGLContext()->CompressedTexImage2D(
 143       target, level, internalformat, width, height, border, imageSize, data);
 144 }
 145 void GLES2CompressedTexSubImage2D(GLenum target,
 146                                   GLint level,
 147                                   GLint xoffset,
 148                                   GLint yoffset,
 149                                   GLsizei width,
 150                                   GLsizei height,
 151                                   GLenum format,
 152                                   GLsizei imageSize,
 153                                   const void* data) {
 154   gles2::GetGLContext()->CompressedTexSubImage2D(
 155       target, level, xoffset, yoffset, width, height, format, imageSize, data);
 156 }
 157 void GLES2CompressedTexImage3D(GLenum target,
 158                                GLint level,
 159                                GLenum internalformat,
 160                                GLsizei width,
 161                                GLsizei height,
 162                                GLsizei depth,
 163                                GLint border,
 164                                GLsizei imageSize,
 165                                const void* data) {
 166   gles2::GetGLContext()->CompressedTexImage3D(target, level, internalformat,
 167                                               width, height, depth, border,
 168                                               imageSize, data);
 169 }
 170 void GLES2CompressedTexSubImage3D(GLenum target,
 171                                   GLint level,
 172                                   GLint xoffset,
 173                                   GLint yoffset,
 174                                   GLint zoffset,
 175                                   GLsizei width,
 176                                   GLsizei height,
 177                                   GLsizei depth,
 178                                   GLenum format,
 179                                   GLsizei imageSize,
 180                                   const void* data) {
 181   gles2::GetGLContext()->CompressedTexSubImage3D(
 182       target, level, xoffset, yoffset, zoffset, width, height, depth, format,
 183       imageSize, data);
 184 }
 185 void GLES2CopyBufferSubData(GLenum readtarget,
 186                             GLenum writetarget,
 187                             GLintptr readoffset,
 188                             GLintptr writeoffset,
 189                             GLsizeiptr size) {
 190   gles2::GetGLContext()->CopyBufferSubData(readtarget, writetarget, readoffset,
 191                                            writeoffset, size);
 192 }
 193 void GLES2CopyTexImage2D(GLenum target,
 194                          GLint level,
 195                          GLenum internalformat,
 196                          GLint x,
 197                          GLint y,
 198                          GLsizei width,
 199                          GLsizei height,
 200                          GLint border) {
 201   gles2::GetGLContext()->CopyTexImage2D(target, level, internalformat, x, y,
 202                                         width, height, border);
 203 }
 204 void GLES2CopyTexSubImage2D(GLenum target,
 205                             GLint level,
 206                             GLint xoffset,
 207                             GLint yoffset,
 208                             GLint x,
 209                             GLint y,
 210                             GLsizei width,
 211                             GLsizei height) {
 212   gles2::GetGLContext()->CopyTexSubImage2D(target, level, xoffset, yoffset, x,
 213                                            y, width, height);
 214 }
 215 void GLES2CopyTexSubImage3D(GLenum target,
 216                             GLint level,
 217                             GLint xoffset,
 218                             GLint yoffset,
 219                             GLint zoffset,
 220                             GLint x,
 221                             GLint y,
 222                             GLsizei width,
 223                             GLsizei height) {
 224   gles2::GetGLContext()->CopyTexSubImage3D(target, level, xoffset, yoffset,
 225                                            zoffset, x, y, width, height);
 226 }
 227 GLuint GLES2CreateProgram() {
 228   return gles2::GetGLContext()->CreateProgram();
 229 }
 230 GLuint GLES2CreateShader(GLenum type) {
 231   return gles2::GetGLContext()->CreateShader(type);
 232 }
 233 void GLES2CullFace(GLenum mode) {
 234   gles2::GetGLContext()->CullFace(mode);
 235 }
 236 void GLES2DeleteBuffers(GLsizei n, const GLuint* buffers) {
 237   gles2::GetGLContext()->DeleteBuffers(n, buffers);
 238 }
 239 void GLES2DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
 240   gles2::GetGLContext()->DeleteFramebuffers(n, framebuffers);
 241 }
 242 void GLES2DeleteProgram(GLuint program) {
 243   gles2::GetGLContext()->DeleteProgram(program);
 244 }
 245 void GLES2DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
 246   gles2::GetGLContext()->DeleteRenderbuffers(n, renderbuffers);
 247 }
 248 void GLES2DeleteSamplers(GLsizei n, const GLuint* samplers) {
 249   gles2::GetGLContext()->DeleteSamplers(n, samplers);
 250 }
 251 void GLES2DeleteSync(GLsync sync) {
 252   gles2::GetGLContext()->DeleteSync(sync);
 253 }
 254 void GLES2DeleteShader(GLuint shader) {
 255   gles2::GetGLContext()->DeleteShader(shader);
 256 }
 257 void GLES2DeleteTextures(GLsizei n, const GLuint* textures) {
 258   gles2::GetGLContext()->DeleteTextures(n, textures);
 259 }
 260 void GLES2DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
 261   gles2::GetGLContext()->DeleteTransformFeedbacks(n, ids);
 262 }
 263 void GLES2DepthFunc(GLenum func) {
 264   gles2::GetGLContext()->DepthFunc(func);
 265 }
 266 void GLES2DepthMask(GLboolean flag) {
 267   gles2::GetGLContext()->DepthMask(flag);
 268 }
 269 void GLES2DepthRangef(GLclampf zNear, GLclampf zFar) {
 270   gles2::GetGLContext()->DepthRangef(zNear, zFar);
 271 }
 272 void GLES2DetachShader(GLuint program, GLuint shader) {
 273   gles2::GetGLContext()->DetachShader(program, shader);
 274 }
 275 void GLES2Disable(GLenum cap) {
 276   gles2::GetGLContext()->Disable(cap);
 277 }
 278 void GLES2DisableVertexAttribArray(GLuint index) {
 279   gles2::GetGLContext()->DisableVertexAttribArray(index);
 280 }
 281 void GLES2DrawArrays(GLenum mode, GLint first, GLsizei count) {
 282   gles2::GetGLContext()->DrawArrays(mode, first, count);
 283 }
 284 void GLES2DrawElements(GLenum mode,
 285                        GLsizei count,
 286                        GLenum type,
 287                        const void* indices) {
 288   gles2::GetGLContext()->DrawElements(mode, count, type, indices);
 289 }
 290 void GLES2DrawRangeElements(GLenum mode,
 291                             GLuint start,
 292                             GLuint end,
 293                             GLsizei count,
 294                             GLenum type,
 295                             const void* indices) {
 296   gles2::GetGLContext()->DrawRangeElements(mode, start, end, count, type,
 297                                            indices);
 298 }
 299 void GLES2Enable(GLenum cap) {
 300   gles2::GetGLContext()->Enable(cap);
 301 }
 302 void GLES2EnableVertexAttribArray(GLuint index) {
 303   gles2::GetGLContext()->EnableVertexAttribArray(index);
 304 }
 305 GLsync GLES2FenceSync(GLenum condition, GLbitfield flags) {
 306   return gles2::GetGLContext()->FenceSync(condition, flags);
 307 }
 308 void GLES2Finish() {
 309   gles2::GetGLContext()->Finish();
 310 }
 311 void GLES2Flush() {
 312   gles2::GetGLContext()->Flush();
 313 }
 314 void GLES2FramebufferRenderbuffer(GLenum target,
 315                                   GLenum attachment,
 316                                   GLenum renderbuffertarget,
 317                                   GLuint renderbuffer) {
 318   gles2::GetGLContext()->FramebufferRenderbuffer(
 319       target, attachment, renderbuffertarget, renderbuffer);
 320 }
 321 void GLES2FramebufferTexture2D(GLenum target,
 322                                GLenum attachment,
 323                                GLenum textarget,
 324                                GLuint texture,
 325                                GLint level) {
 326   gles2::GetGLContext()->FramebufferTexture2D(target, attachment, textarget,
 327                                               texture, level);
 328 }
 329 void GLES2FramebufferTextureLayer(GLenum target,
 330                                   GLenum attachment,
 331                                   GLuint texture,
 332                                   GLint level,
 333                                   GLint layer) {
 334   gles2::GetGLContext()->FramebufferTextureLayer(target, attachment, texture,
 335                                                  level, layer);
 336 }
 337 void GLES2FrontFace(GLenum mode) {
 338   gles2::GetGLContext()->FrontFace(mode);
 339 }
 340 void GLES2GenBuffers(GLsizei n, GLuint* buffers) {
 341   gles2::GetGLContext()->GenBuffers(n, buffers);
 342 }
 343 void GLES2GenerateMipmap(GLenum target) {
 344   gles2::GetGLContext()->GenerateMipmap(target);
 345 }
 346 void GLES2GenFramebuffers(GLsizei n, GLuint* framebuffers) {
 347   gles2::GetGLContext()->GenFramebuffers(n, framebuffers);
 348 }
 349 void GLES2GenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
 350   gles2::GetGLContext()->GenRenderbuffers(n, renderbuffers);
 351 }
 352 void GLES2GenSamplers(GLsizei n, GLuint* samplers) {
 353   gles2::GetGLContext()->GenSamplers(n, samplers);
 354 }
 355 void GLES2GenTextures(GLsizei n, GLuint* textures) {
 356   gles2::GetGLContext()->GenTextures(n, textures);
 357 }
 358 void GLES2GenTransformFeedbacks(GLsizei n, GLuint* ids) {
 359   gles2::GetGLContext()->GenTransformFeedbacks(n, ids);
 360 }
 361 void GLES2GetActiveAttrib(GLuint program,
 362                           GLuint index,
 363                           GLsizei bufsize,
 364                           GLsizei* length,
 365                           GLint* size,
 366                           GLenum* type,
 367                           char* name) {
 368   gles2::GetGLContext()->GetActiveAttrib(program, index, bufsize, length, size,
 369                                          type, name);
 370 }
 371 void GLES2GetActiveUniform(GLuint program,
 372                            GLuint index,
 373                            GLsizei bufsize,
 374                            GLsizei* length,
 375                            GLint* size,
 376                            GLenum* type,
 377                            char* name) {
 378   gles2::GetGLContext()->GetActiveUniform(program, index, bufsize, length, size,
 379                                           type, name);
 380 }
 381 void GLES2GetActiveUniformBlockiv(GLuint program,
 382                                   GLuint index,
 383                                   GLenum pname,
 384                                   GLint* params) {
 385   gles2::GetGLContext()->GetActiveUniformBlockiv(program, index, pname, params);
 386 }
 387 void GLES2GetActiveUniformBlockName(GLuint program,
 388                                     GLuint index,
 389                                     GLsizei bufsize,
 390                                     GLsizei* length,
 391                                     char* name) {
 392   gles2::GetGLContext()->GetActiveUniformBlockName(program, index, bufsize,
 393                                                    length, name);
 394 }
 395 void GLES2GetActiveUniformsiv(GLuint program,
 396                               GLsizei count,
 397                               const GLuint* indices,
 398                               GLenum pname,
 399                               GLint* params) {
 400   gles2::GetGLContext()->GetActiveUniformsiv(program, count, indices, pname,
 401                                              params);
 402 }
 403 void GLES2GetAttachedShaders(GLuint program,
 404                              GLsizei maxcount,
 405                              GLsizei* count,
 406                              GLuint* shaders) {
 407   gles2::GetGLContext()->GetAttachedShaders(program, maxcount, count, shaders);
 408 }
 409 GLint GLES2GetAttribLocation(GLuint program, const char* name) {
 410   return gles2::GetGLContext()->GetAttribLocation(program, name);
 411 }
 412 void GLES2GetBooleanv(GLenum pname, GLboolean* params) {
 413   gles2::GetGLContext()->GetBooleanv(pname, params);
 414 }
 415 void GLES2GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
 416   gles2::GetGLContext()->GetBufferParameteriv(target, pname, params);
 417 }
 418 GLenum GLES2GetError() {
 419   return gles2::GetGLContext()->GetError();
 420 }
 421 void GLES2GetFloatv(GLenum pname, GLfloat* params) {
 422   gles2::GetGLContext()->GetFloatv(pname, params);
 423 }
 424 GLint GLES2GetFragDataLocation(GLuint program, const char* name) {
 425   return gles2::GetGLContext()->GetFragDataLocation(program, name);
 426 }
 427 void GLES2GetFramebufferAttachmentParameteriv(GLenum target,
 428                                               GLenum attachment,
 429                                               GLenum pname,
 430                                               GLint* params) {
 431   gles2::GetGLContext()->GetFramebufferAttachmentParameteriv(target, attachment,
 432                                                              pname, params);
 433 }
 434 void GLES2GetInteger64v(GLenum pname, GLint64* params) {
 435   gles2::GetGLContext()->GetInteger64v(pname, params);
 436 }
 437 void GLES2GetIntegeri_v(GLenum pname, GLuint index, GLint* data) {
 438   gles2::GetGLContext()->GetIntegeri_v(pname, index, data);
 439 }
 440 void GLES2GetInteger64i_v(GLenum pname, GLuint index, GLint64* data) {
 441   gles2::GetGLContext()->GetInteger64i_v(pname, index, data);
 442 }
 443 void GLES2GetIntegerv(GLenum pname, GLint* params) {
 444   gles2::GetGLContext()->GetIntegerv(pname, params);
 445 }
 446 void GLES2GetInternalformativ(GLenum target,
 447                               GLenum format,
 448                               GLenum pname,
 449                               GLsizei bufSize,
 450                               GLint* params) {
 451   gles2::GetGLContext()->GetInternalformativ(target, format, pname, bufSize,
 452                                              params);
 453 }
 454 void GLES2GetProgramiv(GLuint program, GLenum pname, GLint* params) {
 455   gles2::GetGLContext()->GetProgramiv(program, pname, params);
 456 }
 457 void GLES2GetProgramInfoLog(GLuint program,
 458                             GLsizei bufsize,
 459                             GLsizei* length,
 460                             char* infolog) {
 461   gles2::GetGLContext()->GetProgramInfoLog(program, bufsize, length, infolog);
 462 }
 463 void GLES2GetRenderbufferParameteriv(GLenum target,
 464                                      GLenum pname,
 465                                      GLint* params) {
 466   gles2::GetGLContext()->GetRenderbufferParameteriv(target, pname, params);
 467 }
 468 void GLES2GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) {
 469   gles2::GetGLContext()->GetSamplerParameterfv(sampler, pname, params);
 470 }
 471 void GLES2GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) {
 472   gles2::GetGLContext()->GetSamplerParameteriv(sampler, pname, params);
 473 }
 474 void GLES2GetShaderiv(GLuint shader, GLenum pname, GLint* params) {
 475   gles2::GetGLContext()->GetShaderiv(shader, pname, params);
 476 }
 477 void GLES2GetShaderInfoLog(GLuint shader,
 478                            GLsizei bufsize,
 479                            GLsizei* length,
 480                            char* infolog) {
 481   gles2::GetGLContext()->GetShaderInfoLog(shader, bufsize, length, infolog);
 482 }
 483 void GLES2GetShaderPrecisionFormat(GLenum shadertype,
 484                                    GLenum precisiontype,
 485                                    GLint* range,
 486                                    GLint* precision) {
 487   gles2::GetGLContext()->GetShaderPrecisionFormat(shadertype, precisiontype,
 488                                                   range, precision);
 489 }
 490 void GLES2GetShaderSource(GLuint shader,
 491                           GLsizei bufsize,
 492                           GLsizei* length,
 493                           char* source) {
 494   gles2::GetGLContext()->GetShaderSource(shader, bufsize, length, source);
 495 }
 496 const GLubyte* GLES2GetString(GLenum name) {
 497   return gles2::GetGLContext()->GetString(name);
 498 }
 499 void GLES2GetSynciv(GLsync sync,
 500                     GLenum pname,
 501                     GLsizei bufsize,
 502                     GLsizei* length,
 503                     GLint* values) {
 504   gles2::GetGLContext()->GetSynciv(sync, pname, bufsize, length, values);
 505 }
 506 void GLES2GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
 507   gles2::GetGLContext()->GetTexParameterfv(target, pname, params);
 508 }
 509 void GLES2GetTexParameteriv(GLenum target, GLenum pname, GLint* params) {
 510   gles2::GetGLContext()->GetTexParameteriv(target, pname, params);
 511 }
 512 void GLES2GetTransformFeedbackVarying(GLuint program,
 513                                       GLuint index,
 514                                       GLsizei bufsize,
 515                                       GLsizei* length,
 516                                       GLsizei* size,
 517                                       GLenum* type,
 518                                       char* name) {
 519   gles2::GetGLContext()->GetTransformFeedbackVarying(program, index, bufsize,
 520                                                      length, size, type, name);
 521 }
 522 GLuint GLES2GetUniformBlockIndex(GLuint program, const char* name) {
 523   return gles2::GetGLContext()->GetUniformBlockIndex(program, name);
 524 }
 525 void GLES2GetUniformfv(GLuint program, GLint location, GLfloat* params) {
 526   gles2::GetGLContext()->GetUniformfv(program, location, params);
 527 }
 528 void GLES2GetUniformiv(GLuint program, GLint location, GLint* params) {
 529   gles2::GetGLContext()->GetUniformiv(program, location, params);
 530 }
 531 void GLES2GetUniformuiv(GLuint program, GLint location, GLuint* params) {
 532   gles2::GetGLContext()->GetUniformuiv(program, location, params);
 533 }
 534 void GLES2GetUniformIndices(GLuint program,
 535                             GLsizei count,
 536                             const char* const* names,
 537                             GLuint* indices) {
 538   gles2::GetGLContext()->GetUniformIndices(program, count, names, indices);
 539 }
 540 GLint GLES2GetUniformLocation(GLuint program, const char* name) {
 541   return gles2::GetGLContext()->GetUniformLocation(program, name);
 542 }
 543 void GLES2GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) {
 544   gles2::GetGLContext()->GetVertexAttribfv(index, pname, params);
 545 }
 546 void GLES2GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) {
 547   gles2::GetGLContext()->GetVertexAttribiv(index, pname, params);
 548 }
 549 void GLES2GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) {
 550   gles2::GetGLContext()->GetVertexAttribIiv(index, pname, params);
 551 }
 552 void GLES2GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) {
 553   gles2::GetGLContext()->GetVertexAttribIuiv(index, pname, params);
 554 }
 555 void GLES2GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) {
 556   gles2::GetGLContext()->GetVertexAttribPointerv(index, pname, pointer);
 557 }
 558 void GLES2Hint(GLenum target, GLenum mode) {
 559   gles2::GetGLContext()->Hint(target, mode);
 560 }
 561 void GLES2InvalidateFramebuffer(GLenum target,
 562                                 GLsizei count,
 563                                 const GLenum* attachments) {
 564   gles2::GetGLContext()->InvalidateFramebuffer(target, count, attachments);
 565 }
 566 void GLES2InvalidateSubFramebuffer(GLenum target,
 567                                    GLsizei count,
 568                                    const GLenum* attachments,
 569                                    GLint x,
 570                                    GLint y,
 571                                    GLsizei width,
 572                                    GLsizei height) {
 573   gles2::GetGLContext()->InvalidateSubFramebuffer(target, count, attachments, x,
 574                                                   y, width, height);
 575 }
 576 GLboolean GLES2IsBuffer(GLuint buffer) {
 577   return gles2::GetGLContext()->IsBuffer(buffer);
 578 }
 579 GLboolean GLES2IsEnabled(GLenum cap) {
 580   return gles2::GetGLContext()->IsEnabled(cap);
 581 }
 582 GLboolean GLES2IsFramebuffer(GLuint framebuffer) {
 583   return gles2::GetGLContext()->IsFramebuffer(framebuffer);
 584 }
 585 GLboolean GLES2IsProgram(GLuint program) {
 586   return gles2::GetGLContext()->IsProgram(program);
 587 }
 588 GLboolean GLES2IsRenderbuffer(GLuint renderbuffer) {
 589   return gles2::GetGLContext()->IsRenderbuffer(renderbuffer);
 590 }
 591 GLboolean GLES2IsSampler(GLuint sampler) {
 592   return gles2::GetGLContext()->IsSampler(sampler);
 593 }
 594 GLboolean GLES2IsShader(GLuint shader) {
 595   return gles2::GetGLContext()->IsShader(shader);
 596 }
 597 GLboolean GLES2IsSync(GLsync sync) {
 598   return gles2::GetGLContext()->IsSync(sync);
 599 }
 600 GLboolean GLES2IsTexture(GLuint texture) {
 601   return gles2::GetGLContext()->IsTexture(texture);
 602 }
 603 GLboolean GLES2IsTransformFeedback(GLuint transformfeedback) {
 604   return gles2::GetGLContext()->IsTransformFeedback(transformfeedback);
 605 }
 606 void GLES2LineWidth(GLfloat width) {
 607   gles2::GetGLContext()->LineWidth(width);
 608 }
 609 void GLES2LinkProgram(GLuint program) {
 610   gles2::GetGLContext()->LinkProgram(program);
 611 }
 612 void GLES2PauseTransformFeedback() {
 613   gles2::GetGLContext()->PauseTransformFeedback();
 614 }
 615 void GLES2PixelStorei(GLenum pname, GLint param) {
 616   gles2::GetGLContext()->PixelStorei(pname, param);
 617 }
 618 void GLES2PolygonOffset(GLfloat factor, GLfloat units) {
 619   gles2::GetGLContext()->PolygonOffset(factor, units);
 620 }
 621 void GLES2ReadBuffer(GLenum src) {
 622   gles2::GetGLContext()->ReadBuffer(src);
 623 }
 624 void GLES2ReadPixels(GLint x,
 625                      GLint y,
 626                      GLsizei width,
 627                      GLsizei height,
 628                      GLenum format,
 629                      GLenum type,
 630                      void* pixels) {
 631   gles2::GetGLContext()->ReadPixels(x, y, width, height, format, type, pixels);
 632 }
 633 void GLES2ReleaseShaderCompiler() {
 634   gles2::GetGLContext()->ReleaseShaderCompiler();
 635 }
 636 void GLES2RenderbufferStorage(GLenum target,
 637                               GLenum internalformat,
 638                               GLsizei width,
 639                               GLsizei height) {
 640   gles2::GetGLContext()->RenderbufferStorage(target, internalformat, width,
 641                                              height);
 642 }
 643 void GLES2ResumeTransformFeedback() {
 644   gles2::GetGLContext()->ResumeTransformFeedback();
 645 }
 646 void GLES2SampleCoverage(GLclampf value, GLboolean invert) {
 647   gles2::GetGLContext()->SampleCoverage(value, invert);
 648 }
 649 void GLES2SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) {
 650   gles2::GetGLContext()->SamplerParameterf(sampler, pname, param);
 651 }
 652 void GLES2SamplerParameterfv(GLuint sampler,
 653                              GLenum pname,
 654                              const GLfloat* params) {
 655   gles2::GetGLContext()->SamplerParameterfv(sampler, pname, params);
 656 }
 657 void GLES2SamplerParameteri(GLuint sampler, GLenum pname, GLint param) {
 658   gles2::GetGLContext()->SamplerParameteri(sampler, pname, param);
 659 }
 660 void GLES2SamplerParameteriv(GLuint sampler,
 661                              GLenum pname,
 662                              const GLint* params) {
 663   gles2::GetGLContext()->SamplerParameteriv(sampler, pname, params);
 664 }
 665 void GLES2Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
 666   gles2::GetGLContext()->Scissor(x, y, width, height);
 667 }
 668 void GLES2ShaderBinary(GLsizei n,
 669                        const GLuint* shaders,
 670                        GLenum binaryformat,
 671                        const void* binary,
 672                        GLsizei length) {
 673   gles2::GetGLContext()->ShaderBinary(n, shaders, binaryformat, binary, length);
 674 }
 675 void GLES2ShaderSource(GLuint shader,
 676                        GLsizei count,
 677                        const GLchar* const* str,
 678                        const GLint* length) {
 679   gles2::GetGLContext()->ShaderSource(shader, count, str, length);
 680 }
 681 void GLES2ShallowFinishCHROMIUM() {
 682   gles2::GetGLContext()->ShallowFinishCHROMIUM();
 683 }
 684 void GLES2ShallowFlushCHROMIUM() {
 685   gles2::GetGLContext()->ShallowFlushCHROMIUM();
 686 }
 687 void GLES2OrderingBarrierCHROMIUM() {
 688   gles2::GetGLContext()->OrderingBarrierCHROMIUM();
 689 }
 690 void GLES2StencilFunc(GLenum func, GLint ref, GLuint mask) {
 691   gles2::GetGLContext()->StencilFunc(func, ref, mask);
 692 }
 693 void GLES2StencilFuncSeparate(GLenum face,
 694                               GLenum func,
 695                               GLint ref,
 696                               GLuint mask) {
 697   gles2::GetGLContext()->StencilFuncSeparate(face, func, ref, mask);
 698 }
 699 void GLES2StencilMask(GLuint mask) {
 700   gles2::GetGLContext()->StencilMask(mask);
 701 }
 702 void GLES2StencilMaskSeparate(GLenum face, GLuint mask) {
 703   gles2::GetGLContext()->StencilMaskSeparate(face, mask);
 704 }
 705 void GLES2StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
 706   gles2::GetGLContext()->StencilOp(fail, zfail, zpass);
 707 }
 708 void GLES2StencilOpSeparate(GLenum face,
 709                             GLenum fail,
 710                             GLenum zfail,
 711                             GLenum zpass) {
 712   gles2::GetGLContext()->StencilOpSeparate(face, fail, zfail, zpass);
 713 }
 714 void GLES2TexImage2D(GLenum target,
 715                      GLint level,
 716                      GLint internalformat,
 717                      GLsizei width,
 718                      GLsizei height,
 719                      GLint border,
 720                      GLenum format,
 721                      GLenum type,
 722                      const void* pixels) {
 723   gles2::GetGLContext()->TexImage2D(target, level, internalformat, width,
 724                                     height, border, format, type, pixels);
 725 }
 726 void GLES2TexImage3D(GLenum target,
 727                      GLint level,
 728                      GLint internalformat,
 729                      GLsizei width,
 730                      GLsizei height,
 731                      GLsizei depth,
 732                      GLint border,
 733                      GLenum format,
 734                      GLenum type,
 735                      const void* pixels) {
 736   gles2::GetGLContext()->TexImage3D(target, level, internalformat, width,
 737                                     height, depth, border, format, type,
 738                                     pixels);
 739 }
 740 void GLES2TexParameterf(GLenum target, GLenum pname, GLfloat param) {
 741   gles2::GetGLContext()->TexParameterf(target, pname, param);
 742 }
 743 void GLES2TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) {
 744   gles2::GetGLContext()->TexParameterfv(target, pname, params);
 745 }
 746 void GLES2TexParameteri(GLenum target, GLenum pname, GLint param) {
 747   gles2::GetGLContext()->TexParameteri(target, pname, param);
 748 }
 749 void GLES2TexParameteriv(GLenum target, GLenum pname, const GLint* params) {
 750   gles2::GetGLContext()->TexParameteriv(target, pname, params);
 751 }
 752 void GLES2TexStorage3D(GLenum target,
 753                        GLsizei levels,
 754                        GLenum internalFormat,
 755                        GLsizei width,
 756                        GLsizei height,
 757                        GLsizei depth) {
 758   gles2::GetGLContext()->TexStorage3D(target, levels, internalFormat, width,
 759                                       height, depth);
 760 }
 761 void GLES2TexSubImage2D(GLenum target,
 762                         GLint level,
 763                         GLint xoffset,
 764                         GLint yoffset,
 765                         GLsizei width,
 766                         GLsizei height,
 767                         GLenum format,
 768                         GLenum type,
 769                         const void* pixels) {
 770   gles2::GetGLContext()->TexSubImage2D(target, level, xoffset, yoffset, width,
 771                                        height, format, type, pixels);
 772 }
 773 void GLES2TexSubImage3D(GLenum target,
 774                         GLint level,
 775                         GLint xoffset,
 776                         GLint yoffset,
 777                         GLint zoffset,
 778                         GLsizei width,
 779                         GLsizei height,
 780                         GLsizei depth,
 781                         GLenum format,
 782                         GLenum type,
 783                         const void* pixels) {
 784   gles2::GetGLContext()->TexSubImage3D(target, level, xoffset, yoffset, zoffset,
 785                                        width, height, depth, format, type,
 786                                        pixels);
 787 }
 788 void GLES2TransformFeedbackVaryings(GLuint program,
 789                                     GLsizei count,
 790                                     const char* const* varyings,
 791                                     GLenum buffermode) {
 792   gles2::GetGLContext()->TransformFeedbackVaryings(program, count, varyings,
 793                                                    buffermode);
 794 }
 795 void GLES2Uniform1f(GLint location, GLfloat x) {
 796   gles2::GetGLContext()->Uniform1f(location, x);
 797 }
 798 void GLES2Uniform1fv(GLint location, GLsizei count, const GLfloat* v) {
 799   gles2::GetGLContext()->Uniform1fv(location, count, v);
 800 }
 801 void GLES2Uniform1i(GLint location, GLint x) {
 802   gles2::GetGLContext()->Uniform1i(location, x);
 803 }
 804 void GLES2Uniform1iv(GLint location, GLsizei count, const GLint* v) {
 805   gles2::GetGLContext()->Uniform1iv(location, count, v);
 806 }
 807 void GLES2Uniform1ui(GLint location, GLuint x) {
 808   gles2::GetGLContext()->Uniform1ui(location, x);
 809 }
 810 void GLES2Uniform1uiv(GLint location, GLsizei count, const GLuint* v) {
 811   gles2::GetGLContext()->Uniform1uiv(location, count, v);
 812 }
 813 void GLES2Uniform2f(GLint location, GLfloat x, GLfloat y) {
 814   gles2::GetGLContext()->Uniform2f(location, x, y);
 815 }
 816 void GLES2Uniform2fv(GLint location, GLsizei count, const GLfloat* v) {
 817   gles2::GetGLContext()->Uniform2fv(location, count, v);
 818 }
 819 void GLES2Uniform2i(GLint location, GLint x, GLint y) {
 820   gles2::GetGLContext()->Uniform2i(location, x, y);
 821 }
 822 void GLES2Uniform2iv(GLint location, GLsizei count, const GLint* v) {
 823   gles2::GetGLContext()->Uniform2iv(location, count, v);
 824 }
 825 void GLES2Uniform2ui(GLint location, GLuint x, GLuint y) {
 826   gles2::GetGLContext()->Uniform2ui(location, x, y);
 827 }
 828 void GLES2Uniform2uiv(GLint location, GLsizei count, const GLuint* v) {
 829   gles2::GetGLContext()->Uniform2uiv(location, count, v);
 830 }
 831 void GLES2Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
 832   gles2::GetGLContext()->Uniform3f(location, x, y, z);
 833 }
 834 void GLES2Uniform3fv(GLint location, GLsizei count, const GLfloat* v) {
 835   gles2::GetGLContext()->Uniform3fv(location, count, v);
 836 }
 837 void GLES2Uniform3i(GLint location, GLint x, GLint y, GLint z) {
 838   gles2::GetGLContext()->Uniform3i(location, x, y, z);
 839 }
 840 void GLES2Uniform3iv(GLint location, GLsizei count, const GLint* v) {
 841   gles2::GetGLContext()->Uniform3iv(location, count, v);
 842 }
 843 void GLES2Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z) {
 844   gles2::GetGLContext()->Uniform3ui(location, x, y, z);
 845 }
 846 void GLES2Uniform3uiv(GLint location, GLsizei count, const GLuint* v) {
 847   gles2::GetGLContext()->Uniform3uiv(location, count, v);
 848 }
 849 void GLES2Uniform4f(GLint location,
 850                     GLfloat x,
 851                     GLfloat y,
 852                     GLfloat z,
 853                     GLfloat w) {
 854   gles2::GetGLContext()->Uniform4f(location, x, y, z, w);
 855 }
 856 void GLES2Uniform4fv(GLint location, GLsizei count, const GLfloat* v) {
 857   gles2::GetGLContext()->Uniform4fv(location, count, v);
 858 }
 859 void GLES2Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
 860   gles2::GetGLContext()->Uniform4i(location, x, y, z, w);
 861 }
 862 void GLES2Uniform4iv(GLint location, GLsizei count, const GLint* v) {
 863   gles2::GetGLContext()->Uniform4iv(location, count, v);
 864 }
 865 void GLES2Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w) {
 866   gles2::GetGLContext()->Uniform4ui(location, x, y, z, w);
 867 }
 868 void GLES2Uniform4uiv(GLint location, GLsizei count, const GLuint* v) {
 869   gles2::GetGLContext()->Uniform4uiv(location, count, v);
 870 }
 871 void GLES2UniformBlockBinding(GLuint program, GLuint index, GLuint binding) {
 872   gles2::GetGLContext()->UniformBlockBinding(program, index, binding);
 873 }
 874 void GLES2UniformMatrix2fv(GLint location,
 875                            GLsizei count,
 876                            GLboolean transpose,
 877                            const GLfloat* value) {
 878   gles2::GetGLContext()->UniformMatrix2fv(location, count, transpose, value);
 879 }
 880 void GLES2UniformMatrix2x3fv(GLint location,
 881                              GLsizei count,
 882                              GLboolean transpose,
 883                              const GLfloat* value) {
 884   gles2::GetGLContext()->UniformMatrix2x3fv(location, count, transpose, value);
 885 }
 886 void GLES2UniformMatrix2x4fv(GLint location,
 887                              GLsizei count,
 888                              GLboolean transpose,
 889                              const GLfloat* value) {
 890   gles2::GetGLContext()->UniformMatrix2x4fv(location, count, transpose, value);
 891 }
 892 void GLES2UniformMatrix3fv(GLint location,
 893                            GLsizei count,
 894                            GLboolean transpose,
 895                            const GLfloat* value) {
 896   gles2::GetGLContext()->UniformMatrix3fv(location, count, transpose, value);
 897 }
 898 void GLES2UniformMatrix3x2fv(GLint location,
 899                              GLsizei count,
 900                              GLboolean transpose,
 901                              const GLfloat* value) {
 902   gles2::GetGLContext()->UniformMatrix3x2fv(location, count, transpose, value);
 903 }
 904 void GLES2UniformMatrix3x4fv(GLint location,
 905                              GLsizei count,
 906                              GLboolean transpose,
 907                              const GLfloat* value) {
 908   gles2::GetGLContext()->UniformMatrix3x4fv(location, count, transpose, value);
 909 }
 910 void GLES2UniformMatrix4fv(GLint location,
 911                            GLsizei count,
 912                            GLboolean transpose,
 913                            const GLfloat* value) {
 914   gles2::GetGLContext()->UniformMatrix4fv(location, count, transpose, value);
 915 }
 916 void GLES2UniformMatrix4x2fv(GLint location,
 917                              GLsizei count,
 918                              GLboolean transpose,
 919                              const GLfloat* value) {
 920   gles2::GetGLContext()->UniformMatrix4x2fv(location, count, transpose, value);
 921 }
 922 void GLES2UniformMatrix4x3fv(GLint location,
 923                              GLsizei count,
 924                              GLboolean transpose,
 925                              const GLfloat* value) {
 926   gles2::GetGLContext()->UniformMatrix4x3fv(location, count, transpose, value);
 927 }
 928 void GLES2UseProgram(GLuint program) {
 929   gles2::GetGLContext()->UseProgram(program);
 930 }
 931 void GLES2ValidateProgram(GLuint program) {
 932   gles2::GetGLContext()->ValidateProgram(program);
 933 }
 934 void GLES2VertexAttrib1f(GLuint indx, GLfloat x) {
 935   gles2::GetGLContext()->VertexAttrib1f(indx, x);
 936 }
 937 void GLES2VertexAttrib1fv(GLuint indx, const GLfloat* values) {
 938   gles2::GetGLContext()->VertexAttrib1fv(indx, values);
 939 }
 940 void GLES2VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
 941   gles2::GetGLContext()->VertexAttrib2f(indx, x, y);
 942 }
 943 void GLES2VertexAttrib2fv(GLuint indx, const GLfloat* values) {
 944   gles2::GetGLContext()->VertexAttrib2fv(indx, values);
 945 }
 946 void GLES2VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
 947   gles2::GetGLContext()->VertexAttrib3f(indx, x, y, z);
 948 }
 949 void GLES2VertexAttrib3fv(GLuint indx, const GLfloat* values) {
 950   gles2::GetGLContext()->VertexAttrib3fv(indx, values);
 951 }
 952 void GLES2VertexAttrib4f(GLuint indx,
 953                          GLfloat x,
 954                          GLfloat y,
 955                          GLfloat z,
 956                          GLfloat w) {
 957   gles2::GetGLContext()->VertexAttrib4f(indx, x, y, z, w);
 958 }
 959 void GLES2VertexAttrib4fv(GLuint indx, const GLfloat* values) {
 960   gles2::GetGLContext()->VertexAttrib4fv(indx, values);
 961 }
 962 void GLES2VertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w) {
 963   gles2::GetGLContext()->VertexAttribI4i(indx, x, y, z, w);
 964 }
 965 void GLES2VertexAttribI4iv(GLuint indx, const GLint* values) {
 966   gles2::GetGLContext()->VertexAttribI4iv(indx, values);
 967 }
 968 void GLES2VertexAttribI4ui(GLuint indx,
 969                            GLuint x,
 970                            GLuint y,
 971                            GLuint z,
 972                            GLuint w) {
 973   gles2::GetGLContext()->VertexAttribI4ui(indx, x, y, z, w);
 974 }
 975 void GLES2VertexAttribI4uiv(GLuint indx, const GLuint* values) {
 976   gles2::GetGLContext()->VertexAttribI4uiv(indx, values);
 977 }
 978 void GLES2VertexAttribIPointer(GLuint indx,
 979                                GLint size,
 980                                GLenum type,
 981                                GLsizei stride,
 982                                const void* ptr) {
 983   gles2::GetGLContext()->VertexAttribIPointer(indx, size, type, stride, ptr);
 984 }
 985 void GLES2VertexAttribPointer(GLuint indx,
 986                               GLint size,
 987                               GLenum type,
 988                               GLboolean normalized,
 989                               GLsizei stride,
 990                               const void* ptr) {
 991   gles2::GetGLContext()->VertexAttribPointer(indx, size, type, normalized,
 992                                              stride, ptr);
 993 }
 994 void GLES2Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
 995   gles2::GetGLContext()->Viewport(x, y, width, height);
 996 }
 997 void GLES2WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
 998   gles2::GetGLContext()->WaitSync(sync, flags, timeout);
 999 }
1000 void GLES2BlitFramebufferCHROMIUM(GLint srcX0,
1001                                   GLint srcY0,
1002                                   GLint srcX1,
1003                                   GLint srcY1,
1004                                   GLint dstX0,
1005                                   GLint dstY0,
1006                                   GLint dstX1,
1007                                   GLint dstY1,
1008                                   GLbitfield mask,
1009                                   GLenum filter) {
1010   gles2::GetGLContext()->BlitFramebufferCHROMIUM(
1011       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
1012 }
1013 void GLES2RenderbufferStorageMultisampleCHROMIUM(GLenum target,
1014                                                  GLsizei samples,
1015                                                  GLenum internalformat,
1016                                                  GLsizei width,
1017                                                  GLsizei height) {
1018   gles2::GetGLContext()->RenderbufferStorageMultisampleCHROMIUM(
1019       target, samples, internalformat, width, height);
1020 }
1021 void GLES2RenderbufferStorageMultisampleEXT(GLenum target,
1022                                             GLsizei samples,
1023                                             GLenum internalformat,
1024                                             GLsizei width,
1025                                             GLsizei height) {
1026   gles2::GetGLContext()->RenderbufferStorageMultisampleEXT(
1027       target, samples, internalformat, width, height);
1028 }
1029 void GLES2FramebufferTexture2DMultisampleEXT(GLenum target,
1030                                              GLenum attachment,
1031                                              GLenum textarget,
1032                                              GLuint texture,
1033                                              GLint level,
1034                                              GLsizei samples) {
1035   gles2::GetGLContext()->FramebufferTexture2DMultisampleEXT(
1036       target, attachment, textarget, texture, level, samples);
1037 }
1038 void GLES2TexStorage2DEXT(GLenum target,
1039                           GLsizei levels,
1040                           GLenum internalFormat,
1041                           GLsizei width,
1042                           GLsizei height) {
1043   gles2::GetGLContext()->TexStorage2DEXT(target, levels, internalFormat, width,
1044                                          height);
1045 }
1046 void GLES2GenQueriesEXT(GLsizei n, GLuint* queries) {
1047   gles2::GetGLContext()->GenQueriesEXT(n, queries);
1048 }
1049 void GLES2DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
1050   gles2::GetGLContext()->DeleteQueriesEXT(n, queries);
1051 }
1052 void GLES2QueryCounterEXT(GLuint id, GLenum target) {
1053   gles2::GetGLContext()->QueryCounterEXT(id, target);
1054 }
1055 GLboolean GLES2IsQueryEXT(GLuint id) {
1056   return gles2::GetGLContext()->IsQueryEXT(id);
1057 }
1058 void GLES2BeginQueryEXT(GLenum target, GLuint id) {
1059   gles2::GetGLContext()->BeginQueryEXT(target, id);
1060 }
1061 void GLES2BeginTransformFeedback(GLenum primitivemode) {
1062   gles2::GetGLContext()->BeginTransformFeedback(primitivemode);
1063 }
1064 void GLES2EndQueryEXT(GLenum target) {
1065   gles2::GetGLContext()->EndQueryEXT(target);
1066 }
1067 void GLES2EndTransformFeedback() {
1068   gles2::GetGLContext()->EndTransformFeedback();
1069 }
1070 void GLES2GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
1071   gles2::GetGLContext()->GetQueryivEXT(target, pname, params);
1072 }
1073 void GLES2GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint* params) {
1074   gles2::GetGLContext()->GetQueryObjectuivEXT(id, pname, params);
1075 }
1076 void GLES2GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64* params) {
1077   gles2::GetGLContext()->GetQueryObjectui64vEXT(id, pname, params);
1078 }
1079 void GLES2InsertEventMarkerEXT(GLsizei length, const GLchar* marker) {
1080   gles2::GetGLContext()->InsertEventMarkerEXT(length, marker);
1081 }
1082 void GLES2PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
1083   gles2::GetGLContext()->PushGroupMarkerEXT(length, marker);
1084 }
1085 void GLES2PopGroupMarkerEXT() {
1086   gles2::GetGLContext()->PopGroupMarkerEXT();
1087 }
1088 void GLES2GenVertexArraysOES(GLsizei n, GLuint* arrays) {
1089   gles2::GetGLContext()->GenVertexArraysOES(n, arrays);
1090 }
1091 void GLES2DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
1092   gles2::GetGLContext()->DeleteVertexArraysOES(n, arrays);
1093 }
1094 GLboolean GLES2IsVertexArrayOES(GLuint array) {
1095   return gles2::GetGLContext()->IsVertexArrayOES(array);
1096 }
1097 void GLES2BindVertexArrayOES(GLuint array) {
1098   gles2::GetGLContext()->BindVertexArrayOES(array);
1099 }
1100 void GLES2SwapBuffers() {
1101   gles2::GetGLContext()->SwapBuffers();
1102 }
1103 GLuint GLES2GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
1104                                         GLsizei count,
1105                                         GLenum type,
1106                                         GLuint offset) {
1107   return gles2::GetGLContext()->GetMaxValueInBufferCHROMIUM(buffer_id, count,
1108                                                             type, offset);
1109 }
1110 GLboolean GLES2EnableFeatureCHROMIUM(const char* feature) {
1111   return gles2::GetGLContext()->EnableFeatureCHROMIUM(feature);
1112 }
1113 void* GLES2MapBufferCHROMIUM(GLuint target, GLenum access) {
1114   return gles2::GetGLContext()->MapBufferCHROMIUM(target, access);
1115 }
1116 GLboolean GLES2UnmapBufferCHROMIUM(GLuint target) {
1117   return gles2::GetGLContext()->UnmapBufferCHROMIUM(target);
1118 }
1119 void* GLES2MapBufferSubDataCHROMIUM(GLuint target,
1120                                     GLintptr offset,
1121                                     GLsizeiptr size,
1122                                     GLenum access) {
1123   return gles2::GetGLContext()->MapBufferSubDataCHROMIUM(target, offset, size,
1124                                                          access);
1125 }
1126 void GLES2UnmapBufferSubDataCHROMIUM(const void* mem) {
1127   gles2::GetGLContext()->UnmapBufferSubDataCHROMIUM(mem);
1128 }
1129 void* GLES2MapBufferRange(GLenum target,
1130                           GLintptr offset,
1131                           GLsizeiptr size,
1132                           GLbitfield access) {
1133   return gles2::GetGLContext()->MapBufferRange(target, offset, size, access);
1134 }
1135 GLboolean GLES2UnmapBuffer(GLenum target) {
1136   return gles2::GetGLContext()->UnmapBuffer(target);
1137 }
1138 void* GLES2MapTexSubImage2DCHROMIUM(GLenum target,
1139                                     GLint level,
1140                                     GLint xoffset,
1141                                     GLint yoffset,
1142                                     GLsizei width,
1143                                     GLsizei height,
1144                                     GLenum format,
1145                                     GLenum type,
1146                                     GLenum access) {
1147   return gles2::GetGLContext()->MapTexSubImage2DCHROMIUM(
1148       target, level, xoffset, yoffset, width, height, format, type, access);
1149 }
1150 void GLES2UnmapTexSubImage2DCHROMIUM(const void* mem) {
1151   gles2::GetGLContext()->UnmapTexSubImage2DCHROMIUM(mem);
1152 }
1153 void GLES2ResizeCHROMIUM(GLuint width, GLuint height, GLfloat scale_factor) {
1154   gles2::GetGLContext()->ResizeCHROMIUM(width, height, scale_factor);
1155 }
1156 const GLchar* GLES2GetRequestableExtensionsCHROMIUM() {
1157   return gles2::GetGLContext()->GetRequestableExtensionsCHROMIUM();
1158 }
1159 void GLES2RequestExtensionCHROMIUM(const char* extension) {
1160   gles2::GetGLContext()->RequestExtensionCHROMIUM(extension);
1161 }
1162 void GLES2RateLimitOffscreenContextCHROMIUM() {
1163   gles2::GetGLContext()->RateLimitOffscreenContextCHROMIUM();
1164 }
1165 void GLES2GetProgramInfoCHROMIUM(GLuint program,
1166                                  GLsizei bufsize,
1167                                  GLsizei* size,
1168                                  void* info) {
1169   gles2::GetGLContext()->GetProgramInfoCHROMIUM(program, bufsize, size, info);
1170 }
1171 void GLES2GetUniformBlocksCHROMIUM(GLuint program,
1172                                    GLsizei bufsize,
1173                                    GLsizei* size,
1174                                    void* info) {
1175   gles2::GetGLContext()->GetUniformBlocksCHROMIUM(program, bufsize, size, info);
1176 }
1177 void GLES2GetTransformFeedbackVaryingsCHROMIUM(GLuint program,
1178                                                GLsizei bufsize,
1179                                                GLsizei* size,
1180                                                void* info) {
1181   gles2::GetGLContext()->GetTransformFeedbackVaryingsCHROMIUM(program, bufsize,
1182                                                               size, info);
1183 }
1184 void GLES2GetUniformsES3CHROMIUM(GLuint program,
1185                                  GLsizei bufsize,
1186                                  GLsizei* size,
1187                                  void* info) {
1188   gles2::GetGLContext()->GetUniformsES3CHROMIUM(program, bufsize, size, info);
1189 }
1190 GLuint GLES2CreateStreamTextureCHROMIUM(GLuint texture) {
1191   return gles2::GetGLContext()->CreateStreamTextureCHROMIUM(texture);
1192 }
1193 GLuint GLES2CreateImageCHROMIUM(ClientBuffer buffer,
1194                                 GLsizei width,
1195                                 GLsizei height,
1196                                 GLenum internalformat) {
1197   return gles2::GetGLContext()->CreateImageCHROMIUM(buffer, width, height,
1198                                                     internalformat);
1199 }
1200 void GLES2DestroyImageCHROMIUM(GLuint image_id) {
1201   gles2::GetGLContext()->DestroyImageCHROMIUM(image_id);
1202 }
1203 GLuint GLES2CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
1204                                                GLsizei height,
1205                                                GLenum internalformat,
1206                                                GLenum usage) {
1207   return gles2::GetGLContext()->CreateGpuMemoryBufferImageCHROMIUM(
1208       width, height, internalformat, usage);
1209 }
1210 void GLES2GetTranslatedShaderSourceANGLE(GLuint shader,
1211                                          GLsizei bufsize,
1212                                          GLsizei* length,
1213                                          char* source) {
1214   gles2::GetGLContext()->GetTranslatedShaderSourceANGLE(shader, bufsize, length,
1215                                                         source);
1216 }
1217 void GLES2PostSubBufferCHROMIUM(GLint x, GLint y, GLint width, GLint height) {
1218   gles2::GetGLContext()->PostSubBufferCHROMIUM(x, y, width, height);
1219 }
1220 void GLES2TexImageIOSurface2DCHROMIUM(GLenum target,
1221                                       GLsizei width,
1222                                       GLsizei height,
1223                                       GLuint ioSurfaceId,
1224                                       GLuint plane) {
1225   gles2::GetGLContext()->TexImageIOSurface2DCHROMIUM(target, width, height,
1226                                                      ioSurfaceId, plane);
1227 }
1228 void GLES2CopyTextureCHROMIUM(GLenum target,
1229                               GLenum source_id,
1230                               GLenum dest_id,
1231                               GLint internalformat,
1232                               GLenum dest_type,
1233                               GLboolean unpack_flip_y,
1234                               GLboolean unpack_premultiply_alpha,
1235                               GLboolean unpack_unmultiply_alpha) {
1236   gles2::GetGLContext()->CopyTextureCHROMIUM(
1237       target, source_id, dest_id, internalformat, dest_type, unpack_flip_y,
1238       unpack_premultiply_alpha, unpack_unmultiply_alpha);
1239 }
1240 void GLES2CopySubTextureCHROMIUM(GLenum target,
1241                                  GLenum source_id,
1242                                  GLenum dest_id,
1243                                  GLint xoffset,
1244                                  GLint yoffset,
1245                                  GLint x,
1246                                  GLint y,
1247                                  GLsizei width,
1248                                  GLsizei height,
1249                                  GLboolean unpack_flip_y,
1250                                  GLboolean unpack_premultiply_alpha,
1251                                  GLboolean unpack_unmultiply_alpha) {
1252   gles2::GetGLContext()->CopySubTextureCHROMIUM(
1253       target, source_id, dest_id, xoffset, yoffset, x, y, width, height,
1254       unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha);
1255 }
1256 void GLES2CompressedCopyTextureCHROMIUM(GLenum target,
1257                                         GLenum source_id,
1258                                         GLenum dest_id) {
1259   gles2::GetGLContext()->CompressedCopyTextureCHROMIUM(target, source_id,
1260                                                        dest_id);
1261 }
1262 void GLES2DrawArraysInstancedANGLE(GLenum mode,
1263                                    GLint first,
1264                                    GLsizei count,
1265                                    GLsizei primcount) {
1266   gles2::GetGLContext()->DrawArraysInstancedANGLE(mode, first, count,
1267                                                   primcount);
1268 }
1269 void GLES2DrawElementsInstancedANGLE(GLenum mode,
1270                                      GLsizei count,
1271                                      GLenum type,
1272                                      const void* indices,
1273                                      GLsizei primcount) {
1274   gles2::GetGLContext()->DrawElementsInstancedANGLE(mode, count, type, indices,
1275                                                     primcount);
1276 }
1277 void GLES2VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
1278   gles2::GetGLContext()->VertexAttribDivisorANGLE(index, divisor);
1279 }
1280 void GLES2GenMailboxCHROMIUM(GLbyte* mailbox) {
1281   gles2::GetGLContext()->GenMailboxCHROMIUM(mailbox);
1282 }
1283 void GLES2ProduceTextureCHROMIUM(GLenum target, const GLbyte* mailbox) {
1284   gles2::GetGLContext()->ProduceTextureCHROMIUM(target, mailbox);
1285 }
1286 void GLES2ProduceTextureDirectCHROMIUM(GLuint texture,
1287                                        GLenum target,
1288                                        const GLbyte* mailbox) {
1289   gles2::GetGLContext()->ProduceTextureDirectCHROMIUM(texture, target, mailbox);
1290 }
1291 void GLES2ConsumeTextureCHROMIUM(GLenum target, const GLbyte* mailbox) {
1292   gles2::GetGLContext()->ConsumeTextureCHROMIUM(target, mailbox);
1293 }
1294 GLuint GLES2CreateAndConsumeTextureCHROMIUM(GLenum target,
1295                                             const GLbyte* mailbox) {
1296   return gles2::GetGLContext()->CreateAndConsumeTextureCHROMIUM(target,
1297                                                                 mailbox);
1298 }
1299 void GLES2BindUniformLocationCHROMIUM(GLuint program,
1300                                       GLint location,
1301                                       const char* name) {
1302   gles2::GetGLContext()->BindUniformLocationCHROMIUM(program, location, name);
1303 }
1304 void GLES2GenValuebuffersCHROMIUM(GLsizei n, GLuint* buffers) {
1305   gles2::GetGLContext()->GenValuebuffersCHROMIUM(n, buffers);
1306 }
1307 void GLES2DeleteValuebuffersCHROMIUM(GLsizei n, const GLuint* valuebuffers) {
1308   gles2::GetGLContext()->DeleteValuebuffersCHROMIUM(n, valuebuffers);
1309 }
1310 GLboolean GLES2IsValuebufferCHROMIUM(GLuint valuebuffer) {
1311   return gles2::GetGLContext()->IsValuebufferCHROMIUM(valuebuffer);
1312 }
1313 void GLES2BindValuebufferCHROMIUM(GLenum target, GLuint valuebuffer) {
1314   gles2::GetGLContext()->BindValuebufferCHROMIUM(target, valuebuffer);
1315 }
1316 void GLES2SubscribeValueCHROMIUM(GLenum target, GLenum subscription) {
1317   gles2::GetGLContext()->SubscribeValueCHROMIUM(target, subscription);
1318 }
1319 void GLES2PopulateSubscribedValuesCHROMIUM(GLenum target) {
1320   gles2::GetGLContext()->PopulateSubscribedValuesCHROMIUM(target);
1321 }
1322 void GLES2UniformValuebufferCHROMIUM(GLint location,
1323                                      GLenum target,
1324                                      GLenum subscription) {
1325   gles2::GetGLContext()->UniformValuebufferCHROMIUM(location, target,
1326                                                     subscription);
1327 }
1328 void GLES2BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1329   gles2::GetGLContext()->BindTexImage2DCHROMIUM(target, imageId);
1330 }
1331 void GLES2ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
1332   gles2::GetGLContext()->ReleaseTexImage2DCHROMIUM(target, imageId);
1333 }
1334 void GLES2TraceBeginCHROMIUM(const char* category_name,
1335                              const char* trace_name) {
1336   gles2::GetGLContext()->TraceBeginCHROMIUM(category_name, trace_name);
1337 }
1338 void GLES2TraceEndCHROMIUM() {
1339   gles2::GetGLContext()->TraceEndCHROMIUM();
1340 }
1341 void GLES2AsyncTexSubImage2DCHROMIUM(GLenum target,
1342                                      GLint level,
1343                                      GLint xoffset,
1344                                      GLint yoffset,
1345                                      GLsizei width,
1346                                      GLsizei height,
1347                                      GLenum format,
1348                                      GLenum type,
1349                                      const void* data) {
1350   gles2::GetGLContext()->AsyncTexSubImage2DCHROMIUM(
1351       target, level, xoffset, yoffset, width, height, format, type, data);
1352 }
1353 void GLES2AsyncTexImage2DCHROMIUM(GLenum target,
1354                                   GLint level,
1355                                   GLenum internalformat,
1356                                   GLsizei width,
1357                                   GLsizei height,
1358                                   GLint border,
1359                                   GLenum format,
1360                                   GLenum type,
1361                                   const void* pixels) {
1362   gles2::GetGLContext()->AsyncTexImage2DCHROMIUM(target, level, internalformat,
1363                                                  width, height, border, format,
1364                                                  type, pixels);
1365 }
1366 void GLES2WaitAsyncTexImage2DCHROMIUM(GLenum target) {
1367   gles2::GetGLContext()->WaitAsyncTexImage2DCHROMIUM(target);
1368 }
1369 void GLES2WaitAllAsyncTexImage2DCHROMIUM() {
1370   gles2::GetGLContext()->WaitAllAsyncTexImage2DCHROMIUM();
1371 }
1372 void GLES2DiscardFramebufferEXT(GLenum target,
1373                                 GLsizei count,
1374                                 const GLenum* attachments) {
1375   gles2::GetGLContext()->DiscardFramebufferEXT(target, count, attachments);
1376 }
1377 void GLES2LoseContextCHROMIUM(GLenum current, GLenum other) {
1378   gles2::GetGLContext()->LoseContextCHROMIUM(current, other);
1379 }
1380 GLuint GLES2InsertSyncPointCHROMIUM() {
1381   return gles2::GetGLContext()->InsertSyncPointCHROMIUM();
1382 }
1383 void GLES2WaitSyncPointCHROMIUM(GLuint sync_point) {
1384   gles2::GetGLContext()->WaitSyncPointCHROMIUM(sync_point);
1385 }
1386 void GLES2DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
1387   gles2::GetGLContext()->DrawBuffersEXT(count, bufs);
1388 }
1389 void GLES2DiscardBackbufferCHROMIUM() {
1390   gles2::GetGLContext()->DiscardBackbufferCHROMIUM();
1391 }
1392 void GLES2ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
1393                                        GLenum plane_transform,
1394                                        GLuint overlay_texture_id,
1395                                        GLint bounds_x,
1396                                        GLint bounds_y,
1397                                        GLint bounds_width,
1398                                        GLint bounds_height,
1399                                        GLfloat uv_x,
1400                                        GLfloat uv_y,
1401                                        GLfloat uv_width,
1402                                        GLfloat uv_height) {
1403   gles2::GetGLContext()->ScheduleOverlayPlaneCHROMIUM(
1404       plane_z_order, plane_transform, overlay_texture_id, bounds_x, bounds_y,
1405       bounds_width, bounds_height, uv_x, uv_y, uv_width, uv_height);
1406 }
1407 void GLES2SwapInterval(GLint interval) {
1408   gles2::GetGLContext()->SwapInterval(interval);
1409 }
1410 void GLES2FlushDriverCachesCHROMIUM() {
1411   gles2::GetGLContext()->FlushDriverCachesCHROMIUM();
1412 }
1413 void GLES2MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
1414   gles2::GetGLContext()->MatrixLoadfCHROMIUM(matrixMode, m);
1415 }
1416 void GLES2MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
1417   gles2::GetGLContext()->MatrixLoadIdentityCHROMIUM(matrixMode);
1418 }
1419 GLuint GLES2GenPathsCHROMIUM(GLsizei range) {
1420   return gles2::GetGLContext()->GenPathsCHROMIUM(range);
1421 }
1422 void GLES2DeletePathsCHROMIUM(GLuint path, GLsizei range) {
1423   gles2::GetGLContext()->DeletePathsCHROMIUM(path, range);
1424 }
1425 GLboolean GLES2IsPathCHROMIUM(GLuint path) {
1426   return gles2::GetGLContext()->IsPathCHROMIUM(path);
1427 }
1428 void GLES2PathCommandsCHROMIUM(GLuint path,
1429                                GLsizei numCommands,
1430                                const GLubyte* commands,
1431                                GLsizei numCoords,
1432                                GLenum coordType,
1433                                const GLvoid* coords) {
1434   gles2::GetGLContext()->PathCommandsCHROMIUM(path, numCommands, commands,
1435                                               numCoords, coordType, coords);
1436 }
1437 void GLES2PathParameterfCHROMIUM(GLuint path, GLenum pname, GLfloat value) {
1438   gles2::GetGLContext()->PathParameterfCHROMIUM(path, pname, value);
1439 }
1440 void GLES2PathParameteriCHROMIUM(GLuint path, GLenum pname, GLint value) {
1441   gles2::GetGLContext()->PathParameteriCHROMIUM(path, pname, value);
1442 }
1443 void GLES2PathStencilFuncCHROMIUM(GLenum func, GLint ref, GLuint mask) {
1444   gles2::GetGLContext()->PathStencilFuncCHROMIUM(func, ref, mask);
1445 }
1446 void GLES2StencilFillPathCHROMIUM(GLuint path, GLenum fillMode, GLuint mask) {
1447   gles2::GetGLContext()->StencilFillPathCHROMIUM(path, fillMode, mask);
1448 }
1449 void GLES2StencilStrokePathCHROMIUM(GLuint path, GLint reference, GLuint mask) {
1450   gles2::GetGLContext()->StencilStrokePathCHROMIUM(path, reference, mask);
1451 }
1452 void GLES2CoverFillPathCHROMIUM(GLuint path, GLenum coverMode) {
1453   gles2::GetGLContext()->CoverFillPathCHROMIUM(path, coverMode);
1454 }
1455 void GLES2CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode) {
1456   gles2::GetGLContext()->CoverStrokePathCHROMIUM(path, coverMode);
1457 }
1458 void GLES2StencilThenCoverFillPathCHROMIUM(GLuint path,
1459                                            GLenum fillMode,
1460                                            GLuint mask,
1461                                            GLenum coverMode) {
1462   gles2::GetGLContext()->StencilThenCoverFillPathCHROMIUM(path, fillMode, mask,
1463                                                           coverMode);
1464 }
1465 void GLES2StencilThenCoverStrokePathCHROMIUM(GLuint path,
1466                                              GLint reference,
1467                                              GLuint mask,
1468                                              GLenum coverMode) {
1469   gles2::GetGLContext()->StencilThenCoverStrokePathCHROMIUM(path, reference,
1470                                                             mask, coverMode);
1471 }
1472 GLenum GLES2GetGraphicsResetStatusKHR() {
1473   return gles2::GetGLContext()->GetGraphicsResetStatusKHR();
1474 }
1475 void GLES2BlendBarrierKHR() {
1476   gles2::GetGLContext()->BlendBarrierKHR();
1477 }
1478
1479 namespace gles2 {
1480
1481 extern const NameToFunc g_gles2_function_table[] = {
1482     {
1483      "glActiveTexture",
1484      reinterpret_cast<GLES2FunctionPointer>(glActiveTexture),
1485     },
1486     {
1487      "glAttachShader",
1488      reinterpret_cast<GLES2FunctionPointer>(glAttachShader),
1489     },
1490     {
1491      "glBindAttribLocation",
1492      reinterpret_cast<GLES2FunctionPointer>(glBindAttribLocation),
1493     },
1494     {
1495      "glBindBuffer",
1496      reinterpret_cast<GLES2FunctionPointer>(glBindBuffer),
1497     },
1498     {
1499      "glBindBufferBase",
1500      reinterpret_cast<GLES2FunctionPointer>(glBindBufferBase),
1501     },
1502     {
1503      "glBindBufferRange",
1504      reinterpret_cast<GLES2FunctionPointer>(glBindBufferRange),
1505     },
1506     {
1507      "glBindFramebuffer",
1508      reinterpret_cast<GLES2FunctionPointer>(glBindFramebuffer),
1509     },
1510     {
1511      "glBindRenderbuffer",
1512      reinterpret_cast<GLES2FunctionPointer>(glBindRenderbuffer),
1513     },
1514     {
1515      "glBindSampler",
1516      reinterpret_cast<GLES2FunctionPointer>(glBindSampler),
1517     },
1518     {
1519      "glBindTexture",
1520      reinterpret_cast<GLES2FunctionPointer>(glBindTexture),
1521     },
1522     {
1523      "glBindTransformFeedback",
1524      reinterpret_cast<GLES2FunctionPointer>(glBindTransformFeedback),
1525     },
1526     {
1527      "glBlendColor",
1528      reinterpret_cast<GLES2FunctionPointer>(glBlendColor),
1529     },
1530     {
1531      "glBlendEquation",
1532      reinterpret_cast<GLES2FunctionPointer>(glBlendEquation),
1533     },
1534     {
1535      "glBlendEquationSeparate",
1536      reinterpret_cast<GLES2FunctionPointer>(glBlendEquationSeparate),
1537     },
1538     {
1539      "glBlendFunc",
1540      reinterpret_cast<GLES2FunctionPointer>(glBlendFunc),
1541     },
1542     {
1543      "glBlendFuncSeparate",
1544      reinterpret_cast<GLES2FunctionPointer>(glBlendFuncSeparate),
1545     },
1546     {
1547      "glBufferData",
1548      reinterpret_cast<GLES2FunctionPointer>(glBufferData),
1549     },
1550     {
1551      "glBufferSubData",
1552      reinterpret_cast<GLES2FunctionPointer>(glBufferSubData),
1553     },
1554     {
1555      "glCheckFramebufferStatus",
1556      reinterpret_cast<GLES2FunctionPointer>(glCheckFramebufferStatus),
1557     },
1558     {
1559      "glClear",
1560      reinterpret_cast<GLES2FunctionPointer>(glClear),
1561     },
1562     {
1563      "glClearBufferfi",
1564      reinterpret_cast<GLES2FunctionPointer>(glClearBufferfi),
1565     },
1566     {
1567      "glClearBufferfv",
1568      reinterpret_cast<GLES2FunctionPointer>(glClearBufferfv),
1569     },
1570     {
1571      "glClearBufferiv",
1572      reinterpret_cast<GLES2FunctionPointer>(glClearBufferiv),
1573     },
1574     {
1575      "glClearBufferuiv",
1576      reinterpret_cast<GLES2FunctionPointer>(glClearBufferuiv),
1577     },
1578     {
1579      "glClearColor",
1580      reinterpret_cast<GLES2FunctionPointer>(glClearColor),
1581     },
1582     {
1583      "glClearDepthf",
1584      reinterpret_cast<GLES2FunctionPointer>(glClearDepthf),
1585     },
1586     {
1587      "glClearStencil",
1588      reinterpret_cast<GLES2FunctionPointer>(glClearStencil),
1589     },
1590     {
1591      "glClientWaitSync",
1592      reinterpret_cast<GLES2FunctionPointer>(glClientWaitSync),
1593     },
1594     {
1595      "glColorMask",
1596      reinterpret_cast<GLES2FunctionPointer>(glColorMask),
1597     },
1598     {
1599      "glCompileShader",
1600      reinterpret_cast<GLES2FunctionPointer>(glCompileShader),
1601     },
1602     {
1603      "glCompressedTexImage2D",
1604      reinterpret_cast<GLES2FunctionPointer>(glCompressedTexImage2D),
1605     },
1606     {
1607      "glCompressedTexSubImage2D",
1608      reinterpret_cast<GLES2FunctionPointer>(glCompressedTexSubImage2D),
1609     },
1610     {
1611      "glCompressedTexImage3D",
1612      reinterpret_cast<GLES2FunctionPointer>(glCompressedTexImage3D),
1613     },
1614     {
1615      "glCompressedTexSubImage3D",
1616      reinterpret_cast<GLES2FunctionPointer>(glCompressedTexSubImage3D),
1617     },
1618     {
1619      "glCopyBufferSubData",
1620      reinterpret_cast<GLES2FunctionPointer>(glCopyBufferSubData),
1621     },
1622     {
1623      "glCopyTexImage2D",
1624      reinterpret_cast<GLES2FunctionPointer>(glCopyTexImage2D),
1625     },
1626     {
1627      "glCopyTexSubImage2D",
1628      reinterpret_cast<GLES2FunctionPointer>(glCopyTexSubImage2D),
1629     },
1630     {
1631      "glCopyTexSubImage3D",
1632      reinterpret_cast<GLES2FunctionPointer>(glCopyTexSubImage3D),
1633     },
1634     {
1635      "glCreateProgram",
1636      reinterpret_cast<GLES2FunctionPointer>(glCreateProgram),
1637     },
1638     {
1639      "glCreateShader",
1640      reinterpret_cast<GLES2FunctionPointer>(glCreateShader),
1641     },
1642     {
1643      "glCullFace",
1644      reinterpret_cast<GLES2FunctionPointer>(glCullFace),
1645     },
1646     {
1647      "glDeleteBuffers",
1648      reinterpret_cast<GLES2FunctionPointer>(glDeleteBuffers),
1649     },
1650     {
1651      "glDeleteFramebuffers",
1652      reinterpret_cast<GLES2FunctionPointer>(glDeleteFramebuffers),
1653     },
1654     {
1655      "glDeleteProgram",
1656      reinterpret_cast<GLES2FunctionPointer>(glDeleteProgram),
1657     },
1658     {
1659      "glDeleteRenderbuffers",
1660      reinterpret_cast<GLES2FunctionPointer>(glDeleteRenderbuffers),
1661     },
1662     {
1663      "glDeleteSamplers",
1664      reinterpret_cast<GLES2FunctionPointer>(glDeleteSamplers),
1665     },
1666     {
1667      "glDeleteSync",
1668      reinterpret_cast<GLES2FunctionPointer>(glDeleteSync),
1669     },
1670     {
1671      "glDeleteShader",
1672      reinterpret_cast<GLES2FunctionPointer>(glDeleteShader),
1673     },
1674     {
1675      "glDeleteTextures",
1676      reinterpret_cast<GLES2FunctionPointer>(glDeleteTextures),
1677     },
1678     {
1679      "glDeleteTransformFeedbacks",
1680      reinterpret_cast<GLES2FunctionPointer>(glDeleteTransformFeedbacks),
1681     },
1682     {
1683      "glDepthFunc",
1684      reinterpret_cast<GLES2FunctionPointer>(glDepthFunc),
1685     },
1686     {
1687      "glDepthMask",
1688      reinterpret_cast<GLES2FunctionPointer>(glDepthMask),
1689     },
1690     {
1691      "glDepthRangef",
1692      reinterpret_cast<GLES2FunctionPointer>(glDepthRangef),
1693     },
1694     {
1695      "glDetachShader",
1696      reinterpret_cast<GLES2FunctionPointer>(glDetachShader),
1697     },
1698     {
1699      "glDisable",
1700      reinterpret_cast<GLES2FunctionPointer>(glDisable),
1701     },
1702     {
1703      "glDisableVertexAttribArray",
1704      reinterpret_cast<GLES2FunctionPointer>(glDisableVertexAttribArray),
1705     },
1706     {
1707      "glDrawArrays",
1708      reinterpret_cast<GLES2FunctionPointer>(glDrawArrays),
1709     },
1710     {
1711      "glDrawElements",
1712      reinterpret_cast<GLES2FunctionPointer>(glDrawElements),
1713     },
1714     {
1715      "glDrawRangeElements",
1716      reinterpret_cast<GLES2FunctionPointer>(glDrawRangeElements),
1717     },
1718     {
1719      "glEnable",
1720      reinterpret_cast<GLES2FunctionPointer>(glEnable),
1721     },
1722     {
1723      "glEnableVertexAttribArray",
1724      reinterpret_cast<GLES2FunctionPointer>(glEnableVertexAttribArray),
1725     },
1726     {
1727      "glFenceSync",
1728      reinterpret_cast<GLES2FunctionPointer>(glFenceSync),
1729     },
1730     {
1731      "glFinish",
1732      reinterpret_cast<GLES2FunctionPointer>(glFinish),
1733     },
1734     {
1735      "glFlush",
1736      reinterpret_cast<GLES2FunctionPointer>(glFlush),
1737     },
1738     {
1739      "glFramebufferRenderbuffer",
1740      reinterpret_cast<GLES2FunctionPointer>(glFramebufferRenderbuffer),
1741     },
1742     {
1743      "glFramebufferTexture2D",
1744      reinterpret_cast<GLES2FunctionPointer>(glFramebufferTexture2D),
1745     },
1746     {
1747      "glFramebufferTextureLayer",
1748      reinterpret_cast<GLES2FunctionPointer>(glFramebufferTextureLayer),
1749     },
1750     {
1751      "glFrontFace",
1752      reinterpret_cast<GLES2FunctionPointer>(glFrontFace),
1753     },
1754     {
1755      "glGenBuffers",
1756      reinterpret_cast<GLES2FunctionPointer>(glGenBuffers),
1757     },
1758     {
1759      "glGenerateMipmap",
1760      reinterpret_cast<GLES2FunctionPointer>(glGenerateMipmap),
1761     },
1762     {
1763      "glGenFramebuffers",
1764      reinterpret_cast<GLES2FunctionPointer>(glGenFramebuffers),
1765     },
1766     {
1767      "glGenRenderbuffers",
1768      reinterpret_cast<GLES2FunctionPointer>(glGenRenderbuffers),
1769     },
1770     {
1771      "glGenSamplers",
1772      reinterpret_cast<GLES2FunctionPointer>(glGenSamplers),
1773     },
1774     {
1775      "glGenTextures",
1776      reinterpret_cast<GLES2FunctionPointer>(glGenTextures),
1777     },
1778     {
1779      "glGenTransformFeedbacks",
1780      reinterpret_cast<GLES2FunctionPointer>(glGenTransformFeedbacks),
1781     },
1782     {
1783      "glGetActiveAttrib",
1784      reinterpret_cast<GLES2FunctionPointer>(glGetActiveAttrib),
1785     },
1786     {
1787      "glGetActiveUniform",
1788      reinterpret_cast<GLES2FunctionPointer>(glGetActiveUniform),
1789     },
1790     {
1791      "glGetActiveUniformBlockiv",
1792      reinterpret_cast<GLES2FunctionPointer>(glGetActiveUniformBlockiv),
1793     },
1794     {
1795      "glGetActiveUniformBlockName",
1796      reinterpret_cast<GLES2FunctionPointer>(glGetActiveUniformBlockName),
1797     },
1798     {
1799      "glGetActiveUniformsiv",
1800      reinterpret_cast<GLES2FunctionPointer>(glGetActiveUniformsiv),
1801     },
1802     {
1803      "glGetAttachedShaders",
1804      reinterpret_cast<GLES2FunctionPointer>(glGetAttachedShaders),
1805     },
1806     {
1807      "glGetAttribLocation",
1808      reinterpret_cast<GLES2FunctionPointer>(glGetAttribLocation),
1809     },
1810     {
1811      "glGetBooleanv",
1812      reinterpret_cast<GLES2FunctionPointer>(glGetBooleanv),
1813     },
1814     {
1815      "glGetBufferParameteriv",
1816      reinterpret_cast<GLES2FunctionPointer>(glGetBufferParameteriv),
1817     },
1818     {
1819      "glGetError",
1820      reinterpret_cast<GLES2FunctionPointer>(glGetError),
1821     },
1822     {
1823      "glGetFloatv",
1824      reinterpret_cast<GLES2FunctionPointer>(glGetFloatv),
1825     },
1826     {
1827      "glGetFragDataLocation",
1828      reinterpret_cast<GLES2FunctionPointer>(glGetFragDataLocation),
1829     },
1830     {
1831      "glGetFramebufferAttachmentParameteriv",
1832      reinterpret_cast<GLES2FunctionPointer>(
1833          glGetFramebufferAttachmentParameteriv),
1834     },
1835     {
1836      "glGetInteger64v",
1837      reinterpret_cast<GLES2FunctionPointer>(glGetInteger64v),
1838     },
1839     {
1840      "glGetIntegeri_v",
1841      reinterpret_cast<GLES2FunctionPointer>(glGetIntegeri_v),
1842     },
1843     {
1844      "glGetInteger64i_v",
1845      reinterpret_cast<GLES2FunctionPointer>(glGetInteger64i_v),
1846     },
1847     {
1848      "glGetIntegerv",
1849      reinterpret_cast<GLES2FunctionPointer>(glGetIntegerv),
1850     },
1851     {
1852      "glGetInternalformativ",
1853      reinterpret_cast<GLES2FunctionPointer>(glGetInternalformativ),
1854     },
1855     {
1856      "glGetProgramiv",
1857      reinterpret_cast<GLES2FunctionPointer>(glGetProgramiv),
1858     },
1859     {
1860      "glGetProgramInfoLog",
1861      reinterpret_cast<GLES2FunctionPointer>(glGetProgramInfoLog),
1862     },
1863     {
1864      "glGetRenderbufferParameteriv",
1865      reinterpret_cast<GLES2FunctionPointer>(glGetRenderbufferParameteriv),
1866     },
1867     {
1868      "glGetSamplerParameterfv",
1869      reinterpret_cast<GLES2FunctionPointer>(glGetSamplerParameterfv),
1870     },
1871     {
1872      "glGetSamplerParameteriv",
1873      reinterpret_cast<GLES2FunctionPointer>(glGetSamplerParameteriv),
1874     },
1875     {
1876      "glGetShaderiv",
1877      reinterpret_cast<GLES2FunctionPointer>(glGetShaderiv),
1878     },
1879     {
1880      "glGetShaderInfoLog",
1881      reinterpret_cast<GLES2FunctionPointer>(glGetShaderInfoLog),
1882     },
1883     {
1884      "glGetShaderPrecisionFormat",
1885      reinterpret_cast<GLES2FunctionPointer>(glGetShaderPrecisionFormat),
1886     },
1887     {
1888      "glGetShaderSource",
1889      reinterpret_cast<GLES2FunctionPointer>(glGetShaderSource),
1890     },
1891     {
1892      "glGetString",
1893      reinterpret_cast<GLES2FunctionPointer>(glGetString),
1894     },
1895     {
1896      "glGetSynciv",
1897      reinterpret_cast<GLES2FunctionPointer>(glGetSynciv),
1898     },
1899     {
1900      "glGetTexParameterfv",
1901      reinterpret_cast<GLES2FunctionPointer>(glGetTexParameterfv),
1902     },
1903     {
1904      "glGetTexParameteriv",
1905      reinterpret_cast<GLES2FunctionPointer>(glGetTexParameteriv),
1906     },
1907     {
1908      "glGetTransformFeedbackVarying",
1909      reinterpret_cast<GLES2FunctionPointer>(glGetTransformFeedbackVarying),
1910     },
1911     {
1912      "glGetUniformBlockIndex",
1913      reinterpret_cast<GLES2FunctionPointer>(glGetUniformBlockIndex),
1914     },
1915     {
1916      "glGetUniformfv",
1917      reinterpret_cast<GLES2FunctionPointer>(glGetUniformfv),
1918     },
1919     {
1920      "glGetUniformiv",
1921      reinterpret_cast<GLES2FunctionPointer>(glGetUniformiv),
1922     },
1923     {
1924      "glGetUniformuiv",
1925      reinterpret_cast<GLES2FunctionPointer>(glGetUniformuiv),
1926     },
1927     {
1928      "glGetUniformIndices",
1929      reinterpret_cast<GLES2FunctionPointer>(glGetUniformIndices),
1930     },
1931     {
1932      "glGetUniformLocation",
1933      reinterpret_cast<GLES2FunctionPointer>(glGetUniformLocation),
1934     },
1935     {
1936      "glGetVertexAttribfv",
1937      reinterpret_cast<GLES2FunctionPointer>(glGetVertexAttribfv),
1938     },
1939     {
1940      "glGetVertexAttribiv",
1941      reinterpret_cast<GLES2FunctionPointer>(glGetVertexAttribiv),
1942     },
1943     {
1944      "glGetVertexAttribIiv",
1945      reinterpret_cast<GLES2FunctionPointer>(glGetVertexAttribIiv),
1946     },
1947     {
1948      "glGetVertexAttribIuiv",
1949      reinterpret_cast<GLES2FunctionPointer>(glGetVertexAttribIuiv),
1950     },
1951     {
1952      "glGetVertexAttribPointerv",
1953      reinterpret_cast<GLES2FunctionPointer>(glGetVertexAttribPointerv),
1954     },
1955     {
1956      "glHint",
1957      reinterpret_cast<GLES2FunctionPointer>(glHint),
1958     },
1959     {
1960      "glInvalidateFramebuffer",
1961      reinterpret_cast<GLES2FunctionPointer>(glInvalidateFramebuffer),
1962     },
1963     {
1964      "glInvalidateSubFramebuffer",
1965      reinterpret_cast<GLES2FunctionPointer>(glInvalidateSubFramebuffer),
1966     },
1967     {
1968      "glIsBuffer",
1969      reinterpret_cast<GLES2FunctionPointer>(glIsBuffer),
1970     },
1971     {
1972      "glIsEnabled",
1973      reinterpret_cast<GLES2FunctionPointer>(glIsEnabled),
1974     },
1975     {
1976      "glIsFramebuffer",
1977      reinterpret_cast<GLES2FunctionPointer>(glIsFramebuffer),
1978     },
1979     {
1980      "glIsProgram",
1981      reinterpret_cast<GLES2FunctionPointer>(glIsProgram),
1982     },
1983     {
1984      "glIsRenderbuffer",
1985      reinterpret_cast<GLES2FunctionPointer>(glIsRenderbuffer),
1986     },
1987     {
1988      "glIsSampler",
1989      reinterpret_cast<GLES2FunctionPointer>(glIsSampler),
1990     },
1991     {
1992      "glIsShader",
1993      reinterpret_cast<GLES2FunctionPointer>(glIsShader),
1994     },
1995     {
1996      "glIsSync",
1997      reinterpret_cast<GLES2FunctionPointer>(glIsSync),
1998     },
1999     {
2000      "glIsTexture",
2001      reinterpret_cast<GLES2FunctionPointer>(glIsTexture),
2002     },
2003     {
2004      "glIsTransformFeedback",
2005      reinterpret_cast<GLES2FunctionPointer>(glIsTransformFeedback),
2006     },
2007     {
2008      "glLineWidth",
2009      reinterpret_cast<GLES2FunctionPointer>(glLineWidth),
2010     },
2011     {
2012      "glLinkProgram",
2013      reinterpret_cast<GLES2FunctionPointer>(glLinkProgram),
2014     },
2015     {
2016      "glPauseTransformFeedback",
2017      reinterpret_cast<GLES2FunctionPointer>(glPauseTransformFeedback),
2018     },
2019     {
2020      "glPixelStorei",
2021      reinterpret_cast<GLES2FunctionPointer>(glPixelStorei),
2022     },
2023     {
2024      "glPolygonOffset",
2025      reinterpret_cast<GLES2FunctionPointer>(glPolygonOffset),
2026     },
2027     {
2028      "glReadBuffer",
2029      reinterpret_cast<GLES2FunctionPointer>(glReadBuffer),
2030     },
2031     {
2032      "glReadPixels",
2033      reinterpret_cast<GLES2FunctionPointer>(glReadPixels),
2034     },
2035     {
2036      "glReleaseShaderCompiler",
2037      reinterpret_cast<GLES2FunctionPointer>(glReleaseShaderCompiler),
2038     },
2039     {
2040      "glRenderbufferStorage",
2041      reinterpret_cast<GLES2FunctionPointer>(glRenderbufferStorage),
2042     },
2043     {
2044      "glResumeTransformFeedback",
2045      reinterpret_cast<GLES2FunctionPointer>(glResumeTransformFeedback),
2046     },
2047     {
2048      "glSampleCoverage",
2049      reinterpret_cast<GLES2FunctionPointer>(glSampleCoverage),
2050     },
2051     {
2052      "glSamplerParameterf",
2053      reinterpret_cast<GLES2FunctionPointer>(glSamplerParameterf),
2054     },
2055     {
2056      "glSamplerParameterfv",
2057      reinterpret_cast<GLES2FunctionPointer>(glSamplerParameterfv),
2058     },
2059     {
2060      "glSamplerParameteri",
2061      reinterpret_cast<GLES2FunctionPointer>(glSamplerParameteri),
2062     },
2063     {
2064      "glSamplerParameteriv",
2065      reinterpret_cast<GLES2FunctionPointer>(glSamplerParameteriv),
2066     },
2067     {
2068      "glScissor",
2069      reinterpret_cast<GLES2FunctionPointer>(glScissor),
2070     },
2071     {
2072      "glShaderBinary",
2073      reinterpret_cast<GLES2FunctionPointer>(glShaderBinary),
2074     },
2075     {
2076      "glShaderSource",
2077      reinterpret_cast<GLES2FunctionPointer>(glShaderSource),
2078     },
2079     {
2080      "glShallowFinishCHROMIUM",
2081      reinterpret_cast<GLES2FunctionPointer>(glShallowFinishCHROMIUM),
2082     },
2083     {
2084      "glShallowFlushCHROMIUM",
2085      reinterpret_cast<GLES2FunctionPointer>(glShallowFlushCHROMIUM),
2086     },
2087     {
2088      "glOrderingBarrierCHROMIUM",
2089      reinterpret_cast<GLES2FunctionPointer>(glOrderingBarrierCHROMIUM),
2090     },
2091     {
2092      "glStencilFunc",
2093      reinterpret_cast<GLES2FunctionPointer>(glStencilFunc),
2094     },
2095     {
2096      "glStencilFuncSeparate",
2097      reinterpret_cast<GLES2FunctionPointer>(glStencilFuncSeparate),
2098     },
2099     {
2100      "glStencilMask",
2101      reinterpret_cast<GLES2FunctionPointer>(glStencilMask),
2102     },
2103     {
2104      "glStencilMaskSeparate",
2105      reinterpret_cast<GLES2FunctionPointer>(glStencilMaskSeparate),
2106     },
2107     {
2108      "glStencilOp",
2109      reinterpret_cast<GLES2FunctionPointer>(glStencilOp),
2110     },
2111     {
2112      "glStencilOpSeparate",
2113      reinterpret_cast<GLES2FunctionPointer>(glStencilOpSeparate),
2114     },
2115     {
2116      "glTexImage2D",
2117      reinterpret_cast<GLES2FunctionPointer>(glTexImage2D),
2118     },
2119     {
2120      "glTexImage3D",
2121      reinterpret_cast<GLES2FunctionPointer>(glTexImage3D),
2122     },
2123     {
2124      "glTexParameterf",
2125      reinterpret_cast<GLES2FunctionPointer>(glTexParameterf),
2126     },
2127     {
2128      "glTexParameterfv",
2129      reinterpret_cast<GLES2FunctionPointer>(glTexParameterfv),
2130     },
2131     {
2132      "glTexParameteri",
2133      reinterpret_cast<GLES2FunctionPointer>(glTexParameteri),
2134     },
2135     {
2136      "glTexParameteriv",
2137      reinterpret_cast<GLES2FunctionPointer>(glTexParameteriv),
2138     },
2139     {
2140      "glTexStorage3D",
2141      reinterpret_cast<GLES2FunctionPointer>(glTexStorage3D),
2142     },
2143     {
2144      "glTexSubImage2D",
2145      reinterpret_cast<GLES2FunctionPointer>(glTexSubImage2D),
2146     },
2147     {
2148      "glTexSubImage3D",
2149      reinterpret_cast<GLES2FunctionPointer>(glTexSubImage3D),
2150     },
2151     {
2152      "glTransformFeedbackVaryings",
2153      reinterpret_cast<GLES2FunctionPointer>(glTransformFeedbackVaryings),
2154     },
2155     {
2156      "glUniform1f",
2157      reinterpret_cast<GLES2FunctionPointer>(glUniform1f),
2158     },
2159     {
2160      "glUniform1fv",
2161      reinterpret_cast<GLES2FunctionPointer>(glUniform1fv),
2162     },
2163     {
2164      "glUniform1i",
2165      reinterpret_cast<GLES2FunctionPointer>(glUniform1i),
2166     },
2167     {
2168      "glUniform1iv",
2169      reinterpret_cast<GLES2FunctionPointer>(glUniform1iv),
2170     },
2171     {
2172      "glUniform1ui",
2173      reinterpret_cast<GLES2FunctionPointer>(glUniform1ui),
2174     },
2175     {
2176      "glUniform1uiv",
2177      reinterpret_cast<GLES2FunctionPointer>(glUniform1uiv),
2178     },
2179     {
2180      "glUniform2f",
2181      reinterpret_cast<GLES2FunctionPointer>(glUniform2f),
2182     },
2183     {
2184      "glUniform2fv",
2185      reinterpret_cast<GLES2FunctionPointer>(glUniform2fv),
2186     },
2187     {
2188      "glUniform2i",
2189      reinterpret_cast<GLES2FunctionPointer>(glUniform2i),
2190     },
2191     {
2192      "glUniform2iv",
2193      reinterpret_cast<GLES2FunctionPointer>(glUniform2iv),
2194     },
2195     {
2196      "glUniform2ui",
2197      reinterpret_cast<GLES2FunctionPointer>(glUniform2ui),
2198     },
2199     {
2200      "glUniform2uiv",
2201      reinterpret_cast<GLES2FunctionPointer>(glUniform2uiv),
2202     },
2203     {
2204      "glUniform3f",
2205      reinterpret_cast<GLES2FunctionPointer>(glUniform3f),
2206     },
2207     {
2208      "glUniform3fv",
2209      reinterpret_cast<GLES2FunctionPointer>(glUniform3fv),
2210     },
2211     {
2212      "glUniform3i",
2213      reinterpret_cast<GLES2FunctionPointer>(glUniform3i),
2214     },
2215     {
2216      "glUniform3iv",
2217      reinterpret_cast<GLES2FunctionPointer>(glUniform3iv),
2218     },
2219     {
2220      "glUniform3ui",
2221      reinterpret_cast<GLES2FunctionPointer>(glUniform3ui),
2222     },
2223     {
2224      "glUniform3uiv",
2225      reinterpret_cast<GLES2FunctionPointer>(glUniform3uiv),
2226     },
2227     {
2228      "glUniform4f",
2229      reinterpret_cast<GLES2FunctionPointer>(glUniform4f),
2230     },
2231     {
2232      "glUniform4fv",
2233      reinterpret_cast<GLES2FunctionPointer>(glUniform4fv),
2234     },
2235     {
2236      "glUniform4i",
2237      reinterpret_cast<GLES2FunctionPointer>(glUniform4i),
2238     },
2239     {
2240      "glUniform4iv",
2241      reinterpret_cast<GLES2FunctionPointer>(glUniform4iv),
2242     },
2243     {
2244      "glUniform4ui",
2245      reinterpret_cast<GLES2FunctionPointer>(glUniform4ui),
2246     },
2247     {
2248      "glUniform4uiv",
2249      reinterpret_cast<GLES2FunctionPointer>(glUniform4uiv),
2250     },
2251     {
2252      "glUniformBlockBinding",
2253      reinterpret_cast<GLES2FunctionPointer>(glUniformBlockBinding),
2254     },
2255     {
2256      "glUniformMatrix2fv",
2257      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix2fv),
2258     },
2259     {
2260      "glUniformMatrix2x3fv",
2261      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix2x3fv),
2262     },
2263     {
2264      "glUniformMatrix2x4fv",
2265      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix2x4fv),
2266     },
2267     {
2268      "glUniformMatrix3fv",
2269      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix3fv),
2270     },
2271     {
2272      "glUniformMatrix3x2fv",
2273      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix3x2fv),
2274     },
2275     {
2276      "glUniformMatrix3x4fv",
2277      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix3x4fv),
2278     },
2279     {
2280      "glUniformMatrix4fv",
2281      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix4fv),
2282     },
2283     {
2284      "glUniformMatrix4x2fv",
2285      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix4x2fv),
2286     },
2287     {
2288      "glUniformMatrix4x3fv",
2289      reinterpret_cast<GLES2FunctionPointer>(glUniformMatrix4x3fv),
2290     },
2291     {
2292      "glUseProgram",
2293      reinterpret_cast<GLES2FunctionPointer>(glUseProgram),
2294     },
2295     {
2296      "glValidateProgram",
2297      reinterpret_cast<GLES2FunctionPointer>(glValidateProgram),
2298     },
2299     {
2300      "glVertexAttrib1f",
2301      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib1f),
2302     },
2303     {
2304      "glVertexAttrib1fv",
2305      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib1fv),
2306     },
2307     {
2308      "glVertexAttrib2f",
2309      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib2f),
2310     },
2311     {
2312      "glVertexAttrib2fv",
2313      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib2fv),
2314     },
2315     {
2316      "glVertexAttrib3f",
2317      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib3f),
2318     },
2319     {
2320      "glVertexAttrib3fv",
2321      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib3fv),
2322     },
2323     {
2324      "glVertexAttrib4f",
2325      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib4f),
2326     },
2327     {
2328      "glVertexAttrib4fv",
2329      reinterpret_cast<GLES2FunctionPointer>(glVertexAttrib4fv),
2330     },
2331     {
2332      "glVertexAttribI4i",
2333      reinterpret_cast<GLES2FunctionPointer>(glVertexAttribI4i),
2334     },
2335     {
2336      "glVertexAttribI4iv",
2337      reinterpret_cast<GLES2FunctionPointer>(glVertexAttribI4iv),
2338     },
2339     {
2340      "glVertexAttribI4ui",
2341      reinterpret_cast<GLES2FunctionPointer>(glVertexAttribI4ui),
2342     },
2343     {
2344      "glVertexAttribI4uiv",
2345      reinterpret_cast<GLES2FunctionPointer>(glVertexAttribI4uiv),
2346     },
2347     {
2348      "glVertexAttribIPointer",
2349      reinterpret_cast<GLES2FunctionPointer>(glVertexAttribIPointer),
2350     },
2351     {
2352      "glVertexAttribPointer",
2353      reinterpret_cast<GLES2FunctionPointer>(glVertexAttribPointer),
2354     },
2355     {
2356      "glViewport",
2357      reinterpret_cast<GLES2FunctionPointer>(glViewport),
2358     },
2359     {
2360      "glWaitSync",
2361      reinterpret_cast<GLES2FunctionPointer>(glWaitSync),
2362     },
2363     {
2364      "glBlitFramebufferCHROMIUM",
2365      reinterpret_cast<GLES2FunctionPointer>(glBlitFramebufferCHROMIUM),
2366     },
2367     {
2368      "glRenderbufferStorageMultisampleCHROMIUM",
2369      reinterpret_cast<GLES2FunctionPointer>(
2370          glRenderbufferStorageMultisampleCHROMIUM),
2371     },
2372     {
2373      "glRenderbufferStorageMultisampleEXT",
2374      reinterpret_cast<GLES2FunctionPointer>(
2375          glRenderbufferStorageMultisampleEXT),
2376     },
2377     {
2378      "glFramebufferTexture2DMultisampleEXT",
2379      reinterpret_cast<GLES2FunctionPointer>(
2380          glFramebufferTexture2DMultisampleEXT),
2381     },
2382     {
2383      "glTexStorage2DEXT",
2384      reinterpret_cast<GLES2FunctionPointer>(glTexStorage2DEXT),
2385     },
2386     {
2387      "glGenQueriesEXT",
2388      reinterpret_cast<GLES2FunctionPointer>(glGenQueriesEXT),
2389     },
2390     {
2391      "glDeleteQueriesEXT",
2392      reinterpret_cast<GLES2FunctionPointer>(glDeleteQueriesEXT),
2393     },
2394     {
2395      "glQueryCounterEXT",
2396      reinterpret_cast<GLES2FunctionPointer>(glQueryCounterEXT),
2397     },
2398     {
2399      "glIsQueryEXT",
2400      reinterpret_cast<GLES2FunctionPointer>(glIsQueryEXT),
2401     },
2402     {
2403      "glBeginQueryEXT",
2404      reinterpret_cast<GLES2FunctionPointer>(glBeginQueryEXT),
2405     },
2406     {
2407      "glBeginTransformFeedback",
2408      reinterpret_cast<GLES2FunctionPointer>(glBeginTransformFeedback),
2409     },
2410     {
2411      "glEndQueryEXT",
2412      reinterpret_cast<GLES2FunctionPointer>(glEndQueryEXT),
2413     },
2414     {
2415      "glEndTransformFeedback",
2416      reinterpret_cast<GLES2FunctionPointer>(glEndTransformFeedback),
2417     },
2418     {
2419      "glGetQueryivEXT",
2420      reinterpret_cast<GLES2FunctionPointer>(glGetQueryivEXT),
2421     },
2422     {
2423      "glGetQueryObjectuivEXT",
2424      reinterpret_cast<GLES2FunctionPointer>(glGetQueryObjectuivEXT),
2425     },
2426     {
2427      "glGetQueryObjectui64vEXT",
2428      reinterpret_cast<GLES2FunctionPointer>(glGetQueryObjectui64vEXT),
2429     },
2430     {
2431      "glInsertEventMarkerEXT",
2432      reinterpret_cast<GLES2FunctionPointer>(glInsertEventMarkerEXT),
2433     },
2434     {
2435      "glPushGroupMarkerEXT",
2436      reinterpret_cast<GLES2FunctionPointer>(glPushGroupMarkerEXT),
2437     },
2438     {
2439      "glPopGroupMarkerEXT",
2440      reinterpret_cast<GLES2FunctionPointer>(glPopGroupMarkerEXT),
2441     },
2442     {
2443      "glGenVertexArraysOES",
2444      reinterpret_cast<GLES2FunctionPointer>(glGenVertexArraysOES),
2445     },
2446     {
2447      "glDeleteVertexArraysOES",
2448      reinterpret_cast<GLES2FunctionPointer>(glDeleteVertexArraysOES),
2449     },
2450     {
2451      "glIsVertexArrayOES",
2452      reinterpret_cast<GLES2FunctionPointer>(glIsVertexArrayOES),
2453     },
2454     {
2455      "glBindVertexArrayOES",
2456      reinterpret_cast<GLES2FunctionPointer>(glBindVertexArrayOES),
2457     },
2458     {
2459      "glSwapBuffers",
2460      reinterpret_cast<GLES2FunctionPointer>(glSwapBuffers),
2461     },
2462     {
2463      "glGetMaxValueInBufferCHROMIUM",
2464      reinterpret_cast<GLES2FunctionPointer>(glGetMaxValueInBufferCHROMIUM),
2465     },
2466     {
2467      "glEnableFeatureCHROMIUM",
2468      reinterpret_cast<GLES2FunctionPointer>(glEnableFeatureCHROMIUM),
2469     },
2470     {
2471      "glMapBufferCHROMIUM",
2472      reinterpret_cast<GLES2FunctionPointer>(glMapBufferCHROMIUM),
2473     },
2474     {
2475      "glUnmapBufferCHROMIUM",
2476      reinterpret_cast<GLES2FunctionPointer>(glUnmapBufferCHROMIUM),
2477     },
2478     {
2479      "glMapBufferSubDataCHROMIUM",
2480      reinterpret_cast<GLES2FunctionPointer>(glMapBufferSubDataCHROMIUM),
2481     },
2482     {
2483      "glUnmapBufferSubDataCHROMIUM",
2484      reinterpret_cast<GLES2FunctionPointer>(glUnmapBufferSubDataCHROMIUM),
2485     },
2486     {
2487      "glMapBufferRange",
2488      reinterpret_cast<GLES2FunctionPointer>(glMapBufferRange),
2489     },
2490     {
2491      "glUnmapBuffer",
2492      reinterpret_cast<GLES2FunctionPointer>(glUnmapBuffer),
2493     },
2494     {
2495      "glMapTexSubImage2DCHROMIUM",
2496      reinterpret_cast<GLES2FunctionPointer>(glMapTexSubImage2DCHROMIUM),
2497     },
2498     {
2499      "glUnmapTexSubImage2DCHROMIUM",
2500      reinterpret_cast<GLES2FunctionPointer>(glUnmapTexSubImage2DCHROMIUM),
2501     },
2502     {
2503      "glResizeCHROMIUM",
2504      reinterpret_cast<GLES2FunctionPointer>(glResizeCHROMIUM),
2505     },
2506     {
2507      "glGetRequestableExtensionsCHROMIUM",
2508      reinterpret_cast<GLES2FunctionPointer>(glGetRequestableExtensionsCHROMIUM),
2509     },
2510     {
2511      "glRequestExtensionCHROMIUM",
2512      reinterpret_cast<GLES2FunctionPointer>(glRequestExtensionCHROMIUM),
2513     },
2514     {
2515      "glRateLimitOffscreenContextCHROMIUM",
2516      reinterpret_cast<GLES2FunctionPointer>(
2517          glRateLimitOffscreenContextCHROMIUM),
2518     },
2519     {
2520      "glGetProgramInfoCHROMIUM",
2521      reinterpret_cast<GLES2FunctionPointer>(glGetProgramInfoCHROMIUM),
2522     },
2523     {
2524      "glGetUniformBlocksCHROMIUM",
2525      reinterpret_cast<GLES2FunctionPointer>(glGetUniformBlocksCHROMIUM),
2526     },
2527     {
2528      "glGetTransformFeedbackVaryingsCHROMIUM",
2529      reinterpret_cast<GLES2FunctionPointer>(
2530          glGetTransformFeedbackVaryingsCHROMIUM),
2531     },
2532     {
2533      "glGetUniformsES3CHROMIUM",
2534      reinterpret_cast<GLES2FunctionPointer>(glGetUniformsES3CHROMIUM),
2535     },
2536     {
2537      "glCreateStreamTextureCHROMIUM",
2538      reinterpret_cast<GLES2FunctionPointer>(glCreateStreamTextureCHROMIUM),
2539     },
2540     {
2541      "glCreateImageCHROMIUM",
2542      reinterpret_cast<GLES2FunctionPointer>(glCreateImageCHROMIUM),
2543     },
2544     {
2545      "glDestroyImageCHROMIUM",
2546      reinterpret_cast<GLES2FunctionPointer>(glDestroyImageCHROMIUM),
2547     },
2548     {
2549      "glCreateGpuMemoryBufferImageCHROMIUM",
2550      reinterpret_cast<GLES2FunctionPointer>(
2551          glCreateGpuMemoryBufferImageCHROMIUM),
2552     },
2553     {
2554      "glGetTranslatedShaderSourceANGLE",
2555      reinterpret_cast<GLES2FunctionPointer>(glGetTranslatedShaderSourceANGLE),
2556     },
2557     {
2558      "glPostSubBufferCHROMIUM",
2559      reinterpret_cast<GLES2FunctionPointer>(glPostSubBufferCHROMIUM),
2560     },
2561     {
2562      "glTexImageIOSurface2DCHROMIUM",
2563      reinterpret_cast<GLES2FunctionPointer>(glTexImageIOSurface2DCHROMIUM),
2564     },
2565     {
2566      "glCopyTextureCHROMIUM",
2567      reinterpret_cast<GLES2FunctionPointer>(glCopyTextureCHROMIUM),
2568     },
2569     {
2570      "glCopySubTextureCHROMIUM",
2571      reinterpret_cast<GLES2FunctionPointer>(glCopySubTextureCHROMIUM),
2572     },
2573     {
2574      "glCompressedCopyTextureCHROMIUM",
2575      reinterpret_cast<GLES2FunctionPointer>(glCompressedCopyTextureCHROMIUM),
2576     },
2577     {
2578      "glDrawArraysInstancedANGLE",
2579      reinterpret_cast<GLES2FunctionPointer>(glDrawArraysInstancedANGLE),
2580     },
2581     {
2582      "glDrawElementsInstancedANGLE",
2583      reinterpret_cast<GLES2FunctionPointer>(glDrawElementsInstancedANGLE),
2584     },
2585     {
2586      "glVertexAttribDivisorANGLE",
2587      reinterpret_cast<GLES2FunctionPointer>(glVertexAttribDivisorANGLE),
2588     },
2589     {
2590      "glGenMailboxCHROMIUM",
2591      reinterpret_cast<GLES2FunctionPointer>(glGenMailboxCHROMIUM),
2592     },
2593     {
2594      "glProduceTextureCHROMIUM",
2595      reinterpret_cast<GLES2FunctionPointer>(glProduceTextureCHROMIUM),
2596     },
2597     {
2598      "glProduceTextureDirectCHROMIUM",
2599      reinterpret_cast<GLES2FunctionPointer>(glProduceTextureDirectCHROMIUM),
2600     },
2601     {
2602      "glConsumeTextureCHROMIUM",
2603      reinterpret_cast<GLES2FunctionPointer>(glConsumeTextureCHROMIUM),
2604     },
2605     {
2606      "glCreateAndConsumeTextureCHROMIUM",
2607      reinterpret_cast<GLES2FunctionPointer>(glCreateAndConsumeTextureCHROMIUM),
2608     },
2609     {
2610      "glBindUniformLocationCHROMIUM",
2611      reinterpret_cast<GLES2FunctionPointer>(glBindUniformLocationCHROMIUM),
2612     },
2613     {
2614      "glGenValuebuffersCHROMIUM",
2615      reinterpret_cast<GLES2FunctionPointer>(glGenValuebuffersCHROMIUM),
2616     },
2617     {
2618      "glDeleteValuebuffersCHROMIUM",
2619      reinterpret_cast<GLES2FunctionPointer>(glDeleteValuebuffersCHROMIUM),
2620     },
2621     {
2622      "glIsValuebufferCHROMIUM",
2623      reinterpret_cast<GLES2FunctionPointer>(glIsValuebufferCHROMIUM),
2624     },
2625     {
2626      "glBindValuebufferCHROMIUM",
2627      reinterpret_cast<GLES2FunctionPointer>(glBindValuebufferCHROMIUM),
2628     },
2629     {
2630      "glSubscribeValueCHROMIUM",
2631      reinterpret_cast<GLES2FunctionPointer>(glSubscribeValueCHROMIUM),
2632     },
2633     {
2634      "glPopulateSubscribedValuesCHROMIUM",
2635      reinterpret_cast<GLES2FunctionPointer>(glPopulateSubscribedValuesCHROMIUM),
2636     },
2637     {
2638      "glUniformValuebufferCHROMIUM",
2639      reinterpret_cast<GLES2FunctionPointer>(glUniformValuebufferCHROMIUM),
2640     },
2641     {
2642      "glBindTexImage2DCHROMIUM",
2643      reinterpret_cast<GLES2FunctionPointer>(glBindTexImage2DCHROMIUM),
2644     },
2645     {
2646      "glReleaseTexImage2DCHROMIUM",
2647      reinterpret_cast<GLES2FunctionPointer>(glReleaseTexImage2DCHROMIUM),
2648     },
2649     {
2650      "glTraceBeginCHROMIUM",
2651      reinterpret_cast<GLES2FunctionPointer>(glTraceBeginCHROMIUM),
2652     },
2653     {
2654      "glTraceEndCHROMIUM",
2655      reinterpret_cast<GLES2FunctionPointer>(glTraceEndCHROMIUM),
2656     },
2657     {
2658      "glAsyncTexSubImage2DCHROMIUM",
2659      reinterpret_cast<GLES2FunctionPointer>(glAsyncTexSubImage2DCHROMIUM),
2660     },
2661     {
2662      "glAsyncTexImage2DCHROMIUM",
2663      reinterpret_cast<GLES2FunctionPointer>(glAsyncTexImage2DCHROMIUM),
2664     },
2665     {
2666      "glWaitAsyncTexImage2DCHROMIUM",
2667      reinterpret_cast<GLES2FunctionPointer>(glWaitAsyncTexImage2DCHROMIUM),
2668     },
2669     {
2670      "glWaitAllAsyncTexImage2DCHROMIUM",
2671      reinterpret_cast<GLES2FunctionPointer>(glWaitAllAsyncTexImage2DCHROMIUM),
2672     },
2673     {
2674      "glDiscardFramebufferEXT",
2675      reinterpret_cast<GLES2FunctionPointer>(glDiscardFramebufferEXT),
2676     },
2677     {
2678      "glLoseContextCHROMIUM",
2679      reinterpret_cast<GLES2FunctionPointer>(glLoseContextCHROMIUM),
2680     },
2681     {
2682      "glInsertSyncPointCHROMIUM",
2683      reinterpret_cast<GLES2FunctionPointer>(glInsertSyncPointCHROMIUM),
2684     },
2685     {
2686      "glWaitSyncPointCHROMIUM",
2687      reinterpret_cast<GLES2FunctionPointer>(glWaitSyncPointCHROMIUM),
2688     },
2689     {
2690      "glDrawBuffersEXT",
2691      reinterpret_cast<GLES2FunctionPointer>(glDrawBuffersEXT),
2692     },
2693     {
2694      "glDiscardBackbufferCHROMIUM",
2695      reinterpret_cast<GLES2FunctionPointer>(glDiscardBackbufferCHROMIUM),
2696     },
2697     {
2698      "glScheduleOverlayPlaneCHROMIUM",
2699      reinterpret_cast<GLES2FunctionPointer>(glScheduleOverlayPlaneCHROMIUM),
2700     },
2701     {
2702      "glSwapInterval",
2703      reinterpret_cast<GLES2FunctionPointer>(glSwapInterval),
2704     },
2705     {
2706      "glFlushDriverCachesCHROMIUM",
2707      reinterpret_cast<GLES2FunctionPointer>(glFlushDriverCachesCHROMIUM),
2708     },
2709     {
2710      "glMatrixLoadfCHROMIUM",
2711      reinterpret_cast<GLES2FunctionPointer>(glMatrixLoadfCHROMIUM),
2712     },
2713     {
2714      "glMatrixLoadIdentityCHROMIUM",
2715      reinterpret_cast<GLES2FunctionPointer>(glMatrixLoadIdentityCHROMIUM),
2716     },
2717     {
2718      "glGenPathsCHROMIUM",
2719      reinterpret_cast<GLES2FunctionPointer>(glGenPathsCHROMIUM),
2720     },
2721     {
2722      "glDeletePathsCHROMIUM",
2723      reinterpret_cast<GLES2FunctionPointer>(glDeletePathsCHROMIUM),
2724     },
2725     {
2726      "glIsPathCHROMIUM",
2727      reinterpret_cast<GLES2FunctionPointer>(glIsPathCHROMIUM),
2728     },
2729     {
2730      "glPathCommandsCHROMIUM",
2731      reinterpret_cast<GLES2FunctionPointer>(glPathCommandsCHROMIUM),
2732     },
2733     {
2734      "glPathParameterfCHROMIUM",
2735      reinterpret_cast<GLES2FunctionPointer>(glPathParameterfCHROMIUM),
2736     },
2737     {
2738      "glPathParameteriCHROMIUM",
2739      reinterpret_cast<GLES2FunctionPointer>(glPathParameteriCHROMIUM),
2740     },
2741     {
2742      "glPathStencilFuncCHROMIUM",
2743      reinterpret_cast<GLES2FunctionPointer>(glPathStencilFuncCHROMIUM),
2744     },
2745     {
2746      "glStencilFillPathCHROMIUM",
2747      reinterpret_cast<GLES2FunctionPointer>(glStencilFillPathCHROMIUM),
2748     },
2749     {
2750      "glStencilStrokePathCHROMIUM",
2751      reinterpret_cast<GLES2FunctionPointer>(glStencilStrokePathCHROMIUM),
2752     },
2753     {
2754      "glCoverFillPathCHROMIUM",
2755      reinterpret_cast<GLES2FunctionPointer>(glCoverFillPathCHROMIUM),
2756     },
2757     {
2758      "glCoverStrokePathCHROMIUM",
2759      reinterpret_cast<GLES2FunctionPointer>(glCoverStrokePathCHROMIUM),
2760     },
2761     {
2762      "glStencilThenCoverFillPathCHROMIUM",
2763      reinterpret_cast<GLES2FunctionPointer>(glStencilThenCoverFillPathCHROMIUM),
2764     },
2765     {
2766      "glStencilThenCoverStrokePathCHROMIUM",
2767      reinterpret_cast<GLES2FunctionPointer>(
2768          glStencilThenCoverStrokePathCHROMIUM),
2769     },
2770     {
2771      "glGetGraphicsResetStatusKHR",
2772      reinterpret_cast<GLES2FunctionPointer>(glGetGraphicsResetStatusKHR),
2773     },
2774     {
2775      "glBlendBarrierKHR",
2776      reinterpret_cast<GLES2FunctionPointer>(glBlendBarrierKHR),
2777     },
2778     {
2779      NULL,
2780      NULL,
2781     },
2782 };
2783
2784 }  // namespace gles2
2785 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_C_LIB_AUTOGEN_H_