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

ui/gl/gl_bindings_autogen_gl0.cc

Index: ui/gl/gl_bindings_autogen_gl0.cc
diff --git a/ui/gl/gl_bindings_autogen_gl0.cc b/ui/gl/gl_bindings_autogen_gl0.cc
new file mode 100644
index 0000000000000000000000000000000000000000..cf5df3e83d9095e01fea6c18381d8ebc2ecc28ee
--- /dev/null
+++ b/ui/gl/gl_bindings_autogen_gl0.cc
@@ -0,0 +1,2453 @@
+// 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 DriverGL::InitializeStaticBindings() {
+  fn.glActiveTextureFn = reinterpret_cast<glActiveTextureProc>(
+      GetGLProcAddress("glActiveTexture"));
+  fn.glApplyFramebufferAttachmentCMAAINTELFn = 0;
+  fn.glAttachShaderFn =
+      reinterpret_cast<glAttachShaderProc>(GetGLProcAddress("glAttachShader"));
+  fn.glBeginQueryFn = 0;
+  fn.glBeginTransformFeedbackFn = 0;
+  fn.glBindAttribLocationFn = reinterpret_cast<glBindAttribLocationProc>(
+      GetGLProcAddress("glBindAttribLocation"));
+  fn.glBindBufferFn =
+      reinterpret_cast<glBindBufferProc>(GetGLProcAddress("glBindBuffer"));
+  fn.glBindBufferBaseFn = 0;
+  fn.glBindBufferRangeFn = 0;
+  fn.glBindFragDataLocationFn = 0;
+  fn.glBindFragDataLocationIndexedFn = 0;
+  fn.glBindFramebufferEXTFn = 0;
+  fn.glBindImageTextureEXTFn = 0;
+  fn.glBindRenderbufferEXTFn = 0;
+  fn.glBindSamplerFn = 0;
+  fn.glBindTextureFn =
+      reinterpret_cast<glBindTextureProc>(GetGLProcAddress("glBindTexture"));
+  fn.glBindTransformFeedbackFn = 0;
+  fn.glBindUniformLocationCHROMIUMFn = 0;
+  fn.glBindVertexArrayOESFn = 0;
+  fn.glBlendBarrierKHRFn = 0;
+  fn.glBlendColorFn =
+      reinterpret_cast<glBlendColorProc>(GetGLProcAddress("glBlendColor"));
+  fn.glBlendEquationFn = reinterpret_cast<glBlendEquationProc>(
+      GetGLProcAddress("glBlendEquation"));
+  fn.glBlendEquationSeparateFn = reinterpret_cast<glBlendEquationSeparateProc>(
+      GetGLProcAddress("glBlendEquationSeparate"));
+  fn.glBlendFuncFn =
+      reinterpret_cast<glBlendFuncProc>(GetGLProcAddress("glBlendFunc"));
+  fn.glBlendFuncSeparateFn = reinterpret_cast<glBlendFuncSeparateProc>(
+      GetGLProcAddress("glBlendFuncSeparate"));
+  fn.glBlitFramebufferFn = 0;
+  fn.glBlitFramebufferANGLEFn = 0;
+  fn.glBlitFramebufferEXTFn = 0;
+  fn.glBufferDataFn =
+      reinterpret_cast<glBufferDataProc>(GetGLProcAddress("glBufferData"));
+  fn.glBufferSubDataFn = reinterpret_cast<glBufferSubDataProc>(
+      GetGLProcAddress("glBufferSubData"));
+  fn.glCheckFramebufferStatusEXTFn = 0;
+  fn.glClearFn = reinterpret_cast<glClearProc>(GetGLProcAddress("glClear"));
+  fn.glClearBufferfiFn = 0;
+  fn.glClearBufferfvFn = 0;
+  fn.glClearBufferivFn = 0;
+  fn.glClearBufferuivFn = 0;
+  fn.glClearColorFn =
+      reinterpret_cast<glClearColorProc>(GetGLProcAddress("glClearColor"));
+  fn.glClearDepthFn =
+      reinterpret_cast<glClearDepthProc>(GetGLProcAddress("glClearDepth"));
+  fn.glClearDepthfFn = 0;
+  fn.glClearStencilFn =
+      reinterpret_cast<glClearStencilProc>(GetGLProcAddress("glClearStencil"));
+  fn.glClientWaitSyncFn = 0;
+  fn.glColorMaskFn =
+      reinterpret_cast<glColorMaskProc>(GetGLProcAddress("glColorMask"));
+  fn.glCompileShaderFn = reinterpret_cast<glCompileShaderProc>(
+      GetGLProcAddress("glCompileShader"));
+  fn.glCompressedCopyTextureCHROMIUMFn = 0;
+  fn.glCompressedTexImage2DFn = reinterpret_cast<glCompressedTexImage2DProc>(
+      GetGLProcAddress("glCompressedTexImage2D"));
+  fn.glCompressedTexImage3DFn = 0;
+  fn.glCompressedTexSubImage2DFn =
+      reinterpret_cast<glCompressedTexSubImage2DProc>(
+          GetGLProcAddress("glCompressedTexSubImage2D"));
+  fn.glCompressedTexSubImage3DFn = 0;
+  fn.glCopyBufferSubDataFn = 0;
+  fn.glCopySubTextureCHROMIUMFn = 0;
+  fn.glCopyTexImage2DFn = reinterpret_cast<glCopyTexImage2DProc>(
+      GetGLProcAddress("glCopyTexImage2D"));
+  fn.glCopyTexSubImage2DFn = reinterpret_cast<glCopyTexSubImage2DProc>(
+      GetGLProcAddress("glCopyTexSubImage2D"));
+  fn.glCopyTexSubImage3DFn = 0;
+  fn.glCopyTextureCHROMIUMFn = 0;
+  fn.glCoverageModulationNVFn = 0;
+  fn.glCoverFillPathInstancedNVFn = 0;
+  fn.glCoverFillPathNVFn = 0;
+  fn.glCoverStrokePathInstancedNVFn = 0;
+  fn.glCoverStrokePathNVFn = 0;
+  fn.glCreateProgramFn = reinterpret_cast<glCreateProgramProc>(
+      GetGLProcAddress("glCreateProgram"));
+  fn.glCreateShaderFn =
+      reinterpret_cast<glCreateShaderProc>(GetGLProcAddress("glCreateShader"));
+  fn.glCullFaceFn =
+      reinterpret_cast<glCullFaceProc>(GetGLProcAddress("glCullFace"));
+  fn.glDebugMessageCallbackFn = 0;
+  fn.glDebugMessageControlFn = 0;
+  fn.glDebugMessageInsertFn = 0;
+  fn.glDeleteBuffersARBFn = reinterpret_cast<glDeleteBuffersARBProc>(
+      GetGLProcAddress("glDeleteBuffers"));
+  fn.glDeleteFencesAPPLEFn = 0;
+  fn.glDeleteFencesNVFn = 0;
+  fn.glDeleteFramebuffersEXTFn = 0;
+  fn.glDeletePathsNVFn = 0;
+  fn.glDeleteProgramFn = reinterpret_cast<glDeleteProgramProc>(
+      GetGLProcAddress("glDeleteProgram"));
+  fn.glDeleteQueriesFn = 0;
+  fn.glDeleteRenderbuffersEXTFn = 0;
+  fn.glDeleteSamplersFn = 0;
+  fn.glDeleteShaderFn =
+      reinterpret_cast<glDeleteShaderProc>(GetGLProcAddress("glDeleteShader"));
+  fn.glDeleteSyncFn = 0;
+  fn.glDeleteTexturesFn = reinterpret_cast<glDeleteTexturesProc>(
+      GetGLProcAddress("glDeleteTextures"));
+  fn.glDeleteTransformFeedbacksFn = 0;
+  fn.glDeleteVertexArraysOESFn = 0;
+  fn.glDepthFuncFn =
+      reinterpret_cast<glDepthFuncProc>(GetGLProcAddress("glDepthFunc"));
+  fn.glDepthMaskFn =
+      reinterpret_cast<glDepthMaskProc>(GetGLProcAddress("glDepthMask"));
+  fn.glDepthRangeFn =
+      reinterpret_cast<glDepthRangeProc>(GetGLProcAddress("glDepthRange"));
+  fn.glDepthRangefFn = 0;
+  fn.glDetachShaderFn =
+      reinterpret_cast<glDetachShaderProc>(GetGLProcAddress("glDetachShader"));
+  fn.glDisableFn =
+      reinterpret_cast<glDisableProc>(GetGLProcAddress("glDisable"));
+  fn.glDisableVertexAttribArrayFn =
+      reinterpret_cast<glDisableVertexAttribArrayProc>(
+          GetGLProcAddress("glDisableVertexAttribArray"));
+  fn.glDiscardFramebufferEXTFn = 0;
+  fn.glDrawArraysFn =
+      reinterpret_cast<glDrawArraysProc>(GetGLProcAddress("glDrawArrays"));
+  fn.glDrawArraysInstancedANGLEFn = 0;
+  fn.glDrawBufferFn = 0;
+  fn.glDrawBuffersARBFn = 0;
+  fn.glDrawElementsFn =
+      reinterpret_cast<glDrawElementsProc>(GetGLProcAddress("glDrawElements"));
+  fn.glDrawElementsInstancedANGLEFn = 0;
+  fn.glDrawRangeElementsFn = 0;
+  fn.glEGLImageTargetRenderbufferStorageOESFn = 0;
+  fn.glEGLImageTargetTexture2DOESFn = 0;
+  fn.glEnableFn = reinterpret_cast<glEnableProc>(GetGLProcAddress("glEnable"));
+  fn.glEnableVertexAttribArrayFn =
+      reinterpret_cast<glEnableVertexAttribArrayProc>(
+          GetGLProcAddress("glEnableVertexAttribArray"));
+  fn.glEndQueryFn = 0;
+  fn.glEndTransformFeedbackFn = 0;
+  fn.glFenceSyncFn = 0;
+  fn.glFinishFn = reinterpret_cast<glFinishProc>(GetGLProcAddress("glFinish"));
+  fn.glFinishFenceAPPLEFn = 0;
+  fn.glFinishFenceNVFn = 0;
+  fn.glFlushFn = reinterpret_cast<glFlushProc>(GetGLProcAddress("glFlush"));
+  fn.glFlushMappedBufferRangeFn = 0;
+  fn.glFramebufferRenderbufferEXTFn = 0;
+  fn.glFramebufferTexture2DEXTFn = 0;
+  fn.glFramebufferTexture2DMultisampleEXTFn = 0;
+  fn.glFramebufferTexture2DMultisampleIMGFn = 0;
+  fn.glFramebufferTextureLayerFn = 0;
+  fn.glFrontFaceFn =
+      reinterpret_cast<glFrontFaceProc>(GetGLProcAddress("glFrontFace"));
+  fn.glGenBuffersARBFn =
+      reinterpret_cast<glGenBuffersARBProc>(GetGLProcAddress("glGenBuffers"));
+  fn.glGenerateMipmapEXTFn = 0;
+  fn.glGenFencesAPPLEFn = 0;
+  fn.glGenFencesNVFn = 0;
+  fn.glGenFramebuffersEXTFn = 0;
+  fn.glGenPathsNVFn = 0;
+  fn.glGenQueriesFn = 0;
+  fn.glGenRenderbuffersEXTFn = 0;
+  fn.glGenSamplersFn = 0;
+  fn.glGenTexturesFn =
+      reinterpret_cast<glGenTexturesProc>(GetGLProcAddress("glGenTextures"));
+  fn.glGenTransformFeedbacksFn = 0;
+  fn.glGenVertexArraysOESFn = 0;
+  fn.glGetActiveAttribFn = reinterpret_cast<glGetActiveAttribProc>(
+      GetGLProcAddress("glGetActiveAttrib"));
+  fn.glGetActiveUniformFn = reinterpret_cast<glGetActiveUniformProc>(
+      GetGLProcAddress("glGetActiveUniform"));
+  fn.glGetActiveUniformBlockivFn = 0;
+  fn.glGetActiveUniformBlockivRobustANGLEFn = 0;
+  fn.glGetActiveUniformBlockNameFn = 0;
+  fn.glGetActiveUniformsivFn = 0;
+  fn.glGetAttachedShadersFn = reinterpret_cast<glGetAttachedShadersProc>(
+      GetGLProcAddress("glGetAttachedShaders"));
+  fn.glGetAttribLocationFn = reinterpret_cast<glGetAttribLocationProc>(
+      GetGLProcAddress("glGetAttribLocation"));
+  fn.glGetBooleani_vRobustANGLEFn = 0;
+  fn.glGetBooleanvFn =
+      reinterpret_cast<glGetBooleanvProc>(GetGLProcAddress("glGetBooleanv"));
+  fn.glGetBooleanvRobustANGLEFn = 0;
+  fn.glGetBufferParameteri64vRobustANGLEFn = 0;
+  fn.glGetBufferParameterivFn = reinterpret_cast<glGetBufferParameterivProc>(
+      GetGLProcAddress("glGetBufferParameteriv"));
+  fn.glGetBufferParameterivRobustANGLEFn = 0;
+  fn.glGetBufferPointervRobustANGLEFn = 0;
+  fn.glGetDebugMessageLogFn = 0;
+  fn.glGetErrorFn =
+      reinterpret_cast<glGetErrorProc>(GetGLProcAddress("glGetError"));
+  fn.glGetFenceivNVFn = 0;
+  fn.glGetFloatvFn =
+      reinterpret_cast<glGetFloatvProc>(GetGLProcAddress("glGetFloatv"));
+  fn.glGetFloatvRobustANGLEFn = 0;
+  fn.glGetFragDataIndexFn = 0;
+  fn.glGetFragDataLocationFn = 0;
+  fn.glGetFramebufferAttachmentParameterivEXTFn = 0;
+  fn.glGetFramebufferAttachmentParameterivRobustANGLEFn = 0;
+  fn.glGetFramebufferParameterivRobustANGLEFn = 0;
+  fn.glGetGraphicsResetStatusARBFn = 0;
+  fn.glGetInteger64i_vFn = 0;
+  fn.glGetInteger64i_vRobustANGLEFn = 0;
+  fn.glGetInteger64vFn = 0;
+  fn.glGetInteger64vRobustANGLEFn = 0;
+  fn.glGetIntegeri_vFn = 0;
+  fn.glGetIntegeri_vRobustANGLEFn = 0;
+  fn.glGetIntegervFn =
+      reinterpret_cast<glGetIntegervProc>(GetGLProcAddress("glGetIntegerv"));
+  fn.glGetIntegervRobustANGLEFn = 0;
+  fn.glGetInternalformativFn = 0;
+  fn.glGetInternalformativRobustANGLEFn = 0;
+  fn.glGetMultisamplefvRobustANGLEFn = 0;
+  fn.glGetnUniformfvRobustANGLEFn = 0;
+  fn.glGetnUniformivRobustANGLEFn = 0;
+  fn.glGetnUniformuivRobustANGLEFn = 0;
+  fn.glGetObjectLabelFn = 0;
+  fn.glGetObjectPtrLabelFn = 0;
+  fn.glGetPointervFn = 0;
+  fn.glGetPointervRobustANGLERobustANGLEFn = 0;
+  fn.glGetProgramBinaryFn = 0;
+  fn.glGetProgramInfoLogFn = reinterpret_cast<glGetProgramInfoLogProc>(
+      GetGLProcAddress("glGetProgramInfoLog"));
+  fn.glGetProgramInterfaceivFn = 0;
+  fn.glGetProgramInterfaceivRobustANGLEFn = 0;
+  fn.glGetProgramivFn =
+      reinterpret_cast<glGetProgramivProc>(GetGLProcAddress("glGetProgramiv"));
+  fn.glGetProgramivRobustANGLEFn = 0;
+  fn.glGetProgramResourceivFn = 0;
+  fn.glGetProgramResourceLocationFn = 0;
+  fn.glGetProgramResourceNameFn = 0;
+  fn.glGetQueryivFn = 0;
+  fn.glGetQueryivRobustANGLEFn = 0;
+  fn.glGetQueryObjecti64vFn = 0;
+  fn.glGetQueryObjecti64vRobustANGLEFn = 0;
+  fn.glGetQueryObjectivFn = 0;
+  fn.glGetQueryObjectivRobustANGLEFn = 0;
+  fn.glGetQueryObjectui64vFn = 0;
+  fn.glGetQueryObjectui64vRobustANGLEFn = 0;
+  fn.glGetQueryObjectuivFn = 0;
+  fn.glGetQueryObjectuivRobustANGLEFn = 0;
+  fn.glGetRenderbufferParameterivEXTFn = 0;
+  fn.glGetRenderbufferParameterivRobustANGLEFn = 0;
+  fn.glGetSamplerParameterfvFn = 0;
+  fn.glGetSamplerParameterfvRobustANGLEFn = 0;
+  fn.glGetSamplerParameterIivRobustANGLEFn = 0;
+  fn.glGetSamplerParameterIuivRobustANGLEFn = 0;
+  fn.glGetSamplerParameterivFn = 0;
+  fn.glGetSamplerParameterivRobustANGLEFn = 0;
+  fn.glGetShaderInfoLogFn = reinterpret_cast<glGetShaderInfoLogProc>(
+      GetGLProcAddress("glGetShaderInfoLog"));
+  fn.glGetShaderivFn =
+      reinterpret_cast<glGetShaderivProc>(GetGLProcAddress("glGetShaderiv"));
+  fn.glGetShaderivRobustANGLEFn = 0;
+  fn.glGetShaderPrecisionFormatFn = 0;
+  fn.glGetShaderSourceFn = reinterpret_cast<glGetShaderSourceProc>(
+      GetGLProcAddress("glGetShaderSource"));
+  fn.glGetStringFn =
+      reinterpret_cast<glGetStringProc>(GetGLProcAddress("glGetString"));
+  fn.glGetStringiFn =
+      reinterpret_cast<glGetStringiProc>(GetGLProcAddress("glGetStringi"));
+  fn.glGetSyncivFn = 0;
+  fn.glGetTexLevelParameterfvFn = 0;
+  fn.glGetTexLevelParameterfvRobustANGLEFn = 0;
+  fn.glGetTexLevelParameterivFn = 0;
+  fn.glGetTexLevelParameterivRobustANGLEFn = 0;
+  fn.glGetTexParameterfvFn = reinterpret_cast<glGetTexParameterfvProc>(
+      GetGLProcAddress("glGetTexParameterfv"));
+  fn.glGetTexParameterfvRobustANGLEFn = 0;
+  fn.glGetTexParameterIivRobustANGLEFn = 0;
+  fn.glGetTexParameterIuivRobustANGLEFn = 0;
+  fn.glGetTexParameterivFn = reinterpret_cast<glGetTexParameterivProc>(
+      GetGLProcAddress("glGetTexParameteriv"));
+  fn.glGetTexParameterivRobustANGLEFn = 0;
+  fn.glGetTransformFeedbackVaryingFn = 0;
+  fn.glGetTranslatedShaderSourceANGLEFn = 0;
+  fn.glGetUniformBlockIndexFn = 0;
+  fn.glGetUniformfvFn =
+      reinterpret_cast<glGetUniformfvProc>(GetGLProcAddress("glGetUniformfv"));
+  fn.glGetUniformfvRobustANGLEFn = 0;
+  fn.glGetUniformIndicesFn = 0;
+  fn.glGetUniformivFn =
+      reinterpret_cast<glGetUniformivProc>(GetGLProcAddress("glGetUniformiv"));
+  fn.glGetUniformivRobustANGLEFn = 0;
+  fn.glGetUniformLocationFn = reinterpret_cast<glGetUniformLocationProc>(
+      GetGLProcAddress("glGetUniformLocation"));
+  fn.glGetUniformuivFn = 0;
+  fn.glGetUniformuivRobustANGLEFn = 0;
+  fn.glGetVertexAttribfvFn = reinterpret_cast<glGetVertexAttribfvProc>(
+      GetGLProcAddress("glGetVertexAttribfv"));
+  fn.glGetVertexAttribfvRobustANGLEFn = 0;
+  fn.glGetVertexAttribIivRobustANGLEFn = 0;
+  fn.glGetVertexAttribIuivRobustANGLEFn = 0;
+  fn.glGetVertexAttribivFn = reinterpret_cast<glGetVertexAttribivProc>(
+      GetGLProcAddress("glGetVertexAttribiv"));
+  fn.glGetVertexAttribivRobustANGLEFn = 0;
+  fn.glGetVertexAttribPointervFn =
+      reinterpret_cast<glGetVertexAttribPointervProc>(
+          GetGLProcAddress("glGetVertexAttribPointerv"));
+  fn.glGetVertexAttribPointervRobustANGLEFn = 0;
+  fn.glHintFn = reinterpret_cast<glHintProc>(GetGLProcAddress("glHint"));
+  fn.glInsertEventMarkerEXTFn = 0;
+  fn.glInvalidateFramebufferFn = 0;
+  fn.glInvalidateSubFramebufferFn = 0;
+  fn.glIsBufferFn =
+      reinterpret_cast<glIsBufferProc>(GetGLProcAddress("glIsBuffer"));
+  fn.glIsEnabledFn =
+      reinterpret_cast<glIsEnabledProc>(GetGLProcAddress("glIsEnabled"));
+  fn.glIsFenceAPPLEFn = 0;
+  fn.glIsFenceNVFn = 0;
+  fn.glIsFramebufferEXTFn = 0;
+  fn.glIsPathNVFn = 0;
+  fn.glIsProgramFn =
+      reinterpret_cast<glIsProgramProc>(GetGLProcAddress("glIsProgram"));
+  fn.glIsQueryFn = 0;
+  fn.glIsRenderbufferEXTFn = 0;
+  fn.glIsSamplerFn = 0;
+  fn.glIsShaderFn =
+      reinterpret_cast<glIsShaderProc>(GetGLProcAddress("glIsShader"));
+  fn.glIsSyncFn = 0;
+  fn.glIsTextureFn =
+      reinterpret_cast<glIsTextureProc>(GetGLProcAddress("glIsTexture"));
+  fn.glIsTransformFeedbackFn = 0;
+  fn.glIsVertexArrayOESFn = 0;
+  fn.glLineWidthFn =
+      reinterpret_cast<glLineWidthProc>(GetGLProcAddress("glLineWidth"));
+  fn.glLinkProgramFn =
+      reinterpret_cast<glLinkProgramProc>(GetGLProcAddress("glLinkProgram"));
+  fn.glMapBufferFn = 0;
+  fn.glMapBufferRangeFn = 0;
+  fn.glMatrixLoadfEXTFn = 0;
+  fn.glMatrixLoadIdentityEXTFn = 0;
+  fn.glMemoryBarrierEXTFn = 0;
+  fn.glObjectLabelFn = 0;
+  fn.glObjectPtrLabelFn = 0;
+  fn.glPathCommandsNVFn = 0;
+  fn.glPathParameterfNVFn = 0;
+  fn.glPathParameteriNVFn = 0;
+  fn.glPathStencilFuncNVFn = 0;
+  fn.glPauseTransformFeedbackFn = 0;
+  fn.glPixelStoreiFn =
+      reinterpret_cast<glPixelStoreiProc>(GetGLProcAddress("glPixelStorei"));
+  fn.glPointParameteriFn = 0;
+  fn.glPolygonOffsetFn = reinterpret_cast<glPolygonOffsetProc>(
+      GetGLProcAddress("glPolygonOffset"));
+  fn.glPopDebugGroupFn = 0;
+  fn.glPopGroupMarkerEXTFn = 0;
+  fn.glPrimitiveRestartIndexFn = 0;
+  fn.glProgramBinaryFn = 0;
+  fn.glProgramParameteriFn = 0;
+  fn.glProgramPathFragmentInputGenNVFn = 0;
+  fn.glPushDebugGroupFn = 0;
+  fn.glPushGroupMarkerEXTFn = 0;
+  fn.glQueryCounterFn = 0;
+  fn.glReadBufferFn = 0;
+  fn.glReadnPixelsRobustANGLEFn = 0;
+  fn.glReadPixelsFn =
+      reinterpret_cast<glReadPixelsProc>(GetGLProcAddress("glReadPixels"));
+  fn.glReadPixelsRobustANGLEFn = 0;
+  fn.glReleaseShaderCompilerFn = 0;
+  fn.glRenderbufferStorageEXTFn = 0;
+  fn.glRenderbufferStorageMultisampleFn = 0;
+  fn.glRenderbufferStorageMultisampleANGLEFn = 0;
+  fn.glRenderbufferStorageMultisampleEXTFn = 0;
+  fn.glRenderbufferStorageMultisampleIMGFn = 0;
+  fn.glResumeTransformFeedbackFn = 0;
+  fn.glSampleCoverageFn = reinterpret_cast<glSampleCoverageProc>(
+      GetGLProcAddress("glSampleCoverage"));
+  fn.glSamplerParameterfFn = 0;
+  fn.glSamplerParameterfvFn = 0;
+  fn.glSamplerParameterfvRobustANGLEFn = 0;
+  fn.glSamplerParameteriFn = 0;
+  fn.glSamplerParameterIivRobustANGLEFn = 0;
+  fn.glSamplerParameterIuivRobustANGLEFn = 0;
+  fn.glSamplerParameterivFn = 0;
+  fn.glSamplerParameterivRobustANGLEFn = 0;
+  fn.glScissorFn =
+      reinterpret_cast<glScissorProc>(GetGLProcAddress("glScissor"));
+  fn.glSetFenceAPPLEFn = 0;
+  fn.glSetFenceNVFn = 0;
+  fn.glShaderBinaryFn = 0;
+  fn.glShaderSourceFn =
+      reinterpret_cast<glShaderSourceProc>(GetGLProcAddress("glShaderSource"));
+  fn.glStencilFillPathInstancedNVFn = 0;
+  fn.glStencilFillPathNVFn = 0;
+  fn.glStencilFuncFn =
+      reinterpret_cast<glStencilFuncProc>(GetGLProcAddress("glStencilFunc"));
+  fn.glStencilFuncSeparateFn = reinterpret_cast<glStencilFuncSeparateProc>(
+      GetGLProcAddress("glStencilFuncSeparate"));
+  fn.glStencilMaskFn =
+      reinterpret_cast<glStencilMaskProc>(GetGLProcAddress("glStencilMask"));
+  fn.glStencilMaskSeparateFn = reinterpret_cast<glStencilMaskSeparateProc>(
+      GetGLProcAddress("glStencilMaskSeparate"));
+  fn.glStencilOpFn =
+      reinterpret_cast<glStencilOpProc>(GetGLProcAddress("glStencilOp"));
+  fn.glStencilOpSeparateFn = reinterpret_cast<glStencilOpSeparateProc>(
+      GetGLProcAddress("glStencilOpSeparate"));
+  fn.glStencilStrokePathInstancedNVFn = 0;
+  fn.glStencilStrokePathNVFn = 0;
+  fn.glStencilThenCoverFillPathInstancedNVFn = 0;
+  fn.glStencilThenCoverFillPathNVFn = 0;
+  fn.glStencilThenCoverStrokePathInstancedNVFn = 0;
+  fn.glStencilThenCoverStrokePathNVFn = 0;
+  fn.glTestFenceAPPLEFn = 0;
+  fn.glTestFenceNVFn = 0;
+  fn.glTexImage2DFn =
+      reinterpret_cast<glTexImage2DProc>(GetGLProcAddress("glTexImage2D"));
+  fn.glTexImage2DRobustANGLEFn = 0;
+  fn.glTexImage3DFn = 0;
+  fn.glTexImage3DRobustANGLEFn = 0;
+  fn.glTexParameterfFn = reinterpret_cast<glTexParameterfProc>(
+      GetGLProcAddress("glTexParameterf"));
+  fn.glTexParameterfvFn = reinterpret_cast<glTexParameterfvProc>(
+      GetGLProcAddress("glTexParameterfv"));
+  fn.glTexParameterfvRobustANGLEFn = 0;
+  fn.glTexParameteriFn = reinterpret_cast<glTexParameteriProc>(
+      GetGLProcAddress("glTexParameteri"));
+  fn.glTexParameterIivRobustANGLEFn = 0;
+  fn.glTexParameterIuivRobustANGLEFn = 0;
+  fn.glTexParameterivFn = reinterpret_cast<glTexParameterivProc>(
+      GetGLProcAddress("glTexParameteriv"));
+  fn.glTexParameterivRobustANGLEFn = 0;
+  fn.glTexStorage2DEXTFn = 0;
+  fn.glTexStorage3DFn = 0;
+  fn.glTexSubImage2DFn = reinterpret_cast<glTexSubImage2DProc>(
+      GetGLProcAddress("glTexSubImage2D"));
+  fn.glTexSubImage2DRobustANGLEFn = 0;
+  fn.glTexSubImage3DFn = 0;
+  fn.glTexSubImage3DRobustANGLEFn = 0;
+  fn.glTransformFeedbackVaryingsFn = 0;
+  fn.glUniform1fFn =
+      reinterpret_cast<glUniform1fProc>(GetGLProcAddress("glUniform1f"));
+  fn.glUniform1fvFn =
+      reinterpret_cast<glUniform1fvProc>(GetGLProcAddress("glUniform1fv"));
+  fn.glUniform1iFn =
+      reinterpret_cast<glUniform1iProc>(GetGLProcAddress("glUniform1i"));
+  fn.glUniform1ivFn =
+      reinterpret_cast<glUniform1ivProc>(GetGLProcAddress("glUniform1iv"));
+  fn.glUniform1uiFn = 0;
+  fn.glUniform1uivFn = 0;
+  fn.glUniform2fFn =
+      reinterpret_cast<glUniform2fProc>(GetGLProcAddress("glUniform2f"));
+  fn.glUniform2fvFn =
+      reinterpret_cast<glUniform2fvProc>(GetGLProcAddress("glUniform2fv"));
+  fn.glUniform2iFn =
+      reinterpret_cast<glUniform2iProc>(GetGLProcAddress("glUniform2i"));
+  fn.glUniform2ivFn =
+      reinterpret_cast<glUniform2ivProc>(GetGLProcAddress("glUniform2iv"));
+  fn.glUniform2uiFn = 0;
+  fn.glUniform2uivFn = 0;
+  fn.glUniform3fFn =
+      reinterpret_cast<glUniform3fProc>(GetGLProcAddress("glUniform3f"));
+  fn.glUniform3fvFn =
+      reinterpret_cast<glUniform3fvProc>(GetGLProcAddress("glUniform3fv"));
+  fn.glUniform3iFn =
+      reinterpret_cast<glUniform3iProc>(GetGLProcAddress("glUniform3i"));
+  fn.glUniform3ivFn =
+      reinterpret_cast<glUniform3ivProc>(GetGLProcAddress("glUniform3iv"));
+  fn.glUniform3uiFn = 0;
+  fn.glUniform3uivFn = 0;
+  fn.glUniform4fFn =
+      reinterpret_cast<glUniform4fProc>(GetGLProcAddress("glUniform4f"));
+  fn.glUniform4fvFn =
+      reinterpret_cast<glUniform4fvProc>(GetGLProcAddress("glUniform4fv"));
+  fn.glUniform4iFn =
+      reinterpret_cast<glUniform4iProc>(GetGLProcAddress("glUniform4i"));
+  fn.glUniform4ivFn =
+      reinterpret_cast<glUniform4ivProc>(GetGLProcAddress("glUniform4iv"));
+  fn.glUniform4uiFn = 0;
+  fn.glUniform4uivFn = 0;
+  fn.glUniformBlockBindingFn = 0;
+  fn.glUniformMatrix2fvFn = reinterpret_cast<glUniformMatrix2fvProc>(
+      GetGLProcAddress("glUniformMatrix2fv"));
+  fn.glUniformMatrix2x3fvFn = 0;
+  fn.glUniformMatrix2x4fvFn = 0;
+  fn.glUniformMatrix3fvFn = reinterpret_cast<glUniformMatrix3fvProc>(
+      GetGLProcAddress("glUniformMatrix3fv"));
+  fn.glUniformMatrix3x2fvFn = 0;
+  fn.glUniformMatrix3x4fvFn = 0;
+  fn.glUniformMatrix4fvFn = reinterpret_cast<glUniformMatrix4fvProc>(
+      GetGLProcAddress("glUniformMatrix4fv"));
+  fn.glUniformMatrix4x2fvFn = 0;
+  fn.glUniformMatrix4x3fvFn = 0;
+  fn.glUnmapBufferFn = 0;
+  fn.glUseProgramFn =
+      reinterpret_cast<glUseProgramProc>(GetGLProcAddress("glUseProgram"));
+  fn.glValidateProgramFn = reinterpret_cast<glValidateProgramProc>(
+      GetGLProcAddress("glValidateProgram"));
+  fn.glVertexAttrib1fFn = reinterpret_cast<glVertexAttrib1fProc>(
+      GetGLProcAddress("glVertexAttrib1f"));
+  fn.glVertexAttrib1fvFn = reinterpret_cast<glVertexAttrib1fvProc>(
+      GetGLProcAddress("glVertexAttrib1fv"));
+  fn.glVertexAttrib2fFn = reinterpret_cast<glVertexAttrib2fProc>(
+      GetGLProcAddress("glVertexAttrib2f"));
+  fn.glVertexAttrib2fvFn = reinterpret_cast<glVertexAttrib2fvProc>(
+      GetGLProcAddress("glVertexAttrib2fv"));
+  fn.glVertexAttrib3fFn = reinterpret_cast<glVertexAttrib3fProc>(
+      GetGLProcAddress("glVertexAttrib3f"));
+  fn.glVertexAttrib3fvFn = reinterpret_cast<glVertexAttrib3fvProc>(
+      GetGLProcAddress("glVertexAttrib3fv"));
+  fn.glVertexAttrib4fFn = reinterpret_cast<glVertexAttrib4fProc>(
+      GetGLProcAddress("glVertexAttrib4f"));
+  fn.glVertexAttrib4fvFn = reinterpret_cast<glVertexAttrib4fvProc>(
+      GetGLProcAddress("glVertexAttrib4fv"));
+  fn.glVertexAttribDivisorANGLEFn = 0;
+  fn.glVertexAttribI4iFn = 0;
+  fn.glVertexAttribI4ivFn = 0;
+  fn.glVertexAttribI4uiFn = 0;
+  fn.glVertexAttribI4uivFn = 0;
+  fn.glVertexAttribIPointerFn = 0;
+  fn.glVertexAttribPointerFn = reinterpret_cast<glVertexAttribPointerProc>(
+      GetGLProcAddress("glVertexAttribPointer"));
+  fn.glViewportFn =
+      reinterpret_cast<glViewportProc>(GetGLProcAddress("glViewport"));
+  fn.glWaitSyncFn = 0;
+}
+
+void DriverGL::InitializeDynamicBindings(
+    const GLVersionInfo* ver,
+    const std::string& context_extensions) {
+  std::string extensions = context_extensions + " ";
+  ALLOW_UNUSED_LOCAL(extensions);
+
+  ext.b_GL_ANGLE_framebuffer_blit =
+      extensions.find("GL_ANGLE_framebuffer_blit ") != std::string::npos;
+  ext.b_GL_ANGLE_framebuffer_multisample =
+      extensions.find("GL_ANGLE_framebuffer_multisample ") != std::string::npos;
+  ext.b_GL_ANGLE_instanced_arrays =
+      extensions.find("GL_ANGLE_instanced_arrays ") != std::string::npos;
+  ext.b_GL_ANGLE_robust_client_memory =
+      extensions.find("GL_ANGLE_robust_client_memory ") != std::string::npos;
+  ext.b_GL_ANGLE_translated_shader_source =
+      extensions.find("GL_ANGLE_translated_shader_source ") !=
+      std::string::npos;
+  ext.b_GL_APPLE_fence =
+      extensions.find("GL_APPLE_fence ") != std::string::npos;
+  ext.b_GL_APPLE_vertex_array_object =
+      extensions.find("GL_APPLE_vertex_array_object ") != std::string::npos;
+  ext.b_GL_ARB_blend_func_extended =
+      extensions.find("GL_ARB_blend_func_extended ") != std::string::npos;
+  ext.b_GL_ARB_draw_buffers =
+      extensions.find("GL_ARB_draw_buffers ") != std::string::npos;
+  ext.b_GL_ARB_draw_instanced =
+      extensions.find("GL_ARB_draw_instanced ") != std::string::npos;
+  ext.b_GL_ARB_get_program_binary =
+      extensions.find("GL_ARB_get_program_binary ") != std::string::npos;
+  ext.b_GL_ARB_instanced_arrays =
+      extensions.find("GL_ARB_instanced_arrays ") != std::string::npos;
+  ext.b_GL_ARB_map_buffer_range =
+      extensions.find("GL_ARB_map_buffer_range ") != std::string::npos;
+  ext.b_GL_ARB_occlusion_query =
+      extensions.find("GL_ARB_occlusion_query ") != std::string::npos;
+  ext.b_GL_ARB_program_interface_query =
+      extensions.find("GL_ARB_program_interface_query ") != std::string::npos;
+  ext.b_GL_ARB_robustness =
+      extensions.find("GL_ARB_robustness ") != std::string::npos;
+  ext.b_GL_ARB_sampler_objects =
+      extensions.find("GL_ARB_sampler_objects ") != std::string::npos;
+  ext.b_GL_ARB_shader_image_load_store =
+      extensions.find("GL_ARB_shader_image_load_store ") != std::string::npos;
+  ext.b_GL_ARB_sync = extensions.find("GL_ARB_sync ") != std::string::npos;
+  ext.b_GL_ARB_texture_storage =
+      extensions.find("GL_ARB_texture_storage ") != std::string::npos;
+  ext.b_GL_ARB_timer_query =
+      extensions.find("GL_ARB_timer_query ") != std::string::npos;
+  ext.b_GL_ARB_transform_feedback2 =
+      extensions.find("GL_ARB_transform_feedback2 ") != std::string::npos;
+  ext.b_GL_ARB_vertex_array_object =
+      extensions.find("GL_ARB_vertex_array_object ") != std::string::npos;
+  ext.b_GL_CHROMIUM_bind_uniform_location =
+      extensions.find("GL_CHROMIUM_bind_uniform_location ") !=
+      std::string::npos;
+  ext.b_GL_CHROMIUM_compressed_copy_texture =
+      extensions.find("GL_CHROMIUM_compressed_copy_texture ") !=
+      std::string::npos;
+  ext.b_GL_CHROMIUM_copy_compressed_texture =
+      extensions.find("GL_CHROMIUM_copy_compressed_texture ") !=
+      std::string::npos;
+  ext.b_GL_CHROMIUM_copy_texture =
+      extensions.find("GL_CHROMIUM_copy_texture ") != std::string::npos;
+  ext.b_GL_CHROMIUM_gles_depth_binding_hack =
+      extensions.find("GL_CHROMIUM_gles_depth_binding_hack ") !=
+      std::string::npos;
+  ext.b_GL_CHROMIUM_glgetstringi_hack =
+      extensions.find("GL_CHROMIUM_glgetstringi_hack ") != std::string::npos;
+  ext.b_GL_EXT_blend_func_extended =
+      extensions.find("GL_EXT_blend_func_extended ") != std::string::npos;
+  ext.b_GL_EXT_debug_marker =
+      extensions.find("GL_EXT_debug_marker ") != std::string::npos;
+  ext.b_GL_EXT_direct_state_access =
+      extensions.find("GL_EXT_direct_state_access ") != std::string::npos;
+  ext.b_GL_EXT_discard_framebuffer =
+      extensions.find("GL_EXT_discard_framebuffer ") != std::string::npos;
+  ext.b_GL_EXT_disjoint_timer_query =
+      extensions.find("GL_EXT_disjoint_timer_query ") != std::string::npos;
+  ext.b_GL_EXT_draw_buffers =
+      extensions.find("GL_EXT_draw_buffers ") != std::string::npos;
+  ext.b_GL_EXT_framebuffer_blit =
+      extensions.find("GL_EXT_framebuffer_blit ") != std::string::npos;
+  ext.b_GL_EXT_framebuffer_multisample =
+      extensions.find("GL_EXT_framebuffer_multisample ") != std::string::npos;
+  ext.b_GL_EXT_framebuffer_object =
+      extensions.find("GL_EXT_framebuffer_object ") != std::string::npos;
+  ext.b_GL_EXT_gpu_shader4 =
+      extensions.find("GL_EXT_gpu_shader4 ") != std::string::npos;
+  ext.b_GL_EXT_map_buffer_range =
+      extensions.find("GL_EXT_map_buffer_range ") != std::string::npos;
+  ext.b_GL_EXT_multisampled_render_to_texture =
+      extensions.find("GL_EXT_multisampled_render_to_texture ") !=
+      std::string::npos;
+  ext.b_GL_EXT_occlusion_query_boolean =
+      extensions.find("GL_EXT_occlusion_query_boolean ") != std::string::npos;
+  ext.b_GL_EXT_robustness =
+      extensions.find("GL_EXT_robustness ") != std::string::npos;
+  ext.b_GL_EXT_shader_image_load_store =
+      extensions.find("GL_EXT_shader_image_load_store ") != std::string::npos;
+  ext.b_GL_EXT_texture_storage =
+      extensions.find("GL_EXT_texture_storage ") != std::string::npos;
+  ext.b_GL_EXT_timer_query =
+      extensions.find("GL_EXT_timer_query ") != std::string::npos;
+  ext.b_GL_EXT_transform_feedback =
+      extensions.find("GL_EXT_transform_feedback ") != std::string::npos;
+  ext.b_GL_EXT_unpack_subimage =
+      extensions.find("GL_EXT_unpack_subimage ") != std::string::npos;
+  ext.b_GL_IMG_multisampled_render_to_texture =
+      extensions.find("GL_IMG_multisampled_render_to_texture ") !=
+      std::string::npos;
+  ext.b_GL_INTEL_framebuffer_CMAA =
+      extensions.find("GL_INTEL_framebuffer_CMAA ") != std::string::npos;
+  ext.b_GL_KHR_blend_equation_advanced =
+      extensions.find("GL_KHR_blend_equation_advanced ") != std::string::npos;
+  ext.b_GL_KHR_debug = extensions.find("GL_KHR_debug ") != std::string::npos;
+  ext.b_GL_KHR_robustness =
+      extensions.find("GL_KHR_robustness ") != std::string::npos;
+  ext.b_GL_NV_blend_equation_advanced =
+      extensions.find("GL_NV_blend_equation_advanced ") != std::string::npos;
+  ext.b_GL_NV_fence = extensions.find("GL_NV_fence ") != std::string::npos;
+  ext.b_GL_NV_framebuffer_mixed_samples =
+      extensions.find("GL_NV_framebuffer_mixed_samples ") != std::string::npos;
+  ext.b_GL_NV_path_rendering =
+      extensions.find("GL_NV_path_rendering ") != std::string::npos;
+  ext.b_GL_OES_EGL_image =
+      extensions.find("GL_OES_EGL_image ") != std::string::npos;
+  ext.b_GL_OES_get_program_binary =
+      extensions.find("GL_OES_get_program_binary ") != std::string::npos;
+  ext.b_GL_OES_mapbuffer =
+      extensions.find("GL_OES_mapbuffer ") != std::string::npos;
+  ext.b_GL_OES_vertex_array_object =
+      extensions.find("GL_OES_vertex_array_object ") != std::string::npos;
+
+  if (ext.b_GL_INTEL_framebuffer_CMAA) {
+    fn.glApplyFramebufferAttachmentCMAAINTELFn =
+        reinterpret_cast<glApplyFramebufferAttachmentCMAAINTELProc>(
+            GetGLProcAddress("glApplyFramebufferAttachmentCMAAINTEL"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glBeginQueryFn =
+        reinterpret_cast<glBeginQueryProc>(GetGLProcAddress("glBeginQuery"));
+  } else if (ext.b_GL_ARB_occlusion_query) {
+    fn.glBeginQueryFn =
+        reinterpret_cast<glBeginQueryProc>(GetGLProcAddress("glBeginQueryARB"));
+  } else if (ext.b_GL_EXT_disjoint_timer_query ||
+             ext.b_GL_EXT_occlusion_query_boolean) {
+    fn.glBeginQueryFn =
+        reinterpret_cast<glBeginQueryProc>(GetGLProcAddress("glBeginQueryEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glBeginTransformFeedbackFn =
+        reinterpret_cast<glBeginTransformFeedbackProc>(
+            GetGLProcAddress("glBeginTransformFeedback"));
+  } else if (ext.b_GL_EXT_transform_feedback) {
+    fn.glBeginTransformFeedbackFn =
+        reinterpret_cast<glBeginTransformFeedbackProc>(
+            GetGLProcAddress("glBeginTransformFeedbackEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glBindBufferBaseFn = reinterpret_cast<glBindBufferBaseProc>(
+        GetGLProcAddress("glBindBufferBase"));
+  } else if (ext.b_GL_EXT_transform_feedback) {
+    fn.glBindBufferBaseFn = reinterpret_cast<glBindBufferBaseProc>(
+        GetGLProcAddress("glBindBufferBaseEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glBindBufferRangeFn = reinterpret_cast<glBindBufferRangeProc>(
+        GetGLProcAddress("glBindBufferRange"));
+  } else if (ext.b_GL_EXT_transform_feedback) {
+    fn.glBindBufferRangeFn = reinterpret_cast<glBindBufferRangeProc>(
+        GetGLProcAddress("glBindBufferRangeEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ext.b_GL_ARB_blend_func_extended) {
+    fn.glBindFragDataLocationFn = reinterpret_cast<glBindFragDataLocationProc>(
+        GetGLProcAddress("glBindFragDataLocation"));
+  } else if (ext.b_GL_EXT_gpu_shader4 || ext.b_GL_EXT_blend_func_extended) {
+    fn.glBindFragDataLocationFn = reinterpret_cast<glBindFragDataLocationProc>(
+        GetGLProcAddress("glBindFragDataLocationEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ext.b_GL_ARB_blend_func_extended) {
+    fn.glBindFragDataLocationIndexedFn =
+        reinterpret_cast<glBindFragDataLocationIndexedProc>(
+            GetGLProcAddress("glBindFragDataLocationIndexed"));
+  } else if (ext.b_GL_EXT_blend_func_extended) {
+    fn.glBindFragDataLocationIndexedFn =
+        reinterpret_cast<glBindFragDataLocationIndexedProc>(
+            GetGLProcAddress("glBindFragDataLocationIndexedEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glBindFramebufferEXTFn = reinterpret_cast<glBindFramebufferEXTProc>(
+        GetGLProcAddress("glBindFramebuffer"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glBindFramebufferEXTFn = reinterpret_cast<glBindFramebufferEXTProc>(
+        GetGLProcAddress("glBindFramebufferEXT"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 2u) || ver->IsAtLeastGLES(3u, 1u) ||
+      ext.b_GL_ARB_shader_image_load_store) {
+    fn.glBindImageTextureEXTFn = reinterpret_cast<glBindImageTextureEXTProc>(
+        GetGLProcAddress("glBindImageTexture"));
+  } else if (ext.b_GL_EXT_shader_image_load_store) {
+    fn.glBindImageTextureEXTFn = reinterpret_cast<glBindImageTextureEXTProc>(
+        GetGLProcAddress("glBindImageTextureEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glBindRenderbufferEXTFn = reinterpret_cast<glBindRenderbufferEXTProc>(
+        GetGLProcAddress("glBindRenderbuffer"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glBindRenderbufferEXTFn = reinterpret_cast<glBindRenderbufferEXTProc>(
+        GetGLProcAddress("glBindRenderbufferEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sampler_objects) {
+    fn.glBindSamplerFn =
+        reinterpret_cast<glBindSamplerProc>(GetGLProcAddress("glBindSampler"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
+      ext.b_GL_ARB_transform_feedback2) {
+    fn.glBindTransformFeedbackFn =
+        reinterpret_cast<glBindTransformFeedbackProc>(
+            GetGLProcAddress("glBindTransformFeedback"));
+  }
+
+  if (ext.b_GL_CHROMIUM_bind_uniform_location) {
+    fn.glBindUniformLocationCHROMIUMFn =
+        reinterpret_cast<glBindUniformLocationCHROMIUMProc>(
+            GetGLProcAddress("glBindUniformLocationCHROMIUM"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_vertex_array_object) {
+    fn.glBindVertexArrayOESFn = reinterpret_cast<glBindVertexArrayOESProc>(
+        GetGLProcAddress("glBindVertexArray"));
+  } else if (ext.b_GL_OES_vertex_array_object) {
+    fn.glBindVertexArrayOESFn = reinterpret_cast<glBindVertexArrayOESProc>(
+        GetGLProcAddress("glBindVertexArrayOES"));
+  } else if (ext.b_GL_APPLE_vertex_array_object) {
+    fn.glBindVertexArrayOESFn = reinterpret_cast<glBindVertexArrayOESProc>(
+        GetGLProcAddress("glBindVertexArrayAPPLE"));
+  }
+
+  if (ext.b_GL_NV_blend_equation_advanced) {
+    fn.glBlendBarrierKHRFn = reinterpret_cast<glBlendBarrierKHRProc>(
+        GetGLProcAddress("glBlendBarrierNV"));
+  } else if (ext.b_GL_KHR_blend_equation_advanced) {
+    fn.glBlendBarrierKHRFn = reinterpret_cast<glBlendBarrierKHRProc>(
+        GetGLProcAddress("glBlendBarrierKHR"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glBlitFramebufferFn = reinterpret_cast<glBlitFramebufferProc>(
+        GetGLProcAddress("glBlitFramebuffer"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glBlitFramebufferANGLEFn = reinterpret_cast<glBlitFramebufferANGLEProc>(
+        GetGLProcAddress("glBlitFramebuffer"));
+  } else if (ext.b_GL_ANGLE_framebuffer_blit) {
+    fn.glBlitFramebufferANGLEFn = reinterpret_cast<glBlitFramebufferANGLEProc>(
+        GetGLProcAddress("glBlitFramebufferANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glBlitFramebufferEXTFn = reinterpret_cast<glBlitFramebufferEXTProc>(
+        GetGLProcAddress("glBlitFramebuffer"));
+  } else if (ext.b_GL_EXT_framebuffer_blit) {
+    fn.glBlitFramebufferEXTFn = reinterpret_cast<glBlitFramebufferEXTProc>(
+        GetGLProcAddress("glBlitFramebufferEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glCheckFramebufferStatusEXTFn =
+        reinterpret_cast<glCheckFramebufferStatusEXTProc>(
+            GetGLProcAddress("glCheckFramebufferStatus"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glCheckFramebufferStatusEXTFn =
+        reinterpret_cast<glCheckFramebufferStatusEXTProc>(
+            GetGLProcAddress("glCheckFramebufferStatusEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glClearBufferfiFn = reinterpret_cast<glClearBufferfiProc>(
+        GetGLProcAddress("glClearBufferfi"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glClearBufferfvFn = reinterpret_cast<glClearBufferfvProc>(
+        GetGLProcAddress("glClearBufferfv"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glClearBufferivFn = reinterpret_cast<glClearBufferivProc>(
+        GetGLProcAddress("glClearBufferiv"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glClearBufferuivFn = reinterpret_cast<glClearBufferuivProc>(
+        GetGLProcAddress("glClearBufferuiv"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
+    fn.glClearDepthfFn =
+        reinterpret_cast<glClearDepthfProc>(GetGLProcAddress("glClearDepthf"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sync) {
+    fn.glClientWaitSyncFn = reinterpret_cast<glClientWaitSyncProc>(
+        GetGLProcAddress("glClientWaitSync"));
+  }
+
+  if (ext.b_GL_CHROMIUM_copy_compressed_texture ||
+      ext.b_GL_CHROMIUM_compressed_copy_texture) {
+    fn.glCompressedCopyTextureCHROMIUMFn =
+        reinterpret_cast<glCompressedCopyTextureCHROMIUMProc>(
+            GetGLProcAddress("glCompressedCopyTextureCHROMIUM"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glCompressedTexImage3DFn = reinterpret_cast<glCompressedTexImage3DProc>(
+        GetGLProcAddress("glCompressedTexImage3D"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glCompressedTexSubImage3DFn =
+        reinterpret_cast<glCompressedTexSubImage3DProc>(
+            GetGLProcAddress("glCompressedTexSubImage3D"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
+    fn.glCopyBufferSubDataFn = reinterpret_cast<glCopyBufferSubDataProc>(
+        GetGLProcAddress("glCopyBufferSubData"));
+  }
+
+  if (ext.b_GL_CHROMIUM_copy_texture) {
+    fn.glCopySubTextureCHROMIUMFn =
+        reinterpret_cast<glCopySubTextureCHROMIUMProc>(
+            GetGLProcAddress("glCopySubTextureCHROMIUM"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glCopyTexSubImage3DFn = reinterpret_cast<glCopyTexSubImage3DProc>(
+        GetGLProcAddress("glCopyTexSubImage3D"));
+  }
+
+  if (ext.b_GL_CHROMIUM_copy_texture) {
+    fn.glCopyTextureCHROMIUMFn = reinterpret_cast<glCopyTextureCHROMIUMProc>(
+        GetGLProcAddress("glCopyTextureCHROMIUM"));
+  }
+
+  if (ext.b_GL_NV_framebuffer_mixed_samples) {
+    fn.glCoverageModulationNVFn = reinterpret_cast<glCoverageModulationNVProc>(
+        GetGLProcAddress("glCoverageModulationNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverFillPathInstancedNVFn =
+        reinterpret_cast<glCoverFillPathInstancedNVProc>(
+            GetGLProcAddress("glCoverFillPathInstancedNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverFillPathNVFn = reinterpret_cast<glCoverFillPathNVProc>(
+        GetGLProcAddress("glCoverFillPathNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverStrokePathInstancedNVFn =
+        reinterpret_cast<glCoverStrokePathInstancedNVProc>(
+            GetGLProcAddress("glCoverStrokePathInstancedNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glCoverStrokePathNVFn = reinterpret_cast<glCoverStrokePathNVProc>(
+        GetGLProcAddress("glCoverStrokePathNV"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glDebugMessageCallbackFn = reinterpret_cast<glDebugMessageCallbackProc>(
+        GetGLProcAddress("glDebugMessageCallback"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glDebugMessageCallbackFn = reinterpret_cast<glDebugMessageCallbackProc>(
+        GetGLProcAddress("glDebugMessageCallbackKHR"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glDebugMessageControlFn = reinterpret_cast<glDebugMessageControlProc>(
+        GetGLProcAddress("glDebugMessageControl"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glDebugMessageControlFn = reinterpret_cast<glDebugMessageControlProc>(
+        GetGLProcAddress("glDebugMessageControlKHR"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glDebugMessageInsertFn = reinterpret_cast<glDebugMessageInsertProc>(
+        GetGLProcAddress("glDebugMessageInsert"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glDebugMessageInsertFn = reinterpret_cast<glDebugMessageInsertProc>(
+        GetGLProcAddress("glDebugMessageInsertKHR"));
+  }
+
+  if (ext.b_GL_APPLE_fence) {
+    fn.glDeleteFencesAPPLEFn = reinterpret_cast<glDeleteFencesAPPLEProc>(
+        GetGLProcAddress("glDeleteFencesAPPLE"));
+  }
+
+  if (ext.b_GL_NV_fence) {
+    fn.glDeleteFencesNVFn = reinterpret_cast<glDeleteFencesNVProc>(
+        GetGLProcAddress("glDeleteFencesNV"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glDeleteFramebuffersEXTFn =
+        reinterpret_cast<glDeleteFramebuffersEXTProc>(
+            GetGLProcAddress("glDeleteFramebuffers"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glDeleteFramebuffersEXTFn =
+        reinterpret_cast<glDeleteFramebuffersEXTProc>(
+            GetGLProcAddress("glDeleteFramebuffersEXT"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glDeletePathsNVFn = reinterpret_cast<glDeletePathsNVProc>(
+        GetGLProcAddress("glDeletePathsNV"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glDeleteQueriesFn = reinterpret_cast<glDeleteQueriesProc>(
+        GetGLProcAddress("glDeleteQueries"));
+  } else if (ext.b_GL_ARB_occlusion_query) {
+    fn.glDeleteQueriesFn = reinterpret_cast<glDeleteQueriesProc>(
+        GetGLProcAddress("glDeleteQueriesARB"));
+  } else if (ext.b_GL_EXT_disjoint_timer_query ||
+             ext.b_GL_EXT_occlusion_query_boolean) {
+    fn.glDeleteQueriesFn = reinterpret_cast<glDeleteQueriesProc>(
+        GetGLProcAddress("glDeleteQueriesEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glDeleteRenderbuffersEXTFn =
+        reinterpret_cast<glDeleteRenderbuffersEXTProc>(
+            GetGLProcAddress("glDeleteRenderbuffers"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glDeleteRenderbuffersEXTFn =
+        reinterpret_cast<glDeleteRenderbuffersEXTProc>(
+            GetGLProcAddress("glDeleteRenderbuffersEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sampler_objects) {
+    fn.glDeleteSamplersFn = reinterpret_cast<glDeleteSamplersProc>(
+        GetGLProcAddress("glDeleteSamplers"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sync) {
+    fn.glDeleteSyncFn =
+        reinterpret_cast<glDeleteSyncProc>(GetGLProcAddress("glDeleteSync"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
+      ext.b_GL_ARB_transform_feedback2) {
+    fn.glDeleteTransformFeedbacksFn =
+        reinterpret_cast<glDeleteTransformFeedbacksProc>(
+            GetGLProcAddress("glDeleteTransformFeedbacks"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_vertex_array_object) {
+    fn.glDeleteVertexArraysOESFn =
+        reinterpret_cast<glDeleteVertexArraysOESProc>(
+            GetGLProcAddress("glDeleteVertexArrays"));
+  } else if (ext.b_GL_OES_vertex_array_object) {
+    fn.glDeleteVertexArraysOESFn =
+        reinterpret_cast<glDeleteVertexArraysOESProc>(
+            GetGLProcAddress("glDeleteVertexArraysOES"));
+  } else if (ext.b_GL_APPLE_vertex_array_object) {
+    fn.glDeleteVertexArraysOESFn =
+        reinterpret_cast<glDeleteVertexArraysOESProc>(
+            GetGLProcAddress("glDeleteVertexArraysAPPLE"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
+    fn.glDepthRangefFn =
+        reinterpret_cast<glDepthRangefProc>(GetGLProcAddress("glDepthRangef"));
+  }
+
+  if (ext.b_GL_EXT_discard_framebuffer) {
+    fn.glDiscardFramebufferEXTFn =
+        reinterpret_cast<glDiscardFramebufferEXTProc>(
+            GetGLProcAddress("glDiscardFramebufferEXT"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
+    fn.glDrawArraysInstancedANGLEFn =
+        reinterpret_cast<glDrawArraysInstancedANGLEProc>(
+            GetGLProcAddress("glDrawArraysInstanced"));
+  } else if (ext.b_GL_ARB_draw_instanced) {
+    fn.glDrawArraysInstancedANGLEFn =
+        reinterpret_cast<glDrawArraysInstancedANGLEProc>(
+            GetGLProcAddress("glDrawArraysInstancedARB"));
+  } else if (ext.b_GL_ANGLE_instanced_arrays) {
+    fn.glDrawArraysInstancedANGLEFn =
+        reinterpret_cast<glDrawArraysInstancedANGLEProc>(
+            GetGLProcAddress("glDrawArraysInstancedANGLE"));
+  }
+
+  if (!ver->is_es) {
+    fn.glDrawBufferFn =
+        reinterpret_cast<glDrawBufferProc>(GetGLProcAddress("glDrawBuffer"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glDrawBuffersARBFn = reinterpret_cast<glDrawBuffersARBProc>(
+        GetGLProcAddress("glDrawBuffers"));
+  } else if (ext.b_GL_ARB_draw_buffers) {
+    fn.glDrawBuffersARBFn = reinterpret_cast<glDrawBuffersARBProc>(
+        GetGLProcAddress("glDrawBuffersARB"));
+  } else if (ext.b_GL_EXT_draw_buffers) {
+    fn.glDrawBuffersARBFn = reinterpret_cast<glDrawBuffersARBProc>(
+        GetGLProcAddress("glDrawBuffersEXT"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
+    fn.glDrawElementsInstancedANGLEFn =
+        reinterpret_cast<glDrawElementsInstancedANGLEProc>(
+            GetGLProcAddress("glDrawElementsInstanced"));
+  } else if (ext.b_GL_ARB_draw_instanced) {
+    fn.glDrawElementsInstancedANGLEFn =
+        reinterpret_cast<glDrawElementsInstancedANGLEProc>(
+            GetGLProcAddress("glDrawElementsInstancedARB"));
+  } else if (ext.b_GL_ANGLE_instanced_arrays) {
+    fn.glDrawElementsInstancedANGLEFn =
+        reinterpret_cast<glDrawElementsInstancedANGLEProc>(
+            GetGLProcAddress("glDrawElementsInstancedANGLE"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glDrawRangeElementsFn = reinterpret_cast<glDrawRangeElementsProc>(
+        GetGLProcAddress("glDrawRangeElements"));
+  }
+
+  if (ext.b_GL_OES_EGL_image) {
+    fn.glEGLImageTargetRenderbufferStorageOESFn =
+        reinterpret_cast<glEGLImageTargetRenderbufferStorageOESProc>(
+            GetGLProcAddress("glEGLImageTargetRenderbufferStorageOES"));
+  }
+
+  if (ext.b_GL_OES_EGL_image) {
+    fn.glEGLImageTargetTexture2DOESFn =
+        reinterpret_cast<glEGLImageTargetTexture2DOESProc>(
+            GetGLProcAddress("glEGLImageTargetTexture2DOES"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glEndQueryFn =
+        reinterpret_cast<glEndQueryProc>(GetGLProcAddress("glEndQuery"));
+  } else if (ext.b_GL_ARB_occlusion_query) {
+    fn.glEndQueryFn =
+        reinterpret_cast<glEndQueryProc>(GetGLProcAddress("glEndQueryARB"));
+  } else if (ext.b_GL_EXT_disjoint_timer_query ||
+             ext.b_GL_EXT_occlusion_query_boolean) {
+    fn.glEndQueryFn =
+        reinterpret_cast<glEndQueryProc>(GetGLProcAddress("glEndQueryEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glEndTransformFeedbackFn = reinterpret_cast<glEndTransformFeedbackProc>(
+        GetGLProcAddress("glEndTransformFeedback"));
+  } else if (ext.b_GL_EXT_transform_feedback) {
+    fn.glEndTransformFeedbackFn = reinterpret_cast<glEndTransformFeedbackProc>(
+        GetGLProcAddress("glEndTransformFeedbackEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sync) {
+    fn.glFenceSyncFn =
+        reinterpret_cast<glFenceSyncProc>(GetGLProcAddress("glFenceSync"));
+  }
+
+  if (ext.b_GL_APPLE_fence) {
+    fn.glFinishFenceAPPLEFn = reinterpret_cast<glFinishFenceAPPLEProc>(
+        GetGLProcAddress("glFinishFenceAPPLE"));
+  }
+
+  if (ext.b_GL_NV_fence) {
+    fn.glFinishFenceNVFn = reinterpret_cast<glFinishFenceNVProc>(
+        GetGLProcAddress("glFinishFenceNV"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glFlushMappedBufferRangeFn =
+        reinterpret_cast<glFlushMappedBufferRangeProc>(
+            GetGLProcAddress("glFlushMappedBufferRange"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glFramebufferRenderbufferEXTFn =
+        reinterpret_cast<glFramebufferRenderbufferEXTProc>(
+            GetGLProcAddress("glFramebufferRenderbuffer"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glFramebufferRenderbufferEXTFn =
+        reinterpret_cast<glFramebufferRenderbufferEXTProc>(
+            GetGLProcAddress("glFramebufferRenderbufferEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glFramebufferTexture2DEXTFn =
+        reinterpret_cast<glFramebufferTexture2DEXTProc>(
+            GetGLProcAddress("glFramebufferTexture2D"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glFramebufferTexture2DEXTFn =
+        reinterpret_cast<glFramebufferTexture2DEXTProc>(
+            GetGLProcAddress("glFramebufferTexture2DEXT"));
+  }
+
+  if (ext.b_GL_EXT_multisampled_render_to_texture) {
+    fn.glFramebufferTexture2DMultisampleEXTFn =
+        reinterpret_cast<glFramebufferTexture2DMultisampleEXTProc>(
+            GetGLProcAddress("glFramebufferTexture2DMultisampleEXT"));
+  }
+
+  if (ext.b_GL_IMG_multisampled_render_to_texture) {
+    fn.glFramebufferTexture2DMultisampleIMGFn =
+        reinterpret_cast<glFramebufferTexture2DMultisampleIMGProc>(
+            GetGLProcAddress("glFramebufferTexture2DMultisampleIMG"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glFramebufferTextureLayerFn =
+        reinterpret_cast<glFramebufferTextureLayerProc>(
+            GetGLProcAddress("glFramebufferTextureLayer"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glGenerateMipmapEXTFn = reinterpret_cast<glGenerateMipmapEXTProc>(
+        GetGLProcAddress("glGenerateMipmap"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glGenerateMipmapEXTFn = reinterpret_cast<glGenerateMipmapEXTProc>(
+        GetGLProcAddress("glGenerateMipmapEXT"));
+  }
+
+  if (ext.b_GL_APPLE_fence) {
+    fn.glGenFencesAPPLEFn = reinterpret_cast<glGenFencesAPPLEProc>(
+        GetGLProcAddress("glGenFencesAPPLE"));
+  }
+
+  if (ext.b_GL_NV_fence) {
+    fn.glGenFencesNVFn =
+        reinterpret_cast<glGenFencesNVProc>(GetGLProcAddress("glGenFencesNV"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glGenFramebuffersEXTFn = reinterpret_cast<glGenFramebuffersEXTProc>(
+        GetGLProcAddress("glGenFramebuffers"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glGenFramebuffersEXTFn = reinterpret_cast<glGenFramebuffersEXTProc>(
+        GetGLProcAddress("glGenFramebuffersEXT"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glGenPathsNVFn =
+        reinterpret_cast<glGenPathsNVProc>(GetGLProcAddress("glGenPathsNV"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glGenQueriesFn =
+        reinterpret_cast<glGenQueriesProc>(GetGLProcAddress("glGenQueries"));
+  } else if (ext.b_GL_ARB_occlusion_query) {
+    fn.glGenQueriesFn =
+        reinterpret_cast<glGenQueriesProc>(GetGLProcAddress("glGenQueriesARB"));
+  } else if (ext.b_GL_EXT_disjoint_timer_query ||
+             ext.b_GL_EXT_occlusion_query_boolean) {
+    fn.glGenQueriesFn =
+        reinterpret_cast<glGenQueriesProc>(GetGLProcAddress("glGenQueriesEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glGenRenderbuffersEXTFn = reinterpret_cast<glGenRenderbuffersEXTProc>(
+        GetGLProcAddress("glGenRenderbuffers"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glGenRenderbuffersEXTFn = reinterpret_cast<glGenRenderbuffersEXTProc>(
+        GetGLProcAddress("glGenRenderbuffersEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sampler_objects) {
+    fn.glGenSamplersFn =
+        reinterpret_cast<glGenSamplersProc>(GetGLProcAddress("glGenSamplers"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
+      ext.b_GL_ARB_transform_feedback2) {
+    fn.glGenTransformFeedbacksFn =
+        reinterpret_cast<glGenTransformFeedbacksProc>(
+            GetGLProcAddress("glGenTransformFeedbacks"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_vertex_array_object) {
+    fn.glGenVertexArraysOESFn = reinterpret_cast<glGenVertexArraysOESProc>(
+        GetGLProcAddress("glGenVertexArrays"));
+  } else if (ext.b_GL_OES_vertex_array_object) {
+    fn.glGenVertexArraysOESFn = reinterpret_cast<glGenVertexArraysOESProc>(
+        GetGLProcAddress("glGenVertexArraysOES"));
+  } else if (ext.b_GL_APPLE_vertex_array_object) {
+    fn.glGenVertexArraysOESFn = reinterpret_cast<glGenVertexArraysOESProc>(
+        GetGLProcAddress("glGenVertexArraysAPPLE"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
+    fn.glGetActiveUniformBlockivFn =
+        reinterpret_cast<glGetActiveUniformBlockivProc>(
+            GetGLProcAddress("glGetActiveUniformBlockiv"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetActiveUniformBlockivRobustANGLEFn =
+        reinterpret_cast<glGetActiveUniformBlockivRobustANGLEProc>(
+            GetGLProcAddress("glGetActiveUniformBlockivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
+    fn.glGetActiveUniformBlockNameFn =
+        reinterpret_cast<glGetActiveUniformBlockNameProc>(
+            GetGLProcAddress("glGetActiveUniformBlockName"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
+    fn.glGetActiveUniformsivFn = reinterpret_cast<glGetActiveUniformsivProc>(
+        GetGLProcAddress("glGetActiveUniformsiv"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetBooleani_vRobustANGLEFn =
+        reinterpret_cast<glGetBooleani_vRobustANGLEProc>(
+            GetGLProcAddress("glGetBooleani_vRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetBooleanvRobustANGLEFn =
+        reinterpret_cast<glGetBooleanvRobustANGLEProc>(
+            GetGLProcAddress("glGetBooleanvRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetBufferParameteri64vRobustANGLEFn =
+        reinterpret_cast<glGetBufferParameteri64vRobustANGLEProc>(
+            GetGLProcAddress("glGetBufferParameteri64vRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetBufferParameterivRobustANGLEFn =
+        reinterpret_cast<glGetBufferParameterivRobustANGLEProc>(
+            GetGLProcAddress("glGetBufferParameterivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetBufferPointervRobustANGLEFn =
+        reinterpret_cast<glGetBufferPointervRobustANGLEProc>(
+            GetGLProcAddress("glGetBufferPointervRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glGetDebugMessageLogFn = reinterpret_cast<glGetDebugMessageLogProc>(
+        GetGLProcAddress("glGetDebugMessageLog"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glGetDebugMessageLogFn = reinterpret_cast<glGetDebugMessageLogProc>(
+        GetGLProcAddress("glGetDebugMessageLogKHR"));
+  }
+
+  if (ext.b_GL_NV_fence) {
+    fn.glGetFenceivNVFn = reinterpret_cast<glGetFenceivNVProc>(
+        GetGLProcAddress("glGetFenceivNV"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetFloatvRobustANGLEFn = reinterpret_cast<glGetFloatvRobustANGLEProc>(
+        GetGLProcAddress("glGetFloatvRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ext.b_GL_ARB_blend_func_extended) {
+    fn.glGetFragDataIndexFn = reinterpret_cast<glGetFragDataIndexProc>(
+        GetGLProcAddress("glGetFragDataIndex"));
+  } else if (ext.b_GL_EXT_blend_func_extended) {
+    fn.glGetFragDataIndexFn = reinterpret_cast<glGetFragDataIndexProc>(
+        GetGLProcAddress("glGetFragDataIndexEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glGetFragDataLocationFn = reinterpret_cast<glGetFragDataLocationProc>(
+        GetGLProcAddress("glGetFragDataLocation"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glGetFramebufferAttachmentParameterivEXTFn =
+        reinterpret_cast<glGetFramebufferAttachmentParameterivEXTProc>(
+            GetGLProcAddress("glGetFramebufferAttachmentParameteriv"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glGetFramebufferAttachmentParameterivEXTFn =
+        reinterpret_cast<glGetFramebufferAttachmentParameterivEXTProc>(
+            GetGLProcAddress("glGetFramebufferAttachmentParameterivEXT"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetFramebufferAttachmentParameterivRobustANGLEFn =
+        reinterpret_cast<glGetFramebufferAttachmentParameterivRobustANGLEProc>(
+            GetGLProcAddress(
+                "glGetFramebufferAttachmentParameterivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetFramebufferParameterivRobustANGLEFn =
+        reinterpret_cast<glGetFramebufferParameterivRobustANGLEProc>(
+            GetGLProcAddress("glGetFramebufferParameterivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 5u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glGetGraphicsResetStatusARBFn =
+        reinterpret_cast<glGetGraphicsResetStatusARBProc>(
+            GetGLProcAddress("glGetGraphicsResetStatus"));
+  } else if (ext.b_GL_ARB_robustness) {
+    fn.glGetGraphicsResetStatusARBFn =
+        reinterpret_cast<glGetGraphicsResetStatusARBProc>(
+            GetGLProcAddress("glGetGraphicsResetStatusARB"));
+  } else if (ext.b_GL_KHR_robustness) {
+    fn.glGetGraphicsResetStatusARBFn =
+        reinterpret_cast<glGetGraphicsResetStatusARBProc>(
+            GetGLProcAddress("glGetGraphicsResetStatusKHR"));
+  } else if (ext.b_GL_EXT_robustness) {
+    fn.glGetGraphicsResetStatusARBFn =
+        reinterpret_cast<glGetGraphicsResetStatusARBProc>(
+            GetGLProcAddress("glGetGraphicsResetStatusEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glGetInteger64i_vFn = reinterpret_cast<glGetInteger64i_vProc>(
+        GetGLProcAddress("glGetInteger64i_v"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetInteger64i_vRobustANGLEFn =
+        reinterpret_cast<glGetInteger64i_vRobustANGLEProc>(
+            GetGLProcAddress("glGetInteger64i_vRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glGetInteger64vFn = reinterpret_cast<glGetInteger64vProc>(
+        GetGLProcAddress("glGetInteger64v"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetInteger64vRobustANGLEFn =
+        reinterpret_cast<glGetInteger64vRobustANGLEProc>(
+            GetGLProcAddress("glGetInteger64vRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glGetIntegeri_vFn = reinterpret_cast<glGetIntegeri_vProc>(
+        GetGLProcAddress("glGetIntegeri_v"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetIntegeri_vRobustANGLEFn =
+        reinterpret_cast<glGetIntegeri_vRobustANGLEProc>(
+            GetGLProcAddress("glGetIntegeri_vRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetIntegervRobustANGLEFn =
+        reinterpret_cast<glGetIntegervRobustANGLEProc>(
+            GetGLProcAddress("glGetIntegervRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 2u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glGetInternalformativFn = reinterpret_cast<glGetInternalformativProc>(
+        GetGLProcAddress("glGetInternalformativ"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetInternalformativRobustANGLEFn =
+        reinterpret_cast<glGetInternalformativRobustANGLEProc>(
+            GetGLProcAddress("glGetInternalformativRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetMultisamplefvRobustANGLEFn =
+        reinterpret_cast<glGetMultisamplefvRobustANGLEProc>(
+            GetGLProcAddress("glGetMultisamplefvRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetnUniformfvRobustANGLEFn =
+        reinterpret_cast<glGetnUniformfvRobustANGLEProc>(
+            GetGLProcAddress("glGetnUniformfvRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetnUniformivRobustANGLEFn =
+        reinterpret_cast<glGetnUniformivRobustANGLEProc>(
+            GetGLProcAddress("glGetnUniformivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetnUniformuivRobustANGLEFn =
+        reinterpret_cast<glGetnUniformuivRobustANGLEProc>(
+            GetGLProcAddress("glGetnUniformuivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glGetObjectLabelFn = reinterpret_cast<glGetObjectLabelProc>(
+        GetGLProcAddress("glGetObjectLabel"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glGetObjectLabelFn = reinterpret_cast<glGetObjectLabelProc>(
+        GetGLProcAddress("glGetObjectLabelKHR"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glGetObjectPtrLabelFn = reinterpret_cast<glGetObjectPtrLabelProc>(
+        GetGLProcAddress("glGetObjectPtrLabel"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glGetObjectPtrLabelFn = reinterpret_cast<glGetObjectPtrLabelProc>(
+        GetGLProcAddress("glGetObjectPtrLabelKHR"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glGetPointervFn =
+        reinterpret_cast<glGetPointervProc>(GetGLProcAddress("glGetPointerv"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glGetPointervFn = reinterpret_cast<glGetPointervProc>(
+        GetGLProcAddress("glGetPointervKHR"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetPointervRobustANGLERobustANGLEFn =
+        reinterpret_cast<glGetPointervRobustANGLERobustANGLEProc>(
+            GetGLProcAddress("glGetPointervRobustANGLERobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 1u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_get_program_binary) {
+    fn.glGetProgramBinaryFn = reinterpret_cast<glGetProgramBinaryProc>(
+        GetGLProcAddress("glGetProgramBinary"));
+  } else if (ext.b_GL_OES_get_program_binary) {
+    fn.glGetProgramBinaryFn = reinterpret_cast<glGetProgramBinaryProc>(
+        GetGLProcAddress("glGetProgramBinaryOES"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 1u) ||
+      ext.b_GL_ARB_program_interface_query) {
+    fn.glGetProgramInterfaceivFn =
+        reinterpret_cast<glGetProgramInterfaceivProc>(
+            GetGLProcAddress("glGetProgramInterfaceiv"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetProgramInterfaceivRobustANGLEFn =
+        reinterpret_cast<glGetProgramInterfaceivRobustANGLEProc>(
+            GetGLProcAddress("glGetProgramInterfaceivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetProgramivRobustANGLEFn =
+        reinterpret_cast<glGetProgramivRobustANGLEProc>(
+            GetGLProcAddress("glGetProgramivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 1u) ||
+      ext.b_GL_ARB_program_interface_query) {
+    fn.glGetProgramResourceivFn = reinterpret_cast<glGetProgramResourceivProc>(
+        GetGLProcAddress("glGetProgramResourceiv"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 1u)) {
+    fn.glGetProgramResourceLocationFn =
+        reinterpret_cast<glGetProgramResourceLocationProc>(
+            GetGLProcAddress("glGetProgramResourceLocation"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 1u) ||
+      ext.b_GL_ARB_program_interface_query) {
+    fn.glGetProgramResourceNameFn =
+        reinterpret_cast<glGetProgramResourceNameProc>(
+            GetGLProcAddress("glGetProgramResourceName"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glGetQueryivFn =
+        reinterpret_cast<glGetQueryivProc>(GetGLProcAddress("glGetQueryiv"));
+  } else if (ext.b_GL_ARB_occlusion_query) {
+    fn.glGetQueryivFn =
+        reinterpret_cast<glGetQueryivProc>(GetGLProcAddress("glGetQueryivARB"));
+  } else if (ext.b_GL_EXT_disjoint_timer_query ||
+             ext.b_GL_EXT_occlusion_query_boolean) {
+    fn.glGetQueryivFn =
+        reinterpret_cast<glGetQueryivProc>(GetGLProcAddress("glGetQueryivEXT"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetQueryivRobustANGLEFn =
+        reinterpret_cast<glGetQueryivRobustANGLEProc>(
+            GetGLProcAddress("glGetQueryivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ext.b_GL_ARB_timer_query) {
+    fn.glGetQueryObjecti64vFn = reinterpret_cast<glGetQueryObjecti64vProc>(
+        GetGLProcAddress("glGetQueryObjecti64v"));
+  } else if (ext.b_GL_EXT_timer_query || ext.b_GL_EXT_disjoint_timer_query) {
+    fn.glGetQueryObjecti64vFn = reinterpret_cast<glGetQueryObjecti64vProc>(
+        GetGLProcAddress("glGetQueryObjecti64vEXT"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetQueryObjecti64vRobustANGLEFn =
+        reinterpret_cast<glGetQueryObjecti64vRobustANGLEProc>(
+            GetGLProcAddress("glGetQueryObjecti64vRobustANGLE"));
+  }
+
+  if (!ver->is_es) {
+    fn.glGetQueryObjectivFn = reinterpret_cast<glGetQueryObjectivProc>(
+        GetGLProcAddress("glGetQueryObjectiv"));
+  } else if (ext.b_GL_ARB_occlusion_query) {
+    fn.glGetQueryObjectivFn = reinterpret_cast<glGetQueryObjectivProc>(
+        GetGLProcAddress("glGetQueryObjectivARB"));
+  } else if (ext.b_GL_EXT_disjoint_timer_query) {
+    fn.glGetQueryObjectivFn = reinterpret_cast<glGetQueryObjectivProc>(
+        GetGLProcAddress("glGetQueryObjectivEXT"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetQueryObjectivRobustANGLEFn =
+        reinterpret_cast<glGetQueryObjectivRobustANGLEProc>(
+            GetGLProcAddress("glGetQueryObjectivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ext.b_GL_ARB_timer_query) {
+    fn.glGetQueryObjectui64vFn = reinterpret_cast<glGetQueryObjectui64vProc>(
+        GetGLProcAddress("glGetQueryObjectui64v"));
+  } else if (ext.b_GL_EXT_timer_query || ext.b_GL_EXT_disjoint_timer_query) {
+    fn.glGetQueryObjectui64vFn = reinterpret_cast<glGetQueryObjectui64vProc>(
+        GetGLProcAddress("glGetQueryObjectui64vEXT"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetQueryObjectui64vRobustANGLEFn =
+        reinterpret_cast<glGetQueryObjectui64vRobustANGLEProc>(
+            GetGLProcAddress("glGetQueryObjectui64vRobustANGLE"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glGetQueryObjectuivFn = reinterpret_cast<glGetQueryObjectuivProc>(
+        GetGLProcAddress("glGetQueryObjectuiv"));
+  } else if (ext.b_GL_ARB_occlusion_query) {
+    fn.glGetQueryObjectuivFn = reinterpret_cast<glGetQueryObjectuivProc>(
+        GetGLProcAddress("glGetQueryObjectuivARB"));
+  } else if (ext.b_GL_EXT_disjoint_timer_query ||
+             ext.b_GL_EXT_occlusion_query_boolean) {
+    fn.glGetQueryObjectuivFn = reinterpret_cast<glGetQueryObjectuivProc>(
+        GetGLProcAddress("glGetQueryObjectuivEXT"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetQueryObjectuivRobustANGLEFn =
+        reinterpret_cast<glGetQueryObjectuivRobustANGLEProc>(
+            GetGLProcAddress("glGetQueryObjectuivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glGetRenderbufferParameterivEXTFn =
+        reinterpret_cast<glGetRenderbufferParameterivEXTProc>(
+            GetGLProcAddress("glGetRenderbufferParameteriv"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glGetRenderbufferParameterivEXTFn =
+        reinterpret_cast<glGetRenderbufferParameterivEXTProc>(
+            GetGLProcAddress("glGetRenderbufferParameterivEXT"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetRenderbufferParameterivRobustANGLEFn =
+        reinterpret_cast<glGetRenderbufferParameterivRobustANGLEProc>(
+            GetGLProcAddress("glGetRenderbufferParameterivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sampler_objects) {
+    fn.glGetSamplerParameterfvFn =
+        reinterpret_cast<glGetSamplerParameterfvProc>(
+            GetGLProcAddress("glGetSamplerParameterfv"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetSamplerParameterfvRobustANGLEFn =
+        reinterpret_cast<glGetSamplerParameterfvRobustANGLEProc>(
+            GetGLProcAddress("glGetSamplerParameterfvRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetSamplerParameterIivRobustANGLEFn =
+        reinterpret_cast<glGetSamplerParameterIivRobustANGLEProc>(
+            GetGLProcAddress("glGetSamplerParameterIivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetSamplerParameterIuivRobustANGLEFn =
+        reinterpret_cast<glGetSamplerParameterIuivRobustANGLEProc>(
+            GetGLProcAddress("glGetSamplerParameterIuivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sampler_objects) {
+    fn.glGetSamplerParameterivFn =
+        reinterpret_cast<glGetSamplerParameterivProc>(
+            GetGLProcAddress("glGetSamplerParameteriv"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetSamplerParameterivRobustANGLEFn =
+        reinterpret_cast<glGetSamplerParameterivRobustANGLEProc>(
+            GetGLProcAddress("glGetSamplerParameterivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetShaderivRobustANGLEFn =
+        reinterpret_cast<glGetShaderivRobustANGLEProc>(
+            GetGLProcAddress("glGetShaderivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
+    fn.glGetShaderPrecisionFormatFn =
+        reinterpret_cast<glGetShaderPrecisionFormatProc>(
+            GetGLProcAddress("glGetShaderPrecisionFormat"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sync) {
+    fn.glGetSyncivFn =
+        reinterpret_cast<glGetSyncivProc>(GetGLProcAddress("glGetSynciv"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 1u)) {
+    fn.glGetTexLevelParameterfvFn =
+        reinterpret_cast<glGetTexLevelParameterfvProc>(
+            GetGLProcAddress("glGetTexLevelParameterfv"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetTexLevelParameterfvRobustANGLEFn =
+        reinterpret_cast<glGetTexLevelParameterfvRobustANGLEProc>(
+            GetGLProcAddress("glGetTexLevelParameterfvRobustANGLE"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 1u)) {
+    fn.glGetTexLevelParameterivFn =
+        reinterpret_cast<glGetTexLevelParameterivProc>(
+            GetGLProcAddress("glGetTexLevelParameteriv"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetTexLevelParameterivRobustANGLEFn =
+        reinterpret_cast<glGetTexLevelParameterivRobustANGLEProc>(
+            GetGLProcAddress("glGetTexLevelParameterivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetTexParameterfvRobustANGLEFn =
+        reinterpret_cast<glGetTexParameterfvRobustANGLEProc>(
+            GetGLProcAddress("glGetTexParameterfvRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetTexParameterIivRobustANGLEFn =
+        reinterpret_cast<glGetTexParameterIivRobustANGLEProc>(
+            GetGLProcAddress("glGetTexParameterIivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetTexParameterIuivRobustANGLEFn =
+        reinterpret_cast<glGetTexParameterIuivRobustANGLEProc>(
+            GetGLProcAddress("glGetTexParameterIuivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetTexParameterivRobustANGLEFn =
+        reinterpret_cast<glGetTexParameterivRobustANGLEProc>(
+            GetGLProcAddress("glGetTexParameterivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glGetTransformFeedbackVaryingFn =
+        reinterpret_cast<glGetTransformFeedbackVaryingProc>(
+            GetGLProcAddress("glGetTransformFeedbackVarying"));
+  } else if (ext.b_GL_EXT_transform_feedback) {
+    fn.glGetTransformFeedbackVaryingFn =
+        reinterpret_cast<glGetTransformFeedbackVaryingProc>(
+            GetGLProcAddress("glGetTransformFeedbackVaryingEXT"));
+  }
+
+  if (ext.b_GL_ANGLE_translated_shader_source) {
+    fn.glGetTranslatedShaderSourceANGLEFn =
+        reinterpret_cast<glGetTranslatedShaderSourceANGLEProc>(
+            GetGLProcAddress("glGetTranslatedShaderSourceANGLE"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
+    fn.glGetUniformBlockIndexFn = reinterpret_cast<glGetUniformBlockIndexProc>(
+        GetGLProcAddress("glGetUniformBlockIndex"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetUniformfvRobustANGLEFn =
+        reinterpret_cast<glGetUniformfvRobustANGLEProc>(
+            GetGLProcAddress("glGetUniformfvRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
+    fn.glGetUniformIndicesFn = reinterpret_cast<glGetUniformIndicesProc>(
+        GetGLProcAddress("glGetUniformIndices"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetUniformivRobustANGLEFn =
+        reinterpret_cast<glGetUniformivRobustANGLEProc>(
+            GetGLProcAddress("glGetUniformivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glGetUniformuivFn = reinterpret_cast<glGetUniformuivProc>(
+        GetGLProcAddress("glGetUniformuiv"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetUniformuivRobustANGLEFn =
+        reinterpret_cast<glGetUniformuivRobustANGLEProc>(
+            GetGLProcAddress("glGetUniformuivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetVertexAttribfvRobustANGLEFn =
+        reinterpret_cast<glGetVertexAttribfvRobustANGLEProc>(
+            GetGLProcAddress("glGetVertexAttribfvRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetVertexAttribIivRobustANGLEFn =
+        reinterpret_cast<glGetVertexAttribIivRobustANGLEProc>(
+            GetGLProcAddress("glGetVertexAttribIivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetVertexAttribIuivRobustANGLEFn =
+        reinterpret_cast<glGetVertexAttribIuivRobustANGLEProc>(
+            GetGLProcAddress("glGetVertexAttribIuivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetVertexAttribivRobustANGLEFn =
+        reinterpret_cast<glGetVertexAttribivRobustANGLEProc>(
+            GetGLProcAddress("glGetVertexAttribivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glGetVertexAttribPointervRobustANGLEFn =
+        reinterpret_cast<glGetVertexAttribPointervRobustANGLEProc>(
+            GetGLProcAddress("glGetVertexAttribPointervRobustANGLE"));
+  }
+
+  if (ext.b_GL_EXT_debug_marker) {
+    fn.glInsertEventMarkerEXTFn = reinterpret_cast<glInsertEventMarkerEXTProc>(
+        GetGLProcAddress("glInsertEventMarkerEXT"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glInvalidateFramebufferFn =
+        reinterpret_cast<glInvalidateFramebufferProc>(
+            GetGLProcAddress("glInvalidateFramebuffer"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glInvalidateSubFramebufferFn =
+        reinterpret_cast<glInvalidateSubFramebufferProc>(
+            GetGLProcAddress("glInvalidateSubFramebuffer"));
+  }
+
+  if (ext.b_GL_APPLE_fence) {
+    fn.glIsFenceAPPLEFn = reinterpret_cast<glIsFenceAPPLEProc>(
+        GetGLProcAddress("glIsFenceAPPLE"));
+  }
+
+  if (ext.b_GL_NV_fence) {
+    fn.glIsFenceNVFn =
+        reinterpret_cast<glIsFenceNVProc>(GetGLProcAddress("glIsFenceNV"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glIsFramebufferEXTFn = reinterpret_cast<glIsFramebufferEXTProc>(
+        GetGLProcAddress("glIsFramebuffer"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glIsFramebufferEXTFn = reinterpret_cast<glIsFramebufferEXTProc>(
+        GetGLProcAddress("glIsFramebufferEXT"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glIsPathNVFn =
+        reinterpret_cast<glIsPathNVProc>(GetGLProcAddress("glIsPathNV"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glIsQueryFn =
+        reinterpret_cast<glIsQueryProc>(GetGLProcAddress("glIsQuery"));
+  } else if (ext.b_GL_ARB_occlusion_query) {
+    fn.glIsQueryFn =
+        reinterpret_cast<glIsQueryProc>(GetGLProcAddress("glIsQueryARB"));
+  } else if (ext.b_GL_EXT_disjoint_timer_query ||
+             ext.b_GL_EXT_occlusion_query_boolean) {
+    fn.glIsQueryFn =
+        reinterpret_cast<glIsQueryProc>(GetGLProcAddress("glIsQueryEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glIsRenderbufferEXTFn = reinterpret_cast<glIsRenderbufferEXTProc>(
+        GetGLProcAddress("glIsRenderbuffer"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glIsRenderbufferEXTFn = reinterpret_cast<glIsRenderbufferEXTProc>(
+        GetGLProcAddress("glIsRenderbufferEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sampler_objects) {
+    fn.glIsSamplerFn =
+        reinterpret_cast<glIsSamplerProc>(GetGLProcAddress("glIsSampler"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sync) {
+    fn.glIsSyncFn =
+        reinterpret_cast<glIsSyncProc>(GetGLProcAddress("glIsSync"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
+      ext.b_GL_ARB_transform_feedback2) {
+    fn.glIsTransformFeedbackFn = reinterpret_cast<glIsTransformFeedbackProc>(
+        GetGLProcAddress("glIsTransformFeedback"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_vertex_array_object) {
+    fn.glIsVertexArrayOESFn = reinterpret_cast<glIsVertexArrayOESProc>(
+        GetGLProcAddress("glIsVertexArray"));
+  } else if (ext.b_GL_OES_vertex_array_object) {
+    fn.glIsVertexArrayOESFn = reinterpret_cast<glIsVertexArrayOESProc>(
+        GetGLProcAddress("glIsVertexArrayOES"));
+  } else if (ext.b_GL_APPLE_vertex_array_object) {
+    fn.glIsVertexArrayOESFn = reinterpret_cast<glIsVertexArrayOESProc>(
+        GetGLProcAddress("glIsVertexArrayAPPLE"));
+  }
+
+  if (!ver->is_es) {
+    fn.glMapBufferFn =
+        reinterpret_cast<glMapBufferProc>(GetGLProcAddress("glMapBuffer"));
+  } else if (ext.b_GL_OES_mapbuffer) {
+    fn.glMapBufferFn =
+        reinterpret_cast<glMapBufferProc>(GetGLProcAddress("glMapBufferOES"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_map_buffer_range) {
+    fn.glMapBufferRangeFn = reinterpret_cast<glMapBufferRangeProc>(
+        GetGLProcAddress("glMapBufferRange"));
+  } else if (ext.b_GL_EXT_map_buffer_range) {
+    fn.glMapBufferRangeFn = reinterpret_cast<glMapBufferRangeProc>(
+        GetGLProcAddress("glMapBufferRangeEXT"));
+  }
+
+  if (ext.b_GL_EXT_direct_state_access || ext.b_GL_NV_path_rendering) {
+    fn.glMatrixLoadfEXTFn = reinterpret_cast<glMatrixLoadfEXTProc>(
+        GetGLProcAddress("glMatrixLoadfEXT"));
+  }
+
+  if (ext.b_GL_EXT_direct_state_access || ext.b_GL_NV_path_rendering) {
+    fn.glMatrixLoadIdentityEXTFn =
+        reinterpret_cast<glMatrixLoadIdentityEXTProc>(
+            GetGLProcAddress("glMatrixLoadIdentityEXT"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 2u) || ver->IsAtLeastGLES(3u, 1u) ||
+      ext.b_GL_ARB_shader_image_load_store) {
+    fn.glMemoryBarrierEXTFn = reinterpret_cast<glMemoryBarrierEXTProc>(
+        GetGLProcAddress("glMemoryBarrier"));
+  } else if (ext.b_GL_EXT_shader_image_load_store) {
+    fn.glMemoryBarrierEXTFn = reinterpret_cast<glMemoryBarrierEXTProc>(
+        GetGLProcAddress("glMemoryBarrierEXT"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glObjectLabelFn =
+        reinterpret_cast<glObjectLabelProc>(GetGLProcAddress("glObjectLabel"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glObjectLabelFn = reinterpret_cast<glObjectLabelProc>(
+        GetGLProcAddress("glObjectLabelKHR"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glObjectPtrLabelFn = reinterpret_cast<glObjectPtrLabelProc>(
+        GetGLProcAddress("glObjectPtrLabel"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glObjectPtrLabelFn = reinterpret_cast<glObjectPtrLabelProc>(
+        GetGLProcAddress("glObjectPtrLabelKHR"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathCommandsNVFn = reinterpret_cast<glPathCommandsNVProc>(
+        GetGLProcAddress("glPathCommandsNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathParameterfNVFn = reinterpret_cast<glPathParameterfNVProc>(
+        GetGLProcAddress("glPathParameterfNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathParameteriNVFn = reinterpret_cast<glPathParameteriNVProc>(
+        GetGLProcAddress("glPathParameteriNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glPathStencilFuncNVFn = reinterpret_cast<glPathStencilFuncNVProc>(
+        GetGLProcAddress("glPathStencilFuncNV"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
+      ext.b_GL_ARB_transform_feedback2) {
+    fn.glPauseTransformFeedbackFn =
+        reinterpret_cast<glPauseTransformFeedbackProc>(
+            GetGLProcAddress("glPauseTransformFeedback"));
+  }
+
+  if (!ver->is_es) {
+    fn.glPointParameteriFn = reinterpret_cast<glPointParameteriProc>(
+        GetGLProcAddress("glPointParameteri"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glPopDebugGroupFn = reinterpret_cast<glPopDebugGroupProc>(
+        GetGLProcAddress("glPopDebugGroup"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glPopDebugGroupFn = reinterpret_cast<glPopDebugGroupProc>(
+        GetGLProcAddress("glPopDebugGroupKHR"));
+  }
+
+  if (ext.b_GL_EXT_debug_marker) {
+    fn.glPopGroupMarkerEXTFn = reinterpret_cast<glPopGroupMarkerEXTProc>(
+        GetGLProcAddress("glPopGroupMarkerEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 1u)) {
+    fn.glPrimitiveRestartIndexFn =
+        reinterpret_cast<glPrimitiveRestartIndexProc>(
+            GetGLProcAddress("glPrimitiveRestartIndex"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 1u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_get_program_binary) {
+    fn.glProgramBinaryFn = reinterpret_cast<glProgramBinaryProc>(
+        GetGLProcAddress("glProgramBinary"));
+  } else if (ext.b_GL_OES_get_program_binary) {
+    fn.glProgramBinaryFn = reinterpret_cast<glProgramBinaryProc>(
+        GetGLProcAddress("glProgramBinaryOES"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 1u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_get_program_binary) {
+    fn.glProgramParameteriFn = reinterpret_cast<glProgramParameteriProc>(
+        GetGLProcAddress("glProgramParameteri"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glProgramPathFragmentInputGenNVFn =
+        reinterpret_cast<glProgramPathFragmentInputGenNVProc>(
+            GetGLProcAddress("glProgramPathFragmentInputGenNV"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 3u) || ver->IsAtLeastGLES(3u, 2u)) {
+    fn.glPushDebugGroupFn = reinterpret_cast<glPushDebugGroupProc>(
+        GetGLProcAddress("glPushDebugGroup"));
+  } else if (ext.b_GL_KHR_debug) {
+    fn.glPushDebugGroupFn = reinterpret_cast<glPushDebugGroupProc>(
+        GetGLProcAddress("glPushDebugGroupKHR"));
+  }
+
+  if (ext.b_GL_EXT_debug_marker) {
+    fn.glPushGroupMarkerEXTFn = reinterpret_cast<glPushGroupMarkerEXTProc>(
+        GetGLProcAddress("glPushGroupMarkerEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ext.b_GL_ARB_timer_query) {
+    fn.glQueryCounterFn = reinterpret_cast<glQueryCounterProc>(
+        GetGLProcAddress("glQueryCounter"));
+  } else if (ext.b_GL_EXT_disjoint_timer_query) {
+    fn.glQueryCounterFn = reinterpret_cast<glQueryCounterProc>(
+        GetGLProcAddress("glQueryCounterEXT"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glReadBufferFn =
+        reinterpret_cast<glReadBufferProc>(GetGLProcAddress("glReadBuffer"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glReadnPixelsRobustANGLEFn =
+        reinterpret_cast<glReadnPixelsRobustANGLEProc>(
+            GetGLProcAddress("glReadnPixelsRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glReadPixelsRobustANGLEFn =
+        reinterpret_cast<glReadPixelsRobustANGLEProc>(
+            GetGLProcAddress("glReadPixelsRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
+    fn.glReleaseShaderCompilerFn =
+        reinterpret_cast<glReleaseShaderCompilerProc>(
+            GetGLProcAddress("glReleaseShaderCompiler"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->is_es) {
+    fn.glRenderbufferStorageEXTFn =
+        reinterpret_cast<glRenderbufferStorageEXTProc>(
+            GetGLProcAddress("glRenderbufferStorage"));
+  } else if (ext.b_GL_EXT_framebuffer_object) {
+    fn.glRenderbufferStorageEXTFn =
+        reinterpret_cast<glRenderbufferStorageEXTProc>(
+            GetGLProcAddress("glRenderbufferStorageEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glRenderbufferStorageMultisampleFn =
+        reinterpret_cast<glRenderbufferStorageMultisampleProc>(
+            GetGLProcAddress("glRenderbufferStorageMultisample"));
+  }
+
+  if (ext.b_GL_ANGLE_framebuffer_multisample) {
+    fn.glRenderbufferStorageMultisampleANGLEFn =
+        reinterpret_cast<glRenderbufferStorageMultisampleANGLEProc>(
+            GetGLProcAddress("glRenderbufferStorageMultisampleANGLE"));
+  }
+
+  if (ext.b_GL_EXT_multisampled_render_to_texture ||
+      ext.b_GL_EXT_framebuffer_multisample) {
+    fn.glRenderbufferStorageMultisampleEXTFn =
+        reinterpret_cast<glRenderbufferStorageMultisampleEXTProc>(
+            GetGLProcAddress("glRenderbufferStorageMultisampleEXT"));
+  }
+
+  if (ext.b_GL_IMG_multisampled_render_to_texture) {
+    fn.glRenderbufferStorageMultisampleIMGFn =
+        reinterpret_cast<glRenderbufferStorageMultisampleIMGProc>(
+            GetGLProcAddress("glRenderbufferStorageMultisampleIMG"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(4u, 0u) ||
+      ext.b_GL_ARB_transform_feedback2) {
+    fn.glResumeTransformFeedbackFn =
+        reinterpret_cast<glResumeTransformFeedbackProc>(
+            GetGLProcAddress("glResumeTransformFeedback"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sampler_objects) {
+    fn.glSamplerParameterfFn = reinterpret_cast<glSamplerParameterfProc>(
+        GetGLProcAddress("glSamplerParameterf"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sampler_objects) {
+    fn.glSamplerParameterfvFn = reinterpret_cast<glSamplerParameterfvProc>(
+        GetGLProcAddress("glSamplerParameterfv"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glSamplerParameterfvRobustANGLEFn =
+        reinterpret_cast<glSamplerParameterfvRobustANGLEProc>(
+            GetGLProcAddress("glSamplerParameterfvRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sampler_objects) {
+    fn.glSamplerParameteriFn = reinterpret_cast<glSamplerParameteriProc>(
+        GetGLProcAddress("glSamplerParameteri"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glSamplerParameterIivRobustANGLEFn =
+        reinterpret_cast<glSamplerParameterIivRobustANGLEProc>(
+            GetGLProcAddress("glSamplerParameterIivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glSamplerParameterIuivRobustANGLEFn =
+        reinterpret_cast<glSamplerParameterIuivRobustANGLEProc>(
+            GetGLProcAddress("glSamplerParameterIuivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sampler_objects) {
+    fn.glSamplerParameterivFn = reinterpret_cast<glSamplerParameterivProc>(
+        GetGLProcAddress("glSamplerParameteriv"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glSamplerParameterivRobustANGLEFn =
+        reinterpret_cast<glSamplerParameterivRobustANGLEProc>(
+            GetGLProcAddress("glSamplerParameterivRobustANGLE"));
+  }
+
+  if (ext.b_GL_APPLE_fence) {
+    fn.glSetFenceAPPLEFn = reinterpret_cast<glSetFenceAPPLEProc>(
+        GetGLProcAddress("glSetFenceAPPLE"));
+  }
+
+  if (ext.b_GL_NV_fence) {
+    fn.glSetFenceNVFn =
+        reinterpret_cast<glSetFenceNVProc>(GetGLProcAddress("glSetFenceNV"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 1u) || ver->is_es) {
+    fn.glShaderBinaryFn = reinterpret_cast<glShaderBinaryProc>(
+        GetGLProcAddress("glShaderBinary"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilFillPathInstancedNVFn =
+        reinterpret_cast<glStencilFillPathInstancedNVProc>(
+            GetGLProcAddress("glStencilFillPathInstancedNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilFillPathNVFn = reinterpret_cast<glStencilFillPathNVProc>(
+        GetGLProcAddress("glStencilFillPathNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilStrokePathInstancedNVFn =
+        reinterpret_cast<glStencilStrokePathInstancedNVProc>(
+            GetGLProcAddress("glStencilStrokePathInstancedNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilStrokePathNVFn = reinterpret_cast<glStencilStrokePathNVProc>(
+        GetGLProcAddress("glStencilStrokePathNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilThenCoverFillPathInstancedNVFn =
+        reinterpret_cast<glStencilThenCoverFillPathInstancedNVProc>(
+            GetGLProcAddress("glStencilThenCoverFillPathInstancedNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilThenCoverFillPathNVFn =
+        reinterpret_cast<glStencilThenCoverFillPathNVProc>(
+            GetGLProcAddress("glStencilThenCoverFillPathNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilThenCoverStrokePathInstancedNVFn =
+        reinterpret_cast<glStencilThenCoverStrokePathInstancedNVProc>(
+            GetGLProcAddress("glStencilThenCoverStrokePathInstancedNV"));
+  }
+
+  if (ext.b_GL_NV_path_rendering) {
+    fn.glStencilThenCoverStrokePathNVFn =
+        reinterpret_cast<glStencilThenCoverStrokePathNVProc>(
+            GetGLProcAddress("glStencilThenCoverStrokePathNV"));
+  }
+
+  if (ext.b_GL_APPLE_fence) {
+    fn.glTestFenceAPPLEFn = reinterpret_cast<glTestFenceAPPLEProc>(
+        GetGLProcAddress("glTestFenceAPPLE"));
+  }
+
+  if (ext.b_GL_NV_fence) {
+    fn.glTestFenceNVFn =
+        reinterpret_cast<glTestFenceNVProc>(GetGLProcAddress("glTestFenceNV"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glTexImage2DRobustANGLEFn =
+        reinterpret_cast<glTexImage2DRobustANGLEProc>(
+            GetGLProcAddress("glTexImage2DRobustANGLE"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glTexImage3DFn =
+        reinterpret_cast<glTexImage3DProc>(GetGLProcAddress("glTexImage3D"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glTexImage3DRobustANGLEFn =
+        reinterpret_cast<glTexImage3DRobustANGLEProc>(
+            GetGLProcAddress("glTexImage3DRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glTexParameterfvRobustANGLEFn =
+        reinterpret_cast<glTexParameterfvRobustANGLEProc>(
+            GetGLProcAddress("glTexParameterfvRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glTexParameterIivRobustANGLEFn =
+        reinterpret_cast<glTexParameterIivRobustANGLEProc>(
+            GetGLProcAddress("glTexParameterIivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glTexParameterIuivRobustANGLEFn =
+        reinterpret_cast<glTexParameterIuivRobustANGLEProc>(
+            GetGLProcAddress("glTexParameterIuivRobustANGLE"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glTexParameterivRobustANGLEFn =
+        reinterpret_cast<glTexParameterivRobustANGLEProc>(
+            GetGLProcAddress("glTexParameterivRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_texture_storage) {
+    fn.glTexStorage2DEXTFn = reinterpret_cast<glTexStorage2DEXTProc>(
+        GetGLProcAddress("glTexStorage2D"));
+  } else if (ext.b_GL_EXT_texture_storage) {
+    fn.glTexStorage2DEXTFn = reinterpret_cast<glTexStorage2DEXTProc>(
+        GetGLProcAddress("glTexStorage2DEXT"));
+  }
+
+  if (ver->IsAtLeastGL(4u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_texture_storage) {
+    fn.glTexStorage3DFn = reinterpret_cast<glTexStorage3DProc>(
+        GetGLProcAddress("glTexStorage3D"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glTexSubImage2DRobustANGLEFn =
+        reinterpret_cast<glTexSubImage2DRobustANGLEProc>(
+            GetGLProcAddress("glTexSubImage2DRobustANGLE"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glTexSubImage3DFn = reinterpret_cast<glTexSubImage3DProc>(
+        GetGLProcAddress("glTexSubImage3D"));
+  }
+
+  if (ext.b_GL_ANGLE_robust_client_memory) {
+    fn.glTexSubImage3DRobustANGLEFn =
+        reinterpret_cast<glTexSubImage3DRobustANGLEProc>(
+            GetGLProcAddress("glTexSubImage3DRobustANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glTransformFeedbackVaryingsFn =
+        reinterpret_cast<glTransformFeedbackVaryingsProc>(
+            GetGLProcAddress("glTransformFeedbackVaryings"));
+  } else if (ext.b_GL_EXT_transform_feedback) {
+    fn.glTransformFeedbackVaryingsFn =
+        reinterpret_cast<glTransformFeedbackVaryingsProc>(
+            GetGLProcAddress("glTransformFeedbackVaryingsEXT"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniform1uiFn =
+        reinterpret_cast<glUniform1uiProc>(GetGLProcAddress("glUniform1ui"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniform1uivFn =
+        reinterpret_cast<glUniform1uivProc>(GetGLProcAddress("glUniform1uiv"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniform2uiFn =
+        reinterpret_cast<glUniform2uiProc>(GetGLProcAddress("glUniform2ui"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniform2uivFn =
+        reinterpret_cast<glUniform2uivProc>(GetGLProcAddress("glUniform2uiv"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniform3uiFn =
+        reinterpret_cast<glUniform3uiProc>(GetGLProcAddress("glUniform3ui"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniform3uivFn =
+        reinterpret_cast<glUniform3uivProc>(GetGLProcAddress("glUniform3uiv"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniform4uiFn =
+        reinterpret_cast<glUniform4uiProc>(GetGLProcAddress("glUniform4ui"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniform4uivFn =
+        reinterpret_cast<glUniform4uivProc>(GetGLProcAddress("glUniform4uiv"));
+  }
+
+  if (ver->IsAtLeastGLES(3u, 0u) || ver->IsAtLeastGL(3u, 1u)) {
+    fn.glUniformBlockBindingFn = reinterpret_cast<glUniformBlockBindingProc>(
+        GetGLProcAddress("glUniformBlockBinding"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniformMatrix2x3fvFn = reinterpret_cast<glUniformMatrix2x3fvProc>(
+        GetGLProcAddress("glUniformMatrix2x3fv"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniformMatrix2x4fvFn = reinterpret_cast<glUniformMatrix2x4fvProc>(
+        GetGLProcAddress("glUniformMatrix2x4fv"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniformMatrix3x2fvFn = reinterpret_cast<glUniformMatrix3x2fvProc>(
+        GetGLProcAddress("glUniformMatrix3x2fv"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniformMatrix3x4fvFn = reinterpret_cast<glUniformMatrix3x4fvProc>(
+        GetGLProcAddress("glUniformMatrix3x4fv"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniformMatrix4x2fvFn = reinterpret_cast<glUniformMatrix4x2fvProc>(
+        GetGLProcAddress("glUniformMatrix4x2fv"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUniformMatrix4x3fvFn = reinterpret_cast<glUniformMatrix4x3fvProc>(
+        GetGLProcAddress("glUniformMatrix4x3fv"));
+  }
+
+  if (!ver->is_es || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glUnmapBufferFn =
+        reinterpret_cast<glUnmapBufferProc>(GetGLProcAddress("glUnmapBuffer"));
+  } else if (ext.b_GL_OES_mapbuffer) {
+    fn.glUnmapBufferFn = reinterpret_cast<glUnmapBufferProc>(
+        GetGLProcAddress("glUnmapBufferOES"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 3u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glVertexAttribDivisorANGLEFn =
+        reinterpret_cast<glVertexAttribDivisorANGLEProc>(
+            GetGLProcAddress("glVertexAttribDivisor"));
+  } else if (ext.b_GL_ARB_instanced_arrays) {
+    fn.glVertexAttribDivisorANGLEFn =
+        reinterpret_cast<glVertexAttribDivisorANGLEProc>(
+            GetGLProcAddress("glVertexAttribDivisorARB"));
+  } else if (ext.b_GL_ANGLE_instanced_arrays) {
+    fn.glVertexAttribDivisorANGLEFn =
+        reinterpret_cast<glVertexAttribDivisorANGLEProc>(
+            GetGLProcAddress("glVertexAttribDivisorANGLE"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glVertexAttribI4iFn = reinterpret_cast<glVertexAttribI4iProc>(
+        GetGLProcAddress("glVertexAttribI4i"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glVertexAttribI4ivFn = reinterpret_cast<glVertexAttribI4ivProc>(
+        GetGLProcAddress("glVertexAttribI4iv"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glVertexAttribI4uiFn = reinterpret_cast<glVertexAttribI4uiProc>(
+        GetGLProcAddress("glVertexAttribI4ui"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glVertexAttribI4uivFn = reinterpret_cast<glVertexAttribI4uivProc>(
+        GetGLProcAddress("glVertexAttribI4uiv"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 0u) || ver->IsAtLeastGLES(3u, 0u)) {
+    fn.glVertexAttribIPointerFn = reinterpret_cast<glVertexAttribIPointerProc>(
+        GetGLProcAddress("glVertexAttribIPointer"));
+  }
+
+  if (ver->IsAtLeastGL(3u, 2u) || ver->IsAtLeastGLES(3u, 0u) ||
+      ext.b_GL_ARB_sync) {
+    fn.glWaitSyncFn =
+        reinterpret_cast<glWaitSyncProc>(GetGLProcAddress("glWaitSync"));
+  }
+}
+
+void DriverGL::ClearBindings() {
+  memset(this, 0, sizeof(*this));
+}
+
+}  // namespace gl