Refactor GL bindings so there is no global GLApi or DriverGL.

ui/gl/gl_bindings_autogen_gl1.cc

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// This file is auto-generated from
+// ui/gl/generate_bindings.py
+// It's formatted by clang-format using chromium coding style:
+//    clang-format -i -style=chromium filename
+// DO NOT EDIT!
+
+#include <string>
+
+#include "base/trace_event/trace_event.h"
+#include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_context.h"
+#include "ui/gl/gl_enums.h"
+#include "ui/gl/gl_gl_api_implementation.h"
+#include "ui/gl/gl_implementation.h"
+#include "ui/gl/gl_version_info.h"
+
+namespace gl {
+
+void GLApiBase::glActiveTextureFn(GLenum texture) {
+  driver_->fn.glActiveTextureFn(texture);
+}
+
+void GLApiBase::glApplyFramebufferAttachmentCMAAINTELFn(void) {
+  driver_->fn.glApplyFramebufferAttachmentCMAAINTELFn();
+}
+
+void GLApiBase::glAttachShaderFn(GLuint program, GLuint shader) {
+  driver_->fn.glAttachShaderFn(program, shader);
+}
+
+void GLApiBase::glBeginQueryFn(GLenum target, GLuint id) {
+  driver_->fn.glBeginQueryFn(target, id);
+}
+
+void GLApiBase::glBeginTransformFeedbackFn(GLenum primitiveMode) {
+  driver_->fn.glBeginTransformFeedbackFn(primitiveMode);
+}
+
+void GLApiBase::glBindAttribLocationFn(GLuint program,
+                                       GLuint index,
+                                       const char* name) {
+  driver_->fn.glBindAttribLocationFn(program, index, name);
+}
+
+void GLApiBase::glBindBufferFn(GLenum target, GLuint buffer) {
+  driver_->fn.glBindBufferFn(target, buffer);
+}
+
+void GLApiBase::glBindBufferBaseFn(GLenum target, GLuint index, GLuint buffer) {
+  driver_->fn.glBindBufferBaseFn(target, index, buffer);
+}
+
+void GLApiBase::glBindBufferRangeFn(GLenum target,
+                                    GLuint index,
+                                    GLuint buffer,
+                                    GLintptr offset,
+                                    GLsizeiptr size) {
+  driver_->fn.glBindBufferRangeFn(target, index, buffer, offset, size);
+}
+
+void GLApiBase::glBindFragDataLocationFn(GLuint program,
+                                         GLuint colorNumber,
+                                         const char* name) {
+  driver_->fn.glBindFragDataLocationFn(program, colorNumber, name);
+}
+
+void GLApiBase::glBindFragDataLocationIndexedFn(GLuint program,
+                                                GLuint colorNumber,
+                                                GLuint index,
+                                                const char* name) {
+  driver_->fn.glBindFragDataLocationIndexedFn(program, colorNumber, index,
+                                              name);
+}
+
+void GLApiBase::glBindFramebufferEXTFn(GLenum target, GLuint framebuffer) {
+  driver_->fn.glBindFramebufferEXTFn(target, framebuffer);
+}
+
+void GLApiBase::glBindImageTextureEXTFn(GLuint index,
+                                        GLuint texture,
+                                        GLint level,
+                                        GLboolean layered,
+                                        GLint layer,
+                                        GLenum access,
+                                        GLint format) {
+  driver_->fn.glBindImageTextureEXTFn(index, texture, level, layered, layer,
+                                      access, format);
+}
+
+void GLApiBase::glBindRenderbufferEXTFn(GLenum target, GLuint renderbuffer) {
+  driver_->fn.glBindRenderbufferEXTFn(target, renderbuffer);
+}
+
+void GLApiBase::glBindSamplerFn(GLuint unit, GLuint sampler) {
+  driver_->fn.glBindSamplerFn(unit, sampler);
+}
+
+void GLApiBase::glBindTextureFn(GLenum target, GLuint texture) {
+  driver_->fn.glBindTextureFn(target, texture);
+}
+
+void GLApiBase::glBindTransformFeedbackFn(GLenum target, GLuint id) {
+  driver_->fn.glBindTransformFeedbackFn(target, id);
+}
+
+void GLApiBase::glBindUniformLocationCHROMIUMFn(GLuint program,
+                                                GLint location,
+                                                const char* name) {
+  driver_->fn.glBindUniformLocationCHROMIUMFn(program, location, name);
+}
+
+void GLApiBase::glBindVertexArrayOESFn(GLuint array) {
+  driver_->fn.glBindVertexArrayOESFn(array);
+}
+
+void GLApiBase::glBlendBarrierKHRFn(void) {
+  driver_->fn.glBlendBarrierKHRFn();
+}
+
+void GLApiBase::glBlendColorFn(GLclampf red,
+                               GLclampf green,
+                               GLclampf blue,
+                               GLclampf alpha) {
+  driver_->fn.glBlendColorFn(red, green, blue, alpha);
+}
+
+void GLApiBase::glBlendEquationFn(GLenum mode) {
+  driver_->fn.glBlendEquationFn(mode);
+}
+
+void GLApiBase::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) {
+  driver_->fn.glBlendEquationSeparateFn(modeRGB, modeAlpha);
+}
+
+void GLApiBase::glBlendFuncFn(GLenum sfactor, GLenum dfactor) {
+  driver_->fn.glBlendFuncFn(sfactor, dfactor);
+}
+
+void GLApiBase::glBlendFuncSeparateFn(GLenum srcRGB,
+                                      GLenum dstRGB,
+                                      GLenum srcAlpha,
+                                      GLenum dstAlpha) {
+  driver_->fn.glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+void GLApiBase::glBlitFramebufferFn(GLint srcX0,
+                                    GLint srcY0,
+                                    GLint srcX1,
+                                    GLint srcY1,
+                                    GLint dstX0,
+                                    GLint dstY0,
+                                    GLint dstX1,
+                                    GLint dstY1,
+                                    GLbitfield mask,
+                                    GLenum filter) {
+  driver_->fn.glBlitFramebufferFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+                                  dstX1, dstY1, mask, filter);
+}
+
+void GLApiBase::glBlitFramebufferANGLEFn(GLint srcX0,
+                                         GLint srcY0,
+                                         GLint srcX1,
+                                         GLint srcY1,
+                                         GLint dstX0,
+                                         GLint dstY0,
+                                         GLint dstX1,
+                                         GLint dstY1,
+                                         GLbitfield mask,
+                                         GLenum filter) {
+  driver_->fn.glBlitFramebufferANGLEFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+                                       dstX1, dstY1, mask, filter);
+}
+
+void GLApiBase::glBlitFramebufferEXTFn(GLint srcX0,
+                                       GLint srcY0,
+                                       GLint srcX1,
+                                       GLint srcY1,
+                                       GLint dstX0,
+                                       GLint dstY0,
+                                       GLint dstX1,
+                                       GLint dstY1,
+                                       GLbitfield mask,
+                                       GLenum filter) {
+  driver_->fn.glBlitFramebufferEXTFn(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
+                                     dstX1, dstY1, mask, filter);
+}
+
+void GLApiBase::glBufferDataFn(GLenum target,
+                               GLsizeiptr size,
+                               const void* data,
+                               GLenum usage) {
+  driver_->fn.glBufferDataFn(target, size, data, usage);
+}
+
+void GLApiBase::glBufferSubDataFn(GLenum target,
+                                  GLintptr offset,
+                                  GLsizeiptr size,
+                                  const void* data) {
+  driver_->fn.glBufferSubDataFn(target, offset, size, data);
+}
+
+GLenum GLApiBase::glCheckFramebufferStatusEXTFn(GLenum target) {
+  return driver_->fn.glCheckFramebufferStatusEXTFn(target);
+}
+
+void GLApiBase::glClearFn(GLbitfield mask) {
+  driver_->fn.glClearFn(mask);
+}
+
+void GLApiBase::glClearBufferfiFn(GLenum buffer,
+                                  GLint drawbuffer,
+                                  const GLfloat depth,
+                                  GLint stencil) {
+  driver_->fn.glClearBufferfiFn(buffer, drawbuffer, depth, stencil);
+}
+
+void GLApiBase::glClearBufferfvFn(GLenum buffer,
+                                  GLint drawbuffer,
+                                  const GLfloat* value) {
+  driver_->fn.glClearBufferfvFn(buffer, drawbuffer, value);
+}
+
+void GLApiBase::glClearBufferivFn(GLenum buffer,
+                                  GLint drawbuffer,
+                                  const GLint* value) {
+  driver_->fn.glClearBufferivFn(buffer, drawbuffer, value);
+}
+
+void GLApiBase::glClearBufferuivFn(GLenum buffer,
+                                   GLint drawbuffer,
+                                   const GLuint* value) {
+  driver_->fn.glClearBufferuivFn(buffer, drawbuffer, value);
+}
+
+void GLApiBase::glClearColorFn(GLclampf red,
+                               GLclampf green,
+                               GLclampf blue,
+                               GLclampf alpha) {
+  driver_->fn.glClearColorFn(red, green, blue, alpha);
+}
+
+void GLApiBase::glClearDepthFn(GLclampd depth) {
+  driver_->fn.glClearDepthFn(depth);
+}
+
+void GLApiBase::glClearDepthfFn(GLclampf depth) {
+  driver_->fn.glClearDepthfFn(depth);
+}
+
+void GLApiBase::glClearStencilFn(GLint s) {
+  driver_->fn.glClearStencilFn(s);
+}
+
+GLenum GLApiBase::glClientWaitSyncFn(GLsync sync,
+                                     GLbitfield flags,
+                                     GLuint64 timeout) {
+  return driver_->fn.glClientWaitSyncFn(sync, flags, timeout);
+}
+
+void GLApiBase::glColorMaskFn(GLboolean red,
+                              GLboolean green,
+                              GLboolean blue,
+                              GLboolean alpha) {
+  driver_->fn.glColorMaskFn(red, green, blue, alpha);
+}
+
+void GLApiBase::glCompileShaderFn(GLuint shader) {
+  driver_->fn.glCompileShaderFn(shader);
+}
+
+void GLApiBase::glCompressedCopyTextureCHROMIUMFn(GLuint sourceId,
+                                                  GLuint destId) {
+  driver_->fn.glCompressedCopyTextureCHROMIUMFn(sourceId, destId);
+}
+
+void GLApiBase::glCompressedTexImage2DFn(GLenum target,
+                                         GLint level,
+                                         GLenum internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLint border,
+                                         GLsizei imageSize,
+                                         const void* data) {
+  driver_->fn.glCompressedTexImage2DFn(target, level, internalformat, width,
+                                       height, border, imageSize, data);
+}
+
+void GLApiBase::glCompressedTexImage3DFn(GLenum target,
+                                         GLint level,
+                                         GLenum internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLsizei depth,
+                                         GLint border,
+                                         GLsizei imageSize,
+                                         const void* data) {
+  driver_->fn.glCompressedTexImage3DFn(target, level, internalformat, width,
+                                       height, depth, border, imageSize, data);
+}
+
+void GLApiBase::glCompressedTexSubImage2DFn(GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLsizei imageSize,
+                                            const void* data) {
+  driver_->fn.glCompressedTexSubImage2DFn(
+      target, level, xoffset, yoffset, width, height, format, imageSize, data);
+}
+
+void GLApiBase::glCompressedTexSubImage3DFn(GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLint zoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLenum format,
+                                            GLsizei imageSize,
+                                            const void* data) {
+  driver_->fn.glCompressedTexSubImage3DFn(target, level, xoffset, yoffset,
+                                          zoffset, width, height, depth, format,
+                                          imageSize, data);
+}
+
+void GLApiBase::glCopyBufferSubDataFn(GLenum readTarget,
+                                      GLenum writeTarget,
+                                      GLintptr readOffset,
+                                      GLintptr writeOffset,
+                                      GLsizeiptr size) {
+  driver_->fn.glCopyBufferSubDataFn(readTarget, writeTarget, readOffset,
+                                    writeOffset, size);
+}
+
+void GLApiBase::glCopySubTextureCHROMIUMFn(GLuint sourceId,
+                                           GLuint destId,
+                                           GLint xoffset,
+                                           GLint yoffset,
+                                           GLint x,
+                                           GLint y,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLboolean unpackFlipY,
+                                           GLboolean unpackPremultiplyAlpha,
+                                           GLboolean unpackUnmultiplyAlpha) {
+  driver_->fn.glCopySubTextureCHROMIUMFn(
+      sourceId, destId, xoffset, yoffset, x, y, width, height, unpackFlipY,
+      unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+void GLApiBase::glCopyTexImage2DFn(GLenum target,
+                                   GLint level,
+                                   GLenum internalformat,
+                                   GLint x,
+                                   GLint y,
+                                   GLsizei width,
+                                   GLsizei height,
+                                   GLint border) {
+  driver_->fn.glCopyTexImage2DFn(target, level, internalformat, x, y, width,
+                                 height, border);
+}
+
+void GLApiBase::glCopyTexSubImage2DFn(GLenum target,
+                                      GLint level,
+                                      GLint xoffset,
+                                      GLint yoffset,
+                                      GLint x,
+                                      GLint y,
+                                      GLsizei width,
+                                      GLsizei height) {
+  driver_->fn.glCopyTexSubImage2DFn(target, level, xoffset, yoffset, x, y,
+                                    width, height);
+}
+
+void GLApiBase::glCopyTexSubImage3DFn(GLenum target,
+                                      GLint level,
+                                      GLint xoffset,
+                                      GLint yoffset,
+                                      GLint zoffset,
+                                      GLint x,
+                                      GLint y,
+                                      GLsizei width,
+                                      GLsizei height) {
+  driver_->fn.glCopyTexSubImage3DFn(target, level, xoffset, yoffset, zoffset, x,
+                                    y, width, height);
+}
+
+void GLApiBase::glCopyTextureCHROMIUMFn(GLuint sourceId,
+                                        GLuint destId,
+                                        GLint internalFormat,
+                                        GLenum destType,
+                                        GLboolean unpackFlipY,
+                                        GLboolean unpackPremultiplyAlpha,
+                                        GLboolean unpackUnmultiplyAlpha) {
+  driver_->fn.glCopyTextureCHROMIUMFn(
+      sourceId, destId, internalFormat, destType, unpackFlipY,
+      unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
+}
+
+void GLApiBase::glCoverageModulationNVFn(GLenum components) {
+  driver_->fn.glCoverageModulationNVFn(components);
+}
+
+void GLApiBase::glCoverFillPathInstancedNVFn(GLsizei numPaths,
+                                             GLenum pathNameType,
+                                             const void* paths,
+                                             GLuint pathBase,
+                                             GLenum coverMode,
+                                             GLenum transformType,
+                                             const GLfloat* transformValues) {
+  driver_->fn.glCoverFillPathInstancedNVFn(numPaths, pathNameType, paths,
+                                           pathBase, coverMode, transformType,
+                                           transformValues);
+}
+
+void GLApiBase::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
+  driver_->fn.glCoverFillPathNVFn(path, coverMode);
+}
+
+void GLApiBase::glCoverStrokePathInstancedNVFn(GLsizei numPaths,
+                                               GLenum pathNameType,
+                                               const void* paths,
+                                               GLuint pathBase,
+                                               GLenum coverMode,
+                                               GLenum transformType,
+                                               const GLfloat* transformValues) {
+  driver_->fn.glCoverStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+                                             pathBase, coverMode, transformType,
+                                             transformValues);
+}
+
+void GLApiBase::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
+  driver_->fn.glCoverStrokePathNVFn(name, coverMode);
+}
+
+GLuint GLApiBase::glCreateProgramFn(void) {
+  return driver_->fn.glCreateProgramFn();
+}
+
+GLuint GLApiBase::glCreateShaderFn(GLenum type) {
+  return driver_->fn.glCreateShaderFn(type);
+}
+
+void GLApiBase::glCullFaceFn(GLenum mode) {
+  driver_->fn.glCullFaceFn(mode);
+}
+
+void GLApiBase::glDebugMessageCallbackFn(GLDEBUGPROC callback,
+                                         const void* userParam) {
+  driver_->fn.glDebugMessageCallbackFn(callback, userParam);
+}
+
+void GLApiBase::glDebugMessageControlFn(GLenum source,
+                                        GLenum type,
+                                        GLenum severity,
+                                        GLsizei count,
+                                        const GLuint* ids,
+                                        GLboolean enabled) {
+  driver_->fn.glDebugMessageControlFn(source, type, severity, count, ids,
+                                      enabled);
+}
+
+void GLApiBase::glDebugMessageInsertFn(GLenum source,
+                                       GLenum type,
+                                       GLuint id,
+                                       GLenum severity,
+                                       GLsizei length,
+                                       const char* buf) {
+  driver_->fn.glDebugMessageInsertFn(source, type, id, severity, length, buf);
+}
+
+void GLApiBase::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) {
+  driver_->fn.glDeleteBuffersARBFn(n, buffers);
+}
+
+void GLApiBase::glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) {
+  driver_->fn.glDeleteFencesAPPLEFn(n, fences);
+}
+
+void GLApiBase::glDeleteFencesNVFn(GLsizei n, const GLuint* fences) {
+  driver_->fn.glDeleteFencesNVFn(n, fences);
+}
+
+void GLApiBase::glDeleteFramebuffersEXTFn(GLsizei n,
+                                          const GLuint* framebuffers) {
+  driver_->fn.glDeleteFramebuffersEXTFn(n, framebuffers);
+}
+
+void GLApiBase::glDeletePathsNVFn(GLuint path, GLsizei range) {
+  driver_->fn.glDeletePathsNVFn(path, range);
+}
+
+void GLApiBase::glDeleteProgramFn(GLuint program) {
+  driver_->fn.glDeleteProgramFn(program);
+}
+
+void GLApiBase::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
+  driver_->fn.glDeleteQueriesFn(n, ids);
+}
+
+void GLApiBase::glDeleteRenderbuffersEXTFn(GLsizei n,
+                                           const GLuint* renderbuffers) {
+  driver_->fn.glDeleteRenderbuffersEXTFn(n, renderbuffers);
+}
+
+void GLApiBase::glDeleteSamplersFn(GLsizei n, const GLuint* samplers) {
+  driver_->fn.glDeleteSamplersFn(n, samplers);
+}
+
+void GLApiBase::glDeleteShaderFn(GLuint shader) {
+  driver_->fn.glDeleteShaderFn(shader);
+}
+
+void GLApiBase::glDeleteSyncFn(GLsync sync) {
+  driver_->fn.glDeleteSyncFn(sync);
+}
+
+void GLApiBase::glDeleteTexturesFn(GLsizei n, const GLuint* textures) {
+  driver_->fn.glDeleteTexturesFn(n, textures);
+}
+
+void GLApiBase::glDeleteTransformFeedbacksFn(GLsizei n, const GLuint* ids) {
+  driver_->fn.glDeleteTransformFeedbacksFn(n, ids);
+}
+
+void GLApiBase::glDeleteVertexArraysOESFn(GLsizei n, const GLuint* arrays) {
+  driver_->fn.glDeleteVertexArraysOESFn(n, arrays);
+}
+
+void GLApiBase::glDepthFuncFn(GLenum func) {
+  driver_->fn.glDepthFuncFn(func);
+}
+
+void GLApiBase::glDepthMaskFn(GLboolean flag) {
+  driver_->fn.glDepthMaskFn(flag);
+}
+
+void GLApiBase::glDepthRangeFn(GLclampd zNear, GLclampd zFar) {
+  driver_->fn.glDepthRangeFn(zNear, zFar);
+}
+
+void GLApiBase::glDepthRangefFn(GLclampf zNear, GLclampf zFar) {
+  driver_->fn.glDepthRangefFn(zNear, zFar);
+}
+
+void GLApiBase::glDetachShaderFn(GLuint program, GLuint shader) {
+  driver_->fn.glDetachShaderFn(program, shader);
+}
+
+void GLApiBase::glDisableFn(GLenum cap) {
+  driver_->fn.glDisableFn(cap);
+}
+
+void GLApiBase::glDisableVertexAttribArrayFn(GLuint index) {
+  driver_->fn.glDisableVertexAttribArrayFn(index);
+}
+
+void GLApiBase::glDiscardFramebufferEXTFn(GLenum target,
+                                          GLsizei numAttachments,
+                                          const GLenum* attachments) {
+  driver_->fn.glDiscardFramebufferEXTFn(target, numAttachments, attachments);
+}
+
+void GLApiBase::glDrawArraysFn(GLenum mode, GLint first, GLsizei count) {
+  driver_->fn.glDrawArraysFn(mode, first, count);
+}
+
+void GLApiBase::glDrawArraysInstancedANGLEFn(GLenum mode,
+                                             GLint first,
+                                             GLsizei count,
+                                             GLsizei primcount) {
+  driver_->fn.glDrawArraysInstancedANGLEFn(mode, first, count, primcount);
+}
+
+void GLApiBase::glDrawBufferFn(GLenum mode) {
+  driver_->fn.glDrawBufferFn(mode);
+}
+
+void GLApiBase::glDrawBuffersARBFn(GLsizei n, const GLenum* bufs) {
+  driver_->fn.glDrawBuffersARBFn(n, bufs);
+}
+
+void GLApiBase::glDrawElementsFn(GLenum mode,
+                                 GLsizei count,
+                                 GLenum type,
+                                 const void* indices) {
+  driver_->fn.glDrawElementsFn(mode, count, type, indices);
+}
+
+void GLApiBase::glDrawElementsInstancedANGLEFn(GLenum mode,
+                                               GLsizei count,
+                                               GLenum type,
+                                               const void* indices,
+                                               GLsizei primcount) {
+  driver_->fn.glDrawElementsInstancedANGLEFn(mode, count, type, indices,
+                                             primcount);
+}
+
+void GLApiBase::glDrawRangeElementsFn(GLenum mode,
+                                      GLuint start,
+                                      GLuint end,
+                                      GLsizei count,
+                                      GLenum type,
+                                      const void* indices) {
+  driver_->fn.glDrawRangeElementsFn(mode, start, end, count, type, indices);
+}
+
+void GLApiBase::glEGLImageTargetRenderbufferStorageOESFn(GLenum target,
+                                                         GLeglImageOES image) {
+  driver_->fn.glEGLImageTargetRenderbufferStorageOESFn(target, image);
+}
+
+void GLApiBase::glEGLImageTargetTexture2DOESFn(GLenum target,
+                                               GLeglImageOES image) {
+  driver_->fn.glEGLImageTargetTexture2DOESFn(target, image);
+}
+
+void GLApiBase::glEnableFn(GLenum cap) {
+  driver_->fn.glEnableFn(cap);
+}
+
+void GLApiBase::glEnableVertexAttribArrayFn(GLuint index) {
+  driver_->fn.glEnableVertexAttribArrayFn(index);
+}
+
+void GLApiBase::glEndQueryFn(GLenum target) {
+  driver_->fn.glEndQueryFn(target);
+}
+
+void GLApiBase::glEndTransformFeedbackFn(void) {
+  driver_->fn.glEndTransformFeedbackFn();
+}
+
+GLsync GLApiBase::glFenceSyncFn(GLenum condition, GLbitfield flags) {
+  return driver_->fn.glFenceSyncFn(condition, flags);
+}
+
+void GLApiBase::glFinishFn(void) {
+  driver_->fn.glFinishFn();
+}
+
+void GLApiBase::glFinishFenceAPPLEFn(GLuint fence) {
+  driver_->fn.glFinishFenceAPPLEFn(fence);
+}
+
+void GLApiBase::glFinishFenceNVFn(GLuint fence) {
+  driver_->fn.glFinishFenceNVFn(fence);
+}
+
+void GLApiBase::glFlushFn(void) {
+  driver_->fn.glFlushFn();
+}
+
+void GLApiBase::glFlushMappedBufferRangeFn(GLenum target,
+                                           GLintptr offset,
+                                           GLsizeiptr length) {
+  driver_->fn.glFlushMappedBufferRangeFn(target, offset, length);
+}
+
+void GLApiBase::glFramebufferRenderbufferEXTFn(GLenum target,
+                                               GLenum attachment,
+                                               GLenum renderbuffertarget,
+                                               GLuint renderbuffer) {
+  driver_->fn.glFramebufferRenderbufferEXTFn(target, attachment,
+                                             renderbuffertarget, renderbuffer);
+}
+
+void GLApiBase::glFramebufferTexture2DEXTFn(GLenum target,
+                                            GLenum attachment,
+                                            GLenum textarget,
+                                            GLuint texture,
+                                            GLint level) {
+  driver_->fn.glFramebufferTexture2DEXTFn(target, attachment, textarget,
+                                          texture, level);
+}
+
+void GLApiBase::glFramebufferTexture2DMultisampleEXTFn(GLenum target,
+                                                       GLenum attachment,
+                                                       GLenum textarget,
+                                                       GLuint texture,
+                                                       GLint level,
+                                                       GLsizei samples) {
+  driver_->fn.glFramebufferTexture2DMultisampleEXTFn(
+      target, attachment, textarget, texture, level, samples);
+}
+
+void GLApiBase::glFramebufferTexture2DMultisampleIMGFn(GLenum target,
+                                                       GLenum attachment,
+                                                       GLenum textarget,
+                                                       GLuint texture,
+                                                       GLint level,
+                                                       GLsizei samples) {
+  driver_->fn.glFramebufferTexture2DMultisampleIMGFn(
+      target, attachment, textarget, texture, level, samples);
+}
+
+void GLApiBase::glFramebufferTextureLayerFn(GLenum target,
+                                            GLenum attachment,
+                                            GLuint texture,
+                                            GLint level,
+                                            GLint layer) {
+  driver_->fn.glFramebufferTextureLayerFn(target, attachment, texture, level,
+                                          layer);
+}
+
+void GLApiBase::glFrontFaceFn(GLenum mode) {
+  driver_->fn.glFrontFaceFn(mode);
+}
+
+void GLApiBase::glGenBuffersARBFn(GLsizei n, GLuint* buffers) {
+  driver_->fn.glGenBuffersARBFn(n, buffers);
+}
+
+void GLApiBase::glGenerateMipmapEXTFn(GLenum target) {
+  driver_->fn.glGenerateMipmapEXTFn(target);
+}
+
+void GLApiBase::glGenFencesAPPLEFn(GLsizei n, GLuint* fences) {
+  driver_->fn.glGenFencesAPPLEFn(n, fences);
+}
+
+void GLApiBase::glGenFencesNVFn(GLsizei n, GLuint* fences) {
+  driver_->fn.glGenFencesNVFn(n, fences);
+}
+
+void GLApiBase::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
+  driver_->fn.glGenFramebuffersEXTFn(n, framebuffers);
+}
+
+GLuint GLApiBase::glGenPathsNVFn(GLsizei range) {
+  return driver_->fn.glGenPathsNVFn(range);
+}
+
+void GLApiBase::glGenQueriesFn(GLsizei n, GLuint* ids) {
+  driver_->fn.glGenQueriesFn(n, ids);
+}
+
+void GLApiBase::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
+  driver_->fn.glGenRenderbuffersEXTFn(n, renderbuffers);
+}
+
+void GLApiBase::glGenSamplersFn(GLsizei n, GLuint* samplers) {
+  driver_->fn.glGenSamplersFn(n, samplers);
+}
+
+void GLApiBase::glGenTexturesFn(GLsizei n, GLuint* textures) {
+  driver_->fn.glGenTexturesFn(n, textures);
+}
+
+void GLApiBase::glGenTransformFeedbacksFn(GLsizei n, GLuint* ids) {
+  driver_->fn.glGenTransformFeedbacksFn(n, ids);
+}
+
+void GLApiBase::glGenVertexArraysOESFn(GLsizei n, GLuint* arrays) {
+  driver_->fn.glGenVertexArraysOESFn(n, arrays);
+}
+
+void GLApiBase::glGetActiveAttribFn(GLuint program,
+                                    GLuint index,
+                                    GLsizei bufsize,
+                                    GLsizei* length,
+                                    GLint* size,
+                                    GLenum* type,
+                                    char* name) {
+  driver_->fn.glGetActiveAttribFn(program, index, bufsize, length, size, type,
+                                  name);
+}
+
+void GLApiBase::glGetActiveUniformFn(GLuint program,
+                                     GLuint index,
+                                     GLsizei bufsize,
+                                     GLsizei* length,
+                                     GLint* size,
+                                     GLenum* type,
+                                     char* name) {
+  driver_->fn.glGetActiveUniformFn(program, index, bufsize, length, size, type,
+                                   name);
+}
+
+void GLApiBase::glGetActiveUniformBlockivFn(GLuint program,
+                                            GLuint uniformBlockIndex,
+                                            GLenum pname,
+                                            GLint* params) {
+  driver_->fn.glGetActiveUniformBlockivFn(program, uniformBlockIndex, pname,
+                                          params);
+}
+
+void GLApiBase::glGetActiveUniformBlockivRobustANGLEFn(GLuint program,
+                                                       GLuint uniformBlockIndex,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       GLint* params) {
+  driver_->fn.glGetActiveUniformBlockivRobustANGLEFn(
+      program, uniformBlockIndex, pname, bufSize, length, params);
+}
+
+void GLApiBase::glGetActiveUniformBlockNameFn(GLuint program,
+                                              GLuint uniformBlockIndex,
+                                              GLsizei bufSize,
+                                              GLsizei* length,
+                                              char* uniformBlockName) {
+  driver_->fn.glGetActiveUniformBlockNameFn(program, uniformBlockIndex, bufSize,
+                                            length, uniformBlockName);
+}
+
+void GLApiBase::glGetActiveUniformsivFn(GLuint program,
+                                        GLsizei uniformCount,
+                                        const GLuint* uniformIndices,
+                                        GLenum pname,
+                                        GLint* params) {
+  driver_->fn.glGetActiveUniformsivFn(program, uniformCount, uniformIndices,
+                                      pname, params);
+}
+
+void GLApiBase::glGetAttachedShadersFn(GLuint program,
+                                       GLsizei maxcount,
+                                       GLsizei* count,
+                                       GLuint* shaders) {
+  driver_->fn.glGetAttachedShadersFn(program, maxcount, count, shaders);
+}
+
+GLint GLApiBase::glGetAttribLocationFn(GLuint program, const char* name) {
+  return driver_->fn.glGetAttribLocationFn(program, name);
+}
+
+void GLApiBase::glGetBooleani_vRobustANGLEFn(GLenum target,
+                                             GLuint index,
+                                             GLsizei bufSize,
+                                             GLsizei* length,
+                                             GLboolean* data) {
+  driver_->fn.glGetBooleani_vRobustANGLEFn(target, index, bufSize, length,
+                                           data);
+}
+
+void GLApiBase::glGetBooleanvFn(GLenum pname, GLboolean* params) {
+  driver_->fn.glGetBooleanvFn(pname, params);
+}
+
+void GLApiBase::glGetBooleanvRobustANGLEFn(GLenum pname,
+                                           GLsizei bufSize,
+                                           GLsizei* length,
+                                           GLboolean* data) {
+  driver_->fn.glGetBooleanvRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void GLApiBase::glGetBufferParameteri64vRobustANGLEFn(GLenum target,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      GLint64* params) {
+  driver_->fn.glGetBufferParameteri64vRobustANGLEFn(target, pname, bufSize,
+                                                    length, params);
+}
+
+void GLApiBase::glGetBufferParameterivFn(GLenum target,
+                                         GLenum pname,
+                                         GLint* params) {
+  driver_->fn.glGetBufferParameterivFn(target, pname, params);
+}
+
+void GLApiBase::glGetBufferParameterivRobustANGLEFn(GLenum target,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    GLsizei* length,
+                                                    GLint* params) {
+  driver_->fn.glGetBufferParameterivRobustANGLEFn(target, pname, bufSize,
+                                                  length, params);
+}
+
+void GLApiBase::glGetBufferPointervRobustANGLEFn(GLenum target,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 void** params) {
+  driver_->fn.glGetBufferPointervRobustANGLEFn(target, pname, bufSize, length,
+                                               params);
+}
+
+void GLApiBase::glGetDebugMessageLogFn(GLuint count,
+                                       GLsizei bufSize,
+                                       GLenum* sources,
+                                       GLenum* types,
+                                       GLuint* ids,
+                                       GLenum* severities,
+                                       GLsizei* lengths,
+                                       char* messageLog) {
+  driver_->fn.glGetDebugMessageLogFn(count, bufSize, sources, types, ids,
+                                     severities, lengths, messageLog);
+}
+
+GLenum GLApiBase::glGetErrorFn(void) {
+  return driver_->fn.glGetErrorFn();
+}
+
+void GLApiBase::glGetFenceivNVFn(GLuint fence, GLenum pname, GLint* params) {
+  driver_->fn.glGetFenceivNVFn(fence, pname, params);
+}
+
+void GLApiBase::glGetFloatvFn(GLenum pname, GLfloat* params) {
+  driver_->fn.glGetFloatvFn(pname, params);
+}
+
+void GLApiBase::glGetFloatvRobustANGLEFn(GLenum pname,
+                                         GLsizei bufSize,
+                                         GLsizei* length,
+                                         GLfloat* data) {
+  driver_->fn.glGetFloatvRobustANGLEFn(pname, bufSize, length, data);
+}
+
+GLint GLApiBase::glGetFragDataIndexFn(GLuint program, const char* name) {
+  return driver_->fn.glGetFragDataIndexFn(program, name);
+}
+
+GLint GLApiBase::glGetFragDataLocationFn(GLuint program, const char* name) {
+  return driver_->fn.glGetFragDataLocationFn(program, name);
+}
+
+void GLApiBase::glGetFramebufferAttachmentParameterivEXTFn(GLenum target,
+                                                           GLenum attachment,
+                                                           GLenum pname,
+                                                           GLint* params) {
+  driver_->fn.glGetFramebufferAttachmentParameterivEXTFn(target, attachment,
+                                                         pname, params);
+}
+
+void GLApiBase::glGetFramebufferAttachmentParameterivRobustANGLEFn(
+    GLenum target,
+    GLenum attachment,
+    GLenum pname,
+    GLsizei bufSize,
+    GLsizei* length,
+    GLint* params) {
+  driver_->fn.glGetFramebufferAttachmentParameterivRobustANGLEFn(
+      target, attachment, pname, bufSize, length, params);
+}
+
+void GLApiBase::glGetFramebufferParameterivRobustANGLEFn(GLenum target,
+                                                         GLenum pname,
+                                                         GLsizei bufSize,
+                                                         GLsizei* length,
+                                                         GLint* params) {
+  driver_->fn.glGetFramebufferParameterivRobustANGLEFn(target, pname, bufSize,
+                                                       length, params);
+}
+
+GLenum GLApiBase::glGetGraphicsResetStatusARBFn(void) {
+  return driver_->fn.glGetGraphicsResetStatusARBFn();
+}
+
+void GLApiBase::glGetInteger64i_vFn(GLenum target,
+                                    GLuint index,
+                                    GLint64* data) {
+  driver_->fn.glGetInteger64i_vFn(target, index, data);
+}
+
+void GLApiBase::glGetInteger64i_vRobustANGLEFn(GLenum target,
+                                               GLuint index,
+                                               GLsizei bufSize,
+                                               GLsizei* length,
+                                               GLint64* data) {
+  driver_->fn.glGetInteger64i_vRobustANGLEFn(target, index, bufSize, length,
+                                             data);
+}
+
+void GLApiBase::glGetInteger64vFn(GLenum pname, GLint64* params) {
+  driver_->fn.glGetInteger64vFn(pname, params);
+}
+
+void GLApiBase::glGetInteger64vRobustANGLEFn(GLenum pname,
+                                             GLsizei bufSize,
+                                             GLsizei* length,
+                                             GLint64* data) {
+  driver_->fn.glGetInteger64vRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void GLApiBase::glGetIntegeri_vFn(GLenum target, GLuint index, GLint* data) {
+  driver_->fn.glGetIntegeri_vFn(target, index, data);
+}
+
+void GLApiBase::glGetIntegeri_vRobustANGLEFn(GLenum target,
+                                             GLuint index,
+                                             GLsizei bufSize,
+                                             GLsizei* length,
+                                             GLint* data) {
+  driver_->fn.glGetIntegeri_vRobustANGLEFn(target, index, bufSize, length,
+                                           data);
+}
+
+void GLApiBase::glGetIntegervFn(GLenum pname, GLint* params) {
+  driver_->fn.glGetIntegervFn(pname, params);
+}
+
+void GLApiBase::glGetIntegervRobustANGLEFn(GLenum pname,
+                                           GLsizei bufSize,
+                                           GLsizei* length,
+                                           GLint* data) {
+  driver_->fn.glGetIntegervRobustANGLEFn(pname, bufSize, length, data);
+}
+
+void GLApiBase::glGetInternalformativFn(GLenum target,
+                                        GLenum internalformat,
+                                        GLenum pname,
+                                        GLsizei bufSize,
+                                        GLint* params) {
+  driver_->fn.glGetInternalformativFn(target, internalformat, pname, bufSize,
+                                      params);
+}
+
+void GLApiBase::glGetInternalformativRobustANGLEFn(GLenum target,
+                                                   GLenum internalformat,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei* length,
+                                                   GLint* params) {
+  driver_->fn.glGetInternalformativRobustANGLEFn(target, internalformat, pname,
+                                                 bufSize, length, params);
+}
+
+void GLApiBase::glGetMultisamplefvRobustANGLEFn(GLenum pname,
+                                                GLuint index,
+                                                GLsizei bufSize,
+                                                GLsizei* length,
+                                                GLfloat* val) {
+  driver_->fn.glGetMultisamplefvRobustANGLEFn(pname, index, bufSize, length,
+                                              val);
+}
+
+void GLApiBase::glGetnUniformfvRobustANGLEFn(GLuint program,
+                                             GLint location,
+                                             GLsizei bufSize,
+                                             GLsizei* length,
+                                             GLfloat* params) {
+  driver_->fn.glGetnUniformfvRobustANGLEFn(program, location, bufSize, length,
+                                           params);
+}
+
+void GLApiBase::glGetnUniformivRobustANGLEFn(GLuint program,
+                                             GLint location,
+                                             GLsizei bufSize,
+                                             GLsizei* length,
+                                             GLint* params) {
+  driver_->fn.glGetnUniformivRobustANGLEFn(program, location, bufSize, length,
+                                           params);
+}
+
+void GLApiBase::glGetnUniformuivRobustANGLEFn(GLuint program,
+                                              GLint location,
+                                              GLsizei bufSize,
+                                              GLsizei* length,
+                                              GLuint* params) {
+  driver_->fn.glGetnUniformuivRobustANGLEFn(program, location, bufSize, length,
+                                            params);
+}
+
+void GLApiBase::glGetObjectLabelFn(GLenum identifier,
+                                   GLuint name,
+                                   GLsizei bufSize,
+                                   GLsizei* length,
+                                   char* label) {
+  driver_->fn.glGetObjectLabelFn(identifier, name, bufSize, length, label);
+}
+
+void GLApiBase::glGetObjectPtrLabelFn(void* ptr,
+                                      GLsizei bufSize,
+                                      GLsizei* length,
+                                      char* label) {
+  driver_->fn.glGetObjectPtrLabelFn(ptr, bufSize, length, label);
+}
+
+void GLApiBase::glGetPointervFn(GLenum pname, void** params) {
+  driver_->fn.glGetPointervFn(pname, params);
+}
+
+void GLApiBase::glGetPointervRobustANGLERobustANGLEFn(GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      void** params) {
+  driver_->fn.glGetPointervRobustANGLERobustANGLEFn(pname, bufSize, length,
+                                                    params);
+}
+
+void GLApiBase::glGetProgramBinaryFn(GLuint program,
+                                     GLsizei bufSize,
+                                     GLsizei* length,
+                                     GLenum* binaryFormat,
+                                     GLvoid* binary) {
+  driver_->fn.glGetProgramBinaryFn(program, bufSize, length, binaryFormat,
+                                   binary);
+}
+
+void GLApiBase::glGetProgramInfoLogFn(GLuint program,
+                                      GLsizei bufsize,
+                                      GLsizei* length,
+                                      char* infolog) {
+  driver_->fn.glGetProgramInfoLogFn(program, bufsize, length, infolog);
+}
+
+void GLApiBase::glGetProgramInterfaceivFn(GLuint program,
+                                          GLenum programInterface,
+                                          GLenum pname,
+                                          GLint* params) {
+  driver_->fn.glGetProgramInterfaceivFn(program, programInterface, pname,
+                                        params);
+}
+
+void GLApiBase::glGetProgramInterfaceivRobustANGLEFn(GLuint program,
+                                                     GLenum programInterface,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei* length,
+                                                     GLint* params) {
+  driver_->fn.glGetProgramInterfaceivRobustANGLEFn(
+      program, programInterface, pname, bufSize, length, params);
+}
+
+void GLApiBase::glGetProgramivFn(GLuint program, GLenum pname, GLint* params) {
+  driver_->fn.glGetProgramivFn(program, pname, params);
+}
+
+void GLApiBase::glGetProgramivRobustANGLEFn(GLuint program,
+                                            GLenum pname,
+                                            GLsizei bufSize,
+                                            GLsizei* length,
+                                            GLint* params) {
+  driver_->fn.glGetProgramivRobustANGLEFn(program, pname, bufSize, length,
+                                          params);
+}
+
+void GLApiBase::glGetProgramResourceivFn(GLuint program,
+                                         GLenum programInterface,
+                                         GLuint index,
+                                         GLsizei propCount,
+                                         const GLenum* props,
+                                         GLsizei bufSize,
+                                         GLsizei* length,
+                                         GLint* params) {
+  driver_->fn.glGetProgramResourceivFn(program, programInterface, index,
+                                       propCount, props, bufSize, length,
+                                       params);
+}
+
+GLint GLApiBase::glGetProgramResourceLocationFn(GLuint program,
+                                                GLenum programInterface,
+                                                const char* name) {
+  return driver_->fn.glGetProgramResourceLocationFn(program, programInterface,
+                                                    name);
+}
+
+void GLApiBase::glGetProgramResourceNameFn(GLuint program,
+                                           GLenum programInterface,
+                                           GLuint index,
+                                           GLsizei bufSize,
+                                           GLsizei* length,
+                                           GLchar* name) {
+  driver_->fn.glGetProgramResourceNameFn(program, programInterface, index,
+                                         bufSize, length, name);
+}
+
+void GLApiBase::glGetQueryivFn(GLenum target, GLenum pname, GLint* params) {
+  driver_->fn.glGetQueryivFn(target, pname, params);
+}
+
+void GLApiBase::glGetQueryivRobustANGLEFn(GLenum target,
+                                          GLenum pname,
+                                          GLsizei bufSize,
+                                          GLsizei* length,
+                                          GLint* params) {
+  driver_->fn.glGetQueryivRobustANGLEFn(target, pname, bufSize, length, params);
+}
+
+void GLApiBase::glGetQueryObjecti64vFn(GLuint id,
+                                       GLenum pname,
+                                       GLint64* params) {
+  driver_->fn.glGetQueryObjecti64vFn(id, pname, params);
+}
+
+void GLApiBase::glGetQueryObjecti64vRobustANGLEFn(GLuint id,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLint64* params) {
+  driver_->fn.glGetQueryObjecti64vRobustANGLEFn(id, pname, bufSize, length,
+                                                params);
+}
+
+void GLApiBase::glGetQueryObjectivFn(GLuint id, GLenum pname, GLint* params) {
+  driver_->fn.glGetQueryObjectivFn(id, pname, params);
+}
+
+void GLApiBase::glGetQueryObjectivRobustANGLEFn(GLuint id,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                GLsizei* length,
+                                                GLint* params) {
+  driver_->fn.glGetQueryObjectivRobustANGLEFn(id, pname, bufSize, length,
+                                              params);
+}
+
+void GLApiBase::glGetQueryObjectui64vFn(GLuint id,
+                                        GLenum pname,
+                                        GLuint64* params) {
+  driver_->fn.glGetQueryObjectui64vFn(id, pname, params);
+}
+
+void GLApiBase::glGetQueryObjectui64vRobustANGLEFn(GLuint id,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei* length,
+                                                   GLuint64* params) {
+  driver_->fn.glGetQueryObjectui64vRobustANGLEFn(id, pname, bufSize, length,
+                                                 params);
+}
+
+void GLApiBase::glGetQueryObjectuivFn(GLuint id, GLenum pname, GLuint* params) {
+  driver_->fn.glGetQueryObjectuivFn(id, pname, params);
+}
+
+void GLApiBase::glGetQueryObjectuivRobustANGLEFn(GLuint id,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLuint* params) {
+  driver_->fn.glGetQueryObjectuivRobustANGLEFn(id, pname, bufSize, length,
+                                               params);
+}
+
+void GLApiBase::glGetRenderbufferParameterivEXTFn(GLenum target,
+                                                  GLenum pname,
+                                                  GLint* params) {
+  driver_->fn.glGetRenderbufferParameterivEXTFn(target, pname, params);
+}
+
+void GLApiBase::glGetRenderbufferParameterivRobustANGLEFn(GLenum target,
+                                                          GLenum pname,
+                                                          GLsizei bufSize,
+                                                          GLsizei* length,
+                                                          GLint* params) {
+  driver_->fn.glGetRenderbufferParameterivRobustANGLEFn(target, pname, bufSize,
+                                                        length, params);
+}
+
+void GLApiBase::glGetSamplerParameterfvFn(GLuint sampler,
+                                          GLenum pname,
+                                          GLfloat* params) {
+  driver_->fn.glGetSamplerParameterfvFn(sampler, pname, params);
+}
+
+void GLApiBase::glGetSamplerParameterfvRobustANGLEFn(GLuint sampler,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei* length,
+                                                     GLfloat* params) {
+  driver_->fn.glGetSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize,
+                                                   length, params);
+}
+
+void GLApiBase::glGetSamplerParameterIivRobustANGLEFn(GLuint sampler,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      GLint* params) {
+  driver_->fn.glGetSamplerParameterIivRobustANGLEFn(sampler, pname, bufSize,
+                                                    length, params);
+}
+
+void GLApiBase::glGetSamplerParameterIuivRobustANGLEFn(GLuint sampler,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       GLuint* params) {
+  driver_->fn.glGetSamplerParameterIuivRobustANGLEFn(sampler, pname, bufSize,
+                                                     length, params);
+}
+
+void GLApiBase::glGetSamplerParameterivFn(GLuint sampler,
+                                          GLenum pname,
+                                          GLint* params) {
+  driver_->fn.glGetSamplerParameterivFn(sampler, pname, params);
+}
+
+void GLApiBase::glGetSamplerParameterivRobustANGLEFn(GLuint sampler,
+                                                     GLenum pname,
+                                                     GLsizei bufSize,
+                                                     GLsizei* length,
+                                                     GLint* params) {
+  driver_->fn.glGetSamplerParameterivRobustANGLEFn(sampler, pname, bufSize,
+                                                   length, params);
+}
+
+void GLApiBase::glGetShaderInfoLogFn(GLuint shader,
+                                     GLsizei bufsize,
+                                     GLsizei* length,
+                                     char* infolog) {
+  driver_->fn.glGetShaderInfoLogFn(shader, bufsize, length, infolog);
+}
+
+void GLApiBase::glGetShaderivFn(GLuint shader, GLenum pname, GLint* params) {
+  driver_->fn.glGetShaderivFn(shader, pname, params);
+}
+
+void GLApiBase::glGetShaderivRobustANGLEFn(GLuint shader,
+                                           GLenum pname,
+                                           GLsizei bufSize,
+                                           GLsizei* length,
+                                           GLint* params) {
+  driver_->fn.glGetShaderivRobustANGLEFn(shader, pname, bufSize, length,
+                                         params);
+}
+
+void GLApiBase::glGetShaderPrecisionFormatFn(GLenum shadertype,
+                                             GLenum precisiontype,
+                                             GLint* range,
+                                             GLint* precision) {
+  driver_->fn.glGetShaderPrecisionFormatFn(shadertype, precisiontype, range,
+                                           precision);
+}
+
+void GLApiBase::glGetShaderSourceFn(GLuint shader,
+                                    GLsizei bufsize,
+                                    GLsizei* length,
+                                    char* source) {
+  driver_->fn.glGetShaderSourceFn(shader, bufsize, length, source);
+}
+
+const GLubyte* GLApiBase::glGetStringFn(GLenum name) {
+  return driver_->fn.glGetStringFn(name);
+}
+
+const GLubyte* GLApiBase::glGetStringiFn(GLenum name, GLuint index) {
+  return driver_->fn.glGetStringiFn(name, index);
+}
+
+void GLApiBase::glGetSyncivFn(GLsync sync,
+                              GLenum pname,
+                              GLsizei bufSize,
+                              GLsizei* length,
+                              GLint* values) {
+  driver_->fn.glGetSyncivFn(sync, pname, bufSize, length, values);
+}
+
+void GLApiBase::glGetTexLevelParameterfvFn(GLenum target,
+                                           GLint level,
+                                           GLenum pname,
+                                           GLfloat* params) {
+  driver_->fn.glGetTexLevelParameterfvFn(target, level, pname, params);
+}
+
+void GLApiBase::glGetTexLevelParameterfvRobustANGLEFn(GLenum target,
+                                                      GLint level,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      GLfloat* params) {
+  driver_->fn.glGetTexLevelParameterfvRobustANGLEFn(target, level, pname,
+                                                    bufSize, length, params);
+}
+
+void GLApiBase::glGetTexLevelParameterivFn(GLenum target,
+                                           GLint level,
+                                           GLenum pname,
+                                           GLint* params) {
+  driver_->fn.glGetTexLevelParameterivFn(target, level, pname, params);
+}
+
+void GLApiBase::glGetTexLevelParameterivRobustANGLEFn(GLenum target,
+                                                      GLint level,
+                                                      GLenum pname,
+                                                      GLsizei bufSize,
+                                                      GLsizei* length,
+                                                      GLint* params) {
+  driver_->fn.glGetTexLevelParameterivRobustANGLEFn(target, level, pname,
+                                                    bufSize, length, params);
+}
+
+void GLApiBase::glGetTexParameterfvFn(GLenum target,
+                                      GLenum pname,
+                                      GLfloat* params) {
+  driver_->fn.glGetTexParameterfvFn(target, pname, params);
+}
+
+void GLApiBase::glGetTexParameterfvRobustANGLEFn(GLenum target,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLfloat* params) {
+  driver_->fn.glGetTexParameterfvRobustANGLEFn(target, pname, bufSize, length,
+                                               params);
+}
+
+void GLApiBase::glGetTexParameterIivRobustANGLEFn(GLenum target,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLint* params) {
+  driver_->fn.glGetTexParameterIivRobustANGLEFn(target, pname, bufSize, length,
+                                                params);
+}
+
+void GLApiBase::glGetTexParameterIuivRobustANGLEFn(GLenum target,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei* length,
+                                                   GLuint* params) {
+  driver_->fn.glGetTexParameterIuivRobustANGLEFn(target, pname, bufSize, length,
+                                                 params);
+}
+
+void GLApiBase::glGetTexParameterivFn(GLenum target,
+                                      GLenum pname,
+                                      GLint* params) {
+  driver_->fn.glGetTexParameterivFn(target, pname, params);
+}
+
+void GLApiBase::glGetTexParameterivRobustANGLEFn(GLenum target,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLint* params) {
+  driver_->fn.glGetTexParameterivRobustANGLEFn(target, pname, bufSize, length,
+                                               params);
+}
+
+void GLApiBase::glGetTransformFeedbackVaryingFn(GLuint program,
+                                                GLuint index,
+                                                GLsizei bufSize,
+                                                GLsizei* length,
+                                                GLsizei* size,
+                                                GLenum* type,
+                                                char* name) {
+  driver_->fn.glGetTransformFeedbackVaryingFn(program, index, bufSize, length,
+                                              size, type, name);
+}
+
+void GLApiBase::glGetTranslatedShaderSourceANGLEFn(GLuint shader,
+                                                   GLsizei bufsize,
+                                                   GLsizei* length,
+                                                   char* source) {
+  driver_->fn.glGetTranslatedShaderSourceANGLEFn(shader, bufsize, length,
+                                                 source);
+}
+
+GLuint GLApiBase::glGetUniformBlockIndexFn(GLuint program,
+                                           const char* uniformBlockName) {
+  return driver_->fn.glGetUniformBlockIndexFn(program, uniformBlockName);
+}
+
+void GLApiBase::glGetUniformfvFn(GLuint program,
+                                 GLint location,
+                                 GLfloat* params) {
+  driver_->fn.glGetUniformfvFn(program, location, params);
+}
+
+void GLApiBase::glGetUniformfvRobustANGLEFn(GLuint program,
+                                            GLint location,
+                                            GLsizei bufSize,
+                                            GLsizei* length,
+                                            GLfloat* params) {
+  driver_->fn.glGetUniformfvRobustANGLEFn(program, location, bufSize, length,
+                                          params);
+}
+
+void GLApiBase::glGetUniformIndicesFn(GLuint program,
+                                      GLsizei uniformCount,
+                                      const char* const* uniformNames,
+                                      GLuint* uniformIndices) {
+  driver_->fn.glGetUniformIndicesFn(program, uniformCount, uniformNames,
+                                    uniformIndices);
+}
+
+void GLApiBase::glGetUniformivFn(GLuint program,
+                                 GLint location,
+                                 GLint* params) {
+  driver_->fn.glGetUniformivFn(program, location, params);
+}
+
+void GLApiBase::glGetUniformivRobustANGLEFn(GLuint program,
+                                            GLint location,
+                                            GLsizei bufSize,
+                                            GLsizei* length,
+                                            GLint* params) {
+  driver_->fn.glGetUniformivRobustANGLEFn(program, location, bufSize, length,
+                                          params);
+}
+
+GLint GLApiBase::glGetUniformLocationFn(GLuint program, const char* name) {
+  return driver_->fn.glGetUniformLocationFn(program, name);
+}
+
+void GLApiBase::glGetUniformuivFn(GLuint program,
+                                  GLint location,
+                                  GLuint* params) {
+  driver_->fn.glGetUniformuivFn(program, location, params);
+}
+
+void GLApiBase::glGetUniformuivRobustANGLEFn(GLuint program,
+                                             GLint location,
+                                             GLsizei bufSize,
+                                             GLsizei* length,
+                                             GLuint* params) {
+  driver_->fn.glGetUniformuivRobustANGLEFn(program, location, bufSize, length,
+                                           params);
+}
+
+void GLApiBase::glGetVertexAttribfvFn(GLuint index,
+                                      GLenum pname,
+                                      GLfloat* params) {
+  driver_->fn.glGetVertexAttribfvFn(index, pname, params);
+}
+
+void GLApiBase::glGetVertexAttribfvRobustANGLEFn(GLuint index,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLfloat* params) {
+  driver_->fn.glGetVertexAttribfvRobustANGLEFn(index, pname, bufSize, length,
+                                               params);
+}
+
+void GLApiBase::glGetVertexAttribIivRobustANGLEFn(GLuint index,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLsizei* length,
+                                                  GLint* params) {
+  driver_->fn.glGetVertexAttribIivRobustANGLEFn(index, pname, bufSize, length,
+                                                params);
+}
+
+void GLApiBase::glGetVertexAttribIuivRobustANGLEFn(GLuint index,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   GLsizei* length,
+                                                   GLuint* params) {
+  driver_->fn.glGetVertexAttribIuivRobustANGLEFn(index, pname, bufSize, length,
+                                                 params);
+}
+
+void GLApiBase::glGetVertexAttribivFn(GLuint index,
+                                      GLenum pname,
+                                      GLint* params) {
+  driver_->fn.glGetVertexAttribivFn(index, pname, params);
+}
+
+void GLApiBase::glGetVertexAttribivRobustANGLEFn(GLuint index,
+                                                 GLenum pname,
+                                                 GLsizei bufSize,
+                                                 GLsizei* length,
+                                                 GLint* params) {
+  driver_->fn.glGetVertexAttribivRobustANGLEFn(index, pname, bufSize, length,
+                                               params);
+}
+
+void GLApiBase::glGetVertexAttribPointervFn(GLuint index,
+                                            GLenum pname,
+                                            void** pointer) {
+  driver_->fn.glGetVertexAttribPointervFn(index, pname, pointer);
+}
+
+void GLApiBase::glGetVertexAttribPointervRobustANGLEFn(GLuint index,
+                                                       GLenum pname,
+                                                       GLsizei bufSize,
+                                                       GLsizei* length,
+                                                       void** pointer) {
+  driver_->fn.glGetVertexAttribPointervRobustANGLEFn(index, pname, bufSize,
+                                                     length, pointer);
+}
+
+void GLApiBase::glHintFn(GLenum target, GLenum mode) {
+  driver_->fn.glHintFn(target, mode);
+}
+
+void GLApiBase::glInsertEventMarkerEXTFn(GLsizei length, const char* marker) {
+  driver_->fn.glInsertEventMarkerEXTFn(length, marker);
+}
+
+void GLApiBase::glInvalidateFramebufferFn(GLenum target,
+                                          GLsizei numAttachments,
+                                          const GLenum* attachments) {
+  driver_->fn.glInvalidateFramebufferFn(target, numAttachments, attachments);
+}
+
+void GLApiBase::glInvalidateSubFramebufferFn(GLenum target,
+                                             GLsizei numAttachments,
+                                             const GLenum* attachments,
+                                             GLint x,
+                                             GLint y,
+                                             GLint width,
+                                             GLint height) {
+  driver_->fn.glInvalidateSubFramebufferFn(target, numAttachments, attachments,
+                                           x, y, width, height);
+}
+
+GLboolean GLApiBase::glIsBufferFn(GLuint buffer) {
+  return driver_->fn.glIsBufferFn(buffer);
+}
+
+GLboolean GLApiBase::glIsEnabledFn(GLenum cap) {
+  return driver_->fn.glIsEnabledFn(cap);
+}
+
+GLboolean GLApiBase::glIsFenceAPPLEFn(GLuint fence) {
+  return driver_->fn.glIsFenceAPPLEFn(fence);
+}
+
+GLboolean GLApiBase::glIsFenceNVFn(GLuint fence) {
+  return driver_->fn.glIsFenceNVFn(fence);
+}
+
+GLboolean GLApiBase::glIsFramebufferEXTFn(GLuint framebuffer) {
+  return driver_->fn.glIsFramebufferEXTFn(framebuffer);
+}
+
+GLboolean GLApiBase::glIsPathNVFn(GLuint path) {
+  return driver_->fn.glIsPathNVFn(path);
+}
+
+GLboolean GLApiBase::glIsProgramFn(GLuint program) {
+  return driver_->fn.glIsProgramFn(program);
+}
+
+GLboolean GLApiBase::glIsQueryFn(GLuint query) {
+  return driver_->fn.glIsQueryFn(query);
+}
+
+GLboolean GLApiBase::glIsRenderbufferEXTFn(GLuint renderbuffer) {
+  return driver_->fn.glIsRenderbufferEXTFn(renderbuffer);
+}
+
+GLboolean GLApiBase::glIsSamplerFn(GLuint sampler) {
+  return driver_->fn.glIsSamplerFn(sampler);
+}
+
+GLboolean GLApiBase::glIsShaderFn(GLuint shader) {
+  return driver_->fn.glIsShaderFn(shader);
+}
+
+GLboolean GLApiBase::glIsSyncFn(GLsync sync) {
+  return driver_->fn.glIsSyncFn(sync);
+}
+
+GLboolean GLApiBase::glIsTextureFn(GLuint texture) {
+  return driver_->fn.glIsTextureFn(texture);
+}
+
+GLboolean GLApiBase::glIsTransformFeedbackFn(GLuint id) {
+  return driver_->fn.glIsTransformFeedbackFn(id);
+}
+
+GLboolean GLApiBase::glIsVertexArrayOESFn(GLuint array) {
+  return driver_->fn.glIsVertexArrayOESFn(array);
+}
+
+void GLApiBase::glLineWidthFn(GLfloat width) {
+  driver_->fn.glLineWidthFn(width);
+}
+
+void GLApiBase::glLinkProgramFn(GLuint program) {
+  driver_->fn.glLinkProgramFn(program);
+}
+
+void* GLApiBase::glMapBufferFn(GLenum target, GLenum access) {
+  return driver_->fn.glMapBufferFn(target, access);
+}
+
+void* GLApiBase::glMapBufferRangeFn(GLenum target,
+                                    GLintptr offset,
+                                    GLsizeiptr length,
+                                    GLbitfield access) {
+  return driver_->fn.glMapBufferRangeFn(target, offset, length, access);
+}
+
+void GLApiBase::glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) {
+  driver_->fn.glMatrixLoadfEXTFn(matrixMode, m);
+}
+
+void GLApiBase::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
+  driver_->fn.glMatrixLoadIdentityEXTFn(matrixMode);
+}
+
+void GLApiBase::glMemoryBarrierEXTFn(GLbitfield barriers) {
+  driver_->fn.glMemoryBarrierEXTFn(barriers);
+}
+
+void GLApiBase::glObjectLabelFn(GLenum identifier,
+                                GLuint name,
+                                GLsizei length,
+                                const char* label) {
+  driver_->fn.glObjectLabelFn(identifier, name, length, label);
+}
+
+void GLApiBase::glObjectPtrLabelFn(void* ptr,
+                                   GLsizei length,
+                                   const char* label) {
+  driver_->fn.glObjectPtrLabelFn(ptr, length, label);
+}
+
+void GLApiBase::glPathCommandsNVFn(GLuint path,
+                                   GLsizei numCommands,
+                                   const GLubyte* commands,
+                                   GLsizei numCoords,
+                                   GLenum coordType,
+                                   const GLvoid* coords) {
+  driver_->fn.glPathCommandsNVFn(path, numCommands, commands, numCoords,
+                                 coordType, coords);
+}
+
+void GLApiBase::glPathParameterfNVFn(GLuint path, GLenum pname, GLfloat value) {
+  driver_->fn.glPathParameterfNVFn(path, pname, value);
+}
+
+void GLApiBase::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
+  driver_->fn.glPathParameteriNVFn(path, pname, value);
+}
+
+void GLApiBase::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
+  driver_->fn.glPathStencilFuncNVFn(func, ref, mask);
+}
+
+void GLApiBase::glPauseTransformFeedbackFn(void) {
+  driver_->fn.glPauseTransformFeedbackFn();
+}
+
+void GLApiBase::glPixelStoreiFn(GLenum pname, GLint param) {
+  driver_->fn.glPixelStoreiFn(pname, param);
+}
+
+void GLApiBase::glPointParameteriFn(GLenum pname, GLint param) {
+  driver_->fn.glPointParameteriFn(pname, param);
+}
+
+void GLApiBase::glPolygonOffsetFn(GLfloat factor, GLfloat units) {
+  driver_->fn.glPolygonOffsetFn(factor, units);
+}
+
+void GLApiBase::glPopDebugGroupFn() {
+  driver_->fn.glPopDebugGroupFn();
+}
+
+void GLApiBase::glPopGroupMarkerEXTFn(void) {
+  driver_->fn.glPopGroupMarkerEXTFn();
+}
+
+void GLApiBase::glPrimitiveRestartIndexFn(GLuint index) {
+  driver_->fn.glPrimitiveRestartIndexFn(index);
+}
+
+void GLApiBase::glProgramBinaryFn(GLuint program,
+                                  GLenum binaryFormat,
+                                  const GLvoid* binary,
+                                  GLsizei length) {
+  driver_->fn.glProgramBinaryFn(program, binaryFormat, binary, length);
+}
+
+void GLApiBase::glProgramParameteriFn(GLuint program,
+                                      GLenum pname,
+                                      GLint value) {
+  driver_->fn.glProgramParameteriFn(program, pname, value);
+}
+
+void GLApiBase::glProgramPathFragmentInputGenNVFn(GLuint program,
+                                                  GLint location,
+                                                  GLenum genMode,
+                                                  GLint components,
+                                                  const GLfloat* coeffs) {
+  driver_->fn.glProgramPathFragmentInputGenNVFn(program, location, genMode,
+                                                components, coeffs);
+}
+
+void GLApiBase::glPushDebugGroupFn(GLenum source,
+                                   GLuint id,
+                                   GLsizei length,
+                                   const char* message) {
+  driver_->fn.glPushDebugGroupFn(source, id, length, message);
+}
+
+void GLApiBase::glPushGroupMarkerEXTFn(GLsizei length, const char* marker) {
+  driver_->fn.glPushGroupMarkerEXTFn(length, marker);
+}
+
+void GLApiBase::glQueryCounterFn(GLuint id, GLenum target) {
+  driver_->fn.glQueryCounterFn(id, target);
+}
+
+void GLApiBase::glReadBufferFn(GLenum src) {
+  driver_->fn.glReadBufferFn(src);
+}
+
+void GLApiBase::glReadnPixelsRobustANGLEFn(GLint x,
+                                           GLint y,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLenum format,
+                                           GLenum type,
+                                           GLsizei bufSize,
+                                           GLsizei* length,
+                                           void* data) {
+  driver_->fn.glReadnPixelsRobustANGLEFn(x, y, width, height, format, type,
+                                         bufSize, length, data);
+}
+
+void GLApiBase::glReadPixelsFn(GLint x,
+                               GLint y,
+                               GLsizei width,
+                               GLsizei height,
+                               GLenum format,
+                               GLenum type,
+                               void* pixels) {
+  driver_->fn.glReadPixelsFn(x, y, width, height, format, type, pixels);
+}
+
+void GLApiBase::glReadPixelsRobustANGLEFn(GLint x,
+                                          GLint y,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLenum format,
+                                          GLenum type,
+                                          GLsizei bufSize,
+                                          GLsizei* length,
+                                          void* pixels) {
+  driver_->fn.glReadPixelsRobustANGLEFn(x, y, width, height, format, type,
+                                        bufSize, length, pixels);
+}
+
+void GLApiBase::glReleaseShaderCompilerFn(void) {
+  driver_->fn.glReleaseShaderCompilerFn();
+}
+
+void GLApiBase::glRenderbufferStorageEXTFn(GLenum target,
+                                           GLenum internalformat,
+                                           GLsizei width,
+                                           GLsizei height) {
+  driver_->fn.glRenderbufferStorageEXTFn(target, internalformat, width, height);
+}
+
+void GLApiBase::glRenderbufferStorageMultisampleFn(GLenum target,
+                                                   GLsizei samples,
+                                                   GLenum internalformat,
+                                                   GLsizei width,
+                                                   GLsizei height) {
+  driver_->fn.glRenderbufferStorageMultisampleFn(target, samples,
+                                                 internalformat, width, height);
+}
+
+void GLApiBase::glRenderbufferStorageMultisampleANGLEFn(GLenum target,
+                                                        GLsizei samples,
+                                                        GLenum internalformat,
+                                                        GLsizei width,
+                                                        GLsizei height) {
+  driver_->fn.glRenderbufferStorageMultisampleANGLEFn(
+      target, samples, internalformat, width, height);
+}
+
+void GLApiBase::glRenderbufferStorageMultisampleEXTFn(GLenum target,
+                                                      GLsizei samples,
+                                                      GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height) {
+  driver_->fn.glRenderbufferStorageMultisampleEXTFn(
+      target, samples, internalformat, width, height);
+}
+
+void GLApiBase::glRenderbufferStorageMultisampleIMGFn(GLenum target,
+                                                      GLsizei samples,
+                                                      GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height) {
+  driver_->fn.glRenderbufferStorageMultisampleIMGFn(
+      target, samples, internalformat, width, height);
+}
+
+void GLApiBase::glResumeTransformFeedbackFn(void) {
+  driver_->fn.glResumeTransformFeedbackFn();
+}
+
+void GLApiBase::glSampleCoverageFn(GLclampf value, GLboolean invert) {
+  driver_->fn.glSampleCoverageFn(value, invert);
+}
+
+void GLApiBase::glSamplerParameterfFn(GLuint sampler,
+                                      GLenum pname,
+                                      GLfloat param) {
+  driver_->fn.glSamplerParameterfFn(sampler, pname, param);
+}
+
+void GLApiBase::glSamplerParameterfvFn(GLuint sampler,
+                                       GLenum pname,
+                                       const GLfloat* params) {
+  driver_->fn.glSamplerParameterfvFn(sampler, pname, params);
+}
+
+void GLApiBase::glSamplerParameterfvRobustANGLEFn(GLuint sampler,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  const GLfloat* param) {
+  driver_->fn.glSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void GLApiBase::glSamplerParameteriFn(GLuint sampler,
+                                      GLenum pname,
+                                      GLint param) {
+  driver_->fn.glSamplerParameteriFn(sampler, pname, param);
+}
+
+void GLApiBase::glSamplerParameterIivRobustANGLEFn(GLuint sampler,
+                                                   GLenum pname,
+                                                   GLsizei bufSize,
+                                                   const GLint* param) {
+  driver_->fn.glSamplerParameterIivRobustANGLEFn(sampler, pname, bufSize,
+                                                 param);
+}
+
+void GLApiBase::glSamplerParameterIuivRobustANGLEFn(GLuint sampler,
+                                                    GLenum pname,
+                                                    GLsizei bufSize,
+                                                    const GLuint* param) {
+  driver_->fn.glSamplerParameterIuivRobustANGLEFn(sampler, pname, bufSize,
+                                                  param);
+}
+
+void GLApiBase::glSamplerParameterivFn(GLuint sampler,
+                                       GLenum pname,
+                                       const GLint* params) {
+  driver_->fn.glSamplerParameterivFn(sampler, pname, params);
+}
+
+void GLApiBase::glSamplerParameterivRobustANGLEFn(GLuint sampler,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  const GLint* param) {
+  driver_->fn.glSamplerParameterivRobustANGLEFn(sampler, pname, bufSize, param);
+}
+
+void GLApiBase::glScissorFn(GLint x, GLint y, GLsizei width, GLsizei height) {
+  driver_->fn.glScissorFn(x, y, width, height);
+}
+
+void GLApiBase::glSetFenceAPPLEFn(GLuint fence) {
+  driver_->fn.glSetFenceAPPLEFn(fence);
+}
+
+void GLApiBase::glSetFenceNVFn(GLuint fence, GLenum condition) {
+  driver_->fn.glSetFenceNVFn(fence, condition);
+}
+
+void GLApiBase::glShaderBinaryFn(GLsizei n,
+                                 const GLuint* shaders,
+                                 GLenum binaryformat,
+                                 const void* binary,
+                                 GLsizei length) {
+  driver_->fn.glShaderBinaryFn(n, shaders, binaryformat, binary, length);
+}
+
+void GLApiBase::glShaderSourceFn(GLuint shader,
+                                 GLsizei count,
+                                 const char* const* str,
+                                 const GLint* length) {
+  driver_->fn.glShaderSourceFn(shader, count, str, length);
+}
+
+void GLApiBase::glStencilFillPathInstancedNVFn(GLsizei numPaths,
+                                               GLenum pathNameType,
+                                               const void* paths,
+                                               GLuint pathBase,
+                                               GLenum fillMode,
+                                               GLuint mask,
+                                               GLenum transformType,
+                                               const GLfloat* transformValues) {
+  driver_->fn.glStencilFillPathInstancedNVFn(numPaths, pathNameType, paths,
+                                             pathBase, fillMode, mask,
+                                             transformType, transformValues);
+}
+
+void GLApiBase::glStencilFillPathNVFn(GLuint path,
+                                      GLenum fillMode,
+                                      GLuint mask) {
+  driver_->fn.glStencilFillPathNVFn(path, fillMode, mask);
+}
+
+void GLApiBase::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
+  driver_->fn.glStencilFuncFn(func, ref, mask);
+}
+
+void GLApiBase::glStencilFuncSeparateFn(GLenum face,
+                                        GLenum func,
+                                        GLint ref,
+                                        GLuint mask) {
+  driver_->fn.glStencilFuncSeparateFn(face, func, ref, mask);
+}
+
+void GLApiBase::glStencilMaskFn(GLuint mask) {
+  driver_->fn.glStencilMaskFn(mask);
+}
+
+void GLApiBase::glStencilMaskSeparateFn(GLenum face, GLuint mask) {
+  driver_->fn.glStencilMaskSeparateFn(face, mask);
+}
+
+void GLApiBase::glStencilOpFn(GLenum fail, GLenum zfail, GLenum zpass) {
+  driver_->fn.glStencilOpFn(fail, zfail, zpass);
+}
+
+void GLApiBase::glStencilOpSeparateFn(GLenum face,
+                                      GLenum fail,
+                                      GLenum zfail,
+                                      GLenum zpass) {
+  driver_->fn.glStencilOpSeparateFn(face, fail, zfail, zpass);
+}
+
+void GLApiBase::glStencilStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  driver_->fn.glStencilStrokePathInstancedNVFn(numPaths, pathNameType, paths,
+                                               pathBase, ref, mask,
+                                               transformType, transformValues);
+}
+
+void GLApiBase::glStencilStrokePathNVFn(GLuint path,
+                                        GLint reference,
+                                        GLuint mask) {
+  driver_->fn.glStencilStrokePathNVFn(path, reference, mask);
+}
+
+void GLApiBase::glStencilThenCoverFillPathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLenum fillMode,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  driver_->fn.glStencilThenCoverFillPathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
+      transformType, transformValues);
+}
+
+void GLApiBase::glStencilThenCoverFillPathNVFn(GLuint path,
+                                               GLenum fillMode,
+                                               GLuint mask,
+                                               GLenum coverMode) {
+  driver_->fn.glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
+}
+
+void GLApiBase::glStencilThenCoverStrokePathInstancedNVFn(
+    GLsizei numPaths,
+    GLenum pathNameType,
+    const void* paths,
+    GLuint pathBase,
+    GLint ref,
+    GLuint mask,
+    GLenum coverMode,
+    GLenum transformType,
+    const GLfloat* transformValues) {
+  driver_->fn.glStencilThenCoverStrokePathInstancedNVFn(
+      numPaths, pathNameType, paths, pathBase, ref, mask, coverMode,
+      transformType, transformValues);
+}
+
+void GLApiBase::glStencilThenCoverStrokePathNVFn(GLuint path,
+                                                 GLint reference,
+                                                 GLuint mask,
+                                                 GLenum coverMode) {
+  driver_->fn.glStencilThenCoverStrokePathNVFn(path, reference, mask,
+                                               coverMode);
+}
+
+GLboolean GLApiBase::glTestFenceAPPLEFn(GLuint fence) {
+  return driver_->fn.glTestFenceAPPLEFn(fence);
+}
+
+GLboolean GLApiBase::glTestFenceNVFn(GLuint fence) {
+  return driver_->fn.glTestFenceNVFn(fence);
+}
+
+void GLApiBase::glTexImage2DFn(GLenum target,
+                               GLint level,
+                               GLint internalformat,
+                               GLsizei width,
+                               GLsizei height,
+                               GLint border,
+                               GLenum format,
+                               GLenum type,
+                               const void* pixels) {
+  driver_->fn.glTexImage2DFn(target, level, internalformat, width, height,
+                             border, format, type, pixels);
+}
+
+void GLApiBase::glTexImage2DRobustANGLEFn(GLenum target,
+                                          GLint level,
+                                          GLint internalformat,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLint border,
+                                          GLenum format,
+                                          GLenum type,
+                                          GLsizei bufSize,
+                                          const void* pixels) {
+  driver_->fn.glTexImage2DRobustANGLEFn(target, level, internalformat, width,
+                                        height, border, format, type, bufSize,
+                                        pixels);
+}
+
+void GLApiBase::glTexImage3DFn(GLenum target,
+                               GLint level,
+                               GLint internalformat,
+                               GLsizei width,
+                               GLsizei height,
+                               GLsizei depth,
+                               GLint border,
+                               GLenum format,
+                               GLenum type,
+                               const void* pixels) {
+  driver_->fn.glTexImage3DFn(target, level, internalformat, width, height,
+                             depth, border, format, type, pixels);
+}
+
+void GLApiBase::glTexImage3DRobustANGLEFn(GLenum target,
+                                          GLint level,
+                                          GLint internalformat,
+                                          GLsizei width,
+                                          GLsizei height,
+                                          GLsizei depth,
+                                          GLint border,
+                                          GLenum format,
+                                          GLenum type,
+                                          GLsizei bufSize,
+                                          const void* pixels) {
+  driver_->fn.glTexImage3DRobustANGLEFn(target, level, internalformat, width,
+                                        height, depth, border, format, type,
+                                        bufSize, pixels);
+}
+
+void GLApiBase::glTexParameterfFn(GLenum target, GLenum pname, GLfloat param) {
+  driver_->fn.glTexParameterfFn(target, pname, param);
+}
+
+void GLApiBase::glTexParameterfvFn(GLenum target,
+                                   GLenum pname,
+                                   const GLfloat* params) {
+  driver_->fn.glTexParameterfvFn(target, pname, params);
+}
+
+void GLApiBase::glTexParameterfvRobustANGLEFn(GLenum target,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              const GLfloat* params) {
+  driver_->fn.glTexParameterfvRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void GLApiBase::glTexParameteriFn(GLenum target, GLenum pname, GLint param) {
+  driver_->fn.glTexParameteriFn(target, pname, param);
+}
+
+void GLApiBase::glTexParameterIivRobustANGLEFn(GLenum target,
+                                               GLenum pname,
+                                               GLsizei bufSize,
+                                               const GLint* params) {
+  driver_->fn.glTexParameterIivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void GLApiBase::glTexParameterIuivRobustANGLEFn(GLenum target,
+                                                GLenum pname,
+                                                GLsizei bufSize,
+                                                const GLuint* params) {
+  driver_->fn.glTexParameterIuivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void GLApiBase::glTexParameterivFn(GLenum target,
+                                   GLenum pname,
+                                   const GLint* params) {
+  driver_->fn.glTexParameterivFn(target, pname, params);
+}
+
+void GLApiBase::glTexParameterivRobustANGLEFn(GLenum target,
+                                              GLenum pname,
+                                              GLsizei bufSize,
+                                              const GLint* params) {
+  driver_->fn.glTexParameterivRobustANGLEFn(target, pname, bufSize, params);
+}
+
+void GLApiBase::glTexStorage2DEXTFn(GLenum target,
+                                    GLsizei levels,
+                                    GLenum internalformat,
+                                    GLsizei width,
+                                    GLsizei height) {
+  driver_->fn.glTexStorage2DEXTFn(target, levels, internalformat, width,
+                                  height);
+}
+
+void GLApiBase::glTexStorage3DFn(GLenum target,
+                                 GLsizei levels,
+                                 GLenum internalformat,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLsizei depth) {
+  driver_->fn.glTexStorage3DFn(target, levels, internalformat, width, height,
+                               depth);
+}
+
+void GLApiBase::glTexSubImage2DFn(GLenum target,
+                                  GLint level,
+                                  GLint xoffset,
+                                  GLint yoffset,
+                                  GLsizei width,
+                                  GLsizei height,
+                                  GLenum format,
+                                  GLenum type,
+                                  const void* pixels) {
+  driver_->fn.glTexSubImage2DFn(target, level, xoffset, yoffset, width, height,
+                                format, type, pixels);
+}
+
+void GLApiBase::glTexSubImage2DRobustANGLEFn(GLenum target,
+                                             GLint level,
+                                             GLint xoffset,
+                                             GLint yoffset,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLenum format,
+                                             GLenum type,
+                                             GLsizei bufSize,
+                                             const void* pixels) {
+  driver_->fn.glTexSubImage2DRobustANGLEFn(target, level, xoffset, yoffset,
+                                           width, height, format, type, bufSize,
+                                           pixels);
+}
+
+void GLApiBase::glTexSubImage3DFn(GLenum target,
+                                  GLint level,
+                                  GLint xoffset,
+                                  GLint yoffset,
+                                  GLint zoffset,
+                                  GLsizei width,
+                                  GLsizei height,
+                                  GLsizei depth,
+                                  GLenum format,
+                                  GLenum type,
+                                  const void* pixels) {
+  driver_->fn.glTexSubImage3DFn(target, level, xoffset, yoffset, zoffset, width,
+                                height, depth, format, type, pixels);
+}
+
+void GLApiBase::glTexSubImage3DRobustANGLEFn(GLenum target,
+                                             GLint level,
+                                             GLint xoffset,
+                                             GLint yoffset,
+                                             GLint zoffset,
+                                             GLsizei width,
+                                             GLsizei height,
+                                             GLsizei depth,
+                                             GLenum format,
+                                             GLenum type,
+                                             GLsizei bufSize,
+                                             const void* pixels) {
+  driver_->fn.glTexSubImage3DRobustANGLEFn(target, level, xoffset, yoffset,
+                                           zoffset, width, height, depth,
+                                           format, type, bufSize, pixels);
+}
+
+void GLApiBase::glTransformFeedbackVaryingsFn(GLuint program,
+                                              GLsizei count,
+                                              const char* const* varyings,
+                                              GLenum bufferMode) {
+  driver_->fn.glTransformFeedbackVaryingsFn(program, count, varyings,
+                                            bufferMode);
+}
+
+void GLApiBase::glUniform1fFn(GLint location, GLfloat x) {
+  driver_->fn.glUniform1fFn(location, x);
+}
+
+void GLApiBase::glUniform1fvFn(GLint location,
+                               GLsizei count,
+                               const GLfloat* v) {
+  driver_->fn.glUniform1fvFn(location, count, v);
+}
+
+void GLApiBase::glUniform1iFn(GLint location, GLint x) {
+  driver_->fn.glUniform1iFn(location, x);
+}
+
+void GLApiBase::glUniform1ivFn(GLint location, GLsizei count, const GLint* v) {
+  driver_->fn.glUniform1ivFn(location, count, v);
+}
+
+void GLApiBase::glUniform1uiFn(GLint location, GLuint v0) {
+  driver_->fn.glUniform1uiFn(location, v0);
+}
+
+void GLApiBase::glUniform1uivFn(GLint location,
+                                GLsizei count,
+                                const GLuint* v) {
+  driver_->fn.glUniform1uivFn(location, count, v);
+}
+
+void GLApiBase::glUniform2fFn(GLint location, GLfloat x, GLfloat y) {
+  driver_->fn.glUniform2fFn(location, x, y);
+}
+
+void GLApiBase::glUniform2fvFn(GLint location,
+                               GLsizei count,
+                               const GLfloat* v) {
+  driver_->fn.glUniform2fvFn(location, count, v);
+}
+
+void GLApiBase::glUniform2iFn(GLint location, GLint x, GLint y) {
+  driver_->fn.glUniform2iFn(location, x, y);
+}
+
+void GLApiBase::glUniform2ivFn(GLint location, GLsizei count, const GLint* v) {
+  driver_->fn.glUniform2ivFn(location, count, v);
+}
+
+void GLApiBase::glUniform2uiFn(GLint location, GLuint v0, GLuint v1) {
+  driver_->fn.glUniform2uiFn(location, v0, v1);
+}
+
+void GLApiBase::glUniform2uivFn(GLint location,
+                                GLsizei count,
+                                const GLuint* v) {
+  driver_->fn.glUniform2uivFn(location, count, v);
+}
+
+void GLApiBase::glUniform3fFn(GLint location, GLfloat x, GLfloat y, GLfloat z) {
+  driver_->fn.glUniform3fFn(location, x, y, z);
+}
+
+void GLApiBase::glUniform3fvFn(GLint location,
+                               GLsizei count,
+                               const GLfloat* v) {
+  driver_->fn.glUniform3fvFn(location, count, v);
+}
+
+void GLApiBase::glUniform3iFn(GLint location, GLint x, GLint y, GLint z) {
+  driver_->fn.glUniform3iFn(location, x, y, z);
+}
+
+void GLApiBase::glUniform3ivFn(GLint location, GLsizei count, const GLint* v) {
+  driver_->fn.glUniform3ivFn(location, count, v);
+}
+
+void GLApiBase::glUniform3uiFn(GLint location,
+                               GLuint v0,
+                               GLuint v1,
+                               GLuint v2) {
+  driver_->fn.glUniform3uiFn(location, v0, v1, v2);
+}
+
+void GLApiBase::glUniform3uivFn(GLint location,
+                                GLsizei count,
+                                const GLuint* v) {
+  driver_->fn.glUniform3uivFn(location, count, v);
+}
+
+void GLApiBase::glUniform4fFn(GLint location,
+                              GLfloat x,
+                              GLfloat y,
+                              GLfloat z,
+                              GLfloat w) {
+  driver_->fn.glUniform4fFn(location, x, y, z, w);
+}
+
+void GLApiBase::glUniform4fvFn(GLint location,
+                               GLsizei count,
+                               const GLfloat* v) {
+  driver_->fn.glUniform4fvFn(location, count, v);
+}
+
+void GLApiBase::glUniform4iFn(GLint location,
+                              GLint x,
+                              GLint y,
+                              GLint z,
+                              GLint w) {
+  driver_->fn.glUniform4iFn(location, x, y, z, w);
+}
+
+void GLApiBase::glUniform4ivFn(GLint location, GLsizei count, const GLint* v) {
+  driver_->fn.glUniform4ivFn(location, count, v);
+}
+
+void GLApiBase::glUniform4uiFn(GLint location,
+                               GLuint v0,
+                               GLuint v1,
+                               GLuint v2,
+                               GLuint v3) {
+  driver_->fn.glUniform4uiFn(location, v0, v1, v2, v3);
+}
+
+void GLApiBase::glUniform4uivFn(GLint location,
+                                GLsizei count,
+                                const GLuint* v) {
+  driver_->fn.glUniform4uivFn(location, count, v);
+}
+
+void GLApiBase::glUniformBlockBindingFn(GLuint program,
+                                        GLuint uniformBlockIndex,
+                                        GLuint uniformBlockBinding) {
+  driver_->fn.glUniformBlockBindingFn(program, uniformBlockIndex,
+                                      uniformBlockBinding);
+}
+
+void GLApiBase::glUniformMatrix2fvFn(GLint location,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLfloat* value) {
+  driver_->fn.glUniformMatrix2fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix2x3fvFn(GLint location,
+                                       GLsizei count,
+                                       GLboolean transpose,
+                                       const GLfloat* value) {
+  driver_->fn.glUniformMatrix2x3fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix2x4fvFn(GLint location,
+                                       GLsizei count,
+                                       GLboolean transpose,
+                                       const GLfloat* value) {
+  driver_->fn.glUniformMatrix2x4fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix3fvFn(GLint location,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLfloat* value) {
+  driver_->fn.glUniformMatrix3fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix3x2fvFn(GLint location,
+                                       GLsizei count,
+                                       GLboolean transpose,
+                                       const GLfloat* value) {
+  driver_->fn.glUniformMatrix3x2fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix3x4fvFn(GLint location,
+                                       GLsizei count,
+                                       GLboolean transpose,
+                                       const GLfloat* value) {
+  driver_->fn.glUniformMatrix3x4fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix4fvFn(GLint location,
+                                     GLsizei count,
+                                     GLboolean transpose,
+                                     const GLfloat* value) {
+  driver_->fn.glUniformMatrix4fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix4x2fvFn(GLint location,
+                                       GLsizei count,
+                                       GLboolean transpose,
+                                       const GLfloat* value) {
+  driver_->fn.glUniformMatrix4x2fvFn(location, count, transpose, value);
+}
+
+void GLApiBase::glUniformMatrix4x3fvFn(GLint location,
+                                       GLsizei count,
+                                       GLboolean transpose,
+                                       const GLfloat* value) {
+  driver_->fn.glUniformMatrix4x3fvFn(location, count, transpose, value);
+}
+
+GLboolean GLApiBase::glUnmapBufferFn(GLenum target) {
+  return driver_->fn.glUnmapBufferFn(target);
+}
+
+void GLApiBase::glUseProgramFn(GLuint program) {
+  driver_->fn.glUseProgramFn(program);
+}
+
+void GLApiBase::glValidateProgramFn(GLuint program) {
+  driver_->fn.glValidateProgramFn(program);
+}
+
+void GLApiBase::glVertexAttrib1fFn(GLuint indx, GLfloat x) {
+  driver_->fn.glVertexAttrib1fFn(indx, x);
+}
+
+void GLApiBase::glVertexAttrib1fvFn(GLuint indx, const GLfloat* values) {
+  driver_->fn.glVertexAttrib1fvFn(indx, values);
+}
+
+void GLApiBase::glVertexAttrib2fFn(GLuint indx, GLfloat x, GLfloat y) {
+  driver_->fn.glVertexAttrib2fFn(indx, x, y);
+}
+
+void GLApiBase::glVertexAttrib2fvFn(GLuint indx, const GLfloat* values) {
+  driver_->fn.glVertexAttrib2fvFn(indx, values);
+}
+
+void GLApiBase::glVertexAttrib3fFn(GLuint indx,
+                                   GLfloat x,
+                                   GLfloat y,
+                                   GLfloat z) {
+  driver_->fn.glVertexAttrib3fFn(indx, x, y, z);
+}
+
+void GLApiBase::glVertexAttrib3fvFn(GLuint indx, const GLfloat* values) {
+  driver_->fn.glVertexAttrib3fvFn(indx, values);
+}
+
+void GLApiBase::glVertexAttrib4fFn(GLuint indx,
+                                   GLfloat x,
+                                   GLfloat y,
+                                   GLfloat z,
+                                   GLfloat w) {
+  driver_->fn.glVertexAttrib4fFn(indx, x, y, z, w);
+}
+
+void GLApiBase::glVertexAttrib4fvFn(GLuint indx, const GLfloat* values) {
+  driver_->fn.glVertexAttrib4fvFn(indx, values);
+}
+
+void GLApiBase::glVertexAttribDivisorANGLEFn(GLuint index, GLuint divisor) {
+  driver_->fn.glVertexAttribDivisorANGLEFn(index, divisor);
+}
+
+void GLApiBase::glVertexAttribI4iFn(GLuint indx,
+                                    GLint x,
+                                    GLint y,
+                                    GLint z,
+                                    GLint w) {
+  driver_->fn.glVertexAttribI4iFn(indx, x, y, z, w);
+}
+
+void GLApiBase::glVertexAttribI4ivFn(GLuint indx, const GLint* values) {
+  driver_->fn.glVertexAttribI4ivFn(indx, values);
+}
+
+void GLApiBase::glVertexAttribI4uiFn(GLuint indx,
+                                     GLuint x,
+                                     GLuint y,
+                                     GLuint z,
+                                     GLuint w) {
+  driver_->fn.glVertexAttribI4uiFn(indx, x, y, z, w);
+}
+
+void GLApiBase::glVertexAttribI4uivFn(GLuint indx, const GLuint* values) {
+  driver_->fn.glVertexAttribI4uivFn(indx, values);
+}
+
+void GLApiBase::glVertexAttribIPointerFn(GLuint indx,
+                                         GLint size,
+                                         GLenum type,
+                                         GLsizei stride,
+                                         const void* ptr) {
+  driver_->fn.glVertexAttribIPointerFn(indx, size, type, stride, ptr);
+}
+
+void GLApiBase::glVertexAttribPointerFn(GLuint indx,
+                                        GLint size,
+                                        GLenum type,
+                                        GLboolean normalized,
+                                        GLsizei stride,
+                                        const void* ptr) {
+  driver_->fn.glVertexAttribPointerFn(indx, size, type, normalized, stride,
+                                      ptr);
+}
+
+void GLApiBase::glViewportFn(GLint x, GLint y, GLsizei width, GLsizei height) {
+  driver_->fn.glViewportFn(x, y, width, height);
+}
+
+GLenum GLApiBase::glWaitSyncFn(GLsync sync,
+                               GLbitfield flags,
+                               GLuint64 timeout) {
+  return driver_->fn.glWaitSyncFn(sync, flags, timeout);
+}
+
+}  // namespace gl