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