ui/gl/gl_bindings_autogen_mock.cc

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