ui/gl/gl_bindings_autogen_mock.cc

   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 // ui/gl/generate_bindings.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 #include <string.h>
  12
  13 #include "ui/gl/gl_mock.h"
  14
  15 namespace gfx {
  16
  17 // This is called mainly to prevent the compiler combining the code of mock
  18 // functions with identical contents, so that their function pointers will be
  19 // different.
  20 void MakeFunctionUnique(const char* func_name) {
  21   VLOG(2) << "Calling mock " << func_name;
  22 }
  23
  24 void GL_BINDING_CALL MockGLInterface::Mock_glActiveTexture(GLenum texture) {
  25   MakeFunctionUnique("glActiveTexture");
  26   interface_->ActiveTexture(texture);
  27 }
  28
  29 void GL_BINDING_CALL
  30 MockGLInterface::Mock_glAttachShader(GLuint program, GLuint shader) {
  31   MakeFunctionUnique("glAttachShader");
  32   interface_->AttachShader(program, shader);
  33 }
  34
  35 void GL_BINDING_CALL
  36 MockGLInterface::Mock_glBeginQuery(GLenum target, GLuint id) {
  37   MakeFunctionUnique("glBeginQuery");
  38   interface_->BeginQuery(target, id);
  39 }
  40
  41 void GL_BINDING_CALL
  42 MockGLInterface::Mock_glBeginQueryARB(GLenum target, GLuint id) {
  43   MakeFunctionUnique("glBeginQueryARB");
  44   interface_->BeginQuery(target, id);
  45 }
  46
  47 void GL_BINDING_CALL
  48 MockGLInterface::Mock_glBeginQueryEXT(GLenum target, GLuint id) {
  49   MakeFunctionUnique("glBeginQueryEXT");
  50   interface_->BeginQuery(target, id);
  51 }
  52
  53 void GL_BINDING_CALL
  54 MockGLInterface::Mock_glBeginTransformFeedback(GLenum primitiveMode) {
  55   MakeFunctionUnique("glBeginTransformFeedback");
  56   interface_->BeginTransformFeedback(primitiveMode);
  57 }
  58
  59 void GL_BINDING_CALL
  60 MockGLInterface::Mock_glBindAttribLocation(GLuint program,
  61                                            GLuint index,
  62                                            const char* name) {
  63   MakeFunctionUnique("glBindAttribLocation");
  64   interface_->BindAttribLocation(program, index, name);
  65 }
  66
  67 void GL_BINDING_CALL
  68 MockGLInterface::Mock_glBindBuffer(GLenum target, GLuint buffer) {
  69   MakeFunctionUnique("glBindBuffer");
  70   interface_->BindBuffer(target, buffer);
  71 }
  72
  73 void GL_BINDING_CALL MockGLInterface::Mock_glBindBufferBase(GLenum target,
  74                                                             GLuint index,
  75                                                             GLuint buffer) {
  76   MakeFunctionUnique("glBindBufferBase");
  77   interface_->BindBufferBase(target, index, buffer);
  78 }
  79
  80 void GL_BINDING_CALL MockGLInterface::Mock_glBindBufferRange(GLenum target,
  81                                                              GLuint index,
  82                                                              GLuint buffer,
  83                                                              GLintptr offset,
  84                                                              GLsizeiptr size) {
  85   MakeFunctionUnique("glBindBufferRange");
  86   interface_->BindBufferRange(target, index, buffer, offset, size);
  87 }
  88
  89 void GL_BINDING_CALL
  90 MockGLInterface::Mock_glBindFragDataLocation(GLuint program,
  91                                              GLuint colorNumber,
  92                                              const char* name) {
  93   MakeFunctionUnique("glBindFragDataLocation");
  94   interface_->BindFragDataLocation(program, colorNumber, name);
  95 }
  96
  97 void GL_BINDING_CALL
  98 MockGLInterface::Mock_glBindFragDataLocationIndexed(GLuint program,
  99                                                     GLuint colorNumber,
 100                                                     GLuint index,
 101                                                     const char* name) {
 102   MakeFunctionUnique("glBindFragDataLocationIndexed");
 103   interface_->BindFragDataLocationIndexed(program, colorNumber, index, name);
 104 }
 105
 106 void GL_BINDING_CALL
 107 MockGLInterface::Mock_glBindFramebuffer(GLenum target, GLuint framebuffer) {
 108   MakeFunctionUnique("glBindFramebuffer");
 109   interface_->BindFramebufferEXT(target, framebuffer);
 110 }
 111
 112 void GL_BINDING_CALL
 113 MockGLInterface::Mock_glBindFramebufferEXT(GLenum target, GLuint framebuffer) {
 114   MakeFunctionUnique("glBindFramebufferEXT");
 115   interface_->BindFramebufferEXT(target, framebuffer);
 116 }
 117
 118 void GL_BINDING_CALL
 119 MockGLInterface::Mock_glBindRenderbuffer(GLenum target, GLuint renderbuffer) {
 120   MakeFunctionUnique("glBindRenderbuffer");
 121   interface_->BindRenderbufferEXT(target, renderbuffer);
 122 }
 123
 124 void GL_BINDING_CALL
 125 MockGLInterface::Mock_glBindRenderbufferEXT(GLenum target,
 126                                             GLuint renderbuffer) {
 127   MakeFunctionUnique("glBindRenderbufferEXT");
 128   interface_->BindRenderbufferEXT(target, renderbuffer);
 129 }
 130
 131 void GL_BINDING_CALL
 132 MockGLInterface::Mock_glBindSampler(GLuint unit, GLuint sampler) {
 133   MakeFunctionUnique("glBindSampler");
 134   interface_->BindSampler(unit, sampler);
 135 }
 136
 137 void GL_BINDING_CALL
 138 MockGLInterface::Mock_glBindTexture(GLenum target, GLuint texture) {
 139   MakeFunctionUnique("glBindTexture");
 140   interface_->BindTexture(target, texture);
 141 }
 142
 143 void GL_BINDING_CALL
 144 MockGLInterface::Mock_glBindTransformFeedback(GLenum target, GLuint id) {
 145   MakeFunctionUnique("glBindTransformFeedback");
 146   interface_->BindTransformFeedback(target, id);
 147 }
 148
 149 void GL_BINDING_CALL MockGLInterface::Mock_glBindVertexArray(GLuint array) {
 150   MakeFunctionUnique("glBindVertexArray");
 151   interface_->BindVertexArrayOES(array);
 152 }
 153
 154 void GL_BINDING_CALL
 155 MockGLInterface::Mock_glBindVertexArrayAPPLE(GLuint array) {
 156   MakeFunctionUnique("glBindVertexArrayAPPLE");
 157   interface_->BindVertexArrayOES(array);
 158 }
 159
 160 void GL_BINDING_CALL MockGLInterface::Mock_glBindVertexArrayOES(GLuint array) {
 161   MakeFunctionUnique("glBindVertexArrayOES");
 162   interface_->BindVertexArrayOES(array);
 163 }
 164
 165 void GL_BINDING_CALL MockGLInterface::Mock_glBlendBarrierKHR(void) {
 166   MakeFunctionUnique("glBlendBarrierKHR");
 167   interface_->BlendBarrierKHR();
 168 }
 169
 170 void GL_BINDING_CALL MockGLInterface::Mock_glBlendBarrierNV(void) {
 171   MakeFunctionUnique("glBlendBarrierNV");
 172   interface_->BlendBarrierKHR();
 173 }
 174
 175 void GL_BINDING_CALL MockGLInterface::Mock_glBlendColor(GLclampf red,
 176                                                         GLclampf green,
 177                                                         GLclampf blue,
 178                                                         GLclampf alpha) {
 179   MakeFunctionUnique("glBlendColor");
 180   interface_->BlendColor(red, green, blue, alpha);
 181 }
 182
 183 void GL_BINDING_CALL MockGLInterface::Mock_glBlendEquation(GLenum mode) {
 184   MakeFunctionUnique("glBlendEquation");
 185   interface_->BlendEquation(mode);
 186 }
 187
 188 void GL_BINDING_CALL
 189 MockGLInterface::Mock_glBlendEquationSeparate(GLenum modeRGB,
 190                                               GLenum modeAlpha) {
 191   MakeFunctionUnique("glBlendEquationSeparate");
 192   interface_->BlendEquationSeparate(modeRGB, modeAlpha);
 193 }
 194
 195 void GL_BINDING_CALL
 196 MockGLInterface::Mock_glBlendFunc(GLenum sfactor, GLenum dfactor) {
 197   MakeFunctionUnique("glBlendFunc");
 198   interface_->BlendFunc(sfactor, dfactor);
 199 }
 200
 201 void GL_BINDING_CALL
 202 MockGLInterface::Mock_glBlendFuncSeparate(GLenum srcRGB,
 203                                           GLenum dstRGB,
 204                                           GLenum srcAlpha,
 205                                           GLenum dstAlpha) {
 206   MakeFunctionUnique("glBlendFuncSeparate");
 207   interface_->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 208 }
 209
 210 void GL_BINDING_CALL MockGLInterface::Mock_glBlitFramebuffer(GLint srcX0,
 211                                                              GLint srcY0,
 212                                                              GLint srcX1,
 213                                                              GLint srcY1,
 214                                                              GLint dstX0,
 215                                                              GLint dstY0,
 216                                                              GLint dstX1,
 217                                                              GLint dstY1,
 218                                                              GLbitfield mask,
 219                                                              GLenum filter) {
 220   MakeFunctionUnique("glBlitFramebuffer");
 221   interface_->BlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
 222                                  dstX1, dstY1, mask, filter);
 223 }
 224
 225 void GL_BINDING_CALL
 226 MockGLInterface::Mock_glBlitFramebufferANGLE(GLint srcX0,
 227                                              GLint srcY0,
 228                                              GLint srcX1,
 229                                              GLint srcY1,
 230                                              GLint dstX0,
 231                                              GLint dstY0,
 232                                              GLint dstX1,
 233                                              GLint dstY1,
 234                                              GLbitfield mask,
 235                                              GLenum filter) {
 236   MakeFunctionUnique("glBlitFramebufferANGLE");
 237   interface_->BlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
 238                                    dstX1, dstY1, mask, filter);
 239 }
 240
 241 void GL_BINDING_CALL MockGLInterface::Mock_glBlitFramebufferEXT(GLint srcX0,
 242                                                                 GLint srcY0,
 243                                                                 GLint srcX1,
 244                                                                 GLint srcY1,
 245                                                                 GLint dstX0,
 246                                                                 GLint dstY0,
 247                                                                 GLint dstX1,
 248                                                                 GLint dstY1,
 249                                                                 GLbitfield mask,
 250                                                                 GLenum filter) {
 251   MakeFunctionUnique("glBlitFramebufferEXT");
 252   interface_->BlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
 253                                  dstX1, dstY1, mask, filter);
 254 }
 255
 256 void GL_BINDING_CALL MockGLInterface::Mock_glBufferData(GLenum target,
 257                                                         GLsizeiptr size,
 258                                                         const void* data,
 259                                                         GLenum usage) {
 260   MakeFunctionUnique("glBufferData");
 261   interface_->BufferData(target, size, data, usage);
 262 }
 263
 264 void GL_BINDING_CALL MockGLInterface::Mock_glBufferSubData(GLenum target,
 265                                                            GLintptr offset,
 266                                                            GLsizeiptr size,
 267                                                            const void* data) {
 268   MakeFunctionUnique("glBufferSubData");
 269   interface_->BufferSubData(target, offset, size, data);
 270 }
 271
 272 GLenum GL_BINDING_CALL
 273 MockGLInterface::Mock_glCheckFramebufferStatus(GLenum target) {
 274   MakeFunctionUnique("glCheckFramebufferStatus");
 275   return interface_->CheckFramebufferStatusEXT(target);
 276 }
 277
 278 GLenum GL_BINDING_CALL
 279 MockGLInterface::Mock_glCheckFramebufferStatusEXT(GLenum target) {
 280   MakeFunctionUnique("glCheckFramebufferStatusEXT");
 281   return interface_->CheckFramebufferStatusEXT(target);
 282 }
 283
 284 void GL_BINDING_CALL MockGLInterface::Mock_glClear(GLbitfield mask) {
 285   MakeFunctionUnique("glClear");
 286   interface_->Clear(mask);
 287 }
 288
 289 void GL_BINDING_CALL MockGLInterface::Mock_glClearBufferfi(GLenum buffer,
 290                                                            GLint drawbuffer,
 291                                                            const GLfloat depth,
 292                                                            GLint stencil) {
 293   MakeFunctionUnique("glClearBufferfi");
 294   interface_->ClearBufferfi(buffer, drawbuffer, depth, stencil);
 295 }
 296
 297 void GL_BINDING_CALL
 298 MockGLInterface::Mock_glClearBufferfv(GLenum buffer,
 299                                       GLint drawbuffer,
 300                                       const GLfloat* value) {
 301   MakeFunctionUnique("glClearBufferfv");
 302   interface_->ClearBufferfv(buffer, drawbuffer, value);
 303 }
 304
 305 void GL_BINDING_CALL MockGLInterface::Mock_glClearBufferiv(GLenum buffer,
 306                                                            GLint drawbuffer,
 307                                                            const GLint* value) {
 308   MakeFunctionUnique("glClearBufferiv");
 309   interface_->ClearBufferiv(buffer, drawbuffer, value);
 310 }
 311
 312 void GL_BINDING_CALL
 313 MockGLInterface::Mock_glClearBufferuiv(GLenum buffer,
 314                                        GLint drawbuffer,
 315                                        const GLuint* value) {
 316   MakeFunctionUnique("glClearBufferuiv");
 317   interface_->ClearBufferuiv(buffer, drawbuffer, value);
 318 }
 319
 320 void GL_BINDING_CALL MockGLInterface::Mock_glClearColor(GLclampf red,
 321                                                         GLclampf green,
 322                                                         GLclampf blue,
 323                                                         GLclampf alpha) {
 324   MakeFunctionUnique("glClearColor");
 325   interface_->ClearColor(red, green, blue, alpha);
 326 }
 327
 328 void GL_BINDING_CALL MockGLInterface::Mock_glClearDepth(GLclampd depth) {
 329   MakeFunctionUnique("glClearDepth");
 330   interface_->ClearDepth(depth);
 331 }
 332
 333 void GL_BINDING_CALL MockGLInterface::Mock_glClearDepthf(GLclampf depth) {
 334   MakeFunctionUnique("glClearDepthf");
 335   interface_->ClearDepthf(depth);
 336 }
 337
 338 void GL_BINDING_CALL MockGLInterface::Mock_glClearStencil(GLint s) {
 339   MakeFunctionUnique("glClearStencil");
 340   interface_->ClearStencil(s);
 341 }
 342
 343 GLenum GL_BINDING_CALL
 344 MockGLInterface::Mock_glClientWaitSync(GLsync sync,
 345                                        GLbitfield flags,
 346                                        GLuint64 timeout) {
 347   MakeFunctionUnique("glClientWaitSync");
 348   return interface_->ClientWaitSync(sync, flags, timeout);
 349 }
 350
 351 void GL_BINDING_CALL MockGLInterface::Mock_glColorMask(GLboolean red,
 352                                                        GLboolean green,
 353                                                        GLboolean blue,
 354                                                        GLboolean alpha) {
 355   MakeFunctionUnique("glColorMask");
 356   interface_->ColorMask(red, green, blue, alpha);
 357 }
 358
 359 void GL_BINDING_CALL MockGLInterface::Mock_glCompileShader(GLuint shader) {
 360   MakeFunctionUnique("glCompileShader");
 361   interface_->CompileShader(shader);
 362 }
 363
 364 void GL_BINDING_CALL
 365 MockGLInterface::Mock_glCompressedTexImage2D(GLenum target,
 366                                              GLint level,
 367                                              GLenum internalformat,
 368                                              GLsizei width,
 369                                              GLsizei height,
 370                                              GLint border,
 371                                              GLsizei imageSize,
 372                                              const void* data) {
 373   MakeFunctionUnique("glCompressedTexImage2D");
 374   interface_->CompressedTexImage2D(target, level, internalformat, width, height,
 375                                    border, imageSize, data);
 376 }
 377
 378 void GL_BINDING_CALL
 379 MockGLInterface::Mock_glCompressedTexImage3D(GLenum target,
 380                                              GLint level,
 381                                              GLenum internalformat,
 382                                              GLsizei width,
 383                                              GLsizei height,
 384                                              GLsizei depth,
 385                                              GLint border,
 386                                              GLsizei imageSize,
 387                                              const void* data) {
 388   MakeFunctionUnique("glCompressedTexImage3D");
 389   interface_->CompressedTexImage3D(target, level, internalformat, width, height,
 390                                    depth, border, imageSize, data);
 391 }
 392
 393 void GL_BINDING_CALL
 394 MockGLInterface::Mock_glCompressedTexSubImage2D(GLenum target,
 395                                                 GLint level,
 396                                                 GLint xoffset,
 397                                                 GLint yoffset,
 398                                                 GLsizei width,
 399                                                 GLsizei height,
 400                                                 GLenum format,
 401                                                 GLsizei imageSize,
 402                                                 const void* data) {
 403   MakeFunctionUnique("glCompressedTexSubImage2D");
 404   interface_->CompressedTexSubImage2D(target, level, xoffset, yoffset, width,
 405                                       height, format, imageSize, data);
 406 }
 407
 408 void GL_BINDING_CALL
 409 MockGLInterface::Mock_glCopyBufferSubData(GLenum readTarget,
 410                                           GLenum writeTarget,
 411                                           GLintptr readOffset,
 412                                           GLintptr writeOffset,
 413                                           GLsizeiptr size) {
 414   MakeFunctionUnique("glCopyBufferSubData");
 415   interface_->CopyBufferSubData(readTarget, writeTarget, readOffset,
 416                                 writeOffset, size);
 417 }
 418
 419 void GL_BINDING_CALL
 420 MockGLInterface::Mock_glCopyTexImage2D(GLenum target,
 421                                        GLint level,
 422                                        GLenum internalformat,
 423                                        GLint x,
 424                                        GLint y,
 425                                        GLsizei width,
 426                                        GLsizei height,
 427                                        GLint border) {
 428   MakeFunctionUnique("glCopyTexImage2D");
 429   interface_->CopyTexImage2D(target, level, internalformat, x, y, width, height,
 430                              border);
 431 }
 432
 433 void GL_BINDING_CALL MockGLInterface::Mock_glCopyTexSubImage2D(GLenum target,
 434                                                                GLint level,
 435                                                                GLint xoffset,
 436                                                                GLint yoffset,
 437                                                                GLint x,
 438                                                                GLint y,
 439                                                                GLsizei width,
 440                                                                GLsizei height) {
 441   MakeFunctionUnique("glCopyTexSubImage2D");
 442   interface_->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width,
 443                                 height);
 444 }
 445
 446 void GL_BINDING_CALL MockGLInterface::Mock_glCopyTexSubImage3D(GLenum target,
 447                                                                GLint level,
 448                                                                GLint xoffset,
 449                                                                GLint yoffset,
 450                                                                GLint zoffset,
 451                                                                GLint x,
 452                                                                GLint y,
 453                                                                GLsizei width,
 454                                                                GLsizei height) {
 455   MakeFunctionUnique("glCopyTexSubImage3D");
 456   interface_->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y,
 457                                 width, height);
 458 }
 459
 460 GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateProgram(void) {
 461   MakeFunctionUnique("glCreateProgram");
 462   return interface_->CreateProgram();
 463 }
 464
 465 GLuint GL_BINDING_CALL MockGLInterface::Mock_glCreateShader(GLenum type) {
 466   MakeFunctionUnique("glCreateShader");
 467   return interface_->CreateShader(type);
 468 }
 469
 470 void GL_BINDING_CALL MockGLInterface::Mock_glCullFace(GLenum mode) {
 471   MakeFunctionUnique("glCullFace");
 472   interface_->CullFace(mode);
 473 }
 474
 475 void GL_BINDING_CALL
 476 MockGLInterface::Mock_glDeleteBuffers(GLsizei n, const GLuint* buffers) {
 477   MakeFunctionUnique("glDeleteBuffers");
 478   interface_->DeleteBuffersARB(n, buffers);
 479 }
 480
 481 void GL_BINDING_CALL
 482 MockGLInterface::Mock_glDeleteFencesAPPLE(GLsizei n, const GLuint* fences) {
 483   MakeFunctionUnique("glDeleteFencesAPPLE");
 484   interface_->DeleteFencesAPPLE(n, fences);
 485 }
 486
 487 void GL_BINDING_CALL
 488 MockGLInterface::Mock_glDeleteFencesNV(GLsizei n, const GLuint* fences) {
 489   MakeFunctionUnique("glDeleteFencesNV");
 490   interface_->DeleteFencesNV(n, fences);
 491 }
 492
 493 void GL_BINDING_CALL
 494 MockGLInterface::Mock_glDeleteFramebuffers(GLsizei n,
 495                                            const GLuint* framebuffers) {
 496   MakeFunctionUnique("glDeleteFramebuffers");
 497   interface_->DeleteFramebuffersEXT(n, framebuffers);
 498 }
 499
 500 void GL_BINDING_CALL
 501 MockGLInterface::Mock_glDeleteFramebuffersEXT(GLsizei n,
 502                                               const GLuint* framebuffers) {
 503   MakeFunctionUnique("glDeleteFramebuffersEXT");
 504   interface_->DeleteFramebuffersEXT(n, framebuffers);
 505 }
 506
 507 void GL_BINDING_CALL MockGLInterface::Mock_glDeleteProgram(GLuint program) {
 508   MakeFunctionUnique("glDeleteProgram");
 509   interface_->DeleteProgram(program);
 510 }
 511
 512 void GL_BINDING_CALL
 513 MockGLInterface::Mock_glDeleteQueries(GLsizei n, const GLuint* ids) {
 514   MakeFunctionUnique("glDeleteQueries");
 515   interface_->DeleteQueries(n, ids);
 516 }
 517
 518 void GL_BINDING_CALL
 519 MockGLInterface::Mock_glDeleteQueriesARB(GLsizei n, const GLuint* ids) {
 520   MakeFunctionUnique("glDeleteQueriesARB");
 521   interface_->DeleteQueries(n, ids);
 522 }
 523
 524 void GL_BINDING_CALL
 525 MockGLInterface::Mock_glDeleteQueriesEXT(GLsizei n, const GLuint* ids) {
 526   MakeFunctionUnique("glDeleteQueriesEXT");
 527   interface_->DeleteQueries(n, ids);
 528 }
 529
 530 void GL_BINDING_CALL
 531 MockGLInterface::Mock_glDeleteRenderbuffers(GLsizei n,
 532                                             const GLuint* renderbuffers) {
 533   MakeFunctionUnique("glDeleteRenderbuffers");
 534   interface_->DeleteRenderbuffersEXT(n, renderbuffers);
 535 }
 536
 537 void GL_BINDING_CALL
 538 MockGLInterface::Mock_glDeleteRenderbuffersEXT(GLsizei n,
 539                                                const GLuint* renderbuffers) {
 540   MakeFunctionUnique("glDeleteRenderbuffersEXT");
 541   interface_->DeleteRenderbuffersEXT(n, renderbuffers);
 542 }
 543
 544 void GL_BINDING_CALL
 545 MockGLInterface::Mock_glDeleteSamplers(GLsizei n, const GLuint* samplers) {
 546   MakeFunctionUnique("glDeleteSamplers");
 547   interface_->DeleteSamplers(n, samplers);
 548 }
 549
 550 void GL_BINDING_CALL MockGLInterface::Mock_glDeleteShader(GLuint shader) {
 551   MakeFunctionUnique("glDeleteShader");
 552   interface_->DeleteShader(shader);
 553 }
 554
 555 void GL_BINDING_CALL MockGLInterface::Mock_glDeleteSync(GLsync sync) {
 556   MakeFunctionUnique("glDeleteSync");
 557   interface_->DeleteSync(sync);
 558 }
 559
 560 void GL_BINDING_CALL
 561 MockGLInterface::Mock_glDeleteTextures(GLsizei n, const GLuint* textures) {
 562   MakeFunctionUnique("glDeleteTextures");
 563   interface_->DeleteTextures(n, textures);
 564 }
 565
 566 void GL_BINDING_CALL
 567 MockGLInterface::Mock_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
 568   MakeFunctionUnique("glDeleteTransformFeedbacks");
 569   interface_->DeleteTransformFeedbacks(n, ids);
 570 }
 571
 572 void GL_BINDING_CALL
 573 MockGLInterface::Mock_glDeleteVertexArrays(GLsizei n, const GLuint* arrays) {
 574   MakeFunctionUnique("glDeleteVertexArrays");
 575   interface_->DeleteVertexArraysOES(n, arrays);
 576 }
 577
 578 void GL_BINDING_CALL
 579 MockGLInterface::Mock_glDeleteVertexArraysAPPLE(GLsizei n,
 580                                                 const GLuint* arrays) {
 581   MakeFunctionUnique("glDeleteVertexArraysAPPLE");
 582   interface_->DeleteVertexArraysOES(n, arrays);
 583 }
 584
 585 void GL_BINDING_CALL
 586 MockGLInterface::Mock_glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
 587   MakeFunctionUnique("glDeleteVertexArraysOES");
 588   interface_->DeleteVertexArraysOES(n, arrays);
 589 }
 590
 591 void GL_BINDING_CALL MockGLInterface::Mock_glDepthFunc(GLenum func) {
 592   MakeFunctionUnique("glDepthFunc");
 593   interface_->DepthFunc(func);
 594 }
 595
 596 void GL_BINDING_CALL MockGLInterface::Mock_glDepthMask(GLboolean flag) {
 597   MakeFunctionUnique("glDepthMask");
 598   interface_->DepthMask(flag);
 599 }
 600
 601 void GL_BINDING_CALL
 602 MockGLInterface::Mock_glDepthRange(GLclampd zNear, GLclampd zFar) {
 603   MakeFunctionUnique("glDepthRange");
 604   interface_->DepthRange(zNear, zFar);
 605 }
 606
 607 void GL_BINDING_CALL
 608 MockGLInterface::Mock_glDepthRangef(GLclampf zNear, GLclampf zFar) {
 609   MakeFunctionUnique("glDepthRangef");
 610   interface_->DepthRangef(zNear, zFar);
 611 }
 612
 613 void GL_BINDING_CALL
 614 MockGLInterface::Mock_glDetachShader(GLuint program, GLuint shader) {
 615   MakeFunctionUnique("glDetachShader");
 616   interface_->DetachShader(program, shader);
 617 }
 618
 619 void GL_BINDING_CALL MockGLInterface::Mock_glDisable(GLenum cap) {
 620   MakeFunctionUnique("glDisable");
 621   interface_->Disable(cap);
 622 }
 623
 624 void GL_BINDING_CALL
 625 MockGLInterface::Mock_glDisableVertexAttribArray(GLuint index) {
 626   MakeFunctionUnique("glDisableVertexAttribArray");
 627   interface_->DisableVertexAttribArray(index);
 628 }
 629
 630 void GL_BINDING_CALL
 631 MockGLInterface::Mock_glDiscardFramebufferEXT(GLenum target,
 632                                               GLsizei numAttachments,
 633                                               const GLenum* attachments) {
 634   MakeFunctionUnique("glDiscardFramebufferEXT");
 635   interface_->DiscardFramebufferEXT(target, numAttachments, attachments);
 636 }
 637
 638 void GL_BINDING_CALL
 639 MockGLInterface::Mock_glDrawArrays(GLenum mode, GLint first, GLsizei count) {
 640   MakeFunctionUnique("glDrawArrays");
 641   interface_->DrawArrays(mode, first, count);
 642 }
 643
 644 void GL_BINDING_CALL
 645 MockGLInterface::Mock_glDrawArraysInstanced(GLenum mode,
 646                                             GLint first,
 647                                             GLsizei count,
 648                                             GLsizei primcount) {
 649   MakeFunctionUnique("glDrawArraysInstanced");
 650   interface_->DrawArraysInstancedANGLE(mode, first, count, primcount);
 651 }
 652
 653 void GL_BINDING_CALL
 654 MockGLInterface::Mock_glDrawArraysInstancedANGLE(GLenum mode,
 655                                                  GLint first,
 656                                                  GLsizei count,
 657                                                  GLsizei primcount) {
 658   MakeFunctionUnique("glDrawArraysInstancedANGLE");
 659   interface_->DrawArraysInstancedANGLE(mode, first, count, primcount);
 660 }
 661
 662 void GL_BINDING_CALL
 663 MockGLInterface::Mock_glDrawArraysInstancedARB(GLenum mode,
 664                                                GLint first,
 665                                                GLsizei count,
 666                                                GLsizei primcount) {
 667   MakeFunctionUnique("glDrawArraysInstancedARB");
 668   interface_->DrawArraysInstancedANGLE(mode, first, count, primcount);
 669 }
 670
 671 void GL_BINDING_CALL MockGLInterface::Mock_glDrawBuffer(GLenum mode) {
 672   MakeFunctionUnique("glDrawBuffer");
 673   interface_->DrawBuffer(mode);
 674 }
 675
 676 void GL_BINDING_CALL
 677 MockGLInterface::Mock_glDrawBuffers(GLsizei n, const GLenum* bufs) {
 678   MakeFunctionUnique("glDrawBuffers");
 679   interface_->DrawBuffersARB(n, bufs);
 680 }
 681
 682 void GL_BINDING_CALL
 683 MockGLInterface::Mock_glDrawBuffersARB(GLsizei n, const GLenum* bufs) {
 684   MakeFunctionUnique("glDrawBuffersARB");
 685   interface_->DrawBuffersARB(n, bufs);
 686 }
 687
 688 void GL_BINDING_CALL
 689 MockGLInterface::Mock_glDrawBuffersEXT(GLsizei n, const GLenum* bufs) {
 690   MakeFunctionUnique("glDrawBuffersEXT");
 691   interface_->DrawBuffersARB(n, bufs);
 692 }
 693
 694 void GL_BINDING_CALL MockGLInterface::Mock_glDrawElements(GLenum mode,
 695                                                           GLsizei count,
 696                                                           GLenum type,
 697                                                           const void* indices) {
 698   MakeFunctionUnique("glDrawElements");
 699   interface_->DrawElements(mode, count, type, indices);
 700 }
 701
 702 void GL_BINDING_CALL
 703 MockGLInterface::Mock_glDrawElementsInstanced(GLenum mode,
 704                                               GLsizei count,
 705                                               GLenum type,
 706                                               const void* indices,
 707                                               GLsizei primcount) {
 708   MakeFunctionUnique("glDrawElementsInstanced");
 709   interface_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
 710 }
 711
 712 void GL_BINDING_CALL
 713 MockGLInterface::Mock_glDrawElementsInstancedANGLE(GLenum mode,
 714                                                    GLsizei count,
 715                                                    GLenum type,
 716                                                    const void* indices,
 717                                                    GLsizei primcount) {
 718   MakeFunctionUnique("glDrawElementsInstancedANGLE");
 719   interface_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
 720 }
 721
 722 void GL_BINDING_CALL
 723 MockGLInterface::Mock_glDrawElementsInstancedARB(GLenum mode,
 724                                                  GLsizei count,
 725                                                  GLenum type,
 726                                                  const void* indices,
 727                                                  GLsizei primcount) {
 728   MakeFunctionUnique("glDrawElementsInstancedARB");
 729   interface_->DrawElementsInstancedANGLE(mode, count, type, indices, primcount);
 730 }
 731
 732 void GL_BINDING_CALL
 733 MockGLInterface::Mock_glDrawRangeElements(GLenum mode,
 734                                           GLuint start,
 735                                           GLuint end,
 736                                           GLsizei count,
 737                                           GLenum type,
 738                                           const void* indices) {
 739   MakeFunctionUnique("glDrawRangeElements");
 740   interface_->DrawRangeElements(mode, start, end, count, type, indices);
 741 }
 742
 743 void GL_BINDING_CALL
 744 MockGLInterface::Mock_glEGLImageTargetRenderbufferStorageOES(
 745     GLenum target,
 746     GLeglImageOES image) {
 747   MakeFunctionUnique("glEGLImageTargetRenderbufferStorageOES");
 748   interface_->EGLImageTargetRenderbufferStorageOES(target, image);
 749 }
 750
 751 void GL_BINDING_CALL
 752 MockGLInterface::Mock_glEGLImageTargetTexture2DOES(GLenum target,
 753                                                    GLeglImageOES image) {
 754   MakeFunctionUnique("glEGLImageTargetTexture2DOES");
 755   interface_->EGLImageTargetTexture2DOES(target, image);
 756 }
 757
 758 void GL_BINDING_CALL MockGLInterface::Mock_glEnable(GLenum cap) {
 759   MakeFunctionUnique("glEnable");
 760   interface_->Enable(cap);
 761 }
 762
 763 void GL_BINDING_CALL
 764 MockGLInterface::Mock_glEnableVertexAttribArray(GLuint index) {
 765   MakeFunctionUnique("glEnableVertexAttribArray");
 766   interface_->EnableVertexAttribArray(index);
 767 }
 768
 769 void GL_BINDING_CALL MockGLInterface::Mock_glEndQuery(GLenum target) {
 770   MakeFunctionUnique("glEndQuery");
 771   interface_->EndQuery(target);
 772 }
 773
 774 void GL_BINDING_CALL MockGLInterface::Mock_glEndQueryARB(GLenum target) {
 775   MakeFunctionUnique("glEndQueryARB");
 776   interface_->EndQuery(target);
 777 }
 778
 779 void GL_BINDING_CALL MockGLInterface::Mock_glEndQueryEXT(GLenum target) {
 780   MakeFunctionUnique("glEndQueryEXT");
 781   interface_->EndQuery(target);
 782 }
 783
 784 void GL_BINDING_CALL MockGLInterface::Mock_glEndTransformFeedback(void) {
 785   MakeFunctionUnique("glEndTransformFeedback");
 786   interface_->EndTransformFeedback();
 787 }
 788
 789 GLsync GL_BINDING_CALL
 790 MockGLInterface::Mock_glFenceSync(GLenum condition, GLbitfield flags) {
 791   MakeFunctionUnique("glFenceSync");
 792   return interface_->FenceSync(condition, flags);
 793 }
 794
 795 void GL_BINDING_CALL MockGLInterface::Mock_glFinish(void) {
 796   MakeFunctionUnique("glFinish");
 797   interface_->Finish();
 798 }
 799
 800 void GL_BINDING_CALL MockGLInterface::Mock_glFinishFenceAPPLE(GLuint fence) {
 801   MakeFunctionUnique("glFinishFenceAPPLE");
 802   interface_->FinishFenceAPPLE(fence);
 803 }
 804
 805 void GL_BINDING_CALL MockGLInterface::Mock_glFinishFenceNV(GLuint fence) {
 806   MakeFunctionUnique("glFinishFenceNV");
 807   interface_->FinishFenceNV(fence);
 808 }
 809
 810 void GL_BINDING_CALL MockGLInterface::Mock_glFlush(void) {
 811   MakeFunctionUnique("glFlush");
 812   interface_->Flush();
 813 }
 814
 815 void GL_BINDING_CALL
 816 MockGLInterface::Mock_glFlushMappedBufferRange(GLenum target,
 817                                                GLintptr offset,
 818                                                GLsizeiptr length) {
 819   MakeFunctionUnique("glFlushMappedBufferRange");
 820   interface_->FlushMappedBufferRange(target, offset, length);
 821 }
 822
 823 void GL_BINDING_CALL
 824 MockGLInterface::Mock_glFramebufferRenderbuffer(GLenum target,
 825                                                 GLenum attachment,
 826                                                 GLenum renderbuffertarget,
 827                                                 GLuint renderbuffer) {
 828   MakeFunctionUnique("glFramebufferRenderbuffer");
 829   interface_->FramebufferRenderbufferEXT(target, attachment, renderbuffertarget,
 830                                          renderbuffer);
 831 }
 832
 833 void GL_BINDING_CALL
 834 MockGLInterface::Mock_glFramebufferRenderbufferEXT(GLenum target,
 835                                                    GLenum attachment,
 836                                                    GLenum renderbuffertarget,
 837                                                    GLuint renderbuffer) {
 838   MakeFunctionUnique("glFramebufferRenderbufferEXT");
 839   interface_->FramebufferRenderbufferEXT(target, attachment, renderbuffertarget,
 840                                          renderbuffer);
 841 }
 842
 843 void GL_BINDING_CALL
 844 MockGLInterface::Mock_glFramebufferTexture2D(GLenum target,
 845                                              GLenum attachment,
 846                                              GLenum textarget,
 847                                              GLuint texture,
 848                                              GLint level) {
 849   MakeFunctionUnique("glFramebufferTexture2D");
 850   interface_->FramebufferTexture2DEXT(target, attachment, textarget, texture,
 851                                       level);
 852 }
 853
 854 void GL_BINDING_CALL
 855 MockGLInterface::Mock_glFramebufferTexture2DEXT(GLenum target,
 856                                                 GLenum attachment,
 857                                                 GLenum textarget,
 858                                                 GLuint texture,
 859                                                 GLint level) {
 860   MakeFunctionUnique("glFramebufferTexture2DEXT");
 861   interface_->FramebufferTexture2DEXT(target, attachment, textarget, texture,
 862                                       level);
 863 }
 864
 865 void GL_BINDING_CALL
 866 MockGLInterface::Mock_glFramebufferTexture2DMultisampleEXT(GLenum target,
 867                                                            GLenum attachment,
 868                                                            GLenum textarget,
 869                                                            GLuint texture,
 870                                                            GLint level,
 871                                                            GLsizei samples) {
 872   MakeFunctionUnique("glFramebufferTexture2DMultisampleEXT");
 873   interface_->FramebufferTexture2DMultisampleEXT(target, attachment, textarget,
 874                                                  texture, level, samples);
 875 }
 876
 877 void GL_BINDING_CALL
 878 MockGLInterface::Mock_glFramebufferTexture2DMultisampleIMG(GLenum target,
 879                                                            GLenum attachment,
 880                                                            GLenum textarget,
 881                                                            GLuint texture,
 882                                                            GLint level,
 883                                                            GLsizei samples) {
 884   MakeFunctionUnique("glFramebufferTexture2DMultisampleIMG");
 885   interface_->FramebufferTexture2DMultisampleIMG(target, attachment, textarget,
 886                                                  texture, level, samples);
 887 }
 888
 889 void GL_BINDING_CALL
 890 MockGLInterface::Mock_glFramebufferTextureLayer(GLenum target,
 891                                                 GLenum attachment,
 892                                                 GLuint texture,
 893                                                 GLint level,
 894                                                 GLint layer) {
 895   MakeFunctionUnique("glFramebufferTextureLayer");
 896   interface_->FramebufferTextureLayer(target, attachment, texture, level,
 897                                       layer);
 898 }
 899
 900 void GL_BINDING_CALL MockGLInterface::Mock_glFrontFace(GLenum mode) {
 901   MakeFunctionUnique("glFrontFace");
 902   interface_->FrontFace(mode);
 903 }
 904
 905 void GL_BINDING_CALL
 906 MockGLInterface::Mock_glGenBuffers(GLsizei n, GLuint* buffers) {
 907   MakeFunctionUnique("glGenBuffers");
 908   interface_->GenBuffersARB(n, buffers);
 909 }
 910
 911 void GL_BINDING_CALL
 912 MockGLInterface::Mock_glGenFencesAPPLE(GLsizei n, GLuint* fences) {
 913   MakeFunctionUnique("glGenFencesAPPLE");
 914   interface_->GenFencesAPPLE(n, fences);
 915 }
 916
 917 void GL_BINDING_CALL
 918 MockGLInterface::Mock_glGenFencesNV(GLsizei n, GLuint* fences) {
 919   MakeFunctionUnique("glGenFencesNV");
 920   interface_->GenFencesNV(n, fences);
 921 }
 922
 923 void GL_BINDING_CALL
 924 MockGLInterface::Mock_glGenFramebuffers(GLsizei n, GLuint* framebuffers) {
 925   MakeFunctionUnique("glGenFramebuffers");
 926   interface_->GenFramebuffersEXT(n, framebuffers);
 927 }
 928
 929 void GL_BINDING_CALL
 930 MockGLInterface::Mock_glGenFramebuffersEXT(GLsizei n, GLuint* framebuffers) {
 931   MakeFunctionUnique("glGenFramebuffersEXT");
 932   interface_->GenFramebuffersEXT(n, framebuffers);
 933 }
 934
 935 void GL_BINDING_CALL
 936 MockGLInterface::Mock_glGenQueries(GLsizei n, GLuint* ids) {
 937   MakeFunctionUnique("glGenQueries");
 938   interface_->GenQueries(n, ids);
 939 }
 940
 941 void GL_BINDING_CALL
 942 MockGLInterface::Mock_glGenQueriesARB(GLsizei n, GLuint* ids) {
 943   MakeFunctionUnique("glGenQueriesARB");
 944   interface_->GenQueries(n, ids);
 945 }
 946
 947 void GL_BINDING_CALL
 948 MockGLInterface::Mock_glGenQueriesEXT(GLsizei n, GLuint* ids) {
 949   MakeFunctionUnique("glGenQueriesEXT");
 950   interface_->GenQueries(n, ids);
 951 }
 952
 953 void GL_BINDING_CALL
 954 MockGLInterface::Mock_glGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
 955   MakeFunctionUnique("glGenRenderbuffers");
 956   interface_->GenRenderbuffersEXT(n, renderbuffers);
 957 }
 958
 959 void GL_BINDING_CALL
 960 MockGLInterface::Mock_glGenRenderbuffersEXT(GLsizei n, GLuint* renderbuffers) {
 961   MakeFunctionUnique("glGenRenderbuffersEXT");
 962   interface_->GenRenderbuffersEXT(n, renderbuffers);
 963 }
 964
 965 void GL_BINDING_CALL
 966 MockGLInterface::Mock_glGenSamplers(GLsizei n, GLuint* samplers) {
 967   MakeFunctionUnique("glGenSamplers");
 968   interface_->GenSamplers(n, samplers);
 969 }
 970
 971 void GL_BINDING_CALL
 972 MockGLInterface::Mock_glGenTextures(GLsizei n, GLuint* textures) {
 973   MakeFunctionUnique("glGenTextures");
 974   interface_->GenTextures(n, textures);
 975 }
 976
 977 void GL_BINDING_CALL
 978 MockGLInterface::Mock_glGenTransformFeedbacks(GLsizei n, GLuint* ids) {
 979   MakeFunctionUnique("glGenTransformFeedbacks");
 980   interface_->GenTransformFeedbacks(n, ids);
 981 }
 982
 983 void GL_BINDING_CALL
 984 MockGLInterface::Mock_glGenVertexArrays(GLsizei n, GLuint* arrays) {
 985   MakeFunctionUnique("glGenVertexArrays");
 986   interface_->GenVertexArraysOES(n, arrays);
 987 }
 988
 989 void GL_BINDING_CALL
 990 MockGLInterface::Mock_glGenVertexArraysAPPLE(GLsizei n, GLuint* arrays) {
 991   MakeFunctionUnique("glGenVertexArraysAPPLE");
 992   interface_->GenVertexArraysOES(n, arrays);
 993 }
 994
 995 void GL_BINDING_CALL
 996 MockGLInterface::Mock_glGenVertexArraysOES(GLsizei n, GLuint* arrays) {
 997   MakeFunctionUnique("glGenVertexArraysOES");
 998   interface_->GenVertexArraysOES(n, arrays);
 999 }
1000
1001 void GL_BINDING_CALL MockGLInterface::Mock_glGenerateMipmap(GLenum target) {
1002   MakeFunctionUnique("glGenerateMipmap");
1003   interface_->GenerateMipmapEXT(target);
1004 }
1005
1006 void GL_BINDING_CALL MockGLInterface::Mock_glGenerateMipmapEXT(GLenum target) {
1007   MakeFunctionUnique("glGenerateMipmapEXT");
1008   interface_->GenerateMipmapEXT(target);
1009 }
1010
1011 void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveAttrib(GLuint program,
1012                                                              GLuint index,
1013                                                              GLsizei bufsize,
1014                                                              GLsizei* length,
1015                                                              GLint* size,
1016                                                              GLenum* type,
1017                                                              char* name) {
1018   MakeFunctionUnique("glGetActiveAttrib");
1019   interface_->GetActiveAttrib(program, index, bufsize, length, size, type,
1020                               name);
1021 }
1022
1023 void GL_BINDING_CALL MockGLInterface::Mock_glGetActiveUniform(GLuint program,
1024                                                               GLuint index,
1025                                                               GLsizei bufsize,
1026                                                               GLsizei* length,
1027                                                               GLint* size,
1028                                                               GLenum* type,
1029                                                               char* name) {
1030   MakeFunctionUnique("glGetActiveUniform");
1031   interface_->GetActiveUniform(program, index, bufsize, length, size, type,
1032                                name);
1033 }
1034
1035 void GL_BINDING_CALL
1036 MockGLInterface::Mock_glGetActiveUniformBlockName(GLuint program,
1037                                                   GLuint uniformBlockIndex,
1038                                                   GLsizei bufSize,
1039                                                   GLsizei* length,
1040                                                   char* uniformBlockName) {
1041   MakeFunctionUnique("glGetActiveUniformBlockName");
1042   interface_->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize,
1043                                         length, uniformBlockName);
1044 }
1045
1046 void GL_BINDING_CALL
1047 MockGLInterface::Mock_glGetActiveUniformBlockiv(GLuint program,
1048                                                 GLuint uniformBlockIndex,
1049                                                 GLenum pname,
1050                                                 GLint* params) {
1051   MakeFunctionUnique("glGetActiveUniformBlockiv");
1052   interface_->GetActiveUniformBlockiv(program, uniformBlockIndex, pname,
1053                                       params);
1054 }
1055
1056 void GL_BINDING_CALL
1057 MockGLInterface::Mock_glGetActiveUniformsiv(GLuint program,
1058                                             GLsizei uniformCount,
1059                                             const GLuint* uniformIndices,
1060                                             GLenum pname,
1061                                             GLint* params) {
1062   MakeFunctionUnique("glGetActiveUniformsiv");
1063   interface_->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname,
1064                                   params);
1065 }
1066
1067 void GL_BINDING_CALL
1068 MockGLInterface::Mock_glGetAttachedShaders(GLuint program,
1069                                            GLsizei maxcount,
1070                                            GLsizei* count,
1071                                            GLuint* shaders) {
1072   MakeFunctionUnique("glGetAttachedShaders");
1073   interface_->GetAttachedShaders(program, maxcount, count, shaders);
1074 }
1075
1076 GLint GL_BINDING_CALL
1077 MockGLInterface::Mock_glGetAttribLocation(GLuint program, const char* name) {
1078   MakeFunctionUnique("glGetAttribLocation");
1079   return interface_->GetAttribLocation(program, name);
1080 }
1081
1082 void GL_BINDING_CALL
1083 MockGLInterface::Mock_glGetBooleanv(GLenum pname, GLboolean* params) {
1084   MakeFunctionUnique("glGetBooleanv");
1085   interface_->GetBooleanv(pname, params);
1086 }
1087
1088 void GL_BINDING_CALL
1089 MockGLInterface::Mock_glGetBufferParameteriv(GLenum target,
1090                                              GLenum pname,
1091                                              GLint* params) {
1092   MakeFunctionUnique("glGetBufferParameteriv");
1093   interface_->GetBufferParameteriv(target, pname, params);
1094 }
1095
1096 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetError(void) {
1097   MakeFunctionUnique("glGetError");
1098   return interface_->GetError();
1099 }
1100
1101 void GL_BINDING_CALL MockGLInterface::Mock_glGetFenceivNV(GLuint fence,
1102                                                           GLenum pname,
1103                                                           GLint* params) {
1104   MakeFunctionUnique("glGetFenceivNV");
1105   interface_->GetFenceivNV(fence, pname, params);
1106 }
1107
1108 void GL_BINDING_CALL
1109 MockGLInterface::Mock_glGetFloatv(GLenum pname, GLfloat* params) {
1110   MakeFunctionUnique("glGetFloatv");
1111   interface_->GetFloatv(pname, params);
1112 }
1113
1114 GLint GL_BINDING_CALL
1115 MockGLInterface::Mock_glGetFragDataLocation(GLuint program, const char* name) {
1116   MakeFunctionUnique("glGetFragDataLocation");
1117   return interface_->GetFragDataLocation(program, name);
1118 }
1119
1120 void GL_BINDING_CALL
1121 MockGLInterface::Mock_glGetFramebufferAttachmentParameteriv(GLenum target,
1122                                                             GLenum attachment,
1123                                                             GLenum pname,
1124                                                             GLint* params) {
1125   MakeFunctionUnique("glGetFramebufferAttachmentParameteriv");
1126   interface_->GetFramebufferAttachmentParameterivEXT(target, attachment, pname,
1127                                                      params);
1128 }
1129
1130 void GL_BINDING_CALL
1131 MockGLInterface::Mock_glGetFramebufferAttachmentParameterivEXT(
1132     GLenum target,
1133     GLenum attachment,
1134     GLenum pname,
1135     GLint* params) {
1136   MakeFunctionUnique("glGetFramebufferAttachmentParameterivEXT");
1137   interface_->GetFramebufferAttachmentParameterivEXT(target, attachment, pname,
1138                                                      params);
1139 }
1140
1141 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatus(void) {
1142   MakeFunctionUnique("glGetGraphicsResetStatus");
1143   return interface_->GetGraphicsResetStatusARB();
1144 }
1145
1146 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusARB(void) {
1147   MakeFunctionUnique("glGetGraphicsResetStatusARB");
1148   return interface_->GetGraphicsResetStatusARB();
1149 }
1150
1151 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusEXT(void) {
1152   MakeFunctionUnique("glGetGraphicsResetStatusEXT");
1153   return interface_->GetGraphicsResetStatusARB();
1154 }
1155
1156 GLenum GL_BINDING_CALL MockGLInterface::Mock_glGetGraphicsResetStatusKHR(void) {
1157   MakeFunctionUnique("glGetGraphicsResetStatusKHR");
1158   return interface_->GetGraphicsResetStatusARB();
1159 }
1160
1161 void GL_BINDING_CALL MockGLInterface::Mock_glGetInteger64i_v(GLenum target,
1162                                                              GLuint index,
1163                                                              GLint64* data) {
1164   MakeFunctionUnique("glGetInteger64i_v");
1165   interface_->GetInteger64i_v(target, index, data);
1166 }
1167
1168 void GL_BINDING_CALL
1169 MockGLInterface::Mock_glGetInteger64v(GLenum pname, GLint64* params) {
1170   MakeFunctionUnique("glGetInteger64v");
1171   interface_->GetInteger64v(pname, params);
1172 }
1173
1174 void GL_BINDING_CALL MockGLInterface::Mock_glGetIntegeri_v(GLenum target,
1175                                                            GLuint index,
1176                                                            GLint* data) {
1177   MakeFunctionUnique("glGetIntegeri_v");
1178   interface_->GetIntegeri_v(target, index, data);
1179 }
1180
1181 void GL_BINDING_CALL
1182 MockGLInterface::Mock_glGetIntegerv(GLenum pname, GLint* params) {
1183   MakeFunctionUnique("glGetIntegerv");
1184   interface_->GetIntegerv(pname, params);
1185 }
1186
1187 void GL_BINDING_CALL
1188 MockGLInterface::Mock_glGetInternalformativ(GLenum target,
1189                                             GLenum internalformat,
1190                                             GLenum pname,
1191                                             GLsizei bufSize,
1192                                             GLint* params) {
1193   MakeFunctionUnique("glGetInternalformativ");
1194   interface_->GetInternalformativ(target, internalformat, pname, bufSize,
1195                                   params);
1196 }
1197
1198 void GL_BINDING_CALL
1199 MockGLInterface::Mock_glGetProgramBinary(GLuint program,
1200                                          GLsizei bufSize,
1201                                          GLsizei* length,
1202                                          GLenum* binaryFormat,
1203                                          GLvoid* binary) {
1204   MakeFunctionUnique("glGetProgramBinary");
1205   interface_->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
1206 }
1207
1208 void GL_BINDING_CALL
1209 MockGLInterface::Mock_glGetProgramBinaryOES(GLuint program,
1210                                             GLsizei bufSize,
1211                                             GLsizei* length,
1212                                             GLenum* binaryFormat,
1213                                             GLvoid* binary) {
1214   MakeFunctionUnique("glGetProgramBinaryOES");
1215   interface_->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
1216 }
1217
1218 void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramInfoLog(GLuint program,
1219                                                                GLsizei bufsize,
1220                                                                GLsizei* length,
1221                                                                char* infolog) {
1222   MakeFunctionUnique("glGetProgramInfoLog");
1223   interface_->GetProgramInfoLog(program, bufsize, length, infolog);
1224 }
1225
1226 GLint GL_BINDING_CALL
1227 MockGLInterface::Mock_glGetProgramResourceLocation(GLuint program,
1228                                                    GLenum programInterface,
1229                                                    const char* name) {
1230   MakeFunctionUnique("glGetProgramResourceLocation");
1231   return interface_->GetProgramResourceLocation(program, programInterface,
1232                                                 name);
1233 }
1234
1235 void GL_BINDING_CALL MockGLInterface::Mock_glGetProgramiv(GLuint program,
1236                                                           GLenum pname,
1237                                                           GLint* params) {
1238   MakeFunctionUnique("glGetProgramiv");
1239   interface_->GetProgramiv(program, pname, params);
1240 }
1241
1242 void GL_BINDING_CALL
1243 MockGLInterface::Mock_glGetQueryObjecti64v(GLuint id,
1244                                            GLenum pname,
1245                                            GLint64* params) {
1246   MakeFunctionUnique("glGetQueryObjecti64v");
1247   interface_->GetQueryObjecti64v(id, pname, params);
1248 }
1249
1250 void GL_BINDING_CALL
1251 MockGLInterface::Mock_glGetQueryObjecti64vEXT(GLuint id,
1252                                               GLenum pname,
1253                                               GLint64* params) {
1254   MakeFunctionUnique("glGetQueryObjecti64vEXT");
1255   interface_->GetQueryObjecti64v(id, pname, params);
1256 }
1257
1258 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryObjectiv(GLuint id,
1259                                                               GLenum pname,
1260                                                               GLint* params) {
1261   MakeFunctionUnique("glGetQueryObjectiv");
1262   interface_->GetQueryObjectiv(id, pname, params);
1263 }
1264
1265 void GL_BINDING_CALL
1266 MockGLInterface::Mock_glGetQueryObjectivARB(GLuint id,
1267                                             GLenum pname,
1268                                             GLint* params) {
1269   MakeFunctionUnique("glGetQueryObjectivARB");
1270   interface_->GetQueryObjectiv(id, pname, params);
1271 }
1272
1273 void GL_BINDING_CALL
1274 MockGLInterface::Mock_glGetQueryObjectivEXT(GLuint id,
1275                                             GLenum pname,
1276                                             GLint* params) {
1277   MakeFunctionUnique("glGetQueryObjectivEXT");
1278   interface_->GetQueryObjectiv(id, pname, params);
1279 }
1280
1281 void GL_BINDING_CALL
1282 MockGLInterface::Mock_glGetQueryObjectui64v(GLuint id,
1283                                             GLenum pname,
1284                                             GLuint64* params) {
1285   MakeFunctionUnique("glGetQueryObjectui64v");
1286   interface_->GetQueryObjectui64v(id, pname, params);
1287 }
1288
1289 void GL_BINDING_CALL
1290 MockGLInterface::Mock_glGetQueryObjectui64vEXT(GLuint id,
1291                                                GLenum pname,
1292                                                GLuint64* params) {
1293   MakeFunctionUnique("glGetQueryObjectui64vEXT");
1294   interface_->GetQueryObjectui64v(id, pname, params);
1295 }
1296
1297 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryObjectuiv(GLuint id,
1298                                                                GLenum pname,
1299                                                                GLuint* params) {
1300   MakeFunctionUnique("glGetQueryObjectuiv");
1301   interface_->GetQueryObjectuiv(id, pname, params);
1302 }
1303
1304 void GL_BINDING_CALL
1305 MockGLInterface::Mock_glGetQueryObjectuivARB(GLuint id,
1306                                              GLenum pname,
1307                                              GLuint* params) {
1308   MakeFunctionUnique("glGetQueryObjectuivARB");
1309   interface_->GetQueryObjectuiv(id, pname, params);
1310 }
1311
1312 void GL_BINDING_CALL
1313 MockGLInterface::Mock_glGetQueryObjectuivEXT(GLuint id,
1314                                              GLenum pname,
1315                                              GLuint* params) {
1316   MakeFunctionUnique("glGetQueryObjectuivEXT");
1317   interface_->GetQueryObjectuiv(id, pname, params);
1318 }
1319
1320 void GL_BINDING_CALL
1321 MockGLInterface::Mock_glGetQueryiv(GLenum target, GLenum pname, GLint* params) {
1322   MakeFunctionUnique("glGetQueryiv");
1323   interface_->GetQueryiv(target, pname, params);
1324 }
1325
1326 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryivARB(GLenum target,
1327                                                            GLenum pname,
1328                                                            GLint* params) {
1329   MakeFunctionUnique("glGetQueryivARB");
1330   interface_->GetQueryiv(target, pname, params);
1331 }
1332
1333 void GL_BINDING_CALL MockGLInterface::Mock_glGetQueryivEXT(GLenum target,
1334                                                            GLenum pname,
1335                                                            GLint* params) {
1336   MakeFunctionUnique("glGetQueryivEXT");
1337   interface_->GetQueryiv(target, pname, params);
1338 }
1339
1340 void GL_BINDING_CALL
1341 MockGLInterface::Mock_glGetRenderbufferParameteriv(GLenum target,
1342                                                    GLenum pname,
1343                                                    GLint* params) {
1344   MakeFunctionUnique("glGetRenderbufferParameteriv");
1345   interface_->GetRenderbufferParameterivEXT(target, pname, params);
1346 }
1347
1348 void GL_BINDING_CALL
1349 MockGLInterface::Mock_glGetRenderbufferParameterivEXT(GLenum target,
1350                                                       GLenum pname,
1351                                                       GLint* params) {
1352   MakeFunctionUnique("glGetRenderbufferParameterivEXT");
1353   interface_->GetRenderbufferParameterivEXT(target, pname, params);
1354 }
1355
1356 void GL_BINDING_CALL
1357 MockGLInterface::Mock_glGetSamplerParameterfv(GLuint sampler,
1358                                               GLenum pname,
1359                                               GLfloat* params) {
1360   MakeFunctionUnique("glGetSamplerParameterfv");
1361   interface_->GetSamplerParameterfv(sampler, pname, params);
1362 }
1363
1364 void GL_BINDING_CALL
1365 MockGLInterface::Mock_glGetSamplerParameteriv(GLuint sampler,
1366                                               GLenum pname,
1367                                               GLint* params) {
1368   MakeFunctionUnique("glGetSamplerParameteriv");
1369   interface_->GetSamplerParameteriv(sampler, pname, params);
1370 }
1371
1372 void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderInfoLog(GLuint shader,
1373                                                               GLsizei bufsize,
1374                                                               GLsizei* length,
1375                                                               char* infolog) {
1376   MakeFunctionUnique("glGetShaderInfoLog");
1377   interface_->GetShaderInfoLog(shader, bufsize, length, infolog);
1378 }
1379
1380 void GL_BINDING_CALL
1381 MockGLInterface::Mock_glGetShaderPrecisionFormat(GLenum shadertype,
1382                                                  GLenum precisiontype,
1383                                                  GLint* range,
1384                                                  GLint* precision) {
1385   MakeFunctionUnique("glGetShaderPrecisionFormat");
1386   interface_->GetShaderPrecisionFormat(shadertype, precisiontype, range,
1387                                        precision);
1388 }
1389
1390 void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderSource(GLuint shader,
1391                                                              GLsizei bufsize,
1392                                                              GLsizei* length,
1393                                                              char* source) {
1394   MakeFunctionUnique("glGetShaderSource");
1395   interface_->GetShaderSource(shader, bufsize, length, source);
1396 }
1397
1398 void GL_BINDING_CALL MockGLInterface::Mock_glGetShaderiv(GLuint shader,
1399                                                          GLenum pname,
1400                                                          GLint* params) {
1401   MakeFunctionUnique("glGetShaderiv");
1402   interface_->GetShaderiv(shader, pname, params);
1403 }
1404
1405 const GLubyte* GL_BINDING_CALL MockGLInterface::Mock_glGetString(GLenum name) {
1406   MakeFunctionUnique("glGetString");
1407   return interface_->GetString(name);
1408 }
1409
1410 const GLubyte* GL_BINDING_CALL
1411 MockGLInterface::Mock_glGetStringi(GLenum name, GLuint index) {
1412   MakeFunctionUnique("glGetStringi");
1413   return interface_->GetStringi(name, index);
1414 }
1415
1416 void GL_BINDING_CALL MockGLInterface::Mock_glGetSynciv(GLsync sync,
1417                                                        GLenum pname,
1418                                                        GLsizei bufSize,
1419                                                        GLsizei* length,
1420                                                        GLint* values) {
1421   MakeFunctionUnique("glGetSynciv");
1422   interface_->GetSynciv(sync, pname, bufSize, length, values);
1423 }
1424
1425 void GL_BINDING_CALL
1426 MockGLInterface::Mock_glGetTexLevelParameterfv(GLenum target,
1427                                                GLint level,
1428                                                GLenum pname,
1429                                                GLfloat* params) {
1430   MakeFunctionUnique("glGetTexLevelParameterfv");
1431   interface_->GetTexLevelParameterfv(target, level, pname, params);
1432 }
1433
1434 void GL_BINDING_CALL
1435 MockGLInterface::Mock_glGetTexLevelParameteriv(GLenum target,
1436                                                GLint level,
1437                                                GLenum pname,
1438                                                GLint* params) {
1439   MakeFunctionUnique("glGetTexLevelParameteriv");
1440   interface_->GetTexLevelParameteriv(target, level, pname, params);
1441 }
1442
1443 void GL_BINDING_CALL
1444 MockGLInterface::Mock_glGetTexParameterfv(GLenum target,
1445                                           GLenum pname,
1446                                           GLfloat* params) {
1447   MakeFunctionUnique("glGetTexParameterfv");
1448   interface_->GetTexParameterfv(target, pname, params);
1449 }
1450
1451 void GL_BINDING_CALL MockGLInterface::Mock_glGetTexParameteriv(GLenum target,
1452                                                                GLenum pname,
1453                                                                GLint* params) {
1454   MakeFunctionUnique("glGetTexParameteriv");
1455   interface_->GetTexParameteriv(target, pname, params);
1456 }
1457
1458 void GL_BINDING_CALL
1459 MockGLInterface::Mock_glGetTransformFeedbackVarying(GLuint program,
1460                                                     GLuint index,
1461                                                     GLsizei bufSize,
1462                                                     GLsizei* length,
1463                                                     GLsizei* size,
1464                                                     GLenum* type,
1465                                                     char* name) {
1466   MakeFunctionUnique("glGetTransformFeedbackVarying");
1467   interface_->GetTransformFeedbackVarying(program, index, bufSize, length, size,
1468                                           type, name);
1469 }
1470
1471 void GL_BINDING_CALL
1472 MockGLInterface::Mock_glGetTranslatedShaderSourceANGLE(GLuint shader,
1473                                                        GLsizei bufsize,
1474                                                        GLsizei* length,
1475                                                        char* source) {
1476   MakeFunctionUnique("glGetTranslatedShaderSourceANGLE");
1477   interface_->GetTranslatedShaderSourceANGLE(shader, bufsize, length, source);
1478 }
1479
1480 GLuint GL_BINDING_CALL
1481 MockGLInterface::Mock_glGetUniformBlockIndex(GLuint program,
1482                                              const char* uniformBlockName) {
1483   MakeFunctionUnique("glGetUniformBlockIndex");
1484   return interface_->GetUniformBlockIndex(program, uniformBlockName);
1485 }
1486
1487 void GL_BINDING_CALL
1488 MockGLInterface::Mock_glGetUniformIndices(GLuint program,
1489                                           GLsizei uniformCount,
1490                                           const char* const* uniformNames,
1491                                           GLuint* uniformIndices) {
1492   MakeFunctionUnique("glGetUniformIndices");
1493   interface_->GetUniformIndices(program, uniformCount, uniformNames,
1494                                 uniformIndices);
1495 }
1496
1497 GLint GL_BINDING_CALL
1498 MockGLInterface::Mock_glGetUniformLocation(GLuint program, const char* name) {
1499   MakeFunctionUnique("glGetUniformLocation");
1500   return interface_->GetUniformLocation(program, name);
1501 }
1502
1503 void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformfv(GLuint program,
1504                                                           GLint location,
1505                                                           GLfloat* params) {
1506   MakeFunctionUnique("glGetUniformfv");
1507   interface_->GetUniformfv(program, location, params);
1508 }
1509
1510 void GL_BINDING_CALL MockGLInterface::Mock_glGetUniformiv(GLuint program,
1511                                                           GLint location,
1512                                                           GLint* params) {
1513   MakeFunctionUnique("glGetUniformiv");
1514   interface_->GetUniformiv(program, location, params);
1515 }
1516
1517 void GL_BINDING_CALL
1518 MockGLInterface::Mock_glGetVertexAttribPointerv(GLuint index,
1519                                                 GLenum pname,
1520                                                 void** pointer) {
1521   MakeFunctionUnique("glGetVertexAttribPointerv");
1522   interface_->GetVertexAttribPointerv(index, pname, pointer);
1523 }
1524
1525 void GL_BINDING_CALL
1526 MockGLInterface::Mock_glGetVertexAttribfv(GLuint index,
1527                                           GLenum pname,
1528                                           GLfloat* params) {
1529   MakeFunctionUnique("glGetVertexAttribfv");
1530   interface_->GetVertexAttribfv(index, pname, params);
1531 }
1532
1533 void GL_BINDING_CALL MockGLInterface::Mock_glGetVertexAttribiv(GLuint index,
1534                                                                GLenum pname,
1535                                                                GLint* params) {
1536   MakeFunctionUnique("glGetVertexAttribiv");
1537   interface_->GetVertexAttribiv(index, pname, params);
1538 }
1539
1540 void GL_BINDING_CALL MockGLInterface::Mock_glHint(GLenum target, GLenum mode) {
1541   MakeFunctionUnique("glHint");
1542   interface_->Hint(target, mode);
1543 }
1544
1545 void GL_BINDING_CALL
1546 MockGLInterface::Mock_glInsertEventMarkerEXT(GLsizei length,
1547                                              const char* marker) {
1548   MakeFunctionUnique("glInsertEventMarkerEXT");
1549   interface_->InsertEventMarkerEXT(length, marker);
1550 }
1551
1552 void GL_BINDING_CALL
1553 MockGLInterface::Mock_glInvalidateFramebuffer(GLenum target,
1554                                               GLsizei numAttachments,
1555                                               const GLenum* attachments) {
1556   MakeFunctionUnique("glInvalidateFramebuffer");
1557   interface_->InvalidateFramebuffer(target, numAttachments, attachments);
1558 }
1559
1560 void GL_BINDING_CALL
1561 MockGLInterface::Mock_glInvalidateSubFramebuffer(GLenum target,
1562                                                  GLsizei numAttachments,
1563                                                  const GLenum* attachments,
1564                                                  GLint x,
1565                                                  GLint y,
1566                                                  GLint width,
1567                                                  GLint height) {
1568   MakeFunctionUnique("glInvalidateSubFramebuffer");
1569   interface_->InvalidateSubFramebuffer(target, numAttachments, attachments, x,
1570                                        y, width, height);
1571 }
1572
1573 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsBuffer(GLuint buffer) {
1574   MakeFunctionUnique("glIsBuffer");
1575   return interface_->IsBuffer(buffer);
1576 }
1577
1578 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsEnabled(GLenum cap) {
1579   MakeFunctionUnique("glIsEnabled");
1580   return interface_->IsEnabled(cap);
1581 }
1582
1583 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsFenceAPPLE(GLuint fence) {
1584   MakeFunctionUnique("glIsFenceAPPLE");
1585   return interface_->IsFenceAPPLE(fence);
1586 }
1587
1588 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsFenceNV(GLuint fence) {
1589   MakeFunctionUnique("glIsFenceNV");
1590   return interface_->IsFenceNV(fence);
1591 }
1592
1593 GLboolean GL_BINDING_CALL
1594 MockGLInterface::Mock_glIsFramebuffer(GLuint framebuffer) {
1595   MakeFunctionUnique("glIsFramebuffer");
1596   return interface_->IsFramebufferEXT(framebuffer);
1597 }
1598
1599 GLboolean GL_BINDING_CALL
1600 MockGLInterface::Mock_glIsFramebufferEXT(GLuint framebuffer) {
1601   MakeFunctionUnique("glIsFramebufferEXT");
1602   return interface_->IsFramebufferEXT(framebuffer);
1603 }
1604
1605 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsProgram(GLuint program) {
1606   MakeFunctionUnique("glIsProgram");
1607   return interface_->IsProgram(program);
1608 }
1609
1610 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQuery(GLuint query) {
1611   MakeFunctionUnique("glIsQuery");
1612   return interface_->IsQuery(query);
1613 }
1614
1615 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQueryARB(GLuint query) {
1616   MakeFunctionUnique("glIsQueryARB");
1617   return interface_->IsQuery(query);
1618 }
1619
1620 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsQueryEXT(GLuint query) {
1621   MakeFunctionUnique("glIsQueryEXT");
1622   return interface_->IsQuery(query);
1623 }
1624
1625 GLboolean GL_BINDING_CALL
1626 MockGLInterface::Mock_glIsRenderbuffer(GLuint renderbuffer) {
1627   MakeFunctionUnique("glIsRenderbuffer");
1628   return interface_->IsRenderbufferEXT(renderbuffer);
1629 }
1630
1631 GLboolean GL_BINDING_CALL
1632 MockGLInterface::Mock_glIsRenderbufferEXT(GLuint renderbuffer) {
1633   MakeFunctionUnique("glIsRenderbufferEXT");
1634   return interface_->IsRenderbufferEXT(renderbuffer);
1635 }
1636
1637 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsSampler(GLuint sampler) {
1638   MakeFunctionUnique("glIsSampler");
1639   return interface_->IsSampler(sampler);
1640 }
1641
1642 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsShader(GLuint shader) {
1643   MakeFunctionUnique("glIsShader");
1644   return interface_->IsShader(shader);
1645 }
1646
1647 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsSync(GLsync sync) {
1648   MakeFunctionUnique("glIsSync");
1649   return interface_->IsSync(sync);
1650 }
1651
1652 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsTexture(GLuint texture) {
1653   MakeFunctionUnique("glIsTexture");
1654   return interface_->IsTexture(texture);
1655 }
1656
1657 GLboolean GL_BINDING_CALL
1658 MockGLInterface::Mock_glIsTransformFeedback(GLuint id) {
1659   MakeFunctionUnique("glIsTransformFeedback");
1660   return interface_->IsTransformFeedback(id);
1661 }
1662
1663 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glIsVertexArray(GLuint array) {
1664   MakeFunctionUnique("glIsVertexArray");
1665   return interface_->IsVertexArrayOES(array);
1666 }
1667
1668 GLboolean GL_BINDING_CALL
1669 MockGLInterface::Mock_glIsVertexArrayAPPLE(GLuint array) {
1670   MakeFunctionUnique("glIsVertexArrayAPPLE");
1671   return interface_->IsVertexArrayOES(array);
1672 }
1673
1674 GLboolean GL_BINDING_CALL
1675 MockGLInterface::Mock_glIsVertexArrayOES(GLuint array) {
1676   MakeFunctionUnique("glIsVertexArrayOES");
1677   return interface_->IsVertexArrayOES(array);
1678 }
1679
1680 void GL_BINDING_CALL MockGLInterface::Mock_glLineWidth(GLfloat width) {
1681   MakeFunctionUnique("glLineWidth");
1682   interface_->LineWidth(width);
1683 }
1684
1685 void GL_BINDING_CALL MockGLInterface::Mock_glLinkProgram(GLuint program) {
1686   MakeFunctionUnique("glLinkProgram");
1687   interface_->LinkProgram(program);
1688 }
1689
1690 void* GL_BINDING_CALL
1691 MockGLInterface::Mock_glMapBuffer(GLenum target, GLenum access) {
1692   MakeFunctionUnique("glMapBuffer");
1693   return interface_->MapBuffer(target, access);
1694 }
1695
1696 void* GL_BINDING_CALL
1697 MockGLInterface::Mock_glMapBufferOES(GLenum target, GLenum access) {
1698   MakeFunctionUnique("glMapBufferOES");
1699   return interface_->MapBuffer(target, access);
1700 }
1701
1702 void* GL_BINDING_CALL
1703 MockGLInterface::Mock_glMapBufferRange(GLenum target,
1704                                        GLintptr offset,
1705                                        GLsizeiptr length,
1706                                        GLbitfield access) {
1707   MakeFunctionUnique("glMapBufferRange");
1708   return interface_->MapBufferRange(target, offset, length, access);
1709 }
1710
1711 void* GL_BINDING_CALL
1712 MockGLInterface::Mock_glMapBufferRangeEXT(GLenum target,
1713                                           GLintptr offset,
1714                                           GLsizeiptr length,
1715                                           GLbitfield access) {
1716   MakeFunctionUnique("glMapBufferRangeEXT");
1717   return interface_->MapBufferRange(target, offset, length, access);
1718 }
1719
1720 void GL_BINDING_CALL
1721 MockGLInterface::Mock_glMatrixLoadIdentityEXT(GLenum matrixMode) {
1722   MakeFunctionUnique("glMatrixLoadIdentityEXT");
1723   interface_->MatrixLoadIdentityEXT(matrixMode);
1724 }
1725
1726 void GL_BINDING_CALL
1727 MockGLInterface::Mock_glMatrixLoadfEXT(GLenum matrixMode, const GLfloat* m) {
1728   MakeFunctionUnique("glMatrixLoadfEXT");
1729   interface_->MatrixLoadfEXT(matrixMode, m);
1730 }
1731
1732 void GL_BINDING_CALL MockGLInterface::Mock_glPauseTransformFeedback(void) {
1733   MakeFunctionUnique("glPauseTransformFeedback");
1734   interface_->PauseTransformFeedback();
1735 }
1736
1737 void GL_BINDING_CALL
1738 MockGLInterface::Mock_glPixelStorei(GLenum pname, GLint param) {
1739   MakeFunctionUnique("glPixelStorei");
1740   interface_->PixelStorei(pname, param);
1741 }
1742
1743 void GL_BINDING_CALL
1744 MockGLInterface::Mock_glPointParameteri(GLenum pname, GLint param) {
1745   MakeFunctionUnique("glPointParameteri");
1746   interface_->PointParameteri(pname, param);
1747 }
1748
1749 void GL_BINDING_CALL
1750 MockGLInterface::Mock_glPolygonOffset(GLfloat factor, GLfloat units) {
1751   MakeFunctionUnique("glPolygonOffset");
1752   interface_->PolygonOffset(factor, units);
1753 }
1754
1755 void GL_BINDING_CALL MockGLInterface::Mock_glPopGroupMarkerEXT(void) {
1756   MakeFunctionUnique("glPopGroupMarkerEXT");
1757   interface_->PopGroupMarkerEXT();
1758 }
1759
1760 void GL_BINDING_CALL MockGLInterface::Mock_glProgramBinary(GLuint program,
1761                                                            GLenum binaryFormat,
1762                                                            const GLvoid* binary,
1763                                                            GLsizei length) {
1764   MakeFunctionUnique("glProgramBinary");
1765   interface_->ProgramBinary(program, binaryFormat, binary, length);
1766 }
1767
1768 void GL_BINDING_CALL
1769 MockGLInterface::Mock_glProgramBinaryOES(GLuint program,
1770                                          GLenum binaryFormat,
1771                                          const GLvoid* binary,
1772                                          GLsizei length) {
1773   MakeFunctionUnique("glProgramBinaryOES");
1774   interface_->ProgramBinary(program, binaryFormat, binary, length);
1775 }
1776
1777 void GL_BINDING_CALL MockGLInterface::Mock_glProgramParameteri(GLuint program,
1778                                                                GLenum pname,
1779                                                                GLint value) {
1780   MakeFunctionUnique("glProgramParameteri");
1781   interface_->ProgramParameteri(program, pname, value);
1782 }
1783
1784 void GL_BINDING_CALL
1785 MockGLInterface::Mock_glPushGroupMarkerEXT(GLsizei length, const char* marker) {
1786   MakeFunctionUnique("glPushGroupMarkerEXT");
1787   interface_->PushGroupMarkerEXT(length, marker);
1788 }
1789
1790 void GL_BINDING_CALL
1791 MockGLInterface::Mock_glQueryCounter(GLuint id, GLenum target) {
1792   MakeFunctionUnique("glQueryCounter");
1793   interface_->QueryCounter(id, target);
1794 }
1795
1796 void GL_BINDING_CALL
1797 MockGLInterface::Mock_glQueryCounterEXT(GLuint id, GLenum target) {
1798   MakeFunctionUnique("glQueryCounterEXT");
1799   interface_->QueryCounter(id, target);
1800 }
1801
1802 void GL_BINDING_CALL MockGLInterface::Mock_glReadBuffer(GLenum src) {
1803   MakeFunctionUnique("glReadBuffer");
1804   interface_->ReadBuffer(src);
1805 }
1806
1807 void GL_BINDING_CALL MockGLInterface::Mock_glReadPixels(GLint x,
1808                                                         GLint y,
1809                                                         GLsizei width,
1810                                                         GLsizei height,
1811                                                         GLenum format,
1812                                                         GLenum type,
1813                                                         void* pixels) {
1814   MakeFunctionUnique("glReadPixels");
1815   interface_->ReadPixels(x, y, width, height, format, type, pixels);
1816 }
1817
1818 void GL_BINDING_CALL MockGLInterface::Mock_glReleaseShaderCompiler(void) {
1819   MakeFunctionUnique("glReleaseShaderCompiler");
1820   interface_->ReleaseShaderCompiler();
1821 }
1822
1823 void GL_BINDING_CALL
1824 MockGLInterface::Mock_glRenderbufferStorage(GLenum target,
1825                                             GLenum internalformat,
1826                                             GLsizei width,
1827                                             GLsizei height) {
1828   MakeFunctionUnique("glRenderbufferStorage");
1829   interface_->RenderbufferStorageEXT(target, internalformat, width, height);
1830 }
1831
1832 void GL_BINDING_CALL
1833 MockGLInterface::Mock_glRenderbufferStorageEXT(GLenum target,
1834                                                GLenum internalformat,
1835                                                GLsizei width,
1836                                                GLsizei height) {
1837   MakeFunctionUnique("glRenderbufferStorageEXT");
1838   interface_->RenderbufferStorageEXT(target, internalformat, width, height);
1839 }
1840
1841 void GL_BINDING_CALL
1842 MockGLInterface::Mock_glRenderbufferStorageMultisample(GLenum target,
1843                                                        GLsizei samples,
1844                                                        GLenum internalformat,
1845                                                        GLsizei width,
1846                                                        GLsizei height) {
1847   MakeFunctionUnique("glRenderbufferStorageMultisample");
1848   interface_->RenderbufferStorageMultisample(target, samples, internalformat,
1849                                              width, height);
1850 }
1851
1852 void GL_BINDING_CALL
1853 MockGLInterface::Mock_glRenderbufferStorageMultisampleANGLE(
1854     GLenum target,
1855     GLsizei samples,
1856     GLenum internalformat,
1857     GLsizei width,
1858     GLsizei height) {
1859   MakeFunctionUnique("glRenderbufferStorageMultisampleANGLE");
1860   interface_->RenderbufferStorageMultisampleANGLE(
1861       target, samples, internalformat, width, height);
1862 }
1863
1864 void GL_BINDING_CALL
1865 MockGLInterface::Mock_glRenderbufferStorageMultisampleEXT(GLenum target,
1866                                                           GLsizei samples,
1867                                                           GLenum internalformat,
1868                                                           GLsizei width,
1869                                                           GLsizei height) {
1870   MakeFunctionUnique("glRenderbufferStorageMultisampleEXT");
1871   interface_->RenderbufferStorageMultisampleEXT(target, samples, internalformat,
1872                                                 width, height);
1873 }
1874
1875 void GL_BINDING_CALL
1876 MockGLInterface::Mock_glRenderbufferStorageMultisampleIMG(GLenum target,
1877                                                           GLsizei samples,
1878                                                           GLenum internalformat,
1879                                                           GLsizei width,
1880                                                           GLsizei height) {
1881   MakeFunctionUnique("glRenderbufferStorageMultisampleIMG");
1882   interface_->RenderbufferStorageMultisampleIMG(target, samples, internalformat,
1883                                                 width, height);
1884 }
1885
1886 void GL_BINDING_CALL MockGLInterface::Mock_glResumeTransformFeedback(void) {
1887   MakeFunctionUnique("glResumeTransformFeedback");
1888   interface_->ResumeTransformFeedback();
1889 }
1890
1891 void GL_BINDING_CALL
1892 MockGLInterface::Mock_glSampleCoverage(GLclampf value, GLboolean invert) {
1893   MakeFunctionUnique("glSampleCoverage");
1894   interface_->SampleCoverage(value, invert);
1895 }
1896
1897 void GL_BINDING_CALL MockGLInterface::Mock_glSamplerParameterf(GLuint sampler,
1898                                                                GLenum pname,
1899                                                                GLfloat param) {
1900   MakeFunctionUnique("glSamplerParameterf");
1901   interface_->SamplerParameterf(sampler, pname, param);
1902 }
1903
1904 void GL_BINDING_CALL
1905 MockGLInterface::Mock_glSamplerParameterfv(GLuint sampler,
1906                                            GLenum pname,
1907                                            const GLfloat* params) {
1908   MakeFunctionUnique("glSamplerParameterfv");
1909   interface_->SamplerParameterfv(sampler, pname, params);
1910 }
1911
1912 void GL_BINDING_CALL MockGLInterface::Mock_glSamplerParameteri(GLuint sampler,
1913                                                                GLenum pname,
1914                                                                GLint param) {
1915   MakeFunctionUnique("glSamplerParameteri");
1916   interface_->SamplerParameteri(sampler, pname, param);
1917 }
1918
1919 void GL_BINDING_CALL
1920 MockGLInterface::Mock_glSamplerParameteriv(GLuint sampler,
1921                                            GLenum pname,
1922                                            const GLint* params) {
1923   MakeFunctionUnique("glSamplerParameteriv");
1924   interface_->SamplerParameteriv(sampler, pname, params);
1925 }
1926
1927 void GL_BINDING_CALL MockGLInterface::Mock_glScissor(GLint x,
1928                                                      GLint y,
1929                                                      GLsizei width,
1930                                                      GLsizei height) {
1931   MakeFunctionUnique("glScissor");
1932   interface_->Scissor(x, y, width, height);
1933 }
1934
1935 void GL_BINDING_CALL MockGLInterface::Mock_glSetFenceAPPLE(GLuint fence) {
1936   MakeFunctionUnique("glSetFenceAPPLE");
1937   interface_->SetFenceAPPLE(fence);
1938 }
1939
1940 void GL_BINDING_CALL
1941 MockGLInterface::Mock_glSetFenceNV(GLuint fence, GLenum condition) {
1942   MakeFunctionUnique("glSetFenceNV");
1943   interface_->SetFenceNV(fence, condition);
1944 }
1945
1946 void GL_BINDING_CALL MockGLInterface::Mock_glShaderBinary(GLsizei n,
1947                                                           const GLuint* shaders,
1948                                                           GLenum binaryformat,
1949                                                           const void* binary,
1950                                                           GLsizei length) {
1951   MakeFunctionUnique("glShaderBinary");
1952   interface_->ShaderBinary(n, shaders, binaryformat, binary, length);
1953 }
1954
1955 void GL_BINDING_CALL
1956 MockGLInterface::Mock_glShaderSource(GLuint shader,
1957                                      GLsizei count,
1958                                      const char* const* str,
1959                                      const GLint* length) {
1960   MakeFunctionUnique("glShaderSource");
1961   interface_->ShaderSource(shader, count, str, length);
1962 }
1963
1964 void GL_BINDING_CALL
1965 MockGLInterface::Mock_glStencilFunc(GLenum func, GLint ref, GLuint mask) {
1966   MakeFunctionUnique("glStencilFunc");
1967   interface_->StencilFunc(func, ref, mask);
1968 }
1969
1970 void GL_BINDING_CALL MockGLInterface::Mock_glStencilFuncSeparate(GLenum face,
1971                                                                  GLenum func,
1972                                                                  GLint ref,
1973                                                                  GLuint mask) {
1974   MakeFunctionUnique("glStencilFuncSeparate");
1975   interface_->StencilFuncSeparate(face, func, ref, mask);
1976 }
1977
1978 void GL_BINDING_CALL MockGLInterface::Mock_glStencilMask(GLuint mask) {
1979   MakeFunctionUnique("glStencilMask");
1980   interface_->StencilMask(mask);
1981 }
1982
1983 void GL_BINDING_CALL
1984 MockGLInterface::Mock_glStencilMaskSeparate(GLenum face, GLuint mask) {
1985   MakeFunctionUnique("glStencilMaskSeparate");
1986   interface_->StencilMaskSeparate(face, mask);
1987 }
1988
1989 void GL_BINDING_CALL
1990 MockGLInterface::Mock_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
1991   MakeFunctionUnique("glStencilOp");
1992   interface_->StencilOp(fail, zfail, zpass);
1993 }
1994
1995 void GL_BINDING_CALL MockGLInterface::Mock_glStencilOpSeparate(GLenum face,
1996                                                                GLenum fail,
1997                                                                GLenum zfail,
1998                                                                GLenum zpass) {
1999   MakeFunctionUnique("glStencilOpSeparate");
2000   interface_->StencilOpSeparate(face, fail, zfail, zpass);
2001 }
2002
2003 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glTestFenceAPPLE(GLuint fence) {
2004   MakeFunctionUnique("glTestFenceAPPLE");
2005   return interface_->TestFenceAPPLE(fence);
2006 }
2007
2008 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glTestFenceNV(GLuint fence) {
2009   MakeFunctionUnique("glTestFenceNV");
2010   return interface_->TestFenceNV(fence);
2011 }
2012
2013 void GL_BINDING_CALL MockGLInterface::Mock_glTexImage2D(GLenum target,
2014                                                         GLint level,
2015                                                         GLint internalformat,
2016                                                         GLsizei width,
2017                                                         GLsizei height,
2018                                                         GLint border,
2019                                                         GLenum format,
2020                                                         GLenum type,
2021                                                         const void* pixels) {
2022   MakeFunctionUnique("glTexImage2D");
2023   interface_->TexImage2D(target, level, internalformat, width, height, border,
2024                          format, type, pixels);
2025 }
2026
2027 void GL_BINDING_CALL MockGLInterface::Mock_glTexImage3D(GLenum target,
2028                                                         GLint level,
2029                                                         GLint internalformat,
2030                                                         GLsizei width,
2031                                                         GLsizei height,
2032                                                         GLsizei depth,
2033                                                         GLint border,
2034                                                         GLenum format,
2035                                                         GLenum type,
2036                                                         const void* pixels) {
2037   MakeFunctionUnique("glTexImage3D");
2038   interface_->TexImage3D(target, level, internalformat, width, height, depth,
2039                          border, format, type, pixels);
2040 }
2041
2042 void GL_BINDING_CALL MockGLInterface::Mock_glTexParameterf(GLenum target,
2043                                                            GLenum pname,
2044                                                            GLfloat param) {
2045   MakeFunctionUnique("glTexParameterf");
2046   interface_->TexParameterf(target, pname, param);
2047 }
2048
2049 void GL_BINDING_CALL
2050 MockGLInterface::Mock_glTexParameterfv(GLenum target,
2051                                        GLenum pname,
2052                                        const GLfloat* params) {
2053   MakeFunctionUnique("glTexParameterfv");
2054   interface_->TexParameterfv(target, pname, params);
2055 }
2056
2057 void GL_BINDING_CALL MockGLInterface::Mock_glTexParameteri(GLenum target,
2058                                                            GLenum pname,
2059                                                            GLint param) {
2060   MakeFunctionUnique("glTexParameteri");
2061   interface_->TexParameteri(target, pname, param);
2062 }
2063
2064 void GL_BINDING_CALL
2065 MockGLInterface::Mock_glTexParameteriv(GLenum target,
2066                                        GLenum pname,
2067                                        const GLint* params) {
2068   MakeFunctionUnique("glTexParameteriv");
2069   interface_->TexParameteriv(target, pname, params);
2070 }
2071
2072 void GL_BINDING_CALL MockGLInterface::Mock_glTexStorage2D(GLenum target,
2073                                                           GLsizei levels,
2074                                                           GLenum internalformat,
2075                                                           GLsizei width,
2076                                                           GLsizei height) {
2077   MakeFunctionUnique("glTexStorage2D");
2078   interface_->TexStorage2DEXT(target, levels, internalformat, width, height);
2079 }
2080
2081 void GL_BINDING_CALL
2082 MockGLInterface::Mock_glTexStorage2DEXT(GLenum target,
2083                                         GLsizei levels,
2084                                         GLenum internalformat,
2085                                         GLsizei width,
2086                                         GLsizei height) {
2087   MakeFunctionUnique("glTexStorage2DEXT");
2088   interface_->TexStorage2DEXT(target, levels, internalformat, width, height);
2089 }
2090
2091 void GL_BINDING_CALL MockGLInterface::Mock_glTexStorage3D(GLenum target,
2092                                                           GLsizei levels,
2093                                                           GLenum internalformat,
2094                                                           GLsizei width,
2095                                                           GLsizei height,
2096                                                           GLsizei depth) {
2097   MakeFunctionUnique("glTexStorage3D");
2098   interface_->TexStorage3D(target, levels, internalformat, width, height,
2099                            depth);
2100 }
2101
2102 void GL_BINDING_CALL MockGLInterface::Mock_glTexSubImage2D(GLenum target,
2103                                                            GLint level,
2104                                                            GLint xoffset,
2105                                                            GLint yoffset,
2106                                                            GLsizei width,
2107                                                            GLsizei height,
2108                                                            GLenum format,
2109                                                            GLenum type,
2110                                                            const void* pixels) {
2111   MakeFunctionUnique("glTexSubImage2D");
2112   interface_->TexSubImage2D(target, level, xoffset, yoffset, width, height,
2113                             format, type, pixels);
2114 }
2115
2116 void GL_BINDING_CALL
2117 MockGLInterface::Mock_glTransformFeedbackVaryings(GLuint program,
2118                                                   GLsizei count,
2119                                                   const char* const* varyings,
2120                                                   GLenum bufferMode) {
2121   MakeFunctionUnique("glTransformFeedbackVaryings");
2122   interface_->TransformFeedbackVaryings(program, count, varyings, bufferMode);
2123 }
2124
2125 void GL_BINDING_CALL
2126 MockGLInterface::Mock_glUniform1f(GLint location, GLfloat x) {
2127   MakeFunctionUnique("glUniform1f");
2128   interface_->Uniform1f(location, x);
2129 }
2130
2131 void GL_BINDING_CALL MockGLInterface::Mock_glUniform1fv(GLint location,
2132                                                         GLsizei count,
2133                                                         const GLfloat* v) {
2134   MakeFunctionUnique("glUniform1fv");
2135   interface_->Uniform1fv(location, count, v);
2136 }
2137
2138 void GL_BINDING_CALL
2139 MockGLInterface::Mock_glUniform1i(GLint location, GLint x) {
2140   MakeFunctionUnique("glUniform1i");
2141   interface_->Uniform1i(location, x);
2142 }
2143
2144 void GL_BINDING_CALL MockGLInterface::Mock_glUniform1iv(GLint location,
2145                                                         GLsizei count,
2146                                                         const GLint* v) {
2147   MakeFunctionUnique("glUniform1iv");
2148   interface_->Uniform1iv(location, count, v);
2149 }
2150
2151 void GL_BINDING_CALL
2152 MockGLInterface::Mock_glUniform1ui(GLint location, GLuint v0) {
2153   MakeFunctionUnique("glUniform1ui");
2154   interface_->Uniform1ui(location, v0);
2155 }
2156
2157 void GL_BINDING_CALL MockGLInterface::Mock_glUniform1uiv(GLint location,
2158                                                          GLsizei count,
2159                                                          const GLuint* v) {
2160   MakeFunctionUnique("glUniform1uiv");
2161   interface_->Uniform1uiv(location, count, v);
2162 }
2163
2164 void GL_BINDING_CALL
2165 MockGLInterface::Mock_glUniform2f(GLint location, GLfloat x, GLfloat y) {
2166   MakeFunctionUnique("glUniform2f");
2167   interface_->Uniform2f(location, x, y);
2168 }
2169
2170 void GL_BINDING_CALL MockGLInterface::Mock_glUniform2fv(GLint location,
2171                                                         GLsizei count,
2172                                                         const GLfloat* v) {
2173   MakeFunctionUnique("glUniform2fv");
2174   interface_->Uniform2fv(location, count, v);
2175 }
2176
2177 void GL_BINDING_CALL
2178 MockGLInterface::Mock_glUniform2i(GLint location, GLint x, GLint y) {
2179   MakeFunctionUnique("glUniform2i");
2180   interface_->Uniform2i(location, x, y);
2181 }
2182
2183 void GL_BINDING_CALL MockGLInterface::Mock_glUniform2iv(GLint location,
2184                                                         GLsizei count,
2185                                                         const GLint* v) {
2186   MakeFunctionUnique("glUniform2iv");
2187   interface_->Uniform2iv(location, count, v);
2188 }
2189
2190 void GL_BINDING_CALL
2191 MockGLInterface::Mock_glUniform2ui(GLint location, GLuint v0, GLuint v1) {
2192   MakeFunctionUnique("glUniform2ui");
2193   interface_->Uniform2ui(location, v0, v1);
2194 }
2195
2196 void GL_BINDING_CALL MockGLInterface::Mock_glUniform2uiv(GLint location,
2197                                                          GLsizei count,
2198                                                          const GLuint* v) {
2199   MakeFunctionUnique("glUniform2uiv");
2200   interface_->Uniform2uiv(location, count, v);
2201 }
2202
2203 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3f(GLint location,
2204                                                        GLfloat x,
2205                                                        GLfloat y,
2206                                                        GLfloat z) {
2207   MakeFunctionUnique("glUniform3f");
2208   interface_->Uniform3f(location, x, y, z);
2209 }
2210
2211 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3fv(GLint location,
2212                                                         GLsizei count,
2213                                                         const GLfloat* v) {
2214   MakeFunctionUnique("glUniform3fv");
2215   interface_->Uniform3fv(location, count, v);
2216 }
2217
2218 void GL_BINDING_CALL
2219 MockGLInterface::Mock_glUniform3i(GLint location, GLint x, GLint y, GLint z) {
2220   MakeFunctionUnique("glUniform3i");
2221   interface_->Uniform3i(location, x, y, z);
2222 }
2223
2224 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3iv(GLint location,
2225                                                         GLsizei count,
2226                                                         const GLint* v) {
2227   MakeFunctionUnique("glUniform3iv");
2228   interface_->Uniform3iv(location, count, v);
2229 }
2230
2231 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3ui(GLint location,
2232                                                         GLuint v0,
2233                                                         GLuint v1,
2234                                                         GLuint v2) {
2235   MakeFunctionUnique("glUniform3ui");
2236   interface_->Uniform3ui(location, v0, v1, v2);
2237 }
2238
2239 void GL_BINDING_CALL MockGLInterface::Mock_glUniform3uiv(GLint location,
2240                                                          GLsizei count,
2241                                                          const GLuint* v) {
2242   MakeFunctionUnique("glUniform3uiv");
2243   interface_->Uniform3uiv(location, count, v);
2244 }
2245
2246 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4f(GLint location,
2247                                                        GLfloat x,
2248                                                        GLfloat y,
2249                                                        GLfloat z,
2250                                                        GLfloat w) {
2251   MakeFunctionUnique("glUniform4f");
2252   interface_->Uniform4f(location, x, y, z, w);
2253 }
2254
2255 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4fv(GLint location,
2256                                                         GLsizei count,
2257                                                         const GLfloat* v) {
2258   MakeFunctionUnique("glUniform4fv");
2259   interface_->Uniform4fv(location, count, v);
2260 }
2261
2262 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4i(GLint location,
2263                                                        GLint x,
2264                                                        GLint y,
2265                                                        GLint z,
2266                                                        GLint w) {
2267   MakeFunctionUnique("glUniform4i");
2268   interface_->Uniform4i(location, x, y, z, w);
2269 }
2270
2271 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4iv(GLint location,
2272                                                         GLsizei count,
2273                                                         const GLint* v) {
2274   MakeFunctionUnique("glUniform4iv");
2275   interface_->Uniform4iv(location, count, v);
2276 }
2277
2278 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4ui(GLint location,
2279                                                         GLuint v0,
2280                                                         GLuint v1,
2281                                                         GLuint v2,
2282                                                         GLuint v3) {
2283   MakeFunctionUnique("glUniform4ui");
2284   interface_->Uniform4ui(location, v0, v1, v2, v3);
2285 }
2286
2287 void GL_BINDING_CALL MockGLInterface::Mock_glUniform4uiv(GLint location,
2288                                                          GLsizei count,
2289                                                          const GLuint* v) {
2290   MakeFunctionUnique("glUniform4uiv");
2291   interface_->Uniform4uiv(location, count, v);
2292 }
2293
2294 void GL_BINDING_CALL
2295 MockGLInterface::Mock_glUniformBlockBinding(GLuint program,
2296                                             GLuint uniformBlockIndex,
2297                                             GLuint uniformBlockBinding) {
2298   MakeFunctionUnique("glUniformBlockBinding");
2299   interface_->UniformBlockBinding(program, uniformBlockIndex,
2300                                   uniformBlockBinding);
2301 }
2302
2303 void GL_BINDING_CALL
2304 MockGLInterface::Mock_glUniformMatrix2fv(GLint location,
2305                                          GLsizei count,
2306                                          GLboolean transpose,
2307                                          const GLfloat* value) {
2308   MakeFunctionUnique("glUniformMatrix2fv");
2309   interface_->UniformMatrix2fv(location, count, transpose, value);
2310 }
2311
2312 void GL_BINDING_CALL
2313 MockGLInterface::Mock_glUniformMatrix2x3fv(GLint location,
2314                                            GLsizei count,
2315                                            GLboolean transpose,
2316                                            const GLfloat* value) {
2317   MakeFunctionUnique("glUniformMatrix2x3fv");
2318   interface_->UniformMatrix2x3fv(location, count, transpose, value);
2319 }
2320
2321 void GL_BINDING_CALL
2322 MockGLInterface::Mock_glUniformMatrix2x4fv(GLint location,
2323                                            GLsizei count,
2324                                            GLboolean transpose,
2325                                            const GLfloat* value) {
2326   MakeFunctionUnique("glUniformMatrix2x4fv");
2327   interface_->UniformMatrix2x4fv(location, count, transpose, value);
2328 }
2329
2330 void GL_BINDING_CALL
2331 MockGLInterface::Mock_glUniformMatrix3fv(GLint location,
2332                                          GLsizei count,
2333                                          GLboolean transpose,
2334                                          const GLfloat* value) {
2335   MakeFunctionUnique("glUniformMatrix3fv");
2336   interface_->UniformMatrix3fv(location, count, transpose, value);
2337 }
2338
2339 void GL_BINDING_CALL
2340 MockGLInterface::Mock_glUniformMatrix3x2fv(GLint location,
2341                                            GLsizei count,
2342                                            GLboolean transpose,
2343                                            const GLfloat* value) {
2344   MakeFunctionUnique("glUniformMatrix3x2fv");
2345   interface_->UniformMatrix3x2fv(location, count, transpose, value);
2346 }
2347
2348 void GL_BINDING_CALL
2349 MockGLInterface::Mock_glUniformMatrix3x4fv(GLint location,
2350                                            GLsizei count,
2351                                            GLboolean transpose,
2352                                            const GLfloat* value) {
2353   MakeFunctionUnique("glUniformMatrix3x4fv");
2354   interface_->UniformMatrix3x4fv(location, count, transpose, value);
2355 }
2356
2357 void GL_BINDING_CALL
2358 MockGLInterface::Mock_glUniformMatrix4fv(GLint location,
2359                                          GLsizei count,
2360                                          GLboolean transpose,
2361                                          const GLfloat* value) {
2362   MakeFunctionUnique("glUniformMatrix4fv");
2363   interface_->UniformMatrix4fv(location, count, transpose, value);
2364 }
2365
2366 void GL_BINDING_CALL
2367 MockGLInterface::Mock_glUniformMatrix4x2fv(GLint location,
2368                                            GLsizei count,
2369                                            GLboolean transpose,
2370                                            const GLfloat* value) {
2371   MakeFunctionUnique("glUniformMatrix4x2fv");
2372   interface_->UniformMatrix4x2fv(location, count, transpose, value);
2373 }
2374
2375 void GL_BINDING_CALL
2376 MockGLInterface::Mock_glUniformMatrix4x3fv(GLint location,
2377                                            GLsizei count,
2378                                            GLboolean transpose,
2379                                            const GLfloat* value) {
2380   MakeFunctionUnique("glUniformMatrix4x3fv");
2381   interface_->UniformMatrix4x3fv(location, count, transpose, value);
2382 }
2383
2384 GLboolean GL_BINDING_CALL MockGLInterface::Mock_glUnmapBuffer(GLenum target) {
2385   MakeFunctionUnique("glUnmapBuffer");
2386   return interface_->UnmapBuffer(target);
2387 }
2388
2389 GLboolean GL_BINDING_CALL
2390 MockGLInterface::Mock_glUnmapBufferOES(GLenum target) {
2391   MakeFunctionUnique("glUnmapBufferOES");
2392   return interface_->UnmapBuffer(target);
2393 }
2394
2395 void GL_BINDING_CALL MockGLInterface::Mock_glUseProgram(GLuint program) {
2396   MakeFunctionUnique("glUseProgram");
2397   interface_->UseProgram(program);
2398 }
2399
2400 void GL_BINDING_CALL MockGLInterface::Mock_glValidateProgram(GLuint program) {
2401   MakeFunctionUnique("glValidateProgram");
2402   interface_->ValidateProgram(program);
2403 }
2404
2405 void GL_BINDING_CALL
2406 MockGLInterface::Mock_glVertexAttrib1f(GLuint indx, GLfloat x) {
2407   MakeFunctionUnique("glVertexAttrib1f");
2408   interface_->VertexAttrib1f(indx, x);
2409 }
2410
2411 void GL_BINDING_CALL
2412 MockGLInterface::Mock_glVertexAttrib1fv(GLuint indx, const GLfloat* values) {
2413   MakeFunctionUnique("glVertexAttrib1fv");
2414   interface_->VertexAttrib1fv(indx, values);
2415 }
2416
2417 void GL_BINDING_CALL
2418 MockGLInterface::Mock_glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
2419   MakeFunctionUnique("glVertexAttrib2f");
2420   interface_->VertexAttrib2f(indx, x, y);
2421 }
2422
2423 void GL_BINDING_CALL
2424 MockGLInterface::Mock_glVertexAttrib2fv(GLuint indx, const GLfloat* values) {
2425   MakeFunctionUnique("glVertexAttrib2fv");
2426   interface_->VertexAttrib2fv(indx, values);
2427 }
2428
2429 void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib3f(GLuint indx,
2430                                                             GLfloat x,
2431                                                             GLfloat y,
2432                                                             GLfloat z) {
2433   MakeFunctionUnique("glVertexAttrib3f");
2434   interface_->VertexAttrib3f(indx, x, y, z);
2435 }
2436
2437 void GL_BINDING_CALL
2438 MockGLInterface::Mock_glVertexAttrib3fv(GLuint indx, const GLfloat* values) {
2439   MakeFunctionUnique("glVertexAttrib3fv");
2440   interface_->VertexAttrib3fv(indx, values);
2441 }
2442
2443 void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttrib4f(GLuint indx,
2444                                                             GLfloat x,
2445                                                             GLfloat y,
2446                                                             GLfloat z,
2447                                                             GLfloat w) {
2448   MakeFunctionUnique("glVertexAttrib4f");
2449   interface_->VertexAttrib4f(indx, x, y, z, w);
2450 }
2451
2452 void GL_BINDING_CALL
2453 MockGLInterface::Mock_glVertexAttrib4fv(GLuint indx, const GLfloat* values) {
2454   MakeFunctionUnique("glVertexAttrib4fv");
2455   interface_->VertexAttrib4fv(indx, values);
2456 }
2457
2458 void GL_BINDING_CALL
2459 MockGLInterface::Mock_glVertexAttribDivisor(GLuint index, GLuint divisor) {
2460   MakeFunctionUnique("glVertexAttribDivisor");
2461   interface_->VertexAttribDivisorANGLE(index, divisor);
2462 }
2463
2464 void GL_BINDING_CALL
2465 MockGLInterface::Mock_glVertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
2466   MakeFunctionUnique("glVertexAttribDivisorANGLE");
2467   interface_->VertexAttribDivisorANGLE(index, divisor);
2468 }
2469
2470 void GL_BINDING_CALL
2471 MockGLInterface::Mock_glVertexAttribDivisorARB(GLuint index, GLuint divisor) {
2472   MakeFunctionUnique("glVertexAttribDivisorARB");
2473   interface_->VertexAttribDivisorANGLE(index, divisor);
2474 }
2475
2476 void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttribI4i(GLuint indx,
2477                                                              GLint x,
2478                                                              GLint y,
2479                                                              GLint z,
2480                                                              GLint w) {
2481   MakeFunctionUnique("glVertexAttribI4i");
2482   interface_->VertexAttribI4i(indx, x, y, z, w);
2483 }
2484
2485 void GL_BINDING_CALL
2486 MockGLInterface::Mock_glVertexAttribI4iv(GLuint indx, const GLint* values) {
2487   MakeFunctionUnique("glVertexAttribI4iv");
2488   interface_->VertexAttribI4iv(indx, values);
2489 }
2490
2491 void GL_BINDING_CALL MockGLInterface::Mock_glVertexAttribI4ui(GLuint indx,
2492                                                               GLuint x,
2493                                                               GLuint y,
2494                                                               GLuint z,
2495                                                               GLuint w) {
2496   MakeFunctionUnique("glVertexAttribI4ui");
2497   interface_->VertexAttribI4ui(indx, x, y, z, w);
2498 }
2499
2500 void GL_BINDING_CALL
2501 MockGLInterface::Mock_glVertexAttribI4uiv(GLuint indx, const GLuint* values) {
2502   MakeFunctionUnique("glVertexAttribI4uiv");
2503   interface_->VertexAttribI4uiv(indx, values);
2504 }
2505
2506 void GL_BINDING_CALL
2507 MockGLInterface::Mock_glVertexAttribIPointer(GLuint indx,
2508                                              GLint size,
2509                                              GLenum type,
2510                                              GLsizei stride,
2511                                              const void* ptr) {
2512   MakeFunctionUnique("glVertexAttribIPointer");
2513   interface_->VertexAttribIPointer(indx, size, type, stride, ptr);
2514 }
2515
2516 void GL_BINDING_CALL
2517 MockGLInterface::Mock_glVertexAttribPointer(GLuint indx,
2518                                             GLint size,
2519                                             GLenum type,
2520                                             GLboolean normalized,
2521                                             GLsizei stride,
2522                                             const void* ptr) {
2523   MakeFunctionUnique("glVertexAttribPointer");
2524   interface_->VertexAttribPointer(indx, size, type, normalized, stride, ptr);
2525 }
2526
2527 void GL_BINDING_CALL MockGLInterface::Mock_glViewport(GLint x,
2528                                                       GLint y,
2529                                                       GLsizei width,
2530                                                       GLsizei height) {
2531   MakeFunctionUnique("glViewport");
2532   interface_->Viewport(x, y, width, height);
2533 }
2534
2535 GLenum GL_BINDING_CALL MockGLInterface::Mock_glWaitSync(GLsync sync,
2536                                                         GLbitfield flags,
2537                                                         GLuint64 timeout) {
2538   MakeFunctionUnique("glWaitSync");
2539   return interface_->WaitSync(sync, flags, timeout);
2540 }
2541
2542 static void MockInvalidFunction() {
2543   NOTREACHED();
2544 }
2545
2546 void* GL_BINDING_CALL MockGLInterface::GetGLProcAddress(const char* name) {
2547   if (strcmp(name, "glActiveTexture") == 0)
2548     return reinterpret_cast<void*>(Mock_glActiveTexture);
2549   if (strcmp(name, "glAttachShader") == 0)
2550     return reinterpret_cast<void*>(Mock_glAttachShader);
2551   if (strcmp(name, "glBeginQuery") == 0)
2552     return reinterpret_cast<void*>(Mock_glBeginQuery);
2553   if (strcmp(name, "glBeginQueryARB") == 0)
2554     return reinterpret_cast<void*>(Mock_glBeginQueryARB);
2555   if (strcmp(name, "glBeginQueryEXT") == 0)
2556     return reinterpret_cast<void*>(Mock_glBeginQueryEXT);
2557   if (strcmp(name, "glBeginTransformFeedback") == 0)
2558     return reinterpret_cast<void*>(Mock_glBeginTransformFeedback);
2559   if (strcmp(name, "glBindAttribLocation") == 0)
2560     return reinterpret_cast<void*>(Mock_glBindAttribLocation);
2561   if (strcmp(name, "glBindBuffer") == 0)
2562     return reinterpret_cast<void*>(Mock_glBindBuffer);
2563   if (strcmp(name, "glBindBufferBase") == 0)
2564     return reinterpret_cast<void*>(Mock_glBindBufferBase);
2565   if (strcmp(name, "glBindBufferRange") == 0)
2566     return reinterpret_cast<void*>(Mock_glBindBufferRange);
2567   if (strcmp(name, "glBindFragDataLocation") == 0)
2568     return reinterpret_cast<void*>(Mock_glBindFragDataLocation);
2569   if (strcmp(name, "glBindFragDataLocationIndexed") == 0)
2570     return reinterpret_cast<void*>(Mock_glBindFragDataLocationIndexed);
2571   if (strcmp(name, "glBindFramebuffer") == 0)
2572     return reinterpret_cast<void*>(Mock_glBindFramebuffer);
2573   if (strcmp(name, "glBindFramebufferEXT") == 0)
2574     return reinterpret_cast<void*>(Mock_glBindFramebufferEXT);
2575   if (strcmp(name, "glBindRenderbuffer") == 0)
2576     return reinterpret_cast<void*>(Mock_glBindRenderbuffer);
2577   if (strcmp(name, "glBindRenderbufferEXT") == 0)
2578     return reinterpret_cast<void*>(Mock_glBindRenderbufferEXT);
2579   if (strcmp(name, "glBindSampler") == 0)
2580     return reinterpret_cast<void*>(Mock_glBindSampler);
2581   if (strcmp(name, "glBindTexture") == 0)
2582     return reinterpret_cast<void*>(Mock_glBindTexture);
2583   if (strcmp(name, "glBindTransformFeedback") == 0)
2584     return reinterpret_cast<void*>(Mock_glBindTransformFeedback);
2585   if (strcmp(name, "glBindVertexArray") == 0)
2586     return reinterpret_cast<void*>(Mock_glBindVertexArray);
2587   if (strcmp(name, "glBindVertexArrayAPPLE") == 0)
2588     return reinterpret_cast<void*>(Mock_glBindVertexArrayAPPLE);
2589   if (strcmp(name, "glBindVertexArrayOES") == 0)
2590     return reinterpret_cast<void*>(Mock_glBindVertexArrayOES);
2591   if (strcmp(name, "glBlendBarrierKHR") == 0)
2592     return reinterpret_cast<void*>(Mock_glBlendBarrierKHR);
2593   if (strcmp(name, "glBlendBarrierNV") == 0)
2594     return reinterpret_cast<void*>(Mock_glBlendBarrierNV);
2595   if (strcmp(name, "glBlendColor") == 0)
2596     return reinterpret_cast<void*>(Mock_glBlendColor);
2597   if (strcmp(name, "glBlendEquation") == 0)
2598     return reinterpret_cast<void*>(Mock_glBlendEquation);
2599   if (strcmp(name, "glBlendEquationSeparate") == 0)
2600     return reinterpret_cast<void*>(Mock_glBlendEquationSeparate);
2601   if (strcmp(name, "glBlendFunc") == 0)
2602     return reinterpret_cast<void*>(Mock_glBlendFunc);
2603   if (strcmp(name, "glBlendFuncSeparate") == 0)
2604     return reinterpret_cast<void*>(Mock_glBlendFuncSeparate);
2605   if (strcmp(name, "glBlitFramebuffer") == 0)
2606     return reinterpret_cast<void*>(Mock_glBlitFramebuffer);
2607   if (strcmp(name, "glBlitFramebufferANGLE") == 0)
2608     return reinterpret_cast<void*>(Mock_glBlitFramebufferANGLE);
2609   if (strcmp(name, "glBlitFramebufferEXT") == 0)
2610     return reinterpret_cast<void*>(Mock_glBlitFramebufferEXT);
2611   if (strcmp(name, "glBufferData") == 0)
2612     return reinterpret_cast<void*>(Mock_glBufferData);
2613   if (strcmp(name, "glBufferSubData") == 0)
2614     return reinterpret_cast<void*>(Mock_glBufferSubData);
2615   if (strcmp(name, "glCheckFramebufferStatus") == 0)
2616     return reinterpret_cast<void*>(Mock_glCheckFramebufferStatus);
2617   if (strcmp(name, "glCheckFramebufferStatusEXT") == 0)
2618     return reinterpret_cast<void*>(Mock_glCheckFramebufferStatusEXT);
2619   if (strcmp(name, "glClear") == 0)
2620     return reinterpret_cast<void*>(Mock_glClear);
2621   if (strcmp(name, "glClearBufferfi") == 0)
2622     return reinterpret_cast<void*>(Mock_glClearBufferfi);
2623   if (strcmp(name, "glClearBufferfv") == 0)
2624     return reinterpret_cast<void*>(Mock_glClearBufferfv);
2625   if (strcmp(name, "glClearBufferiv") == 0)
2626     return reinterpret_cast<void*>(Mock_glClearBufferiv);
2627   if (strcmp(name, "glClearBufferuiv") == 0)
2628     return reinterpret_cast<void*>(Mock_glClearBufferuiv);
2629   if (strcmp(name, "glClearColor") == 0)
2630     return reinterpret_cast<void*>(Mock_glClearColor);
2631   if (strcmp(name, "glClearDepth") == 0)
2632     return reinterpret_cast<void*>(Mock_glClearDepth);
2633   if (strcmp(name, "glClearDepthf") == 0)
2634     return reinterpret_cast<void*>(Mock_glClearDepthf);
2635   if (strcmp(name, "glClearStencil") == 0)
2636     return reinterpret_cast<void*>(Mock_glClearStencil);
2637   if (strcmp(name, "glClientWaitSync") == 0)
2638     return reinterpret_cast<void*>(Mock_glClientWaitSync);
2639   if (strcmp(name, "glColorMask") == 0)
2640     return reinterpret_cast<void*>(Mock_glColorMask);
2641   if (strcmp(name, "glCompileShader") == 0)
2642     return reinterpret_cast<void*>(Mock_glCompileShader);
2643   if (strcmp(name, "glCompressedTexImage2D") == 0)
2644     return reinterpret_cast<void*>(Mock_glCompressedTexImage2D);
2645   if (strcmp(name, "glCompressedTexImage3D") == 0)
2646     return reinterpret_cast<void*>(Mock_glCompressedTexImage3D);
2647   if (strcmp(name, "glCompressedTexSubImage2D") == 0)
2648     return reinterpret_cast<void*>(Mock_glCompressedTexSubImage2D);
2649   if (strcmp(name, "glCopyBufferSubData") == 0)
2650     return reinterpret_cast<void*>(Mock_glCopyBufferSubData);
2651   if (strcmp(name, "glCopyTexImage2D") == 0)
2652     return reinterpret_cast<void*>(Mock_glCopyTexImage2D);
2653   if (strcmp(name, "glCopyTexSubImage2D") == 0)
2654     return reinterpret_cast<void*>(Mock_glCopyTexSubImage2D);
2655   if (strcmp(name, "glCopyTexSubImage3D") == 0)
2656     return reinterpret_cast<void*>(Mock_glCopyTexSubImage3D);
2657   if (strcmp(name, "glCreateProgram") == 0)
2658     return reinterpret_cast<void*>(Mock_glCreateProgram);
2659   if (strcmp(name, "glCreateShader") == 0)
2660     return reinterpret_cast<void*>(Mock_glCreateShader);
2661   if (strcmp(name, "glCullFace") == 0)
2662     return reinterpret_cast<void*>(Mock_glCullFace);
2663   if (strcmp(name, "glDeleteBuffers") == 0)
2664     return reinterpret_cast<void*>(Mock_glDeleteBuffers);
2665   if (strcmp(name, "glDeleteFencesAPPLE") == 0)
2666     return reinterpret_cast<void*>(Mock_glDeleteFencesAPPLE);
2667   if (strcmp(name, "glDeleteFencesNV") == 0)
2668     return reinterpret_cast<void*>(Mock_glDeleteFencesNV);
2669   if (strcmp(name, "glDeleteFramebuffers") == 0)
2670     return reinterpret_cast<void*>(Mock_glDeleteFramebuffers);
2671   if (strcmp(name, "glDeleteFramebuffersEXT") == 0)
2672     return reinterpret_cast<void*>(Mock_glDeleteFramebuffersEXT);
2673   if (strcmp(name, "glDeleteProgram") == 0)
2674     return reinterpret_cast<void*>(Mock_glDeleteProgram);
2675   if (strcmp(name, "glDeleteQueries") == 0)
2676     return reinterpret_cast<void*>(Mock_glDeleteQueries);
2677   if (strcmp(name, "glDeleteQueriesARB") == 0)
2678     return reinterpret_cast<void*>(Mock_glDeleteQueriesARB);
2679   if (strcmp(name, "glDeleteQueriesEXT") == 0)
2680     return reinterpret_cast<void*>(Mock_glDeleteQueriesEXT);
2681   if (strcmp(name, "glDeleteRenderbuffers") == 0)
2682     return reinterpret_cast<void*>(Mock_glDeleteRenderbuffers);
2683   if (strcmp(name, "glDeleteRenderbuffersEXT") == 0)
2684     return reinterpret_cast<void*>(Mock_glDeleteRenderbuffersEXT);
2685   if (strcmp(name, "glDeleteSamplers") == 0)
2686     return reinterpret_cast<void*>(Mock_glDeleteSamplers);
2687   if (strcmp(name, "glDeleteShader") == 0)
2688     return reinterpret_cast<void*>(Mock_glDeleteShader);
2689   if (strcmp(name, "glDeleteSync") == 0)
2690     return reinterpret_cast<void*>(Mock_glDeleteSync);
2691   if (strcmp(name, "glDeleteTextures") == 0)
2692     return reinterpret_cast<void*>(Mock_glDeleteTextures);
2693   if (strcmp(name, "glDeleteTransformFeedbacks") == 0)
2694     return reinterpret_cast<void*>(Mock_glDeleteTransformFeedbacks);
2695   if (strcmp(name, "glDeleteVertexArrays") == 0)
2696     return reinterpret_cast<void*>(Mock_glDeleteVertexArrays);
2697   if (strcmp(name, "glDeleteVertexArraysAPPLE") == 0)
2698     return reinterpret_cast<void*>(Mock_glDeleteVertexArraysAPPLE);
2699   if (strcmp(name, "glDeleteVertexArraysOES") == 0)
2700     return reinterpret_cast<void*>(Mock_glDeleteVertexArraysOES);
2701   if (strcmp(name, "glDepthFunc") == 0)
2702     return reinterpret_cast<void*>(Mock_glDepthFunc);
2703   if (strcmp(name, "glDepthMask") == 0)
2704     return reinterpret_cast<void*>(Mock_glDepthMask);
2705   if (strcmp(name, "glDepthRange") == 0)
2706     return reinterpret_cast<void*>(Mock_glDepthRange);
2707   if (strcmp(name, "glDepthRangef") == 0)
2708     return reinterpret_cast<void*>(Mock_glDepthRangef);
2709   if (strcmp(name, "glDetachShader") == 0)
2710     return reinterpret_cast<void*>(Mock_glDetachShader);
2711   if (strcmp(name, "glDisable") == 0)
2712     return reinterpret_cast<void*>(Mock_glDisable);
2713   if (strcmp(name, "glDisableVertexAttribArray") == 0)
2714     return reinterpret_cast<void*>(Mock_glDisableVertexAttribArray);
2715   if (strcmp(name, "glDiscardFramebufferEXT") == 0)
2716     return reinterpret_cast<void*>(Mock_glDiscardFramebufferEXT);
2717   if (strcmp(name, "glDrawArrays") == 0)
2718     return reinterpret_cast<void*>(Mock_glDrawArrays);
2719   if (strcmp(name, "glDrawArraysInstanced") == 0)
2720     return reinterpret_cast<void*>(Mock_glDrawArraysInstanced);
2721   if (strcmp(name, "glDrawArraysInstancedANGLE") == 0)
2722     return reinterpret_cast<void*>(Mock_glDrawArraysInstancedANGLE);
2723   if (strcmp(name, "glDrawArraysInstancedARB") == 0)
2724     return reinterpret_cast<void*>(Mock_glDrawArraysInstancedARB);
2725   if (strcmp(name, "glDrawBuffer") == 0)
2726     return reinterpret_cast<void*>(Mock_glDrawBuffer);
2727   if (strcmp(name, "glDrawBuffers") == 0)
2728     return reinterpret_cast<void*>(Mock_glDrawBuffers);
2729   if (strcmp(name, "glDrawBuffersARB") == 0)
2730     return reinterpret_cast<void*>(Mock_glDrawBuffersARB);
2731   if (strcmp(name, "glDrawBuffersEXT") == 0)
2732     return reinterpret_cast<void*>(Mock_glDrawBuffersEXT);
2733   if (strcmp(name, "glDrawElements") == 0)
2734     return reinterpret_cast<void*>(Mock_glDrawElements);
2735   if (strcmp(name, "glDrawElementsInstanced") == 0)
2736     return reinterpret_cast<void*>(Mock_glDrawElementsInstanced);
2737   if (strcmp(name, "glDrawElementsInstancedANGLE") == 0)
2738     return reinterpret_cast<void*>(Mock_glDrawElementsInstancedANGLE);
2739   if (strcmp(name, "glDrawElementsInstancedARB") == 0)
2740     return reinterpret_cast<void*>(Mock_glDrawElementsInstancedARB);
2741   if (strcmp(name, "glDrawRangeElements") == 0)
2742     return reinterpret_cast<void*>(Mock_glDrawRangeElements);
2743   if (strcmp(name, "glEGLImageTargetRenderbufferStorageOES") == 0)
2744     return reinterpret_cast<void*>(Mock_glEGLImageTargetRenderbufferStorageOES);
2745   if (strcmp(name, "glEGLImageTargetTexture2DOES") == 0)
2746     return reinterpret_cast<void*>(Mock_glEGLImageTargetTexture2DOES);
2747   if (strcmp(name, "glEnable") == 0)
2748     return reinterpret_cast<void*>(Mock_glEnable);
2749   if (strcmp(name, "glEnableVertexAttribArray") == 0)
2750     return reinterpret_cast<void*>(Mock_glEnableVertexAttribArray);
2751   if (strcmp(name, "glEndQuery") == 0)
2752     return reinterpret_cast<void*>(Mock_glEndQuery);
2753   if (strcmp(name, "glEndQueryARB") == 0)
2754     return reinterpret_cast<void*>(Mock_glEndQueryARB);
2755   if (strcmp(name, "glEndQueryEXT") == 0)
2756     return reinterpret_cast<void*>(Mock_glEndQueryEXT);
2757   if (strcmp(name, "glEndTransformFeedback") == 0)
2758     return reinterpret_cast<void*>(Mock_glEndTransformFeedback);
2759   if (strcmp(name, "glFenceSync") == 0)
2760     return reinterpret_cast<void*>(Mock_glFenceSync);
2761   if (strcmp(name, "glFinish") == 0)
2762     return reinterpret_cast<void*>(Mock_glFinish);
2763   if (strcmp(name, "glFinishFenceAPPLE") == 0)
2764     return reinterpret_cast<void*>(Mock_glFinishFenceAPPLE);
2765   if (strcmp(name, "glFinishFenceNV") == 0)
2766     return reinterpret_cast<void*>(Mock_glFinishFenceNV);
2767   if (strcmp(name, "glFlush") == 0)
2768     return reinterpret_cast<void*>(Mock_glFlush);
2769   if (strcmp(name, "glFlushMappedBufferRange") == 0)
2770     return reinterpret_cast<void*>(Mock_glFlushMappedBufferRange);
2771   if (strcmp(name, "glFramebufferRenderbuffer") == 0)
2772     return reinterpret_cast<void*>(Mock_glFramebufferRenderbuffer);
2773   if (strcmp(name, "glFramebufferRenderbufferEXT") == 0)
2774     return reinterpret_cast<void*>(Mock_glFramebufferRenderbufferEXT);
2775   if (strcmp(name, "glFramebufferTexture2D") == 0)
2776     return reinterpret_cast<void*>(Mock_glFramebufferTexture2D);
2777   if (strcmp(name, "glFramebufferTexture2DEXT") == 0)
2778     return reinterpret_cast<void*>(Mock_glFramebufferTexture2DEXT);
2779   if (strcmp(name, "glFramebufferTexture2DMultisampleEXT") == 0)
2780     return reinterpret_cast<void*>(Mock_glFramebufferTexture2DMultisampleEXT);
2781   if (strcmp(name, "glFramebufferTexture2DMultisampleIMG") == 0)
2782     return reinterpret_cast<void*>(Mock_glFramebufferTexture2DMultisampleIMG);
2783   if (strcmp(name, "glFramebufferTextureLayer") == 0)
2784     return reinterpret_cast<void*>(Mock_glFramebufferTextureLayer);
2785   if (strcmp(name, "glFrontFace") == 0)
2786     return reinterpret_cast<void*>(Mock_glFrontFace);
2787   if (strcmp(name, "glGenBuffers") == 0)
2788     return reinterpret_cast<void*>(Mock_glGenBuffers);
2789   if (strcmp(name, "glGenFencesAPPLE") == 0)
2790     return reinterpret_cast<void*>(Mock_glGenFencesAPPLE);
2791   if (strcmp(name, "glGenFencesNV") == 0)
2792     return reinterpret_cast<void*>(Mock_glGenFencesNV);
2793   if (strcmp(name, "glGenFramebuffers") == 0)
2794     return reinterpret_cast<void*>(Mock_glGenFramebuffers);
2795   if (strcmp(name, "glGenFramebuffersEXT") == 0)
2796     return reinterpret_cast<void*>(Mock_glGenFramebuffersEXT);
2797   if (strcmp(name, "glGenQueries") == 0)
2798     return reinterpret_cast<void*>(Mock_glGenQueries);
2799   if (strcmp(name, "glGenQueriesARB") == 0)
2800     return reinterpret_cast<void*>(Mock_glGenQueriesARB);
2801   if (strcmp(name, "glGenQueriesEXT") == 0)
2802     return reinterpret_cast<void*>(Mock_glGenQueriesEXT);
2803   if (strcmp(name, "glGenRenderbuffers") == 0)
2804     return reinterpret_cast<void*>(Mock_glGenRenderbuffers);
2805   if (strcmp(name, "glGenRenderbuffersEXT") == 0)
2806     return reinterpret_cast<void*>(Mock_glGenRenderbuffersEXT);
2807   if (strcmp(name, "glGenSamplers") == 0)
2808     return reinterpret_cast<void*>(Mock_glGenSamplers);
2809   if (strcmp(name, "glGenTextures") == 0)
2810     return reinterpret_cast<void*>(Mock_glGenTextures);
2811   if (strcmp(name, "glGenTransformFeedbacks") == 0)
2812     return reinterpret_cast<void*>(Mock_glGenTransformFeedbacks);
2813   if (strcmp(name, "glGenVertexArrays") == 0)
2814     return reinterpret_cast<void*>(Mock_glGenVertexArrays);
2815   if (strcmp(name, "glGenVertexArraysAPPLE") == 0)
2816     return reinterpret_cast<void*>(Mock_glGenVertexArraysAPPLE);
2817   if (strcmp(name, "glGenVertexArraysOES") == 0)
2818     return reinterpret_cast<void*>(Mock_glGenVertexArraysOES);
2819   if (strcmp(name, "glGenerateMipmap") == 0)
2820     return reinterpret_cast<void*>(Mock_glGenerateMipmap);
2821   if (strcmp(name, "glGenerateMipmapEXT") == 0)
2822     return reinterpret_cast<void*>(Mock_glGenerateMipmapEXT);
2823   if (strcmp(name, "glGetActiveAttrib") == 0)
2824     return reinterpret_cast<void*>(Mock_glGetActiveAttrib);
2825   if (strcmp(name, "glGetActiveUniform") == 0)
2826     return reinterpret_cast<void*>(Mock_glGetActiveUniform);
2827   if (strcmp(name, "glGetActiveUniformBlockName") == 0)
2828     return reinterpret_cast<void*>(Mock_glGetActiveUniformBlockName);
2829   if (strcmp(name, "glGetActiveUniformBlockiv") == 0)
2830     return reinterpret_cast<void*>(Mock_glGetActiveUniformBlockiv);
2831   if (strcmp(name, "glGetActiveUniformsiv") == 0)
2832     return reinterpret_cast<void*>(Mock_glGetActiveUniformsiv);
2833   if (strcmp(name, "glGetAttachedShaders") == 0)
2834     return reinterpret_cast<void*>(Mock_glGetAttachedShaders);
2835   if (strcmp(name, "glGetAttribLocation") == 0)
2836     return reinterpret_cast<void*>(Mock_glGetAttribLocation);
2837   if (strcmp(name, "glGetBooleanv") == 0)
2838     return reinterpret_cast<void*>(Mock_glGetBooleanv);
2839   if (strcmp(name, "glGetBufferParameteriv") == 0)
2840     return reinterpret_cast<void*>(Mock_glGetBufferParameteriv);
2841   if (strcmp(name, "glGetError") == 0)
2842     return reinterpret_cast<void*>(Mock_glGetError);
2843   if (strcmp(name, "glGetFenceivNV") == 0)
2844     return reinterpret_cast<void*>(Mock_glGetFenceivNV);
2845   if (strcmp(name, "glGetFloatv") == 0)
2846     return reinterpret_cast<void*>(Mock_glGetFloatv);
2847   if (strcmp(name, "glGetFragDataLocation") == 0)
2848     return reinterpret_cast<void*>(Mock_glGetFragDataLocation);
2849   if (strcmp(name, "glGetFramebufferAttachmentParameteriv") == 0)
2850     return reinterpret_cast<void*>(Mock_glGetFramebufferAttachmentParameteriv);
2851   if (strcmp(name, "glGetFramebufferAttachmentParameterivEXT") == 0)
2852     return reinterpret_cast<void*>(
2853         Mock_glGetFramebufferAttachmentParameterivEXT);
2854   if (strcmp(name, "glGetGraphicsResetStatus") == 0)
2855     return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatus);
2856   if (strcmp(name, "glGetGraphicsResetStatusARB") == 0)
2857     return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatusARB);
2858   if (strcmp(name, "glGetGraphicsResetStatusEXT") == 0)
2859     return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatusEXT);
2860   if (strcmp(name, "glGetGraphicsResetStatusKHR") == 0)
2861     return reinterpret_cast<void*>(Mock_glGetGraphicsResetStatusKHR);
2862   if (strcmp(name, "glGetInteger64i_v") == 0)
2863     return reinterpret_cast<void*>(Mock_glGetInteger64i_v);
2864   if (strcmp(name, "glGetInteger64v") == 0)
2865     return reinterpret_cast<void*>(Mock_glGetInteger64v);
2866   if (strcmp(name, "glGetIntegeri_v") == 0)
2867     return reinterpret_cast<void*>(Mock_glGetIntegeri_v);
2868   if (strcmp(name, "glGetIntegerv") == 0)
2869     return reinterpret_cast<void*>(Mock_glGetIntegerv);
2870   if (strcmp(name, "glGetInternalformativ") == 0)
2871     return reinterpret_cast<void*>(Mock_glGetInternalformativ);
2872   if (strcmp(name, "glGetProgramBinary") == 0)
2873     return reinterpret_cast<void*>(Mock_glGetProgramBinary);
2874   if (strcmp(name, "glGetProgramBinaryOES") == 0)
2875     return reinterpret_cast<void*>(Mock_glGetProgramBinaryOES);
2876   if (strcmp(name, "glGetProgramInfoLog") == 0)
2877     return reinterpret_cast<void*>(Mock_glGetProgramInfoLog);
2878   if (strcmp(name, "glGetProgramResourceLocation") == 0)
2879     return reinterpret_cast<void*>(Mock_glGetProgramResourceLocation);
2880   if (strcmp(name, "glGetProgramiv") == 0)
2881     return reinterpret_cast<void*>(Mock_glGetProgramiv);
2882   if (strcmp(name, "glGetQueryObjecti64v") == 0)
2883     return reinterpret_cast<void*>(Mock_glGetQueryObjecti64v);
2884   if (strcmp(name, "glGetQueryObjecti64vEXT") == 0)
2885     return reinterpret_cast<void*>(Mock_glGetQueryObjecti64vEXT);
2886   if (strcmp(name, "glGetQueryObjectiv") == 0)
2887     return reinterpret_cast<void*>(Mock_glGetQueryObjectiv);
2888   if (strcmp(name, "glGetQueryObjectivARB") == 0)
2889     return reinterpret_cast<void*>(Mock_glGetQueryObjectivARB);
2890   if (strcmp(name, "glGetQueryObjectivEXT") == 0)
2891     return reinterpret_cast<void*>(Mock_glGetQueryObjectivEXT);
2892   if (strcmp(name, "glGetQueryObjectui64v") == 0)
2893     return reinterpret_cast<void*>(Mock_glGetQueryObjectui64v);
2894   if (strcmp(name, "glGetQueryObjectui64vEXT") == 0)
2895     return reinterpret_cast<void*>(Mock_glGetQueryObjectui64vEXT);
2896   if (strcmp(name, "glGetQueryObjectuiv") == 0)
2897     return reinterpret_cast<void*>(Mock_glGetQueryObjectuiv);
2898   if (strcmp(name, "glGetQueryObjectuivARB") == 0)
2899     return reinterpret_cast<void*>(Mock_glGetQueryObjectuivARB);
2900   if (strcmp(name, "glGetQueryObjectuivEXT") == 0)
2901     return reinterpret_cast<void*>(Mock_glGetQueryObjectuivEXT);
2902   if (strcmp(name, "glGetQueryiv") == 0)
2903     return reinterpret_cast<void*>(Mock_glGetQueryiv);
2904   if (strcmp(name, "glGetQueryivARB") == 0)
2905     return reinterpret_cast<void*>(Mock_glGetQueryivARB);
2906   if (strcmp(name, "glGetQueryivEXT") == 0)
2907     return reinterpret_cast<void*>(Mock_glGetQueryivEXT);
2908   if (strcmp(name, "glGetRenderbufferParameteriv") == 0)
2909     return reinterpret_cast<void*>(Mock_glGetRenderbufferParameteriv);
2910   if (strcmp(name, "glGetRenderbufferParameterivEXT") == 0)
2911     return reinterpret_cast<void*>(Mock_glGetRenderbufferParameterivEXT);
2912   if (strcmp(name, "glGetSamplerParameterfv") == 0)
2913     return reinterpret_cast<void*>(Mock_glGetSamplerParameterfv);
2914   if (strcmp(name, "glGetSamplerParameteriv") == 0)
2915     return reinterpret_cast<void*>(Mock_glGetSamplerParameteriv);
2916   if (strcmp(name, "glGetShaderInfoLog") == 0)
2917     return reinterpret_cast<void*>(Mock_glGetShaderInfoLog);
2918   if (strcmp(name, "glGetShaderPrecisionFormat") == 0)
2919     return reinterpret_cast<void*>(Mock_glGetShaderPrecisionFormat);
2920   if (strcmp(name, "glGetShaderSource") == 0)
2921     return reinterpret_cast<void*>(Mock_glGetShaderSource);
2922   if (strcmp(name, "glGetShaderiv") == 0)
2923     return reinterpret_cast<void*>(Mock_glGetShaderiv);
2924   if (strcmp(name, "glGetString") == 0)
2925     return reinterpret_cast<void*>(Mock_glGetString);
2926   if (strcmp(name, "glGetStringi") == 0)
2927     return reinterpret_cast<void*>(Mock_glGetStringi);
2928   if (strcmp(name, "glGetSynciv") == 0)
2929     return reinterpret_cast<void*>(Mock_glGetSynciv);
2930   if (strcmp(name, "glGetTexLevelParameterfv") == 0)
2931     return reinterpret_cast<void*>(Mock_glGetTexLevelParameterfv);
2932   if (strcmp(name, "glGetTexLevelParameteriv") == 0)
2933     return reinterpret_cast<void*>(Mock_glGetTexLevelParameteriv);
2934   if (strcmp(name, "glGetTexParameterfv") == 0)
2935     return reinterpret_cast<void*>(Mock_glGetTexParameterfv);
2936   if (strcmp(name, "glGetTexParameteriv") == 0)
2937     return reinterpret_cast<void*>(Mock_glGetTexParameteriv);
2938   if (strcmp(name, "glGetTransformFeedbackVarying") == 0)
2939     return reinterpret_cast<void*>(Mock_glGetTransformFeedbackVarying);
2940   if (strcmp(name, "glGetTranslatedShaderSourceANGLE") == 0)
2941     return reinterpret_cast<void*>(Mock_glGetTranslatedShaderSourceANGLE);
2942   if (strcmp(name, "glGetUniformBlockIndex") == 0)
2943     return reinterpret_cast<void*>(Mock_glGetUniformBlockIndex);
2944   if (strcmp(name, "glGetUniformIndices") == 0)
2945     return reinterpret_cast<void*>(Mock_glGetUniformIndices);
2946   if (strcmp(name, "glGetUniformLocation") == 0)
2947     return reinterpret_cast<void*>(Mock_glGetUniformLocation);
2948   if (strcmp(name, "glGetUniformfv") == 0)
2949     return reinterpret_cast<void*>(Mock_glGetUniformfv);
2950   if (strcmp(name, "glGetUniformiv") == 0)
2951     return reinterpret_cast<void*>(Mock_glGetUniformiv);
2952   if (strcmp(name, "glGetVertexAttribPointerv") == 0)
2953     return reinterpret_cast<void*>(Mock_glGetVertexAttribPointerv);
2954   if (strcmp(name, "glGetVertexAttribfv") == 0)
2955     return reinterpret_cast<void*>(Mock_glGetVertexAttribfv);
2956   if (strcmp(name, "glGetVertexAttribiv") == 0)
2957     return reinterpret_cast<void*>(Mock_glGetVertexAttribiv);
2958   if (strcmp(name, "glHint") == 0)
2959     return reinterpret_cast<void*>(Mock_glHint);
2960   if (strcmp(name, "glInsertEventMarkerEXT") == 0)
2961     return reinterpret_cast<void*>(Mock_glInsertEventMarkerEXT);
2962   if (strcmp(name, "glInvalidateFramebuffer") == 0)
2963     return reinterpret_cast<void*>(Mock_glInvalidateFramebuffer);
2964   if (strcmp(name, "glInvalidateSubFramebuffer") == 0)
2965     return reinterpret_cast<void*>(Mock_glInvalidateSubFramebuffer);
2966   if (strcmp(name, "glIsBuffer") == 0)
2967     return reinterpret_cast<void*>(Mock_glIsBuffer);
2968   if (strcmp(name, "glIsEnabled") == 0)
2969     return reinterpret_cast<void*>(Mock_glIsEnabled);
2970   if (strcmp(name, "glIsFenceAPPLE") == 0)
2971     return reinterpret_cast<void*>(Mock_glIsFenceAPPLE);
2972   if (strcmp(name, "glIsFenceNV") == 0)
2973     return reinterpret_cast<void*>(Mock_glIsFenceNV);
2974   if (strcmp(name, "glIsFramebuffer") == 0)
2975     return reinterpret_cast<void*>(Mock_glIsFramebuffer);
2976   if (strcmp(name, "glIsFramebufferEXT") == 0)
2977     return reinterpret_cast<void*>(Mock_glIsFramebufferEXT);
2978   if (strcmp(name, "glIsProgram") == 0)
2979     return reinterpret_cast<void*>(Mock_glIsProgram);
2980   if (strcmp(name, "glIsQuery") == 0)
2981     return reinterpret_cast<void*>(Mock_glIsQuery);
2982   if (strcmp(name, "glIsQueryARB") == 0)
2983     return reinterpret_cast<void*>(Mock_glIsQueryARB);
2984   if (strcmp(name, "glIsQueryEXT") == 0)
2985     return reinterpret_cast<void*>(Mock_glIsQueryEXT);
2986   if (strcmp(name, "glIsRenderbuffer") == 0)
2987     return reinterpret_cast<void*>(Mock_glIsRenderbuffer);
2988   if (strcmp(name, "glIsRenderbufferEXT") == 0)
2989     return reinterpret_cast<void*>(Mock_glIsRenderbufferEXT);
2990   if (strcmp(name, "glIsSampler") == 0)
2991     return reinterpret_cast<void*>(Mock_glIsSampler);
2992   if (strcmp(name, "glIsShader") == 0)
2993     return reinterpret_cast<void*>(Mock_glIsShader);
2994   if (strcmp(name, "glIsSync") == 0)
2995     return reinterpret_cast<void*>(Mock_glIsSync);
2996   if (strcmp(name, "glIsTexture") == 0)
2997     return reinterpret_cast<void*>(Mock_glIsTexture);
2998   if (strcmp(name, "glIsTransformFeedback") == 0)
2999     return reinterpret_cast<void*>(Mock_glIsTransformFeedback);
3000   if (strcmp(name, "glIsVertexArray") == 0)
3001     return reinterpret_cast<void*>(Mock_glIsVertexArray);
3002   if (strcmp(name, "glIsVertexArrayAPPLE") == 0)
3003     return reinterpret_cast<void*>(Mock_glIsVertexArrayAPPLE);
3004   if (strcmp(name, "glIsVertexArrayOES") == 0)
3005     return reinterpret_cast<void*>(Mock_glIsVertexArrayOES);
3006   if (strcmp(name, "glLineWidth") == 0)
3007     return reinterpret_cast<void*>(Mock_glLineWidth);
3008   if (strcmp(name, "glLinkProgram") == 0)
3009     return reinterpret_cast<void*>(Mock_glLinkProgram);
3010   if (strcmp(name, "glMapBuffer") == 0)
3011     return reinterpret_cast<void*>(Mock_glMapBuffer);
3012   if (strcmp(name, "glMapBufferOES") == 0)
3013     return reinterpret_cast<void*>(Mock_glMapBufferOES);
3014   if (strcmp(name, "glMapBufferRange") == 0)
3015     return reinterpret_cast<void*>(Mock_glMapBufferRange);
3016   if (strcmp(name, "glMapBufferRangeEXT") == 0)
3017     return reinterpret_cast<void*>(Mock_glMapBufferRangeEXT);
3018   if (strcmp(name, "glMatrixLoadIdentityEXT") == 0)
3019     return reinterpret_cast<void*>(Mock_glMatrixLoadIdentityEXT);
3020   if (strcmp(name, "glMatrixLoadfEXT") == 0)
3021     return reinterpret_cast<void*>(Mock_glMatrixLoadfEXT);
3022   if (strcmp(name, "glPauseTransformFeedback") == 0)
3023     return reinterpret_cast<void*>(Mock_glPauseTransformFeedback);
3024   if (strcmp(name, "glPixelStorei") == 0)
3025     return reinterpret_cast<void*>(Mock_glPixelStorei);
3026   if (strcmp(name, "glPointParameteri") == 0)
3027     return reinterpret_cast<void*>(Mock_glPointParameteri);
3028   if (strcmp(name, "glPolygonOffset") == 0)
3029     return reinterpret_cast<void*>(Mock_glPolygonOffset);
3030   if (strcmp(name, "glPopGroupMarkerEXT") == 0)
3031     return reinterpret_cast<void*>(Mock_glPopGroupMarkerEXT);
3032   if (strcmp(name, "glProgramBinary") == 0)
3033     return reinterpret_cast<void*>(Mock_glProgramBinary);
3034   if (strcmp(name, "glProgramBinaryOES") == 0)
3035     return reinterpret_cast<void*>(Mock_glProgramBinaryOES);
3036   if (strcmp(name, "glProgramParameteri") == 0)
3037     return reinterpret_cast<void*>(Mock_glProgramParameteri);
3038   if (strcmp(name, "glPushGroupMarkerEXT") == 0)
3039     return reinterpret_cast<void*>(Mock_glPushGroupMarkerEXT);
3040   if (strcmp(name, "glQueryCounter") == 0)
3041     return reinterpret_cast<void*>(Mock_glQueryCounter);
3042   if (strcmp(name, "glQueryCounterEXT") == 0)
3043     return reinterpret_cast<void*>(Mock_glQueryCounterEXT);
3044   if (strcmp(name, "glReadBuffer") == 0)
3045     return reinterpret_cast<void*>(Mock_glReadBuffer);
3046   if (strcmp(name, "glReadPixels") == 0)
3047     return reinterpret_cast<void*>(Mock_glReadPixels);
3048   if (strcmp(name, "glReleaseShaderCompiler") == 0)
3049     return reinterpret_cast<void*>(Mock_glReleaseShaderCompiler);
3050   if (strcmp(name, "glRenderbufferStorage") == 0)
3051     return reinterpret_cast<void*>(Mock_glRenderbufferStorage);
3052   if (strcmp(name, "glRenderbufferStorageEXT") == 0)
3053     return reinterpret_cast<void*>(Mock_glRenderbufferStorageEXT);
3054   if (strcmp(name, "glRenderbufferStorageMultisample") == 0)
3055     return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisample);
3056   if (strcmp(name, "glRenderbufferStorageMultisampleANGLE") == 0)
3057     return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisampleANGLE);
3058   if (strcmp(name, "glRenderbufferStorageMultisampleEXT") == 0)
3059     return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisampleEXT);
3060   if (strcmp(name, "glRenderbufferStorageMultisampleIMG") == 0)
3061     return reinterpret_cast<void*>(Mock_glRenderbufferStorageMultisampleIMG);
3062   if (strcmp(name, "glResumeTransformFeedback") == 0)
3063     return reinterpret_cast<void*>(Mock_glResumeTransformFeedback);
3064   if (strcmp(name, "glSampleCoverage") == 0)
3065     return reinterpret_cast<void*>(Mock_glSampleCoverage);
3066   if (strcmp(name, "glSamplerParameterf") == 0)
3067     return reinterpret_cast<void*>(Mock_glSamplerParameterf);
3068   if (strcmp(name, "glSamplerParameterfv") == 0)
3069     return reinterpret_cast<void*>(Mock_glSamplerParameterfv);
3070   if (strcmp(name, "glSamplerParameteri") == 0)
3071     return reinterpret_cast<void*>(Mock_glSamplerParameteri);
3072   if (strcmp(name, "glSamplerParameteriv") == 0)
3073     return reinterpret_cast<void*>(Mock_glSamplerParameteriv);
3074   if (strcmp(name, "glScissor") == 0)
3075     return reinterpret_cast<void*>(Mock_glScissor);
3076   if (strcmp(name, "glSetFenceAPPLE") == 0)
3077     return reinterpret_cast<void*>(Mock_glSetFenceAPPLE);
3078   if (strcmp(name, "glSetFenceNV") == 0)
3079     return reinterpret_cast<void*>(Mock_glSetFenceNV);
3080   if (strcmp(name, "glShaderBinary") == 0)
3081     return reinterpret_cast<void*>(Mock_glShaderBinary);
3082   if (strcmp(name, "glShaderSource") == 0)
3083     return reinterpret_cast<void*>(Mock_glShaderSource);
3084   if (strcmp(name, "glStencilFunc") == 0)
3085     return reinterpret_cast<void*>(Mock_glStencilFunc);
3086   if (strcmp(name, "glStencilFuncSeparate") == 0)
3087     return reinterpret_cast<void*>(Mock_glStencilFuncSeparate);
3088   if (strcmp(name, "glStencilMask") == 0)
3089     return reinterpret_cast<void*>(Mock_glStencilMask);
3090   if (strcmp(name, "glStencilMaskSeparate") == 0)
3091     return reinterpret_cast<void*>(Mock_glStencilMaskSeparate);
3092   if (strcmp(name, "glStencilOp") == 0)
3093     return reinterpret_cast<void*>(Mock_glStencilOp);
3094   if (strcmp(name, "glStencilOpSeparate") == 0)
3095     return reinterpret_cast<void*>(Mock_glStencilOpSeparate);
3096   if (strcmp(name, "glTestFenceAPPLE") == 0)
3097     return reinterpret_cast<void*>(Mock_glTestFenceAPPLE);
3098   if (strcmp(name, "glTestFenceNV") == 0)
3099     return reinterpret_cast<void*>(Mock_glTestFenceNV);
3100   if (strcmp(name, "glTexImage2D") == 0)
3101     return reinterpret_cast<void*>(Mock_glTexImage2D);
3102   if (strcmp(name, "glTexImage3D") == 0)
3103     return reinterpret_cast<void*>(Mock_glTexImage3D);
3104   if (strcmp(name, "glTexParameterf") == 0)
3105     return reinterpret_cast<void*>(Mock_glTexParameterf);
3106   if (strcmp(name, "glTexParameterfv") == 0)
3107     return reinterpret_cast<void*>(Mock_glTexParameterfv);
3108   if (strcmp(name, "glTexParameteri") == 0)
3109     return reinterpret_cast<void*>(Mock_glTexParameteri);
3110   if (strcmp(name, "glTexParameteriv") == 0)
3111     return reinterpret_cast<void*>(Mock_glTexParameteriv);
3112   if (strcmp(name, "glTexStorage2D") == 0)
3113     return reinterpret_cast<void*>(Mock_glTexStorage2D);
3114   if (strcmp(name, "glTexStorage2DEXT") == 0)
3115     return reinterpret_cast<void*>(Mock_glTexStorage2DEXT);
3116   if (strcmp(name, "glTexStorage3D") == 0)
3117     return reinterpret_cast<void*>(Mock_glTexStorage3D);
3118   if (strcmp(name, "glTexSubImage2D") == 0)
3119     return reinterpret_cast<void*>(Mock_glTexSubImage2D);
3120   if (strcmp(name, "glTransformFeedbackVaryings") == 0)
3121     return reinterpret_cast<void*>(Mock_glTransformFeedbackVaryings);
3122   if (strcmp(name, "glUniform1f") == 0)
3123     return reinterpret_cast<void*>(Mock_glUniform1f);
3124   if (strcmp(name, "glUniform1fv") == 0)
3125     return reinterpret_cast<void*>(Mock_glUniform1fv);
3126   if (strcmp(name, "glUniform1i") == 0)
3127     return reinterpret_cast<void*>(Mock_glUniform1i);
3128   if (strcmp(name, "glUniform1iv") == 0)
3129     return reinterpret_cast<void*>(Mock_glUniform1iv);
3130   if (strcmp(name, "glUniform1ui") == 0)
3131     return reinterpret_cast<void*>(Mock_glUniform1ui);
3132   if (strcmp(name, "glUniform1uiv") == 0)
3133     return reinterpret_cast<void*>(Mock_glUniform1uiv);
3134   if (strcmp(name, "glUniform2f") == 0)
3135     return reinterpret_cast<void*>(Mock_glUniform2f);
3136   if (strcmp(name, "glUniform2fv") == 0)
3137     return reinterpret_cast<void*>(Mock_glUniform2fv);
3138   if (strcmp(name, "glUniform2i") == 0)
3139     return reinterpret_cast<void*>(Mock_glUniform2i);
3140   if (strcmp(name, "glUniform2iv") == 0)
3141     return reinterpret_cast<void*>(Mock_glUniform2iv);
3142   if (strcmp(name, "glUniform2ui") == 0)
3143     return reinterpret_cast<void*>(Mock_glUniform2ui);
3144   if (strcmp(name, "glUniform2uiv") == 0)
3145     return reinterpret_cast<void*>(Mock_glUniform2uiv);
3146   if (strcmp(name, "glUniform3f") == 0)
3147     return reinterpret_cast<void*>(Mock_glUniform3f);
3148   if (strcmp(name, "glUniform3fv") == 0)
3149     return reinterpret_cast<void*>(Mock_glUniform3fv);
3150   if (strcmp(name, "glUniform3i") == 0)
3151     return reinterpret_cast<void*>(Mock_glUniform3i);
3152   if (strcmp(name, "glUniform3iv") == 0)
3153     return reinterpret_cast<void*>(Mock_glUniform3iv);
3154   if (strcmp(name, "glUniform3ui") == 0)
3155     return reinterpret_cast<void*>(Mock_glUniform3ui);
3156   if (strcmp(name, "glUniform3uiv") == 0)
3157     return reinterpret_cast<void*>(Mock_glUniform3uiv);
3158   if (strcmp(name, "glUniform4f") == 0)
3159     return reinterpret_cast<void*>(Mock_glUniform4f);
3160   if (strcmp(name, "glUniform4fv") == 0)
3161     return reinterpret_cast<void*>(Mock_glUniform4fv);
3162   if (strcmp(name, "glUniform4i") == 0)
3163     return reinterpret_cast<void*>(Mock_glUniform4i);
3164   if (strcmp(name, "glUniform4iv") == 0)
3165     return reinterpret_cast<void*>(Mock_glUniform4iv);
3166   if (strcmp(name, "glUniform4ui") == 0)
3167     return reinterpret_cast<void*>(Mock_glUniform4ui);
3168   if (strcmp(name, "glUniform4uiv") == 0)
3169     return reinterpret_cast<void*>(Mock_glUniform4uiv);
3170   if (strcmp(name, "glUniformBlockBinding") == 0)
3171     return reinterpret_cast<void*>(Mock_glUniformBlockBinding);
3172   if (strcmp(name, "glUniformMatrix2fv") == 0)
3173     return reinterpret_cast<void*>(Mock_glUniformMatrix2fv);
3174   if (strcmp(name, "glUniformMatrix2x3fv") == 0)
3175     return reinterpret_cast<void*>(Mock_glUniformMatrix2x3fv);
3176   if (strcmp(name, "glUniformMatrix2x4fv") == 0)
3177     return reinterpret_cast<void*>(Mock_glUniformMatrix2x4fv);
3178   if (strcmp(name, "glUniformMatrix3fv") == 0)
3179     return reinterpret_cast<void*>(Mock_glUniformMatrix3fv);
3180   if (strcmp(name, "glUniformMatrix3x2fv") == 0)
3181     return reinterpret_cast<void*>(Mock_glUniformMatrix3x2fv);
3182   if (strcmp(name, "glUniformMatrix3x4fv") == 0)
3183     return reinterpret_cast<void*>(Mock_glUniformMatrix3x4fv);
3184   if (strcmp(name, "glUniformMatrix4fv") == 0)
3185     return reinterpret_cast<void*>(Mock_glUniformMatrix4fv);
3186   if (strcmp(name, "glUniformMatrix4x2fv") == 0)
3187     return reinterpret_cast<void*>(Mock_glUniformMatrix4x2fv);
3188   if (strcmp(name, "glUniformMatrix4x3fv") == 0)
3189     return reinterpret_cast<void*>(Mock_glUniformMatrix4x3fv);
3190   if (strcmp(name, "glUnmapBuffer") == 0)
3191     return reinterpret_cast<void*>(Mock_glUnmapBuffer);
3192   if (strcmp(name, "glUnmapBufferOES") == 0)
3193     return reinterpret_cast<void*>(Mock_glUnmapBufferOES);
3194   if (strcmp(name, "glUseProgram") == 0)
3195     return reinterpret_cast<void*>(Mock_glUseProgram);
3196   if (strcmp(name, "glValidateProgram") == 0)
3197     return reinterpret_cast<void*>(Mock_glValidateProgram);
3198   if (strcmp(name, "glVertexAttrib1f") == 0)
3199     return reinterpret_cast<void*>(Mock_glVertexAttrib1f);
3200   if (strcmp(name, "glVertexAttrib1fv") == 0)
3201     return reinterpret_cast<void*>(Mock_glVertexAttrib1fv);
3202   if (strcmp(name, "glVertexAttrib2f") == 0)
3203     return reinterpret_cast<void*>(Mock_glVertexAttrib2f);
3204   if (strcmp(name, "glVertexAttrib2fv") == 0)
3205     return reinterpret_cast<void*>(Mock_glVertexAttrib2fv);
3206   if (strcmp(name, "glVertexAttrib3f") == 0)
3207     return reinterpret_cast<void*>(Mock_glVertexAttrib3f);
3208   if (strcmp(name, "glVertexAttrib3fv") == 0)
3209     return reinterpret_cast<void*>(Mock_glVertexAttrib3fv);
3210   if (strcmp(name, "glVertexAttrib4f") == 0)
3211     return reinterpret_cast<void*>(Mock_glVertexAttrib4f);
3212   if (strcmp(name, "glVertexAttrib4fv") == 0)
3213     return reinterpret_cast<void*>(Mock_glVertexAttrib4fv);
3214   if (strcmp(name, "glVertexAttribDivisor") == 0)
3215     return reinterpret_cast<void*>(Mock_glVertexAttribDivisor);
3216   if (strcmp(name, "glVertexAttribDivisorANGLE") == 0)
3217     return reinterpret_cast<void*>(Mock_glVertexAttribDivisorANGLE);
3218   if (strcmp(name, "glVertexAttribDivisorARB") == 0)
3219     return reinterpret_cast<void*>(Mock_glVertexAttribDivisorARB);
3220   if (strcmp(name, "glVertexAttribI4i") == 0)
3221     return reinterpret_cast<void*>(Mock_glVertexAttribI4i);
3222   if (strcmp(name, "glVertexAttribI4iv") == 0)
3223     return reinterpret_cast<void*>(Mock_glVertexAttribI4iv);
3224   if (strcmp(name, "glVertexAttribI4ui") == 0)
3225     return reinterpret_cast<void*>(Mock_glVertexAttribI4ui);
3226   if (strcmp(name, "glVertexAttribI4uiv") == 0)
3227     return reinterpret_cast<void*>(Mock_glVertexAttribI4uiv);
3228   if (strcmp(name, "glVertexAttribIPointer") == 0)
3229     return reinterpret_cast<void*>(Mock_glVertexAttribIPointer);
3230   if (strcmp(name, "glVertexAttribPointer") == 0)
3231     return reinterpret_cast<void*>(Mock_glVertexAttribPointer);
3232   if (strcmp(name, "glViewport") == 0)
3233     return reinterpret_cast<void*>(Mock_glViewport);
3234   if (strcmp(name, "glWaitSync") == 0)
3235     return reinterpret_cast<void*>(Mock_glWaitSync);
3236   return reinterpret_cast<void*>(&MockInvalidFunction);
3237 }
3238
3239 }  // namespace gfx