ui/gl/gl_bindings_autogen_mock.cc

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