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