Make GL bindings conditional

ui/gl/gl_bindings_autogen_gl.cc

Index: ui/gl/gl_bindings_autogen_gl.cc
diff --git a/ui/gl/gl_bindings_autogen_gl.cc b/ui/gl/gl_bindings_autogen_gl.cc
index 435758de7bfe9ac44796346b67e96a6e6277f4f8..99848f6fdad52d230e2082cab42bf3edc2d4f5c0 100644
--- a/ui/gl/gl_bindings_autogen_gl.cc
+++ b/ui/gl/gl_bindings_autogen_gl.cc
@@ -23,13 +23,40 @@ namespace gfx {
 static bool g_debugBindingsInitialized;
 DriverGL g_driver_gl;
 
+void glBeginQueryNotBound(GLenum target, GLuint id) {
+  NOTREACHED();
+}
 void glBeginQueryARBNotBound(GLenum target, GLuint id) {
   NOTREACHED();
 }
-void glBindFramebufferEXTNotBound(GLenum target, GLuint framebuffer) {
+void glBeginTransformFeedbackNotBound(GLenum primitiveMode) {
+  NOTREACHED();
+}
+void glBindBufferBaseNotBound(GLenum target, GLuint index, GLuint buffer) {
+  NOTREACHED();
+}
+void glBindBufferRangeNotBound(GLenum target,
+                               GLuint index,
+                               GLuint buffer,
+                               GLintptr offset,
+                               GLsizeiptr size) {
+  NOTREACHED();
+}
+void glBindFragDataLocationNotBound(GLuint program,
+                                    GLuint colorNumber,
+                                    const char* name) {
+  NOTREACHED();
+}
+void glBindFragDataLocationIndexedNotBound(GLuint program,
+                                           GLuint colorNumber,
+                                           GLuint index,
+                                           const char* name) {
+  NOTREACHED();
+}
+void glBindSamplerNotBound(GLuint unit, GLuint sampler) {
   NOTREACHED();
 }
-void glBindRenderbufferEXTNotBound(GLenum target, GLuint renderbuffer) {
+void glBindTransformFeedbackNotBound(GLenum target, GLuint id) {
   NOTREACHED();
 }
 void glBindVertexArrayOESNotBound(GLuint array) {
@@ -38,6 +65,18 @@ void glBindVertexArrayOESNotBound(GLuint array) {
 void glBlendBarrierKHRNotBound(void) {
   NOTREACHED();
 }
+void glBlitFramebufferNotBound(GLint srcX0,
+                               GLint srcY0,
+                               GLint srcX1,
+                               GLint srcY1,
+                               GLint dstX0,
+                               GLint dstY0,
+                               GLint dstX1,
+                               GLint dstY1,
+                               GLbitfield mask,
+                               GLenum filter) {
+  NOTREACHED();
+}
 void glBlitFramebufferANGLENotBound(GLint srcX0,
                                     GLint srcY0,
                                     GLint srcX1,
@@ -62,31 +101,106 @@ void glBlitFramebufferEXTNotBound(GLint srcX0,
                                   GLenum filter) {
   NOTREACHED();
 }
-GLenum glCheckFramebufferStatusEXTNotBound(GLenum target) {
+void glClearBufferfiNotBound(GLenum buffer,
+                             GLint drawbuffer,
+                             const GLfloat depth,
+                             GLint stencil) {
+  NOTREACHED();
+}
+void glClearBufferfvNotBound(GLenum buffer,
+                             GLint drawbuffer,
+                             const GLfloat* value) {
+  NOTREACHED();
+}
+void glClearBufferivNotBound(GLenum buffer,
+                             GLint drawbuffer,
+                             const GLint* value) {
+  NOTREACHED();
+}
+void glClearBufferuivNotBound(GLenum buffer,
+                              GLint drawbuffer,
+                              const GLuint* value) {
+  NOTREACHED();
+}
+void glClearDepthfNotBound(GLclampf depth) {
+  NOTREACHED();
+}
+GLenum glClientWaitSyncNotBound(GLsync sync,
+                                GLbitfield flags,
+                                GLuint64 timeout) {
   NOTREACHED();
   return 0;
 }
-void glDeleteBuffersARBNotBound(GLsizei n, const GLuint* buffers) {
+void glCompressedTexImage3DNotBound(GLenum target,
+                                    GLint level,
+                                    GLenum internalformat,
+                                    GLsizei width,
+                                    GLsizei height,
+                                    GLsizei depth,
+                                    GLint border,
+                                    GLsizei imageSize,
+                                    const void* data) {
+  NOTREACHED();
+}
+void glCopyBufferSubDataNotBound(GLenum readTarget,
+                                 GLenum writeTarget,
+                                 GLintptr readOffset,
+                                 GLintptr writeOffset,
+                                 GLsizeiptr size) {
+  NOTREACHED();
+}
+void glCopyTexSubImage3DNotBound(GLenum target,
+                                 GLint level,
+                                 GLint xoffset,
+                                 GLint yoffset,
+                                 GLint zoffset,
+                                 GLint x,
+                                 GLint y,
+                                 GLsizei width,
+                                 GLsizei height) {
+  NOTREACHED();
+}
+void glDeleteFencesAPPLENotBound(GLsizei n, const GLuint* fences) {
+  NOTREACHED();
+}
+void glDeleteFencesNVNotBound(GLsizei n, const GLuint* fences) {
   NOTREACHED();
 }
-void glDeleteFramebuffersEXTNotBound(GLsizei n, const GLuint* framebuffers) {
+void glDeleteQueriesNotBound(GLsizei n, const GLuint* ids) {
   NOTREACHED();
 }
 void glDeleteQueriesARBNotBound(GLsizei n, const GLuint* ids) {
   NOTREACHED();
 }
-void glDeleteRenderbuffersEXTNotBound(GLsizei n, const GLuint* renderbuffers) {
+void glDeleteSamplersNotBound(GLsizei n, const GLuint* samplers) {
+  NOTREACHED();
+}
+void glDeleteSyncNotBound(GLsync sync) {
+  NOTREACHED();
+}
+void glDeleteTransformFeedbacksNotBound(GLsizei n, const GLuint* ids) {
   NOTREACHED();
 }
 void glDeleteVertexArraysOESNotBound(GLsizei n, const GLuint* arrays) {
   NOTREACHED();
 }
+void glDepthRangefNotBound(GLclampf zNear, GLclampf zFar) {
+  NOTREACHED();
+}
+void glDiscardFramebufferEXTNotBound(GLenum target,
+                                     GLsizei numAttachments,
+                                     const GLenum* attachments) {
+  NOTREACHED();
+}
 void glDrawArraysInstancedANGLENotBound(GLenum mode,
                                         GLint first,
                                         GLsizei count,
                                         GLsizei primcount) {
   NOTREACHED();
 }
+void glDrawBufferNotBound(GLenum mode) {
+  NOTREACHED();
+}
 void glDrawBuffersARBNotBound(GLsizei n, const GLenum* bufs) {
   NOTREACHED();
 }
@@ -97,50 +211,136 @@ void glDrawElementsInstancedANGLENotBound(GLenum mode,
                                           GLsizei primcount) {
   NOTREACHED();
 }
+void glDrawRangeElementsNotBound(GLenum mode,
+                                 GLuint start,
+                                 GLuint end,
+                                 GLsizei count,
+                                 GLenum type,
+                                 const void* indices) {
+  NOTREACHED();
+}
+void glEGLImageTargetRenderbufferStorageOESNotBound(GLenum target,
+                                                    GLeglImageOES image) {
+  NOTREACHED();
+}
+void glEGLImageTargetTexture2DOESNotBound(GLenum target, GLeglImageOES image) {
+  NOTREACHED();
+}
+void glEndQueryNotBound(GLenum target) {
+  NOTREACHED();
+}
 void glEndQueryARBNotBound(GLenum target) {
   NOTREACHED();
 }
-void glFramebufferRenderbufferEXTNotBound(GLenum target,
-                                          GLenum attachment,
-                                          GLenum renderbuffertarget,
-                                          GLuint renderbuffer) {
+void glEndTransformFeedbackNotBound(void) {
+  NOTREACHED();
+}
+GLsync glFenceSyncNotBound(GLenum condition, GLbitfield flags) {
+  NOTREACHED();
+  return 0;
+}
+void glFinishFenceAPPLENotBound(GLuint fence) {
+  NOTREACHED();
+}
+void glFinishFenceNVNotBound(GLuint fence) {
   NOTREACHED();
 }
-void glFramebufferTexture2DEXTNotBound(GLenum target,
+void glFlushMappedBufferRangeNotBound(GLenum target,
+                                      GLintptr offset,
+                                      GLsizeiptr length) {
+  NOTREACHED();
+}
+void glFramebufferTexture2DMultisampleEXTNotBound(GLenum target,
+                                                  GLenum attachment,
+                                                  GLenum textarget,
+                                                  GLuint texture,
+                                                  GLint level,
+                                                  GLsizei samples) {
+  NOTREACHED();
+}
+void glFramebufferTexture2DMultisampleIMGNotBound(GLenum target,
+                                                  GLenum attachment,
+                                                  GLenum textarget,
+                                                  GLuint texture,
+                                                  GLint level,
+                                                  GLsizei samples) {
+  NOTREACHED();
+}
+void glFramebufferTextureLayerNotBound(GLenum target,
                                        GLenum attachment,
-                                       GLenum textarget,
                                        GLuint texture,
-                                       GLint level) {
+                                       GLint level,
+                                       GLint layer) {
   NOTREACHED();
 }
-void glGenBuffersARBNotBound(GLsizei n, GLuint* buffers) {
+void glGenFencesAPPLENotBound(GLsizei n, GLuint* fences) {
   NOTREACHED();
 }
-void glGenerateMipmapEXTNotBound(GLenum target) {
+void glGenFencesNVNotBound(GLsizei n, GLuint* fences) {
   NOTREACHED();
 }
-void glGenFramebuffersEXTNotBound(GLsizei n, GLuint* framebuffers) {
+void glGenQueriesNotBound(GLsizei n, GLuint* ids) {
   NOTREACHED();
 }
 void glGenQueriesARBNotBound(GLsizei n, GLuint* ids) {
   NOTREACHED();
 }
-void glGenRenderbuffersEXTNotBound(GLsizei n, GLuint* renderbuffers) {
+void glGenSamplersNotBound(GLsizei n, GLuint* samplers) {
+  NOTREACHED();
+}
+void glGenTransformFeedbacksNotBound(GLsizei n, GLuint* ids) {
   NOTREACHED();
 }
 void glGenVertexArraysOESNotBound(GLsizei n, GLuint* arrays) {
   NOTREACHED();
 }
-void glGetFramebufferAttachmentParameterivEXTNotBound(GLenum target,
-                                                      GLenum attachment,
-                                                      GLenum pname,
-                                                      GLint* params) {
+void glGetActiveUniformBlockivNotBound(GLuint program,
+                                       GLuint uniformBlockIndex,
+                                       GLenum pname,
+                                       GLint* params) {
+  NOTREACHED();
+}
+void glGetActiveUniformBlockNameNotBound(GLuint program,
+                                         GLuint uniformBlockIndex,
+                                         GLsizei bufSize,
+                                         GLsizei* length,
+                                         char* uniformBlockName) {
+  NOTREACHED();
+}
+void glGetActiveUniformsivNotBound(GLuint program,
+                                   GLsizei uniformCount,
+                                   const GLuint* uniformIndices,
+                                   GLenum pname,
+                                   GLint* params) {
+  NOTREACHED();
+}
+void glGetFenceivNVNotBound(GLuint fence, GLenum pname, GLint* params) {
   NOTREACHED();
 }
+GLint glGetFragDataLocationNotBound(GLuint program, const char* name) {
+  NOTREACHED();
+  return 0;
+}
 GLenum glGetGraphicsResetStatusARBNotBound(void) {
   NOTREACHED();
   return 0;
 }
+void glGetInteger64i_vNotBound(GLenum target, GLuint index, GLint64* data) {
+  NOTREACHED();
+}
+void glGetInteger64vNotBound(GLenum pname, GLint64* params) {
+  NOTREACHED();
+}
+void glGetIntegeri_vNotBound(GLenum target, GLuint index, GLint* data) {
+  NOTREACHED();
+}
+void glGetInternalformativNotBound(GLenum target,
+                                   GLenum internalformat,
+                                   GLenum pname,
+                                   GLsizei bufSize,
+                                   GLint* params) {
+  NOTREACHED();
+}
 void glGetProgramBinaryNotBound(GLuint program,
                                 GLsizei bufSize,
                                 GLsizei* length,
@@ -148,24 +348,116 @@ void glGetProgramBinaryNotBound(GLuint program,
                                 GLvoid* binary) {
   NOTREACHED();
 }
+void glGetQueryivNotBound(GLenum target, GLenum pname, GLint* params) {
+  NOTREACHED();
+}
 void glGetQueryivARBNotBound(GLenum target, GLenum pname, GLint* params) {
   NOTREACHED();
 }
+void glGetQueryObjecti64vNotBound(GLuint id, GLenum pname, GLint64* params) {
+  NOTREACHED();
+}
+void glGetQueryObjectivNotBound(GLuint id, GLenum pname, GLint* params) {
+  NOTREACHED();
+}
 void glGetQueryObjectivARBNotBound(GLuint id, GLenum pname, GLint* params) {
   NOTREACHED();
 }
 void glGetQueryObjectui64vNotBound(GLuint id, GLenum pname, GLuint64* params) {
   NOTREACHED();
 }
+void glGetQueryObjectuivNotBound(GLuint id, GLenum pname, GLuint* params) {
+  NOTREACHED();
+}
 void glGetQueryObjectuivARBNotBound(GLuint id, GLenum pname, GLuint* params) {
   NOTREACHED();
 }
-void glGetRenderbufferParameterivEXTNotBound(GLenum target,
-                                             GLenum pname,
-                                             GLint* params) {
+void glGetSamplerParameterfvNotBound(GLuint sampler,
+                                     GLenum pname,
+                                     GLfloat* params) {
+  NOTREACHED();
+}
+void glGetSamplerParameterivNotBound(GLuint sampler,
+                                     GLenum pname,
+                                     GLint* params) {
+  NOTREACHED();
+}
+void glGetShaderPrecisionFormatNotBound(GLenum shadertype,
+                                        GLenum precisiontype,
+                                        GLint* range,
+                                        GLint* precision) {
+  NOTREACHED();
+}
+void glGetSyncivNotBound(GLsync sync,
+                         GLenum pname,
+                         GLsizei bufSize,
+                         GLsizei* length,
+                         GLint* values) {
   NOTREACHED();
 }
-GLboolean glIsFramebufferEXTNotBound(GLuint framebuffer) {
+void glGetTexLevelParameterfvNotBound(GLenum target,
+                                      GLint level,
+                                      GLenum pname,
+                                      GLfloat* params) {
+  NOTREACHED();
+}
+void glGetTexLevelParameterivNotBound(GLenum target,
+                                      GLint level,
+                                      GLenum pname,
+                                      GLint* params) {
+  NOTREACHED();
+}
+void glGetTransformFeedbackVaryingNotBound(GLuint program,
+                                           GLuint index,
+                                           GLsizei bufSize,
+                                           GLsizei* length,
+                                           GLenum* type,
+                                           char* name) {
+  NOTREACHED();
+}
+void glGetTranslatedShaderSourceANGLENotBound(GLuint shader,
+                                              GLsizei bufsize,
+                                              GLsizei* length,
+                                              char* source) {
+  NOTREACHED();
+}
+GLuint glGetUniformBlockIndexNotBound(GLuint program,
+                                      const char* uniformBlockName) {
+  NOTREACHED();
+  return 0;
+}
+void glGetUniformIndicesNotBound(GLuint program,
+                                 GLsizei uniformCount,
+                                 const char* const* uniformNames,
+                                 GLuint* uniformIndices) {
+  NOTREACHED();
+}
+void glInsertEventMarkerEXTNotBound(GLsizei length, const char* marker) {
+  NOTREACHED();
+}
+void glInvalidateFramebufferNotBound(GLenum target,
+                                     GLsizei numAttachments,
+                                     const GLenum* attachments) {
+  NOTREACHED();
+}
+void glInvalidateSubFramebufferNotBound(GLenum target,
+                                        GLsizei numAttachments,
+                                        const GLenum* attachments,
+                                        GLint x,
+                                        GLint y,
+                                        GLint width,
+                                        GLint height) {
+  NOTREACHED();
+}
+GLboolean glIsFenceAPPLENotBound(GLuint fence) {
+  NOTREACHED();
+  return 0;
+}
+GLboolean glIsFenceNVNotBound(GLuint fence) {
+  NOTREACHED();
+  return 0;
+}
+GLboolean glIsQueryNotBound(GLuint query) {
   NOTREACHED();
   return 0;
 }
@@ -173,7 +465,15 @@ GLboolean glIsQueryARBNotBound(GLuint query) {
   NOTREACHED();
   return 0;
 }
-GLboolean glIsRenderbufferEXTNotBound(GLuint renderbuffer) {
+GLboolean glIsSamplerNotBound(GLuint sampler) {
+  NOTREACHED();
+  return 0;
+}
+GLboolean glIsSyncNotBound(GLsync sync) {
+  NOTREACHED();
+  return 0;
+}
+GLboolean glIsTransformFeedbackNotBound(GLuint id) {
   NOTREACHED();
   return 0;
 }
@@ -192,19 +492,47 @@ void* glMapBufferRangeNotBound(GLenum target,
   NOTREACHED();
   return 0;
 }
+void glMatrixLoadfEXTNotBound(GLenum matrixMode, const GLfloat* m) {
+  NOTREACHED();
+}
+void glMatrixLoadIdentityEXTNotBound(GLenum matrixMode) {
+  NOTREACHED();
+}
+void glPauseTransformFeedbackNotBound(void) {
+  NOTREACHED();
+}
+void glPointParameteriNotBound(GLenum pname, GLint param) {
+  NOTREACHED();
+}
+void glPopGroupMarkerEXTNotBound(void) {
+  NOTREACHED();
+}
 void glProgramBinaryNotBound(GLuint program,
                              GLenum binaryFormat,
                              const GLvoid* binary,
                              GLsizei length) {
   NOTREACHED();
 }
+void glProgramParameteriNotBound(GLuint program, GLenum pname, GLint value) {
+  NOTREACHED();
+}
+void glPushGroupMarkerEXTNotBound(GLsizei length, const char* marker) {
+  NOTREACHED();
+}
 void glQueryCounterNotBound(GLuint id, GLenum target) {
   NOTREACHED();
 }
-void glRenderbufferStorageEXTNotBound(GLenum target,
-                                      GLenum internalformat,
-                                      GLsizei width,
-                                      GLsizei height) {
+void glReadBufferNotBound(GLenum src) {
+  NOTREACHED();
+}
+void glReleaseShaderCompilerNotBound(void) {
+  NOTREACHED();
+}
+void glRenderbufferStorageMultisampleNotBound(GLenum target,
+                                              GLsizei samples,
+                                              GLenum internalformat,
+                                              GLsizei width,
+                                              GLsizei height) {
   NOTREACHED();
 }
 void glRenderbufferStorageMultisampleANGLENotBound(GLenum target,
@@ -221,6 +549,65 @@ void glRenderbufferStorageMultisampleEXTNotBound(GLenum target,
                                                  GLsizei height) {
   NOTREACHED();
 }
+void glRenderbufferStorageMultisampleIMGNotBound(GLenum target,
+                                                 GLsizei samples,
+                                                 GLenum internalformat,
+                                                 GLsizei width,
+                                                 GLsizei height) {
+  NOTREACHED();
+}
+void glResumeTransformFeedbackNotBound(void) {
+  NOTREACHED();
+}
+void glSamplerParameterfNotBound(GLuint sampler, GLenum pname, GLfloat param) {
+  NOTREACHED();
+}
+void glSamplerParameterfvNotBound(GLuint sampler,
+                                  GLenum pname,
+                                  const GLfloat* params) {
+  NOTREACHED();
+}
+void glSamplerParameteriNotBound(GLuint sampler, GLenum pname, GLint param) {
+  NOTREACHED();
+}
+void glSamplerParameterivNotBound(GLuint sampler,
+                                  GLenum pname,
+                                  const GLint* params) {
+  NOTREACHED();
+}
+void glSetFenceAPPLENotBound(GLuint fence) {
+  NOTREACHED();
+}
+void glSetFenceNVNotBound(GLuint fence, GLenum condition) {
+  NOTREACHED();
+}
+void glShaderBinaryNotBound(GLsizei n,
+                            const GLuint* shaders,
+                            GLenum binaryformat,
+                            const void* binary,
+                            GLsizei length) {
+  NOTREACHED();
+}
+GLboolean glTestFenceAPPLENotBound(GLuint fence) {
+  NOTREACHED();
+  return 0;
+}
+GLboolean glTestFenceNVNotBound(GLuint fence) {
+  NOTREACHED();
+  return 0;
+}
+void glTexImage3DNotBound(GLenum target,
+                          GLint level,
+                          GLint internalformat,
+                          GLsizei width,
+                          GLsizei height,
+                          GLsizei depth,
+                          GLint border,
+                          GLenum format,
+                          GLenum type,
+                          const void* pixels) {
+  NOTREACHED();
+}
 void glTexStorage2DEXTNotBound(GLenum target,
                                GLsizei levels,
                                GLenum internalformat,
@@ -228,6 +615,89 @@ void glTexStorage2DEXTNotBound(GLenum target,
                                GLsizei height) {
   NOTREACHED();
 }
+void glTexStorage3DNotBound(GLenum target,
+                            GLsizei levels,
+                            GLenum internalformat,
+                            GLsizei width,
+                            GLsizei height,
+                            GLsizei depth) {
+  NOTREACHED();
+}
+void glTransformFeedbackVaryingsNotBound(GLuint program,
+                                         GLsizei count,
+                                         const char* const* varyings,
+                                         GLenum bufferMode) {
+  NOTREACHED();
+}
+void glUniform1uiNotBound(GLint location, GLuint v0) {
+  NOTREACHED();
+}
+void glUniform1uivNotBound(GLint location, GLsizei count, const GLuint* v) {
+  NOTREACHED();
+}
+void glUniform2uiNotBound(GLint location, GLuint v0, GLuint v1) {
+  NOTREACHED();
+}
+void glUniform2uivNotBound(GLint location, GLsizei count, const GLuint* v) {
+  NOTREACHED();
+}
+void glUniform3uiNotBound(GLint location, GLuint v0, GLuint v1, GLuint v2) {
+  NOTREACHED();
+}
+void glUniform3uivNotBound(GLint location, GLsizei count, const GLuint* v) {
+  NOTREACHED();
+}
+void glUniform4uiNotBound(GLint location,
+                          GLuint v0,
+                          GLuint v1,
+                          GLuint v2,
+                          GLuint v3) {
+  NOTREACHED();
+}
+void glUniform4uivNotBound(GLint location, GLsizei count, const GLuint* v) {
+  NOTREACHED();
+}
+void glUniformBlockBindingNotBound(GLuint program,
+                                   GLuint uniformBlockIndex,
+                                   GLuint uniformBlockBinding) {
+  NOTREACHED();
+}
+void glUniformMatrix2x3fvNotBound(GLint location,
+                                  GLsizei count,
+                                  GLboolean transpose,
+                                  const GLfloat* value) {
+  NOTREACHED();
+}
+void glUniformMatrix2x4fvNotBound(GLint location,
+                                  GLsizei count,
+                                  GLboolean transpose,
+                                  const GLfloat* value) {
+  NOTREACHED();
+}
+void glUniformMatrix3x2fvNotBound(GLint location,
+                                  GLsizei count,
+                                  GLboolean transpose,
+                                  const GLfloat* value) {
+  NOTREACHED();
+}
+void glUniformMatrix3x4fvNotBound(GLint location,
+                                  GLsizei count,
+                                  GLboolean transpose,
+                                  const GLfloat* value) {
+  NOTREACHED();
+}
+void glUniformMatrix4x2fvNotBound(GLint location,
+                                  GLsizei count,
+                                  GLboolean transpose,
+                                  const GLfloat* value) {
+  NOTREACHED();
+}
+void glUniformMatrix4x3fvNotBound(GLint location,
+                                  GLsizei count,
+                                  GLboolean transpose,
+                                  const GLfloat* value) {
+  NOTREACHED();
+}
 GLboolean glUnmapBufferNotBound(GLenum target) {
   NOTREACHED();
   return 0;
@@ -235,42 +705,72 @@ GLboolean glUnmapBufferNotBound(GLenum target) {
 void glVertexAttribDivisorANGLENotBound(GLuint index, GLuint divisor) {
   NOTREACHED();
 }
+void glVertexAttribI4iNotBound(GLuint indx,
+                               GLint x,
+                               GLint y,
+                               GLint z,
+                               GLint w) {
+  NOTREACHED();
+}
+void glVertexAttribI4ivNotBound(GLuint indx, const GLint* values) {
+  NOTREACHED();
+}
+void glVertexAttribI4uiNotBound(GLuint indx,
+                                GLuint x,
+                                GLuint y,
+                                GLuint z,
+                                GLuint w) {
+  NOTREACHED();
+}
+void glVertexAttribI4uivNotBound(GLuint indx, const GLuint* values) {
+  NOTREACHED();
+}
+void glVertexAttribIPointerNotBound(GLuint indx,
+                                    GLint size,
+                                    GLenum type,
+                                    GLsizei stride,
+                                    const void* ptr) {
+  NOTREACHED();
+}
+GLenum glWaitSyncNotBound(GLsync sync, GLbitfield flags, GLuint64 timeout) {
+  NOTREACHED();
+  return 0;
+}
 
 void DriverGL::InitializeStaticBindings() {
   fn.glActiveTextureFn = reinterpret_cast<glActiveTextureProc>(
       GetGLProcAddress("glActiveTexture"));
   fn.glAttachShaderFn =
       reinterpret_cast<glAttachShaderProc>(GetGLProcAddress("glAttachShader"));
-  fn.glBeginQueryFn =
-      reinterpret_cast<glBeginQueryProc>(GetGLProcAddress("glBeginQuery"));
+  fn.glBeginQueryFn = reinterpret_cast<glBeginQueryProc>(glBeginQueryNotBound);
   fn.glBeginQueryARBFn =
       reinterpret_cast<glBeginQueryARBProc>(glBeginQueryARBNotBound);
   fn.glBeginTransformFeedbackFn =
       reinterpret_cast<glBeginTransformFeedbackProc>(
-          GetGLProcAddress("glBeginTransformFeedback"));
+          glBeginTransformFeedbackNotBound);

[Zhenyao Mo, 2015/01/23 01:48:20]

Can't these just be NULL?  Then you don't have to generate all these NOTREACHED
functions.

Call them will end up crashing either way.

[no sievers, 2015/01/24 01:50:46]

Except for in a release build we would handle it more gracefully.
But I don't feel strongly either way. What do others think?

[no sievers, 2015/01/24 01:52:38]

On second thought: it would be nice to get crash reports if there is some
problem (like we are missing a binding because an extension in the header didn't
list the prototypes or so). How about I do it in a follow-up?

   fn.glBindAttribLocationFn = reinterpret_cast<glBindAttribLocationProc>(
       GetGLProcAddress("glBindAttribLocation"));
   fn.glBindBufferFn =
       reinterpret_cast<glBindBufferProc>(GetGLProcAddress("glBindBuffer"));
-  fn.glBindBufferBaseFn = reinterpret_cast<glBindBufferBaseProc>(
-      GetGLProcAddress("glBindBufferBase"));
-  fn.glBindBufferRangeFn = reinterpret_cast<glBindBufferRangeProc>(
-      GetGLProcAddress("glBindBufferRange"));
+  fn.glBindBufferBaseFn =
+      reinterpret_cast<glBindBufferBaseProc>(glBindBufferBaseNotBound);
+  fn.glBindBufferRangeFn =
+      reinterpret_cast<glBindBufferRangeProc>(glBindBufferRangeNotBound);
   fn.glBindFragDataLocationFn = reinterpret_cast<glBindFragDataLocationProc>(
-      GetGLProcAddress("glBindFragDataLocation"));
+      glBindFragDataLocationNotBound);
   fn.glBindFragDataLocationIndexedFn =
       reinterpret_cast<glBindFragDataLocationIndexedProc>(
-          GetGLProcAddress("glBindFragDataLocationIndexed"));
-  fn.glBindFramebufferEXTFn =
-      reinterpret_cast<glBindFramebufferEXTProc>(glBindFramebufferEXTNotBound);
+          glBindFragDataLocationIndexedNotBound);
+  fn.glBindFramebufferEXTFn = reinterpret_cast<glBindFramebufferEXTProc>(
+      GetGLProcAddress("glBindFramebufferEXT"));
   fn.glBindRenderbufferEXTFn = reinterpret_cast<glBindRenderbufferEXTProc>(
-      glBindRenderbufferEXTNotBound);
+      GetGLProcAddress("glBindRenderbufferEXT"));
   fn.glBindSamplerFn =
-      reinterpret_cast<glBindSamplerProc>(GetGLProcAddress("glBindSampler"));
+      reinterpret_cast<glBindSamplerProc>(glBindSamplerNotBound);
   fn.glBindTextureFn =
       reinterpret_cast<glBindTextureProc>(GetGLProcAddress("glBindTexture"));
   fn.glBindTransformFeedbackFn = reinterpret_cast<glBindTransformFeedbackProc>(
-      GetGLProcAddress("glBindTransformFeedback"));
+      glBindTransformFeedbackNotBound);
   fn.glBindVertexArrayOESFn =
       reinterpret_cast<glBindVertexArrayOESProc>(glBindVertexArrayOESNotBound);
   fn.glBlendBarrierKHRFn =
@@ -285,8 +785,8 @@ void DriverGL::InitializeStaticBindings() {
       reinterpret_cast<glBlendFuncProc>(GetGLProcAddress("glBlendFunc"));
   fn.glBlendFuncSeparateFn = reinterpret_cast<glBlendFuncSeparateProc>(
       GetGLProcAddress("glBlendFuncSeparate"));
-  fn.glBlitFramebufferFn = reinterpret_cast<glBlitFramebufferProc>(
-      GetGLProcAddress("glBlitFramebuffer"));
+  fn.glBlitFramebufferFn =
+      reinterpret_cast<glBlitFramebufferProc>(glBlitFramebufferNotBound);
   fn.glBlitFramebufferANGLEFn = reinterpret_cast<glBlitFramebufferANGLEProc>(
       glBlitFramebufferANGLENotBound);
   fn.glBlitFramebufferEXTFn =
@@ -297,26 +797,26 @@ void DriverGL::InitializeStaticBindings() {
       GetGLProcAddress("glBufferSubData"));
   fn.glCheckFramebufferStatusEXTFn =
       reinterpret_cast<glCheckFramebufferStatusEXTProc>(
-          glCheckFramebufferStatusEXTNotBound);
+          GetGLProcAddress("glCheckFramebufferStatusEXT"));
   fn.glClearFn = reinterpret_cast<glClearProc>(GetGLProcAddress("glClear"));
-  fn.glClearBufferfiFn = reinterpret_cast<glClearBufferfiProc>(
-      GetGLProcAddress("glClearBufferfi"));
-  fn.glClearBufferfvFn = reinterpret_cast<glClearBufferfvProc>(
-      GetGLProcAddress("glClearBufferfv"));
-  fn.glClearBufferivFn = reinterpret_cast<glClearBufferivProc>(
-      GetGLProcAddress("glClearBufferiv"));
-  fn.glClearBufferuivFn = reinterpret_cast<glClearBufferuivProc>(
-      GetGLProcAddress("glClearBufferuiv"));
+  fn.glClearBufferfiFn =
+      reinterpret_cast<glClearBufferfiProc>(glClearBufferfiNotBound);
+  fn.glClearBufferfvFn =
+      reinterpret_cast<glClearBufferfvProc>(glClearBufferfvNotBound);
+  fn.glClearBufferivFn =
+      reinterpret_cast<glClearBufferivProc>(glClearBufferivNotBound);
+  fn.glClearBufferuivFn =
+      reinterpret_cast<glClearBufferuivProc>(glClearBufferuivNotBound);
   fn.glClearColorFn =
       reinterpret_cast<glClearColorProc>(GetGLProcAddress("glClearColor"));
   fn.glClearDepthFn =
       reinterpret_cast<glClearDepthProc>(GetGLProcAddress("glClearDepth"));
   fn.glClearDepthfFn =
-      reinterpret_cast<glClearDepthfProc>(GetGLProcAddress("glClearDepthf"));
+      reinterpret_cast<glClearDepthfProc>(glClearDepthfNotBound);
   fn.glClearStencilFn =
       reinterpret_cast<glClearStencilProc>(GetGLProcAddress("glClearStencil"));
-  fn.glClientWaitSyncFn = reinterpret_cast<glClientWaitSyncProc>(
-      GetGLProcAddress("glClientWaitSync"));
+  fn.glClientWaitSyncFn =
+      reinterpret_cast<glClientWaitSyncProc>(glClientWaitSyncNotBound);
   fn.glColorMaskFn =
       reinterpret_cast<glColorMaskProc>(GetGLProcAddress("glColorMask"));
   fn.glCompileShaderFn = reinterpret_cast<glCompileShaderProc>(
@@ -324,52 +824,51 @@ void DriverGL::InitializeStaticBindings() {
   fn.glCompressedTexImage2DFn = reinterpret_cast<glCompressedTexImage2DProc>(
       GetGLProcAddress("glCompressedTexImage2D"));
   fn.glCompressedTexImage3DFn = reinterpret_cast<glCompressedTexImage3DProc>(
-      GetGLProcAddress("glCompressedTexImage3D"));
+      glCompressedTexImage3DNotBound);
   fn.glCompressedTexSubImage2DFn =
       reinterpret_cast<glCompressedTexSubImage2DProc>(
           GetGLProcAddress("glCompressedTexSubImage2D"));
-  fn.glCopyBufferSubDataFn = reinterpret_cast<glCopyBufferSubDataProc>(
-      GetGLProcAddress("glCopyBufferSubData"));
+  fn.glCopyBufferSubDataFn =
+      reinterpret_cast<glCopyBufferSubDataProc>(glCopyBufferSubDataNotBound);
   fn.glCopyTexImage2DFn = reinterpret_cast<glCopyTexImage2DProc>(
       GetGLProcAddress("glCopyTexImage2D"));
   fn.glCopyTexSubImage2DFn = reinterpret_cast<glCopyTexSubImage2DProc>(
       GetGLProcAddress("glCopyTexSubImage2D"));
-  fn.glCopyTexSubImage3DFn = reinterpret_cast<glCopyTexSubImage3DProc>(
-      GetGLProcAddress("glCopyTexSubImage3D"));
+  fn.glCopyTexSubImage3DFn =
+      reinterpret_cast<glCopyTexSubImage3DProc>(glCopyTexSubImage3DNotBound);
   fn.glCreateProgramFn = reinterpret_cast<glCreateProgramProc>(
       GetGLProcAddress("glCreateProgram"));
   fn.glCreateShaderFn =
       reinterpret_cast<glCreateShaderProc>(GetGLProcAddress("glCreateShader"));
   fn.glCullFaceFn =
       reinterpret_cast<glCullFaceProc>(GetGLProcAddress("glCullFace"));
-  fn.glDeleteBuffersARBFn =
-      reinterpret_cast<glDeleteBuffersARBProc>(glDeleteBuffersARBNotBound);
-  fn.glDeleteFencesAPPLEFn = reinterpret_cast<glDeleteFencesAPPLEProc>(
-      GetGLProcAddress("glDeleteFencesAPPLE"));
-  fn.glDeleteFencesNVFn = reinterpret_cast<glDeleteFencesNVProc>(
-      GetGLProcAddress("glDeleteFencesNV"));
+  fn.glDeleteBuffersARBFn = reinterpret_cast<glDeleteBuffersARBProc>(
+      GetGLProcAddress("glDeleteBuffers"));
+  fn.glDeleteFencesAPPLEFn =
+      reinterpret_cast<glDeleteFencesAPPLEProc>(glDeleteFencesAPPLENotBound);
+  fn.glDeleteFencesNVFn =
+      reinterpret_cast<glDeleteFencesNVProc>(glDeleteFencesNVNotBound);
   fn.glDeleteFramebuffersEXTFn = reinterpret_cast<glDeleteFramebuffersEXTProc>(
-      glDeleteFramebuffersEXTNotBound);
+      GetGLProcAddress("glDeleteFramebuffersEXT"));
   fn.glDeleteProgramFn = reinterpret_cast<glDeleteProgramProc>(
       GetGLProcAddress("glDeleteProgram"));
-  fn.glDeleteQueriesFn = reinterpret_cast<glDeleteQueriesProc>(
-      GetGLProcAddress("glDeleteQueries"));
+  fn.glDeleteQueriesFn =
+      reinterpret_cast<glDeleteQueriesProc>(glDeleteQueriesNotBound);
   fn.glDeleteQueriesARBFn =
       reinterpret_cast<glDeleteQueriesARBProc>(glDeleteQueriesARBNotBound);
   fn.glDeleteRenderbuffersEXTFn =
       reinterpret_cast<glDeleteRenderbuffersEXTProc>(
-          glDeleteRenderbuffersEXTNotBound);
-  fn.glDeleteSamplersFn = reinterpret_cast<glDeleteSamplersProc>(
-      GetGLProcAddress("glDeleteSamplers"));
+          GetGLProcAddress("glDeleteRenderbuffersEXT"));
+  fn.glDeleteSamplersFn =
+      reinterpret_cast<glDeleteSamplersProc>(glDeleteSamplersNotBound);
   fn.glDeleteShaderFn =
       reinterpret_cast<glDeleteShaderProc>(GetGLProcAddress("glDeleteShader"));
-  fn.glDeleteSyncFn =
-      reinterpret_cast<glDeleteSyncProc>(GetGLProcAddress("glDeleteSync"));
+  fn.glDeleteSyncFn = reinterpret_cast<glDeleteSyncProc>(glDeleteSyncNotBound);
   fn.glDeleteTexturesFn = reinterpret_cast<glDeleteTexturesProc>(
       GetGLProcAddress("glDeleteTextures"));
   fn.glDeleteTransformFeedbacksFn =
       reinterpret_cast<glDeleteTransformFeedbacksProc>(
-          GetGLProcAddress("glDeleteTransformFeedbacks"));
+          glDeleteTransformFeedbacksNotBound);
   fn.glDeleteVertexArraysOESFn = reinterpret_cast<glDeleteVertexArraysOESProc>(
       glDeleteVertexArraysOESNotBound);
   fn.glDepthFuncFn =
@@ -379,7 +878,7 @@ void DriverGL::InitializeStaticBindings() {
   fn.glDepthRangeFn =
       reinterpret_cast<glDepthRangeProc>(GetGLProcAddress("glDepthRange"));
   fn.glDepthRangefFn =
-      reinterpret_cast<glDepthRangefProc>(GetGLProcAddress("glDepthRangef"));
+      reinterpret_cast<glDepthRangefProc>(glDepthRangefNotBound);
   fn.glDetachShaderFn =
       reinterpret_cast<glDetachShaderProc>(GetGLProcAddress("glDetachShader"));
   fn.glDisableFn =
@@ -388,14 +887,13 @@ void DriverGL::InitializeStaticBindings() {
       reinterpret_cast<glDisableVertexAttribArrayProc>(
           GetGLProcAddress("glDisableVertexAttribArray"));
   fn.glDiscardFramebufferEXTFn = reinterpret_cast<glDiscardFramebufferEXTProc>(
-      GetGLProcAddress("glDiscardFramebufferEXT"));
+      glDiscardFramebufferEXTNotBound);
   fn.glDrawArraysFn =
       reinterpret_cast<glDrawArraysProc>(GetGLProcAddress("glDrawArrays"));
   fn.glDrawArraysInstancedANGLEFn =
       reinterpret_cast<glDrawArraysInstancedANGLEProc>(
           glDrawArraysInstancedANGLENotBound);
-  fn.glDrawBufferFn =
-      reinterpret_cast<glDrawBufferProc>(GetGLProcAddress("glDrawBuffer"));
+  fn.glDrawBufferFn = reinterpret_cast<glDrawBufferProc>(glDrawBufferNotBound);
   fn.glDrawBuffersARBFn =
       reinterpret_cast<glDrawBuffersARBProc>(glDrawBuffersARBNotBound);
   fn.glDrawElementsFn =
@@ -403,74 +901,71 @@ void DriverGL::InitializeStaticBindings() {
   fn.glDrawElementsInstancedANGLEFn =
       reinterpret_cast<glDrawElementsInstancedANGLEProc>(
           glDrawElementsInstancedANGLENotBound);
-  fn.glDrawRangeElementsFn = reinterpret_cast<glDrawRangeElementsProc>(
-      GetGLProcAddress("glDrawRangeElements"));
+  fn.glDrawRangeElementsFn =
+      reinterpret_cast<glDrawRangeElementsProc>(glDrawRangeElementsNotBound);
   fn.glEGLImageTargetRenderbufferStorageOESFn =
       reinterpret_cast<glEGLImageTargetRenderbufferStorageOESProc>(
-          GetGLProcAddress("glEGLImageTargetRenderbufferStorageOES"));
+          glEGLImageTargetRenderbufferStorageOESNotBound);
   fn.glEGLImageTargetTexture2DOESFn =
       reinterpret_cast<glEGLImageTargetTexture2DOESProc>(
-          GetGLProcAddress("glEGLImageTargetTexture2DOES"));
+          glEGLImageTargetTexture2DOESNotBound);
   fn.glEnableFn = reinterpret_cast<glEnableProc>(GetGLProcAddress("glEnable"));
   fn.glEnableVertexAttribArrayFn =
       reinterpret_cast<glEnableVertexAttribArrayProc>(
           GetGLProcAddress("glEnableVertexAttribArray"));
-  fn.glEndQueryFn =
-      reinterpret_cast<glEndQueryProc>(GetGLProcAddress("glEndQuery"));
+  fn.glEndQueryFn = reinterpret_cast<glEndQueryProc>(glEndQueryNotBound);
   fn.glEndQueryARBFn =
       reinterpret_cast<glEndQueryARBProc>(glEndQueryARBNotBound);
   fn.glEndTransformFeedbackFn = reinterpret_cast<glEndTransformFeedbackProc>(
-      GetGLProcAddress("glEndTransformFeedback"));
-  fn.glFenceSyncFn =
-      reinterpret_cast<glFenceSyncProc>(GetGLProcAddress("glFenceSync"));
+      glEndTransformFeedbackNotBound);
+  fn.glFenceSyncFn = reinterpret_cast<glFenceSyncProc>(glFenceSyncNotBound);
   fn.glFinishFn = reinterpret_cast<glFinishProc>(GetGLProcAddress("glFinish"));
-  fn.glFinishFenceAPPLEFn = reinterpret_cast<glFinishFenceAPPLEProc>(
-      GetGLProcAddress("glFinishFenceAPPLE"));
-  fn.glFinishFenceNVFn = reinterpret_cast<glFinishFenceNVProc>(
-      GetGLProcAddress("glFinishFenceNV"));
+  fn.glFinishFenceAPPLEFn =
+      reinterpret_cast<glFinishFenceAPPLEProc>(glFinishFenceAPPLENotBound);
+  fn.glFinishFenceNVFn =
+      reinterpret_cast<glFinishFenceNVProc>(glFinishFenceNVNotBound);
   fn.glFlushFn = reinterpret_cast<glFlushProc>(GetGLProcAddress("glFlush"));
   fn.glFlushMappedBufferRangeFn =
       reinterpret_cast<glFlushMappedBufferRangeProc>(
-          GetGLProcAddress("glFlushMappedBufferRange"));
+          glFlushMappedBufferRangeNotBound);
   fn.glFramebufferRenderbufferEXTFn =
       reinterpret_cast<glFramebufferRenderbufferEXTProc>(
-          glFramebufferRenderbufferEXTNotBound);
+          GetGLProcAddress("glFramebufferRenderbufferEXT"));
   fn.glFramebufferTexture2DEXTFn =
       reinterpret_cast<glFramebufferTexture2DEXTProc>(
-          glFramebufferTexture2DEXTNotBound);
+          GetGLProcAddress("glFramebufferTexture2DEXT"));
   fn.glFramebufferTexture2DMultisampleEXTFn =
       reinterpret_cast<glFramebufferTexture2DMultisampleEXTProc>(
-          GetGLProcAddress("glFramebufferTexture2DMultisampleEXT"));
+          glFramebufferTexture2DMultisampleEXTNotBound);
   fn.glFramebufferTexture2DMultisampleIMGFn =
       reinterpret_cast<glFramebufferTexture2DMultisampleIMGProc>(
-          GetGLProcAddress("glFramebufferTexture2DMultisampleIMG"));
+          glFramebufferTexture2DMultisampleIMGNotBound);
   fn.glFramebufferTextureLayerFn =
       reinterpret_cast<glFramebufferTextureLayerProc>(
-          GetGLProcAddress("glFramebufferTextureLayer"));
+          glFramebufferTextureLayerNotBound);
   fn.glFrontFaceFn =
       reinterpret_cast<glFrontFaceProc>(GetGLProcAddress("glFrontFace"));
   fn.glGenBuffersARBFn =
-      reinterpret_cast<glGenBuffersARBProc>(glGenBuffersARBNotBound);
-  fn.glGenerateMipmapEXTFn =
-      reinterpret_cast<glGenerateMipmapEXTProc>(glGenerateMipmapEXTNotBound);
-  fn.glGenFencesAPPLEFn = reinterpret_cast<glGenFencesAPPLEProc>(
-      GetGLProcAddress("glGenFencesAPPLE"));
+      reinterpret_cast<glGenBuffersARBProc>(GetGLProcAddress("glGenBuffers"));
+  fn.glGenerateMipmapEXTFn = reinterpret_cast<glGenerateMipmapEXTProc>(
+      GetGLProcAddress("glGenerateMipmapEXT"));
+  fn.glGenFencesAPPLEFn =
+      reinterpret_cast<glGenFencesAPPLEProc>(glGenFencesAPPLENotBound);
   fn.glGenFencesNVFn =
-      reinterpret_cast<glGenFencesNVProc>(GetGLProcAddress("glGenFencesNV"));
-  fn.glGenFramebuffersEXTFn =
-      reinterpret_cast<glGenFramebuffersEXTProc>(glGenFramebuffersEXTNotBound);
-  fn.glGenQueriesFn =
-      reinterpret_cast<glGenQueriesProc>(GetGLProcAddress("glGenQueries"));
+      reinterpret_cast<glGenFencesNVProc>(glGenFencesNVNotBound);
+  fn.glGenFramebuffersEXTFn = reinterpret_cast<glGenFramebuffersEXTProc>(
+      GetGLProcAddress("glGenFramebuffersEXT"));
+  fn.glGenQueriesFn = reinterpret_cast<glGenQueriesProc>(glGenQueriesNotBound);
   fn.glGenQueriesARBFn =
       reinterpret_cast<glGenQueriesARBProc>(glGenQueriesARBNotBound);
   fn.glGenRenderbuffersEXTFn = reinterpret_cast<glGenRenderbuffersEXTProc>(
-      glGenRenderbuffersEXTNotBound);
+      GetGLProcAddress("glGenRenderbuffersEXT"));
   fn.glGenSamplersFn =
-      reinterpret_cast<glGenSamplersProc>(GetGLProcAddress("glGenSamplers"));
+      reinterpret_cast<glGenSamplersProc>(glGenSamplersNotBound);
   fn.glGenTexturesFn =
       reinterpret_cast<glGenTexturesProc>(GetGLProcAddress("glGenTextures"));
   fn.glGenTransformFeedbacksFn = reinterpret_cast<glGenTransformFeedbacksProc>(
-      GetGLProcAddress("glGenTransformFeedbacks"));
+      glGenTransformFeedbacksNotBound);
   fn.glGenVertexArraysOESFn =
       reinterpret_cast<glGenVertexArraysOESProc>(glGenVertexArraysOESNotBound);
   fn.glGetActiveAttribFn = reinterpret_cast<glGetActiveAttribProc>(
@@ -479,12 +974,12 @@ void DriverGL::InitializeStaticBindings() {
       GetGLProcAddress("glGetActiveUniform"));
   fn.glGetActiveUniformBlockivFn =
       reinterpret_cast<glGetActiveUniformBlockivProc>(
-          GetGLProcAddress("glGetActiveUniformBlockiv"));
+          glGetActiveUniformBlockivNotBound);
   fn.glGetActiveUniformBlockNameFn =
       reinterpret_cast<glGetActiveUniformBlockNameProc>(
-          GetGLProcAddress("glGetActiveUniformBlockName"));
+          glGetActiveUniformBlockNameNotBound);
   fn.glGetActiveUniformsivFn = reinterpret_cast<glGetActiveUniformsivProc>(
-      GetGLProcAddress("glGetActiveUniformsiv"));
+      glGetActiveUniformsivNotBound);
   fn.glGetAttachedShadersFn = reinterpret_cast<glGetAttachedShadersProc>(
       GetGLProcAddress("glGetAttachedShaders"));
   fn.glGetAttribLocationFn = reinterpret_cast<glGetAttribLocationProc>(
@@ -496,91 +991,89 @@ void DriverGL::InitializeStaticBindings() {
   fn.glGetErrorFn =
       reinterpret_cast<glGetErrorProc>(GetGLProcAddress("glGetError"));
   fn.glGetFenceivNVFn =
-      reinterpret_cast<glGetFenceivNVProc>(GetGLProcAddress("glGetFenceivNV"));
+      reinterpret_cast<glGetFenceivNVProc>(glGetFenceivNVNotBound);
   fn.glGetFloatvFn =
       reinterpret_cast<glGetFloatvProc>(GetGLProcAddress("glGetFloatv"));
   fn.glGetFragDataLocationFn = reinterpret_cast<glGetFragDataLocationProc>(
-      GetGLProcAddress("glGetFragDataLocation"));
+      glGetFragDataLocationNotBound);
   fn.glGetFramebufferAttachmentParameterivEXTFn =
       reinterpret_cast<glGetFramebufferAttachmentParameterivEXTProc>(
-          glGetFramebufferAttachmentParameterivEXTNotBound);
+          GetGLProcAddress("glGetFramebufferAttachmentParameterivEXT"));
   fn.glGetGraphicsResetStatusARBFn =
       reinterpret_cast<glGetGraphicsResetStatusARBProc>(
           glGetGraphicsResetStatusARBNotBound);
-  fn.glGetInteger64i_vFn = reinterpret_cast<glGetInteger64i_vProc>(
-      GetGLProcAddress("glGetInteger64i_v"));
-  fn.glGetInteger64vFn = reinterpret_cast<glGetInteger64vProc>(
-      GetGLProcAddress("glGetInteger64v"));
-  fn.glGetIntegeri_vFn = reinterpret_cast<glGetIntegeri_vProc>(
-      GetGLProcAddress("glGetIntegeri_v"));
+  fn.glGetInteger64i_vFn =
+      reinterpret_cast<glGetInteger64i_vProc>(glGetInteger64i_vNotBound);
+  fn.glGetInteger64vFn =
+      reinterpret_cast<glGetInteger64vProc>(glGetInteger64vNotBound);
+  fn.glGetIntegeri_vFn =
+      reinterpret_cast<glGetIntegeri_vProc>(glGetIntegeri_vNotBound);
   fn.glGetIntegervFn =
       reinterpret_cast<glGetIntegervProc>(GetGLProcAddress("glGetIntegerv"));
   fn.glGetInternalformativFn = reinterpret_cast<glGetInternalformativProc>(
-      GetGLProcAddress("glGetInternalformativ"));
+      glGetInternalformativNotBound);
   fn.glGetProgramBinaryFn =
       reinterpret_cast<glGetProgramBinaryProc>(glGetProgramBinaryNotBound);
   fn.glGetProgramInfoLogFn = reinterpret_cast<glGetProgramInfoLogProc>(
       GetGLProcAddress("glGetProgramInfoLog"));
   fn.glGetProgramivFn =
       reinterpret_cast<glGetProgramivProc>(GetGLProcAddress("glGetProgramiv"));
-  fn.glGetQueryivFn =
-      reinterpret_cast<glGetQueryivProc>(GetGLProcAddress("glGetQueryiv"));
+  fn.glGetQueryivFn = reinterpret_cast<glGetQueryivProc>(glGetQueryivNotBound);
   fn.glGetQueryivARBFn =
       reinterpret_cast<glGetQueryivARBProc>(glGetQueryivARBNotBound);
-  fn.glGetQueryObjecti64vFn = reinterpret_cast<glGetQueryObjecti64vProc>(
-      GetGLProcAddress("glGetQueryObjecti64v"));
-  fn.glGetQueryObjectivFn = reinterpret_cast<glGetQueryObjectivProc>(
-      GetGLProcAddress("glGetQueryObjectiv"));
+  fn.glGetQueryObjecti64vFn =
+      reinterpret_cast<glGetQueryObjecti64vProc>(glGetQueryObjecti64vNotBound);
+  fn.glGetQueryObjectivFn =
+      reinterpret_cast<glGetQueryObjectivProc>(glGetQueryObjectivNotBound);
   fn.glGetQueryObjectivARBFn = reinterpret_cast<glGetQueryObjectivARBProc>(
       glGetQueryObjectivARBNotBound);
   fn.glGetQueryObjectui64vFn = reinterpret_cast<glGetQueryObjectui64vProc>(
       glGetQueryObjectui64vNotBound);
-  fn.glGetQueryObjectuivFn = reinterpret_cast<glGetQueryObjectuivProc>(
-      GetGLProcAddress("glGetQueryObjectuiv"));
+  fn.glGetQueryObjectuivFn =
+      reinterpret_cast<glGetQueryObjectuivProc>(glGetQueryObjectuivNotBound);
   fn.glGetQueryObjectuivARBFn = reinterpret_cast<glGetQueryObjectuivARBProc>(
       glGetQueryObjectuivARBNotBound);
   fn.glGetRenderbufferParameterivEXTFn =
       reinterpret_cast<glGetRenderbufferParameterivEXTProc>(
-          glGetRenderbufferParameterivEXTNotBound);
+          GetGLProcAddress("glGetRenderbufferParameterivEXT"));
   fn.glGetSamplerParameterfvFn = reinterpret_cast<glGetSamplerParameterfvProc>(
-      GetGLProcAddress("glGetSamplerParameterfv"));
+      glGetSamplerParameterfvNotBound);
   fn.glGetSamplerParameterivFn = reinterpret_cast<glGetSamplerParameterivProc>(
-      GetGLProcAddress("glGetSamplerParameteriv"));
+      glGetSamplerParameterivNotBound);
   fn.glGetShaderInfoLogFn = reinterpret_cast<glGetShaderInfoLogProc>(
       GetGLProcAddress("glGetShaderInfoLog"));
   fn.glGetShaderivFn =
       reinterpret_cast<glGetShaderivProc>(GetGLProcAddress("glGetShaderiv"));
   fn.glGetShaderPrecisionFormatFn =
       reinterpret_cast<glGetShaderPrecisionFormatProc>(
-          GetGLProcAddress("glGetShaderPrecisionFormat"));
+          glGetShaderPrecisionFormatNotBound);
   fn.glGetShaderSourceFn = reinterpret_cast<glGetShaderSourceProc>(
       GetGLProcAddress("glGetShaderSource"));
   fn.glGetStringFn =
       reinterpret_cast<glGetStringProc>(GetGLProcAddress("glGetString"));
-  fn.glGetSyncivFn =
-      reinterpret_cast<glGetSyncivProc>(GetGLProcAddress("glGetSynciv"));
+  fn.glGetSyncivFn = reinterpret_cast<glGetSyncivProc>(glGetSyncivNotBound);
   fn.glGetTexLevelParameterfvFn =
       reinterpret_cast<glGetTexLevelParameterfvProc>(
-          GetGLProcAddress("glGetTexLevelParameterfv"));
+          glGetTexLevelParameterfvNotBound);
   fn.glGetTexLevelParameterivFn =
       reinterpret_cast<glGetTexLevelParameterivProc>(
-          GetGLProcAddress("glGetTexLevelParameteriv"));
+          glGetTexLevelParameterivNotBound);
   fn.glGetTexParameterfvFn = reinterpret_cast<glGetTexParameterfvProc>(
       GetGLProcAddress("glGetTexParameterfv"));
   fn.glGetTexParameterivFn = reinterpret_cast<glGetTexParameterivProc>(
       GetGLProcAddress("glGetTexParameteriv"));
   fn.glGetTransformFeedbackVaryingFn =
       reinterpret_cast<glGetTransformFeedbackVaryingProc>(
-          GetGLProcAddress("glGetTransformFeedbackVarying"));
+          glGetTransformFeedbackVaryingNotBound);
   fn.glGetTranslatedShaderSourceANGLEFn =
       reinterpret_cast<glGetTranslatedShaderSourceANGLEProc>(
-          GetGLProcAddress("glGetTranslatedShaderSourceANGLE"));
+          glGetTranslatedShaderSourceANGLENotBound);
   fn.glGetUniformBlockIndexFn = reinterpret_cast<glGetUniformBlockIndexProc>(
-      GetGLProcAddress("glGetUniformBlockIndex"));
+      glGetUniformBlockIndexNotBound);
   fn.glGetUniformfvFn =
       reinterpret_cast<glGetUniformfvProc>(GetGLProcAddress("glGetUniformfv"));
-  fn.glGetUniformIndicesFn = reinterpret_cast<glGetUniformIndicesProc>(
-      GetGLProcAddress("glGetUniformIndices"));
+  fn.glGetUniformIndicesFn =
+      reinterpret_cast<glGetUniformIndicesProc>(glGetUniformIndicesNotBound);
   fn.glGetUniformivFn =
       reinterpret_cast<glGetUniformivProc>(GetGLProcAddress("glGetUniformiv"));
   fn.glGetUniformLocationFn = reinterpret_cast<glGetUniformLocationProc>(
@@ -594,38 +1087,35 @@ void DriverGL::InitializeStaticBindings() {
           GetGLProcAddress("glGetVertexAttribPointerv"));
   fn.glHintFn = reinterpret_cast<glHintProc>(GetGLProcAddress("glHint"));
   fn.glInsertEventMarkerEXTFn = reinterpret_cast<glInsertEventMarkerEXTProc>(
-      GetGLProcAddress("glInsertEventMarkerEXT"));
+      glInsertEventMarkerEXTNotBound);
   fn.glInvalidateFramebufferFn = reinterpret_cast<glInvalidateFramebufferProc>(
-      GetGLProcAddress("glInvalidateFramebuffer"));
+      glInvalidateFramebufferNotBound);
   fn.glInvalidateSubFramebufferFn =
       reinterpret_cast<glInvalidateSubFramebufferProc>(
-          GetGLProcAddress("glInvalidateSubFramebuffer"));
+          glInvalidateSubFramebufferNotBound);
   fn.glIsBufferFn =
       reinterpret_cast<glIsBufferProc>(GetGLProcAddress("glIsBuffer"));
   fn.glIsEnabledFn =
       reinterpret_cast<glIsEnabledProc>(GetGLProcAddress("glIsEnabled"));
   fn.glIsFenceAPPLEFn =
-      reinterpret_cast<glIsFenceAPPLEProc>(GetGLProcAddress("glIsFenceAPPLE"));
-  fn.glIsFenceNVFn =
-      reinterpret_cast<glIsFenceNVProc>(GetGLProcAddress("glIsFenceNV"));
-  fn.glIsFramebufferEXTFn =
-      reinterpret_cast<glIsFramebufferEXTProc>(glIsFramebufferEXTNotBound);
+      reinterpret_cast<glIsFenceAPPLEProc>(glIsFenceAPPLENotBound);
+  fn.glIsFenceNVFn = reinterpret_cast<glIsFenceNVProc>(glIsFenceNVNotBound);
+  fn.glIsFramebufferEXTFn = reinterpret_cast<glIsFramebufferEXTProc>(
+      GetGLProcAddress("glIsFramebufferEXT"));
   fn.glIsProgramFn =
       reinterpret_cast<glIsProgramProc>(GetGLProcAddress("glIsProgram"));
-  fn.glIsQueryFn =
-      reinterpret_cast<glIsQueryProc>(GetGLProcAddress("glIsQuery"));
+  fn.glIsQueryFn = reinterpret_cast<glIsQueryProc>(glIsQueryNotBound);
   fn.glIsQueryARBFn = reinterpret_cast<glIsQueryARBProc>(glIsQueryARBNotBound);
-  fn.glIsRenderbufferEXTFn =
-      reinterpret_cast<glIsRenderbufferEXTProc>(glIsRenderbufferEXTNotBound);
-  fn.glIsSamplerFn =
-      reinterpret_cast<glIsSamplerProc>(GetGLProcAddress("glIsSampler"));
+  fn.glIsRenderbufferEXTFn = reinterpret_cast<glIsRenderbufferEXTProc>(
+      GetGLProcAddress("glIsRenderbufferEXT"));
+  fn.glIsSamplerFn = reinterpret_cast<glIsSamplerProc>(glIsSamplerNotBound);
   fn.glIsShaderFn =
       reinterpret_cast<glIsShaderProc>(GetGLProcAddress("glIsShader"));
-  fn.glIsSyncFn = reinterpret_cast<glIsSyncProc>(GetGLProcAddress("glIsSync"));
+  fn.glIsSyncFn = reinterpret_cast<glIsSyncProc>(glIsSyncNotBound);
   fn.glIsTextureFn =
       reinterpret_cast<glIsTextureProc>(GetGLProcAddress("glIsTexture"));
   fn.glIsTransformFeedbackFn = reinterpret_cast<glIsTransformFeedbackProc>(
-      GetGLProcAddress("glIsTransformFeedback"));
+      glIsTransformFeedbackNotBound);
   fn.glIsVertexArrayOESFn =
       reinterpret_cast<glIsVertexArrayOESProc>(glIsVertexArrayOESNotBound);
   fn.glLineWidthFn =
@@ -635,41 +1125,40 @@ void DriverGL::InitializeStaticBindings() {
   fn.glMapBufferFn = reinterpret_cast<glMapBufferProc>(glMapBufferNotBound);
   fn.glMapBufferRangeFn =
       reinterpret_cast<glMapBufferRangeProc>(glMapBufferRangeNotBound);
-  fn.glMatrixLoadfEXTFn = reinterpret_cast<glMatrixLoadfEXTProc>(
-      GetGLProcAddress("glMatrixLoadfEXT"));
+  fn.glMatrixLoadfEXTFn =
+      reinterpret_cast<glMatrixLoadfEXTProc>(glMatrixLoadfEXTNotBound);
   fn.glMatrixLoadIdentityEXTFn = reinterpret_cast<glMatrixLoadIdentityEXTProc>(
-      GetGLProcAddress("glMatrixLoadIdentityEXT"));
+      glMatrixLoadIdentityEXTNotBound);
   fn.glPauseTransformFeedbackFn =
       reinterpret_cast<glPauseTransformFeedbackProc>(
-          GetGLProcAddress("glPauseTransformFeedback"));
+          glPauseTransformFeedbackNotBound);
   fn.glPixelStoreiFn =
       reinterpret_cast<glPixelStoreiProc>(GetGLProcAddress("glPixelStorei"));
-  fn.glPointParameteriFn = reinterpret_cast<glPointParameteriProc>(
-      GetGLProcAddress("glPointParameteri"));
+  fn.glPointParameteriFn =
+      reinterpret_cast<glPointParameteriProc>(glPointParameteriNotBound);
   fn.glPolygonOffsetFn = reinterpret_cast<glPolygonOffsetProc>(
       GetGLProcAddress("glPolygonOffset"));
-  fn.glPopGroupMarkerEXTFn = reinterpret_cast<glPopGroupMarkerEXTProc>(
-      GetGLProcAddress("glPopGroupMarkerEXT"));
+  fn.glPopGroupMarkerEXTFn =
+      reinterpret_cast<glPopGroupMarkerEXTProc>(glPopGroupMarkerEXTNotBound);
   fn.glProgramBinaryFn =
       reinterpret_cast<glProgramBinaryProc>(glProgramBinaryNotBound);
-  fn.glProgramParameteriFn = reinterpret_cast<glProgramParameteriProc>(
-      GetGLProcAddress("glProgramParameteri"));
-  fn.glPushGroupMarkerEXTFn = reinterpret_cast<glPushGroupMarkerEXTProc>(
-      GetGLProcAddress("glPushGroupMarkerEXT"));
+  fn.glProgramParameteriFn =
+      reinterpret_cast<glProgramParameteriProc>(glProgramParameteriNotBound);
+  fn.glPushGroupMarkerEXTFn =
+      reinterpret_cast<glPushGroupMarkerEXTProc>(glPushGroupMarkerEXTNotBound);
   fn.glQueryCounterFn =
       reinterpret_cast<glQueryCounterProc>(glQueryCounterNotBound);
-  fn.glReadBufferFn =
-      reinterpret_cast<glReadBufferProc>(GetGLProcAddress("glReadBuffer"));
+  fn.glReadBufferFn = reinterpret_cast<glReadBufferProc>(glReadBufferNotBound);
   fn.glReadPixelsFn =
       reinterpret_cast<glReadPixelsProc>(GetGLProcAddress("glReadPixels"));
   fn.glReleaseShaderCompilerFn = reinterpret_cast<glReleaseShaderCompilerProc>(
-      GetGLProcAddress("glReleaseShaderCompiler"));
+      glReleaseShaderCompilerNotBound);
   fn.glRenderbufferStorageEXTFn =
       reinterpret_cast<glRenderbufferStorageEXTProc>(
-          glRenderbufferStorageEXTNotBound);
+          GetGLProcAddress("glRenderbufferStorageEXT"));
   fn.glRenderbufferStorageMultisampleFn =
       reinterpret_cast<glRenderbufferStorageMultisampleProc>(
-          GetGLProcAddress("glRenderbufferStorageMultisample"));
+          glRenderbufferStorageMultisampleNotBound);
   fn.glRenderbufferStorageMultisampleANGLEFn =
       reinterpret_cast<glRenderbufferStorageMultisampleANGLEProc>(
           glRenderbufferStorageMultisampleANGLENotBound);
@@ -678,28 +1167,27 @@ void DriverGL::InitializeStaticBindings() {
           glRenderbufferStorageMultisampleEXTNotBound);
   fn.glRenderbufferStorageMultisampleIMGFn =
       reinterpret_cast<glRenderbufferStorageMultisampleIMGProc>(
-          GetGLProcAddress("glRenderbufferStorageMultisampleIMG"));
+          glRenderbufferStorageMultisampleIMGNotBound);
   fn.glResumeTransformFeedbackFn =
       reinterpret_cast<glResumeTransformFeedbackProc>(
-          GetGLProcAddress("glResumeTransformFeedback"));
+          glResumeTransformFeedbackNotBound);
   fn.glSampleCoverageFn = reinterpret_cast<glSampleCoverageProc>(
       GetGLProcAddress("glSampleCoverage"));
-  fn.glSamplerParameterfFn = reinterpret_cast<glSamplerParameterfProc>(
-      GetGLProcAddress("glSamplerParameterf"));
-  fn.glSamplerParameterfvFn = reinterpret_cast<glSamplerParameterfvProc>(
-      GetGLProcAddress("glSamplerParameterfv"));
-  fn.glSamplerParameteriFn = reinterpret_cast<glSamplerParameteriProc>(
-      GetGLProcAddress("glSamplerParameteri"));
-  fn.glSamplerParameterivFn = reinterpret_cast<glSamplerParameterivProc>(
-      GetGLProcAddress("glSamplerParameteriv"));
+  fn.glSamplerParameterfFn =
+      reinterpret_cast<glSamplerParameterfProc>(glSamplerParameterfNotBound);
+  fn.glSamplerParameterfvFn =
+      reinterpret_cast<glSamplerParameterfvProc>(glSamplerParameterfvNotBound);
+  fn.glSamplerParameteriFn =
+      reinterpret_cast<glSamplerParameteriProc>(glSamplerParameteriNotBound);
+  fn.glSamplerParameterivFn =
+      reinterpret_cast<glSamplerParameterivProc>(glSamplerParameterivNotBound);
   fn.glScissorFn =
       reinterpret_cast<glScissorProc>(GetGLProcAddress("glScissor"));
-  fn.glSetFenceAPPLEFn = reinterpret_cast<glSetFenceAPPLEProc>(
-      GetGLProcAddress("glSetFenceAPPLE"));
-  fn.glSetFenceNVFn =
-      reinterpret_cast<glSetFenceNVProc>(GetGLProcAddress("glSetFenceNV"));
+  fn.glSetFenceAPPLEFn =
+      reinterpret_cast<glSetFenceAPPLEProc>(glSetFenceAPPLENotBound);
+  fn.glSetFenceNVFn = reinterpret_cast<glSetFenceNVProc>(glSetFenceNVNotBound);
   fn.glShaderBinaryFn =
-      reinterpret_cast<glShaderBinaryProc>(GetGLProcAddress("glShaderBinary"));
+      reinterpret_cast<glShaderBinaryProc>(glShaderBinaryNotBound);
   fn.glShaderSourceFn =
       reinterpret_cast<glShaderSourceProc>(GetGLProcAddress("glShaderSource"));
   fn.glStencilFuncFn =
@@ -714,14 +1202,13 @@ void DriverGL::InitializeStaticBindings() {
       reinterpret_cast<glStencilOpProc>(GetGLProcAddress("glStencilOp"));
   fn.glStencilOpSeparateFn = reinterpret_cast<glStencilOpSeparateProc>(
       GetGLProcAddress("glStencilOpSeparate"));
-  fn.glTestFenceAPPLEFn = reinterpret_cast<glTestFenceAPPLEProc>(
-      GetGLProcAddress("glTestFenceAPPLE"));
+  fn.glTestFenceAPPLEFn =
+      reinterpret_cast<glTestFenceAPPLEProc>(glTestFenceAPPLENotBound);
   fn.glTestFenceNVFn =
-      reinterpret_cast<glTestFenceNVProc>(GetGLProcAddress("glTestFenceNV"));
+      reinterpret_cast<glTestFenceNVProc>(glTestFenceNVNotBound);
   fn.glTexImage2DFn =
       reinterpret_cast<glTexImage2DProc>(GetGLProcAddress("glTexImage2D"));
-  fn.glTexImage3DFn =
-      reinterpret_cast<glTexImage3DProc>(GetGLProcAddress("glTexImage3D"));
+  fn.glTexImage3DFn = reinterpret_cast<glTexImage3DProc>(glTexImage3DNotBound);
   fn.glTexParameterfFn = reinterpret_cast<glTexParameterfProc>(
       GetGLProcAddress("glTexParameterf"));
   fn.glTexParameterfvFn = reinterpret_cast<glTexParameterfvProc>(
@@ -733,12 +1220,12 @@ void DriverGL::InitializeStaticBindings() {
   fn.glTexStorage2DEXTFn =
       reinterpret_cast<glTexStorage2DEXTProc>(glTexStorage2DEXTNotBound);
   fn.glTexStorage3DFn =
-      reinterpret_cast<glTexStorage3DProc>(GetGLProcAddress("glTexStorage3D"));
+      reinterpret_cast<glTexStorage3DProc>(glTexStorage3DNotBound);
   fn.glTexSubImage2DFn = reinterpret_cast<glTexSubImage2DProc>(
       GetGLProcAddress("glTexSubImage2D"));
   fn.glTransformFeedbackVaryingsFn =
       reinterpret_cast<glTransformFeedbackVaryingsProc>(
-          GetGLProcAddress("glTransformFeedbackVaryings"));
+          glTransformFeedbackVaryingsNotBound);
   fn.glUniform1fFn =
       reinterpret_cast<glUniform1fProc>(GetGLProcAddress("glUniform1f"));
   fn.glUniform1fvFn =
@@ -747,10 +1234,9 @@ void DriverGL::InitializeStaticBindings() {
       reinterpret_cast<glUniform1iProc>(GetGLProcAddress("glUniform1i"));
   fn.glUniform1ivFn =
       reinterpret_cast<glUniform1ivProc>(GetGLProcAddress("glUniform1iv"));
-  fn.glUniform1uiFn =
-      reinterpret_cast<glUniform1uiProc>(GetGLProcAddress("glUniform1ui"));
+  fn.glUniform1uiFn = reinterpret_cast<glUniform1uiProc>(glUniform1uiNotBound);
   fn.glUniform1uivFn =
-      reinterpret_cast<glUniform1uivProc>(GetGLProcAddress("glUniform1uiv"));
+      reinterpret_cast<glUniform1uivProc>(glUniform1uivNotBound);
   fn.glUniform2fFn =
       reinterpret_cast<glUniform2fProc>(GetGLProcAddress("glUniform2f"));
   fn.glUniform2fvFn =
@@ -759,10 +1245,9 @@ void DriverGL::InitializeStaticBindings() {
       reinterpret_cast<glUniform2iProc>(GetGLProcAddress("glUniform2i"));
   fn.glUniform2ivFn =
       reinterpret_cast<glUniform2ivProc>(GetGLProcAddress("glUniform2iv"));
-  fn.glUniform2uiFn =
-      reinterpret_cast<glUniform2uiProc>(GetGLProcAddress("glUniform2ui"));
+  fn.glUniform2uiFn = reinterpret_cast<glUniform2uiProc>(glUniform2uiNotBound);
   fn.glUniform2uivFn =
-      reinterpret_cast<glUniform2uivProc>(GetGLProcAddress("glUniform2uiv"));
+      reinterpret_cast<glUniform2uivProc>(glUniform2uivNotBound);
   fn.glUniform3fFn =
       reinterpret_cast<glUniform3fProc>(GetGLProcAddress("glUniform3f"));
   fn.glUniform3fvFn =
@@ -771,10 +1256,9 @@ void DriverGL::InitializeStaticBindings() {
       reinterpret_cast<glUniform3iProc>(GetGLProcAddress("glUniform3i"));
   fn.glUniform3ivFn =
       reinterpret_cast<glUniform3ivProc>(GetGLProcAddress("glUniform3iv"));
-  fn.glUniform3uiFn =
-      reinterpret_cast<glUniform3uiProc>(GetGLProcAddress("glUniform3ui"));
+  fn.glUniform3uiFn = reinterpret_cast<glUniform3uiProc>(glUniform3uiNotBound);
   fn.glUniform3uivFn =
-      reinterpret_cast<glUniform3uivProc>(GetGLProcAddress("glUniform3uiv"));
+      reinterpret_cast<glUniform3uivProc>(glUniform3uivNotBound);
   fn.glUniform4fFn =
       reinterpret_cast<glUniform4fProc>(GetGLProcAddress("glUniform4f"));
   fn.glUniform4fvFn =
@@ -783,30 +1267,29 @@ void DriverGL::InitializeStaticBindings() {
       reinterpret_cast<glUniform4iProc>(GetGLProcAddress("glUniform4i"));
   fn.glUniform4ivFn =
       reinterpret_cast<glUniform4ivProc>(GetGLProcAddress("glUniform4iv"));
-  fn.glUniform4uiFn =
-      reinterpret_cast<glUniform4uiProc>(GetGLProcAddress("glUniform4ui"));
+  fn.glUniform4uiFn = reinterpret_cast<glUniform4uiProc>(glUniform4uiNotBound);
   fn.glUniform4uivFn =
-      reinterpret_cast<glUniform4uivProc>(GetGLProcAddress("glUniform4uiv"));
+      reinterpret_cast<glUniform4uivProc>(glUniform4uivNotBound);
   fn.glUniformBlockBindingFn = reinterpret_cast<glUniformBlockBindingProc>(
-      GetGLProcAddress("glUniformBlockBinding"));
+      glUniformBlockBindingNotBound);
   fn.glUniformMatrix2fvFn = reinterpret_cast<glUniformMatrix2fvProc>(
       GetGLProcAddress("glUniformMatrix2fv"));
-  fn.glUniformMatrix2x3fvFn = reinterpret_cast<glUniformMatrix2x3fvProc>(
-      GetGLProcAddress("glUniformMatrix2x3fv"));
-  fn.glUniformMatrix2x4fvFn = reinterpret_cast<glUniformMatrix2x4fvProc>(
-      GetGLProcAddress("glUniformMatrix2x4fv"));
+  fn.glUniformMatrix2x3fvFn =
+      reinterpret_cast<glUniformMatrix2x3fvProc>(glUniformMatrix2x3fvNotBound);
+  fn.glUniformMatrix2x4fvFn =
+      reinterpret_cast<glUniformMatrix2x4fvProc>(glUniformMatrix2x4fvNotBound);
   fn.glUniformMatrix3fvFn = reinterpret_cast<glUniformMatrix3fvProc>(
       GetGLProcAddress("glUniformMatrix3fv"));
-  fn.glUniformMatrix3x2fvFn = reinterpret_cast<glUniformMatrix3x2fvProc>(
-      GetGLProcAddress("glUniformMatrix3x2fv"));
-  fn.glUniformMatrix3x4fvFn = reinterpret_cast<glUniformMatrix3x4fvProc>(
-      GetGLProcAddress("glUniformMatrix3x4fv"));
+  fn.glUniformMatrix3x2fvFn =
+      reinterpret_cast<glUniformMatrix3x2fvProc>(glUniformMatrix3x2fvNotBound);
+  fn.glUniformMatrix3x4fvFn =
+      reinterpret_cast<glUniformMatrix3x4fvProc>(glUniformMatrix3x4fvNotBound);
   fn.glUniformMatrix4fvFn = reinterpret_cast<glUniformMatrix4fvProc>(
       GetGLProcAddress("glUniformMatrix4fv"));
-  fn.glUniformMatrix4x2fvFn = reinterpret_cast<glUniformMatrix4x2fvProc>(
-      GetGLProcAddress("glUniformMatrix4x2fv"));
-  fn.glUniformMatrix4x3fvFn = reinterpret_cast<glUniformMatrix4x3fvProc>(
-      GetGLProcAddress("glUniformMatrix4x3fv"));
+  fn.glUniformMatrix4x2fvFn =
+      reinterpret_cast<glUniformMatrix4x2fvProc>(glUniformMatrix4x2fvNotBound);
+  fn.glUniformMatrix4x3fvFn =
+      reinterpret_cast<glUniformMatrix4x3fvProc>(glUniformMatrix4x3fvNotBound);
   fn.glUnmapBufferFn =
       reinterpret_cast<glUnmapBufferProc>(glUnmapBufferNotBound);
   fn.glUseProgramFn =
@@ -832,22 +1315,21 @@ void DriverGL::InitializeStaticBindings() {
   fn.glVertexAttribDivisorANGLEFn =
       reinterpret_cast<glVertexAttribDivisorANGLEProc>(
           glVertexAttribDivisorANGLENotBound);
-  fn.glVertexAttribI4iFn = reinterpret_cast<glVertexAttribI4iProc>(
-      GetGLProcAddress("glVertexAttribI4i"));
-  fn.glVertexAttribI4ivFn = reinterpret_cast<glVertexAttribI4ivProc>(
-      GetGLProcAddress("glVertexAttribI4iv"));
-  fn.glVertexAttribI4uiFn = reinterpret_cast<glVertexAttribI4uiProc>(
-      GetGLProcAddress("glVertexAttribI4ui"));
-  fn.glVertexAttribI4uivFn = reinterpret_cast<glVertexAttribI4uivProc>(
-      GetGLProcAddress("glVertexAttribI4uiv"));
+  fn.glVertexAttribI4iFn =
+      reinterpret_cast<glVertexAttribI4iProc>(glVertexAttribI4iNotBound);
+  fn.glVertexAttribI4ivFn =
+      reinterpret_cast<glVertexAttribI4ivProc>(glVertexAttribI4ivNotBound);
+  fn.glVertexAttribI4uiFn =
+      reinterpret_cast<glVertexAttribI4uiProc>(glVertexAttribI4uiNotBound);
+  fn.glVertexAttribI4uivFn =
+      reinterpret_cast<glVertexAttribI4uivProc>(glVertexAttribI4uivNotBound);
   fn.glVertexAttribIPointerFn = reinterpret_cast<glVertexAttribIPointerProc>(
-      GetGLProcAddress("glVertexAttribIPointer"));
+      glVertexAttribIPointerNotBound);
   fn.glVertexAttribPointerFn = reinterpret_cast<glVertexAttribPointerProc>(
       GetGLProcAddress("glVertexAttribPointer"));
   fn.glViewportFn =
       reinterpret_cast<glViewportProc>(GetGLProcAddress("glViewport"));
-  fn.glWaitSyncFn =
-      reinterpret_cast<glWaitSyncProc>(GetGLProcAddress("glWaitSync"));
+  fn.glWaitSyncFn = reinterpret_cast<glWaitSyncProc>(glWaitSyncNotBound);
 }
 
 void DriverGL::InitializeDynamicBindings(GLContext* context) {
@@ -870,47 +1352,32 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
       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_ES2_compatibility =
-      extensions.find("GL_ARB_ES2_compatibility ") != std::string::npos;
-  ext.b_GL_ARB_blend_func_extended =
-      extensions.find("GL_ARB_blend_func_extended ") != std::string::npos;
-  ext.b_GL_ARB_copy_buffer =
-      extensions.find("GL_ARB_copy_buffer ") != 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_framebuffer_object =
-      extensions.find("GL_ARB_framebuffer_object ") != 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_internalformat_query =
-      extensions.find("GL_ARB_internalformat_query ") != std::string::npos;
-  ext.b_GL_ARB_invalidate_subdata =
-      extensions.find("GL_ARB_invalidate_subdata ") != 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_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_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_uniform_buffer_object =
-      extensions.find("GL_ARB_uniform_buffer_object ") != std::string::npos;
   ext.b_GL_ARB_vertex_array_object =
       extensions.find("GL_ARB_vertex_array_object ") != std::string::npos;
   ext.b_GL_ARB_vertex_buffer_object =
       extensions.find("GL_ARB_vertex_buffer_object ") != 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_EXT_debug_marker =
       extensions.find("GL_EXT_debug_marker ") != std::string::npos;
   ext.b_GL_EXT_direct_state_access =
@@ -932,6 +1399,8 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
   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_texture_storage =
@@ -959,604 +1428,2074 @@ void DriverGL::InitializeDynamicBindings(GLContext* context) {
   ext.b_GL_OES_vertex_array_object =
       extensions.find("GL_OES_vertex_array_object ") != std::string::npos;
 
+  fn.glBeginQueryFn = 0;
+  debug_fn.glBeginQueryFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glBeginQueryFn =
+        reinterpret_cast<glBeginQueryProc>(GetGLProcAddress("glBeginQuery"));
+  } else {
+    fn.glBeginQueryFn =
+        reinterpret_cast<glBeginQueryProc>(glBeginQueryNotBound);
+  }
+  DCHECK(fn.glBeginQueryFn);
+
   fn.glBeginQueryARBFn = 0;
   debug_fn.glBeginQueryARBFn = 0;
   if (ext.b_GL_ARB_occlusion_query) {
     fn.glBeginQueryARBFn = reinterpret_cast<glBeginQueryARBProc>(
         GetGLProcAddress("glBeginQueryARB"));
-  }
-  if (!fn.glBeginQueryARBFn) {
+  } else if ((ext.b_GL_EXT_disjoint_timer_query ||
+              ext.b_GL_EXT_occlusion_query_boolean)) {
     fn.glBeginQueryARBFn = reinterpret_cast<glBeginQueryARBProc>(
         GetGLProcAddress("glBeginQueryEXT"));
-  }
-
-  fn.glBindFramebufferEXTFn = 0;
-  debug_fn.glBindFramebufferEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glBindFramebufferEXTFn = reinterpret_cast<glBindFramebufferEXTProc>(
-        GetGLProcAddress("glBindFramebufferEXT"));
-  }
-  if (!fn.glBindFramebufferEXTFn) {
-    fn.glBindFramebufferEXTFn = reinterpret_cast<glBindFramebufferEXTProc>(
-        GetGLProcAddress("glBindFramebuffer"));
-  }
-
-  fn.glBindRenderbufferEXTFn = 0;
-  debug_fn.glBindRenderbufferEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glBindRenderbufferEXTFn = reinterpret_cast<glBindRenderbufferEXTProc>(
-        GetGLProcAddress("glBindRenderbufferEXT"));
-  }
-  if (!fn.glBindRenderbufferEXTFn) {
-    fn.glBindRenderbufferEXTFn = reinterpret_cast<glBindRenderbufferEXTProc>(
-        GetGLProcAddress("glBindRenderbuffer"));
-  }
+  } else {
+    fn.glBeginQueryARBFn =
+        reinterpret_cast<glBeginQueryARBProc>(glBeginQueryARBNotBound);
+  }
+  DCHECK(fn.glBeginQueryARBFn);
+
+  fn.glBeginTransformFeedbackFn = 0;
+  debug_fn.glBeginTransformFeedbackFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glBeginTransformFeedbackFn =
+        reinterpret_cast<glBeginTransformFeedbackProc>(
+            GetGLProcAddress("glBeginTransformFeedback"));
+  } else {
+    fn.glBeginTransformFeedbackFn =
+        reinterpret_cast<glBeginTransformFeedbackProc>(
+            glBeginTransformFeedbackNotBound);
+  }
+  DCHECK(fn.glBeginTransformFeedbackFn);
+
+  fn.glBindBufferBaseFn = 0;
+  debug_fn.glBindBufferBaseFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glBindBufferBaseFn = reinterpret_cast<glBindBufferBaseProc>(
+        GetGLProcAddress("glBindBufferBase"));
+  } else {
+    fn.glBindBufferBaseFn =
+        reinterpret_cast<glBindBufferBaseProc>(glBindBufferBaseNotBound);
+  }
+  DCHECK(fn.glBindBufferBaseFn);
+
+  fn.glBindBufferRangeFn = 0;
+  debug_fn.glBindBufferRangeFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glBindBufferRangeFn = reinterpret_cast<glBindBufferRangeProc>(
+        GetGLProcAddress("glBindBufferRange"));
+  } else {
+    fn.glBindBufferRangeFn =
+        reinterpret_cast<glBindBufferRangeProc>(glBindBufferRangeNotBound);
+  }
+  DCHECK(fn.glBindBufferRangeFn);
+
+  fn.glBindFragDataLocationFn = 0;
+  debug_fn.glBindFragDataLocationFn = 0;
+  if ((!ver->is_es && (ver->major_version >= 3u))) {
+    fn.glBindFragDataLocationFn = reinterpret_cast<glBindFragDataLocationProc>(
+        GetGLProcAddress("glBindFragDataLocation"));
+  } else {
+    fn.glBindFragDataLocationFn = reinterpret_cast<glBindFragDataLocationProc>(
+        glBindFragDataLocationNotBound);
+  }
+  DCHECK(fn.glBindFragDataLocationFn);
+
+  fn.glBindFragDataLocationIndexedFn = 0;
+  debug_fn.glBindFragDataLocationIndexedFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))))) {
+    fn.glBindFragDataLocationIndexedFn =
+        reinterpret_cast<glBindFragDataLocationIndexedProc>(
+            GetGLProcAddress("glBindFragDataLocationIndexed"));
+  } else {
+    fn.glBindFragDataLocationIndexedFn =
+        reinterpret_cast<glBindFragDataLocationIndexedProc>(
+            glBindFragDataLocationIndexedNotBound);
+  }
+  DCHECK(fn.glBindFragDataLocationIndexedFn);
+
+  fn.glBindSamplerFn = 0;
+  debug_fn.glBindSamplerFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glBindSamplerFn =
+        reinterpret_cast<glBindSamplerProc>(GetGLProcAddress("glBindSampler"));
+  } else {
+    fn.glBindSamplerFn =
+        reinterpret_cast<glBindSamplerProc>(glBindSamplerNotBound);
+  }
+  DCHECK(fn.glBindSamplerFn);
+
+  fn.glBindTransformFeedbackFn = 0;
+  debug_fn.glBindTransformFeedbackFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es && (ver->major_version >= 4u)))) {
+    fn.glBindTransformFeedbackFn =
+        reinterpret_cast<glBindTransformFeedbackProc>(
+            GetGLProcAddress("glBindTransformFeedback"));
+  } else {
+    fn.glBindTransformFeedbackFn =
+        reinterpret_cast<glBindTransformFeedbackProc>(
+            glBindTransformFeedbackNotBound);
+  }
+  DCHECK(fn.glBindTransformFeedbackFn);
 
   fn.glBindVertexArrayOESFn = 0;
   debug_fn.glBindVertexArrayOESFn = 0;
-  if ((ver->is_gl3 || ver->is_gl4 || ver->is_es3) ||
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
       ext.b_GL_ARB_vertex_array_object) {
     fn.glBindVertexArrayOESFn = reinterpret_cast<glBindVertexArrayOESProc>(
         GetGLProcAddress("glBindVertexArray"));
-  }
-  if (!fn.glBindVertexArrayOESFn && (ext.b_GL_OES_vertex_array_object)) {
+  } else if (ext.b_GL_OES_vertex_array_object) {
     fn.glBindVertexArrayOESFn = reinterpret_cast<glBindVertexArrayOESProc>(
         GetGLProcAddress("glBindVertexArrayOES"));
-  }
-  if (!fn.glBindVertexArrayOESFn) {
+  } else if (ext.b_GL_APPLE_vertex_array_object) {
     fn.glBindVertexArrayOESFn = reinterpret_cast<glBindVertexArrayOESProc>(
         GetGLProcAddress("glBindVertexArrayAPPLE"));
+  } else {
+    fn.glBindVertexArrayOESFn = reinterpret_cast<glBindVertexArrayOESProc>(
+        glBindVertexArrayOESNotBound);
   }
+  DCHECK(fn.glBindVertexArrayOESFn);
 
   fn.glBlendBarrierKHRFn = 0;
   debug_fn.glBlendBarrierKHRFn = 0;
   if (ext.b_GL_NV_blend_equation_advanced) {
     fn.glBlendBarrierKHRFn = reinterpret_cast<glBlendBarrierKHRProc>(
         GetGLProcAddress("glBlendBarrierNV"));
-  }
-  if (!fn.glBlendBarrierKHRFn) {
+  } else if (ext.b_GL_KHR_blend_equation_advanced) {
     fn.glBlendBarrierKHRFn = reinterpret_cast<glBlendBarrierKHRProc>(
         GetGLProcAddress("glBlendBarrierKHR"));
+  } else {
+    fn.glBlendBarrierKHRFn =
+        reinterpret_cast<glBlendBarrierKHRProc>(glBlendBarrierKHRNotBound);
+  }
+  DCHECK(fn.glBlendBarrierKHRFn);
+
+  fn.glBlitFramebufferFn = 0;
+  debug_fn.glBlitFramebufferFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glBlitFramebufferFn = reinterpret_cast<glBlitFramebufferProc>(
+        GetGLProcAddress("glBlitFramebuffer"));
+  } else {
+    fn.glBlitFramebufferFn =
+        reinterpret_cast<glBlitFramebufferProc>(glBlitFramebufferNotBound);
   }
+  DCHECK(fn.glBlitFramebufferFn);
 
   fn.glBlitFramebufferANGLEFn = 0;
   debug_fn.glBlitFramebufferANGLEFn = 0;
-  if (ext.b_GL_ANGLE_framebuffer_blit) {
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glBlitFramebufferANGLEFn = reinterpret_cast<glBlitFramebufferANGLEProc>(
+        GetGLProcAddress("glBlitFramebuffer"));
+  } else if (ext.b_GL_ANGLE_framebuffer_blit) {
     fn.glBlitFramebufferANGLEFn = reinterpret_cast<glBlitFramebufferANGLEProc>(
         GetGLProcAddress("glBlitFramebufferANGLE"));
-  }
-  if (!fn.glBlitFramebufferANGLEFn) {
+  } else {
     fn.glBlitFramebufferANGLEFn = reinterpret_cast<glBlitFramebufferANGLEProc>(
-        GetGLProcAddress("glBlitFramebuffer"));
+        glBlitFramebufferANGLENotBound);
   }
+  DCHECK(fn.glBlitFramebufferANGLEFn);
 
   fn.glBlitFramebufferEXTFn = 0;
   debug_fn.glBlitFramebufferEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_blit) {
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glBlitFramebufferEXTFn = reinterpret_cast<glBlitFramebufferEXTProc>(
+        GetGLProcAddress("glBlitFramebuffer"));
+  } else if (ext.b_GL_EXT_framebuffer_blit) {
     fn.glBlitFramebufferEXTFn = reinterpret_cast<glBlitFramebufferEXTProc>(
         GetGLProcAddress("glBlitFramebufferEXT"));
-  }
-  if (!fn.glBlitFramebufferEXTFn) {
+  } else {
     fn.glBlitFramebufferEXTFn = reinterpret_cast<glBlitFramebufferEXTProc>(
-        GetGLProcAddress("glBlitFramebuffer"));
-  }
-
-  fn.glCheckFramebufferStatusEXTFn = 0;
-  debug_fn.glCheckFramebufferStatusEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glCheckFramebufferStatusEXTFn =
-        reinterpret_cast<glCheckFramebufferStatusEXTProc>(
-            GetGLProcAddress("glCheckFramebufferStatusEXT"));
-  }
-  if (!fn.glCheckFramebufferStatusEXTFn) {
-    fn.glCheckFramebufferStatusEXTFn =
-        reinterpret_cast<glCheckFramebufferStatusEXTProc>(
-            GetGLProcAddress("glCheckFramebufferStatus"));
-  }
-
-  fn.glDeleteBuffersARBFn = 0;
-  debug_fn.glDeleteBuffersARBFn = 0;
-  if (ext.b_GL_ARB_vertex_buffer_object) {
-    fn.glDeleteBuffersARBFn = reinterpret_cast<glDeleteBuffersARBProc>(
-        GetGLProcAddress("glDeleteBuffersARB"));
-  }
-  if (!fn.glDeleteBuffersARBFn) {
-    fn.glDeleteBuffersARBFn = reinterpret_cast<glDeleteBuffersARBProc>(
-        GetGLProcAddress("glDeleteBuffers"));
-  }
-
-  fn.glDeleteFramebuffersEXTFn = 0;
-  debug_fn.glDeleteFramebuffersEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glDeleteFramebuffersEXTFn =
-        reinterpret_cast<glDeleteFramebuffersEXTProc>(
-            GetGLProcAddress("glDeleteFramebuffersEXT"));
-  }
-  if (!fn.glDeleteFramebuffersEXTFn) {
-    fn.glDeleteFramebuffersEXTFn =
-        reinterpret_cast<glDeleteFramebuffersEXTProc>(
-            GetGLProcAddress("glDeleteFramebuffers"));
-  }
+        glBlitFramebufferEXTNotBound);
+  }
+  DCHECK(fn.glBlitFramebufferEXTFn);
+
+  fn.glClearBufferfiFn = 0;
+  debug_fn.glClearBufferfiFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glClearBufferfiFn = reinterpret_cast<glClearBufferfiProc>(
+        GetGLProcAddress("glClearBufferfi"));
+  } else {
+    fn.glClearBufferfiFn =
+        reinterpret_cast<glClearBufferfiProc>(glClearBufferfiNotBound);
+  }
+  DCHECK(fn.glClearBufferfiFn);
+
+  fn.glClearBufferfvFn = 0;
+  debug_fn.glClearBufferfvFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glClearBufferfvFn = reinterpret_cast<glClearBufferfvProc>(
+        GetGLProcAddress("glClearBufferfv"));
+  } else {
+    fn.glClearBufferfvFn =
+        reinterpret_cast<glClearBufferfvProc>(glClearBufferfvNotBound);
+  }
+  DCHECK(fn.glClearBufferfvFn);
+
+  fn.glClearBufferivFn = 0;
+  debug_fn.glClearBufferivFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glClearBufferivFn = reinterpret_cast<glClearBufferivProc>(
+        GetGLProcAddress("glClearBufferiv"));
+  } else {
+    fn.glClearBufferivFn =
+        reinterpret_cast<glClearBufferivProc>(glClearBufferivNotBound);
+  }
+  DCHECK(fn.glClearBufferivFn);
+
+  fn.glClearBufferuivFn = 0;
+  debug_fn.glClearBufferuivFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glClearBufferuivFn = reinterpret_cast<glClearBufferuivProc>(
+        GetGLProcAddress("glClearBufferuiv"));
+  } else {
+    fn.glClearBufferuivFn =
+        reinterpret_cast<glClearBufferuivProc>(glClearBufferuivNotBound);
+  }
+  DCHECK(fn.glClearBufferuivFn);
+
+  fn.glClearDepthfFn = 0;
+  debug_fn.glClearDepthfFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 1u))) ||
+       ver->is_es)) {
+    fn.glClearDepthfFn =
+        reinterpret_cast<glClearDepthfProc>(GetGLProcAddress("glClearDepthf"));
+  } else {
+    fn.glClearDepthfFn =
+        reinterpret_cast<glClearDepthfProc>(glClearDepthfNotBound);
+  }
+  DCHECK(fn.glClearDepthfFn);
+
+  fn.glClientWaitSyncFn = 0;
+  debug_fn.glClientWaitSyncFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
+      ext.b_GL_ARB_sync) {
+    fn.glClientWaitSyncFn = reinterpret_cast<glClientWaitSyncProc>(
+        GetGLProcAddress("glClientWaitSync"));
+  } else {
+    fn.glClientWaitSyncFn =
+        reinterpret_cast<glClientWaitSyncProc>(glClientWaitSyncNotBound);
+  }
+  DCHECK(fn.glClientWaitSyncFn);
+
+  fn.glCompressedTexImage3DFn = 0;
+  debug_fn.glCompressedTexImage3DFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glCompressedTexImage3DFn = reinterpret_cast<glCompressedTexImage3DProc>(
+        GetGLProcAddress("glCompressedTexImage3D"));
+  } else {
+    fn.glCompressedTexImage3DFn = reinterpret_cast<glCompressedTexImage3DProc>(
+        glCompressedTexImage3DNotBound);
+  }
+  DCHECK(fn.glCompressedTexImage3DFn);
+
+  fn.glCopyBufferSubDataFn = 0;
+  debug_fn.glCopyBufferSubDataFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 1u))))) {
+    fn.glCopyBufferSubDataFn = reinterpret_cast<glCopyBufferSubDataProc>(
+        GetGLProcAddress("glCopyBufferSubData"));
+  } else {
+    fn.glCopyBufferSubDataFn =
+        reinterpret_cast<glCopyBufferSubDataProc>(glCopyBufferSubDataNotBound);
+  }
+  DCHECK(fn.glCopyBufferSubDataFn);
+
+  fn.glCopyTexSubImage3DFn = 0;
+  debug_fn.glCopyTexSubImage3DFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glCopyTexSubImage3DFn = reinterpret_cast<glCopyTexSubImage3DProc>(
+        GetGLProcAddress("glCopyTexSubImage3D"));
+  } else {
+    fn.glCopyTexSubImage3DFn =
+        reinterpret_cast<glCopyTexSubImage3DProc>(glCopyTexSubImage3DNotBound);
+  }
+  DCHECK(fn.glCopyTexSubImage3DFn);
+
+  fn.glDeleteFencesAPPLEFn = 0;
+  debug_fn.glDeleteFencesAPPLEFn = 0;
+  if (ext.b_GL_APPLE_fence) {
+    fn.glDeleteFencesAPPLEFn = reinterpret_cast<glDeleteFencesAPPLEProc>(
+        GetGLProcAddress("glDeleteFencesAPPLE"));
+  } else {
+    fn.glDeleteFencesAPPLEFn =
+        reinterpret_cast<glDeleteFencesAPPLEProc>(glDeleteFencesAPPLENotBound);
+  }
+  DCHECK(fn.glDeleteFencesAPPLEFn);
+
+  fn.glDeleteFencesNVFn = 0;
+  debug_fn.glDeleteFencesNVFn = 0;
+  if (ext.b_GL_NV_fence) {
+    fn.glDeleteFencesNVFn = reinterpret_cast<glDeleteFencesNVProc>(
+        GetGLProcAddress("glDeleteFencesNV"));
+  } else {
+    fn.glDeleteFencesNVFn =
+        reinterpret_cast<glDeleteFencesNVProc>(glDeleteFencesNVNotBound);
+  }
+  DCHECK(fn.glDeleteFencesNVFn);
+
+  fn.glDeleteQueriesFn = 0;
+  debug_fn.glDeleteQueriesFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glDeleteQueriesFn = reinterpret_cast<glDeleteQueriesProc>(
+        GetGLProcAddress("glDeleteQueries"));
+  } else {
+    fn.glDeleteQueriesFn =
+        reinterpret_cast<glDeleteQueriesProc>(glDeleteQueriesNotBound);
+  }
+  DCHECK(fn.glDeleteQueriesFn);
 
   fn.glDeleteQueriesARBFn = 0;
   debug_fn.glDeleteQueriesARBFn = 0;
   if (ext.b_GL_ARB_occlusion_query) {
     fn.glDeleteQueriesARBFn = reinterpret_cast<glDeleteQueriesARBProc>(
         GetGLProcAddress("glDeleteQueriesARB"));
-  }
-  if (!fn.glDeleteQueriesARBFn) {
+  } else if ((ext.b_GL_EXT_disjoint_timer_query ||
+              ext.b_GL_EXT_occlusion_query_boolean)) {
     fn.glDeleteQueriesARBFn = reinterpret_cast<glDeleteQueriesARBProc>(
         GetGLProcAddress("glDeleteQueriesEXT"));
-  }
-
-  fn.glDeleteRenderbuffersEXTFn = 0;
-  debug_fn.glDeleteRenderbuffersEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glDeleteRenderbuffersEXTFn =
-        reinterpret_cast<glDeleteRenderbuffersEXTProc>(
-            GetGLProcAddress("glDeleteRenderbuffersEXT"));
-  }
-  if (!fn.glDeleteRenderbuffersEXTFn) {
-    fn.glDeleteRenderbuffersEXTFn =
-        reinterpret_cast<glDeleteRenderbuffersEXTProc>(
-            GetGLProcAddress("glDeleteRenderbuffers"));
-  }
+  } else {
+    fn.glDeleteQueriesARBFn =
+        reinterpret_cast<glDeleteQueriesARBProc>(glDeleteQueriesARBNotBound);
+  }
+  DCHECK(fn.glDeleteQueriesARBFn);
+
+  fn.glDeleteSamplersFn = 0;
+  debug_fn.glDeleteSamplersFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glDeleteSamplersFn = reinterpret_cast<glDeleteSamplersProc>(
+        GetGLProcAddress("glDeleteSamplers"));
+  } else {
+    fn.glDeleteSamplersFn =
+        reinterpret_cast<glDeleteSamplersProc>(glDeleteSamplersNotBound);
+  }
+  DCHECK(fn.glDeleteSamplersFn);
+
+  fn.glDeleteSyncFn = 0;
+  debug_fn.glDeleteSyncFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
+      ext.b_GL_ARB_sync) {
+    fn.glDeleteSyncFn =
+        reinterpret_cast<glDeleteSyncProc>(GetGLProcAddress("glDeleteSync"));
+  } else {
+    fn.glDeleteSyncFn =
+        reinterpret_cast<glDeleteSyncProc>(glDeleteSyncNotBound);
+  }
+  DCHECK(fn.glDeleteSyncFn);
+
+  fn.glDeleteTransformFeedbacksFn = 0;
+  debug_fn.glDeleteTransformFeedbacksFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es && (ver->major_version >= 4u)))) {
+    fn.glDeleteTransformFeedbacksFn =
+        reinterpret_cast<glDeleteTransformFeedbacksProc>(
+            GetGLProcAddress("glDeleteTransformFeedbacks"));
+  } else {
+    fn.glDeleteTransformFeedbacksFn =
+        reinterpret_cast<glDeleteTransformFeedbacksProc>(
+            glDeleteTransformFeedbacksNotBound);
+  }
+  DCHECK(fn.glDeleteTransformFeedbacksFn);
 
   fn.glDeleteVertexArraysOESFn = 0;
   debug_fn.glDeleteVertexArraysOESFn = 0;
-  if ((ver->is_gl3 || ver->is_gl4 || ver->is_es3) ||
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
       ext.b_GL_ARB_vertex_array_object) {
     fn.glDeleteVertexArraysOESFn =
         reinterpret_cast<glDeleteVertexArraysOESProc>(
             GetGLProcAddress("glDeleteVertexArrays"));
-  }
-  if (!fn.glDeleteVertexArraysOESFn && (ext.b_GL_OES_vertex_array_object)) {
+  } else if (ext.b_GL_OES_vertex_array_object) {
     fn.glDeleteVertexArraysOESFn =
         reinterpret_cast<glDeleteVertexArraysOESProc>(
             GetGLProcAddress("glDeleteVertexArraysOES"));
-  }
-  if (!fn.glDeleteVertexArraysOESFn) {
+  } else if (ext.b_GL_APPLE_vertex_array_object) {
     fn.glDeleteVertexArraysOESFn =
         reinterpret_cast<glDeleteVertexArraysOESProc>(
             GetGLProcAddress("glDeleteVertexArraysAPPLE"));
-  }
+  } else {
+    fn.glDeleteVertexArraysOESFn =
+        reinterpret_cast<glDeleteVertexArraysOESProc>(
+            glDeleteVertexArraysOESNotBound);
+  }
+  DCHECK(fn.glDeleteVertexArraysOESFn);
+
+  fn.glDepthRangefFn = 0;
+  debug_fn.glDepthRangefFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 1u))) ||
+       ver->is_es)) {
+    fn.glDepthRangefFn =
+        reinterpret_cast<glDepthRangefProc>(GetGLProcAddress("glDepthRangef"));
+  } else {
+    fn.glDepthRangefFn =
+        reinterpret_cast<glDepthRangefProc>(glDepthRangefNotBound);
+  }
+  DCHECK(fn.glDepthRangefFn);
+
+  fn.glDiscardFramebufferEXTFn = 0;
+  debug_fn.glDiscardFramebufferEXTFn = 0;
+  if (ext.b_GL_EXT_discard_framebuffer) {
+    fn.glDiscardFramebufferEXTFn =
+        reinterpret_cast<glDiscardFramebufferEXTProc>(
+            GetGLProcAddress("glDiscardFramebufferEXT"));
+  } else {
+    fn.glDiscardFramebufferEXTFn =
+        reinterpret_cast<glDiscardFramebufferEXTProc>(
+            glDiscardFramebufferEXTNotBound);
+  }
+  DCHECK(fn.glDiscardFramebufferEXTFn);
 
   fn.glDrawArraysInstancedANGLEFn = 0;
   debug_fn.glDrawArraysInstancedANGLEFn = 0;
-  if (ext.b_GL_ARB_draw_instanced) {
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 1u))))) {
+    fn.glDrawArraysInstancedANGLEFn =
+        reinterpret_cast<glDrawArraysInstancedANGLEProc>(
+            GetGLProcAddress("glDrawArraysInstanced"));
+  } else if (ext.b_GL_ARB_draw_instanced) {
     fn.glDrawArraysInstancedANGLEFn =
         reinterpret_cast<glDrawArraysInstancedANGLEProc>(
             GetGLProcAddress("glDrawArraysInstancedARB"));
-  }
-  if (!fn.glDrawArraysInstancedANGLEFn && (ext.b_GL_ANGLE_instanced_arrays)) {
+  } else if (ext.b_GL_ANGLE_instanced_arrays) {
     fn.glDrawArraysInstancedANGLEFn =
         reinterpret_cast<glDrawArraysInstancedANGLEProc>(
             GetGLProcAddress("glDrawArraysInstancedANGLE"));
-  }
-  if (!fn.glDrawArraysInstancedANGLEFn) {
+  } else {
     fn.glDrawArraysInstancedANGLEFn =
         reinterpret_cast<glDrawArraysInstancedANGLEProc>(
-            GetGLProcAddress("glDrawArraysInstanced"));
+            glDrawArraysInstancedANGLENotBound);
+  }
+  DCHECK(fn.glDrawArraysInstancedANGLEFn);
+
+  fn.glDrawBufferFn = 0;
+  debug_fn.glDrawBufferFn = 0;
+  if (!ver->is_es) {
+    fn.glDrawBufferFn =
+        reinterpret_cast<glDrawBufferProc>(GetGLProcAddress("glDrawBuffer"));
+  } else {
+    fn.glDrawBufferFn =
+        reinterpret_cast<glDrawBufferProc>(glDrawBufferNotBound);
   }
+  DCHECK(fn.glDrawBufferFn);
 
   fn.glDrawBuffersARBFn = 0;
   debug_fn.glDrawBuffersARBFn = 0;
-  if (ext.b_GL_ARB_draw_buffers) {
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glDrawBuffersARBFn = reinterpret_cast<glDrawBuffersARBProc>(
+        GetGLProcAddress("glDrawBuffers"));
+  } else if (ext.b_GL_ARB_draw_buffers) {
     fn.glDrawBuffersARBFn = reinterpret_cast<glDrawBuffersARBProc>(
         GetGLProcAddress("glDrawBuffersARB"));
-  }
-  if (!fn.glDrawBuffersARBFn && (ext.b_GL_EXT_draw_buffers)) {
+  } else if (ext.b_GL_EXT_draw_buffers) {
     fn.glDrawBuffersARBFn = reinterpret_cast<glDrawBuffersARBProc>(
         GetGLProcAddress("glDrawBuffersEXT"));
+  } else {
+    fn.glDrawBuffersARBFn =
+        reinterpret_cast<glDrawBuffersARBProc>(glDrawBuffersARBNotBound);
   }
-  if (!fn.glDrawBuffersARBFn) {
-    fn.glDrawBuffersARBFn = reinterpret_cast<glDrawBuffersARBProc>(
-        GetGLProcAddress("glDrawBuffers"));
-  }
+  DCHECK(fn.glDrawBuffersARBFn);
 
   fn.glDrawElementsInstancedANGLEFn = 0;
   debug_fn.glDrawElementsInstancedANGLEFn = 0;
-  if (ext.b_GL_ARB_draw_instanced) {
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 1u))))) {
+    fn.glDrawElementsInstancedANGLEFn =
+        reinterpret_cast<glDrawElementsInstancedANGLEProc>(
+            GetGLProcAddress("glDrawElementsInstanced"));
+  } else if (ext.b_GL_ARB_draw_instanced) {
     fn.glDrawElementsInstancedANGLEFn =
         reinterpret_cast<glDrawElementsInstancedANGLEProc>(
             GetGLProcAddress("glDrawElementsInstancedARB"));
-  }
-  if (!fn.glDrawElementsInstancedANGLEFn && (ext.b_GL_ANGLE_instanced_arrays)) {
+  } else if (ext.b_GL_ANGLE_instanced_arrays) {
     fn.glDrawElementsInstancedANGLEFn =
         reinterpret_cast<glDrawElementsInstancedANGLEProc>(
             GetGLProcAddress("glDrawElementsInstancedANGLE"));
-  }
-  if (!fn.glDrawElementsInstancedANGLEFn) {
+  } else {
     fn.glDrawElementsInstancedANGLEFn =
         reinterpret_cast<glDrawElementsInstancedANGLEProc>(
-            GetGLProcAddress("glDrawElementsInstanced"));
+            glDrawElementsInstancedANGLENotBound);
   }
+  DCHECK(fn.glDrawElementsInstancedANGLEFn);
+
+  fn.glDrawRangeElementsFn = 0;
+  debug_fn.glDrawRangeElementsFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glDrawRangeElementsFn = reinterpret_cast<glDrawRangeElementsProc>(
+        GetGLProcAddress("glDrawRangeElements"));
+  } else {
+    fn.glDrawRangeElementsFn =
+        reinterpret_cast<glDrawRangeElementsProc>(glDrawRangeElementsNotBound);
+  }
+  DCHECK(fn.glDrawRangeElementsFn);
+
+  fn.glEGLImageTargetRenderbufferStorageOESFn = 0;
+  debug_fn.glEGLImageTargetRenderbufferStorageOESFn = 0;
+  if (ext.b_GL_OES_EGL_image) {
+    fn.glEGLImageTargetRenderbufferStorageOESFn =
+        reinterpret_cast<glEGLImageTargetRenderbufferStorageOESProc>(
+            GetGLProcAddress("glEGLImageTargetRenderbufferStorageOES"));
+  } else {
+    fn.glEGLImageTargetRenderbufferStorageOESFn =
+        reinterpret_cast<glEGLImageTargetRenderbufferStorageOESProc>(
+            glEGLImageTargetRenderbufferStorageOESNotBound);
+  }
+  DCHECK(fn.glEGLImageTargetRenderbufferStorageOESFn);
+
+  fn.glEGLImageTargetTexture2DOESFn = 0;
+  debug_fn.glEGLImageTargetTexture2DOESFn = 0;
+  if (ext.b_GL_OES_EGL_image) {
+    fn.glEGLImageTargetTexture2DOESFn =
+        reinterpret_cast<glEGLImageTargetTexture2DOESProc>(
+            GetGLProcAddress("glEGLImageTargetTexture2DOES"));
+  } else {
+    fn.glEGLImageTargetTexture2DOESFn =
+        reinterpret_cast<glEGLImageTargetTexture2DOESProc>(
+            glEGLImageTargetTexture2DOESNotBound);
+  }
+  DCHECK(fn.glEGLImageTargetTexture2DOESFn);
+
+  fn.glEndQueryFn = 0;
+  debug_fn.glEndQueryFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glEndQueryFn =
+        reinterpret_cast<glEndQueryProc>(GetGLProcAddress("glEndQuery"));
+  } else {
+    fn.glEndQueryFn = reinterpret_cast<glEndQueryProc>(glEndQueryNotBound);
+  }
+  DCHECK(fn.glEndQueryFn);
 
   fn.glEndQueryARBFn = 0;
   debug_fn.glEndQueryARBFn = 0;
   if (ext.b_GL_ARB_occlusion_query) {
     fn.glEndQueryARBFn =
         reinterpret_cast<glEndQueryARBProc>(GetGLProcAddress("glEndQueryARB"));
-  }
-  if (!fn.glEndQueryARBFn) {
+  } else if ((ext.b_GL_EXT_disjoint_timer_query ||
+              ext.b_GL_EXT_occlusion_query_boolean)) {
     fn.glEndQueryARBFn =
         reinterpret_cast<glEndQueryARBProc>(GetGLProcAddress("glEndQueryEXT"));
+  } else {
+    fn.glEndQueryARBFn =
+        reinterpret_cast<glEndQueryARBProc>(glEndQueryARBNotBound);
+  }
+  DCHECK(fn.glEndQueryARBFn);
+
+  fn.glEndTransformFeedbackFn = 0;
+  debug_fn.glEndTransformFeedbackFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glEndTransformFeedbackFn = reinterpret_cast<glEndTransformFeedbackProc>(
+        GetGLProcAddress("glEndTransformFeedback"));
+  } else {
+    fn.glEndTransformFeedbackFn = reinterpret_cast<glEndTransformFeedbackProc>(
+        glEndTransformFeedbackNotBound);
+  }
+  DCHECK(fn.glEndTransformFeedbackFn);
+
+  fn.glFenceSyncFn = 0;
+  debug_fn.glFenceSyncFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
+      ext.b_GL_ARB_sync) {
+    fn.glFenceSyncFn =
+        reinterpret_cast<glFenceSyncProc>(GetGLProcAddress("glFenceSync"));
+  } else {
+    fn.glFenceSyncFn = reinterpret_cast<glFenceSyncProc>(glFenceSyncNotBound);
+  }
+  DCHECK(fn.glFenceSyncFn);
+
+  fn.glFinishFenceAPPLEFn = 0;
+  debug_fn.glFinishFenceAPPLEFn = 0;
+  if (ext.b_GL_APPLE_fence) {
+    fn.glFinishFenceAPPLEFn = reinterpret_cast<glFinishFenceAPPLEProc>(
+        GetGLProcAddress("glFinishFenceAPPLE"));
+  } else {
+    fn.glFinishFenceAPPLEFn =
+        reinterpret_cast<glFinishFenceAPPLEProc>(glFinishFenceAPPLENotBound);
+  }
+  DCHECK(fn.glFinishFenceAPPLEFn);
+
+  fn.glFinishFenceNVFn = 0;
+  debug_fn.glFinishFenceNVFn = 0;
+  if (ext.b_GL_NV_fence) {
+    fn.glFinishFenceNVFn = reinterpret_cast<glFinishFenceNVProc>(
+        GetGLProcAddress("glFinishFenceNV"));
+  } else {
+    fn.glFinishFenceNVFn =
+        reinterpret_cast<glFinishFenceNVProc>(glFinishFenceNVNotBound);
+  }
+  DCHECK(fn.glFinishFenceNVFn);
+
+  fn.glFlushMappedBufferRangeFn = 0;
+  debug_fn.glFlushMappedBufferRangeFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glFlushMappedBufferRangeFn =
+        reinterpret_cast<glFlushMappedBufferRangeProc>(
+            GetGLProcAddress("glFlushMappedBufferRange"));
+  } else {
+    fn.glFlushMappedBufferRangeFn =
+        reinterpret_cast<glFlushMappedBufferRangeProc>(
+            glFlushMappedBufferRangeNotBound);
+  }
+  DCHECK(fn.glFlushMappedBufferRangeFn);
+
+  fn.glFramebufferTexture2DMultisampleEXTFn = 0;
+  debug_fn.glFramebufferTexture2DMultisampleEXTFn = 0;
+  if (ext.b_GL_EXT_multisampled_render_to_texture) {
+    fn.glFramebufferTexture2DMultisampleEXTFn =
+        reinterpret_cast<glFramebufferTexture2DMultisampleEXTProc>(
+            GetGLProcAddress("glFramebufferTexture2DMultisampleEXT"));
+  } else {
+    fn.glFramebufferTexture2DMultisampleEXTFn =
+        reinterpret_cast<glFramebufferTexture2DMultisampleEXTProc>(
+            glFramebufferTexture2DMultisampleEXTNotBound);
   }
+  DCHECK(fn.glFramebufferTexture2DMultisampleEXTFn);
 
-  fn.glFramebufferRenderbufferEXTFn = 0;
-  debug_fn.glFramebufferRenderbufferEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glFramebufferRenderbufferEXTFn =
-        reinterpret_cast<glFramebufferRenderbufferEXTProc>(
-            GetGLProcAddress("glFramebufferRenderbufferEXT"));
-  }
-  if (!fn.glFramebufferRenderbufferEXTFn) {
-    fn.glFramebufferRenderbufferEXTFn =
-        reinterpret_cast<glFramebufferRenderbufferEXTProc>(
-            GetGLProcAddress("glFramebufferRenderbuffer"));
-  }
-
-  fn.glFramebufferTexture2DEXTFn = 0;
-  debug_fn.glFramebufferTexture2DEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glFramebufferTexture2DEXTFn =
-        reinterpret_cast<glFramebufferTexture2DEXTProc>(
-            GetGLProcAddress("glFramebufferTexture2DEXT"));
-  }
-  if (!fn.glFramebufferTexture2DEXTFn) {
-    fn.glFramebufferTexture2DEXTFn =
-        reinterpret_cast<glFramebufferTexture2DEXTProc>(
-            GetGLProcAddress("glFramebufferTexture2D"));
-  }
-
-  fn.glGenBuffersARBFn = 0;
-  debug_fn.glGenBuffersARBFn = 0;
-  if (ext.b_GL_ARB_vertex_buffer_object) {
-    fn.glGenBuffersARBFn = reinterpret_cast<glGenBuffersARBProc>(
-        GetGLProcAddress("glGenBuffersARB"));
-  }
-  if (!fn.glGenBuffersARBFn) {
-    fn.glGenBuffersARBFn =
-        reinterpret_cast<glGenBuffersARBProc>(GetGLProcAddress("glGenBuffers"));
-  }
-
-  fn.glGenerateMipmapEXTFn = 0;
-  debug_fn.glGenerateMipmapEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glGenerateMipmapEXTFn = reinterpret_cast<glGenerateMipmapEXTProc>(
-        GetGLProcAddress("glGenerateMipmapEXT"));
-  }
-  if (!fn.glGenerateMipmapEXTFn) {
-    fn.glGenerateMipmapEXTFn = reinterpret_cast<glGenerateMipmapEXTProc>(
-        GetGLProcAddress("glGenerateMipmap"));
-  }
-
-  fn.glGenFramebuffersEXTFn = 0;
-  debug_fn.glGenFramebuffersEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glGenFramebuffersEXTFn = reinterpret_cast<glGenFramebuffersEXTProc>(
-        GetGLProcAddress("glGenFramebuffersEXT"));
-  }
-  if (!fn.glGenFramebuffersEXTFn) {
-    fn.glGenFramebuffersEXTFn = reinterpret_cast<glGenFramebuffersEXTProc>(
-        GetGLProcAddress("glGenFramebuffers"));
-  }
+  fn.glFramebufferTexture2DMultisampleIMGFn = 0;
+  debug_fn.glFramebufferTexture2DMultisampleIMGFn = 0;
+  if (ext.b_GL_IMG_multisampled_render_to_texture) {
+    fn.glFramebufferTexture2DMultisampleIMGFn =
+        reinterpret_cast<glFramebufferTexture2DMultisampleIMGProc>(
+            GetGLProcAddress("glFramebufferTexture2DMultisampleIMG"));
+  } else {
+    fn.glFramebufferTexture2DMultisampleIMGFn =
+        reinterpret_cast<glFramebufferTexture2DMultisampleIMGProc>(
+            glFramebufferTexture2DMultisampleIMGNotBound);
+  }
+  DCHECK(fn.glFramebufferTexture2DMultisampleIMGFn);
+
+  fn.glFramebufferTextureLayerFn = 0;
+  debug_fn.glFramebufferTextureLayerFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glFramebufferTextureLayerFn =
+        reinterpret_cast<glFramebufferTextureLayerProc>(
+            GetGLProcAddress("glFramebufferTextureLayer"));
+  } else {
+    fn.glFramebufferTextureLayerFn =
+        reinterpret_cast<glFramebufferTextureLayerProc>(
+            glFramebufferTextureLayerNotBound);
+  }
+  DCHECK(fn.glFramebufferTextureLayerFn);
+
+  fn.glGenFencesAPPLEFn = 0;
+  debug_fn.glGenFencesAPPLEFn = 0;
+  if (ext.b_GL_APPLE_fence) {
+    fn.glGenFencesAPPLEFn = reinterpret_cast<glGenFencesAPPLEProc>(
+        GetGLProcAddress("glGenFencesAPPLE"));
+  } else {
+    fn.glGenFencesAPPLEFn =
+        reinterpret_cast<glGenFencesAPPLEProc>(glGenFencesAPPLENotBound);
+  }
+  DCHECK(fn.glGenFencesAPPLEFn);
+
+  fn.glGenFencesNVFn = 0;
+  debug_fn.glGenFencesNVFn = 0;
+  if (ext.b_GL_NV_fence) {
+    fn.glGenFencesNVFn =
+        reinterpret_cast<glGenFencesNVProc>(GetGLProcAddress("glGenFencesNV"));
+  } else {
+    fn.glGenFencesNVFn =
+        reinterpret_cast<glGenFencesNVProc>(glGenFencesNVNotBound);
+  }
+  DCHECK(fn.glGenFencesNVFn);
+
+  fn.glGenQueriesFn = 0;
+  debug_fn.glGenQueriesFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGenQueriesFn =
+        reinterpret_cast<glGenQueriesProc>(GetGLProcAddress("glGenQueries"));
+  } else {
+    fn.glGenQueriesFn =
+        reinterpret_cast<glGenQueriesProc>(glGenQueriesNotBound);
+  }
+  DCHECK(fn.glGenQueriesFn);
 
   fn.glGenQueriesARBFn = 0;
   debug_fn.glGenQueriesARBFn = 0;
   if (ext.b_GL_ARB_occlusion_query) {
     fn.glGenQueriesARBFn = reinterpret_cast<glGenQueriesARBProc>(
         GetGLProcAddress("glGenQueriesARB"));
-  }
-  if (!fn.glGenQueriesARBFn) {
+  } else if ((ext.b_GL_EXT_disjoint_timer_query ||
+              ext.b_GL_EXT_occlusion_query_boolean)) {
     fn.glGenQueriesARBFn = reinterpret_cast<glGenQueriesARBProc>(
         GetGLProcAddress("glGenQueriesEXT"));
-  }
-
-  fn.glGenRenderbuffersEXTFn = 0;
-  debug_fn.glGenRenderbuffersEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glGenRenderbuffersEXTFn = reinterpret_cast<glGenRenderbuffersEXTProc>(
-        GetGLProcAddress("glGenRenderbuffersEXT"));
-  }
-  if (!fn.glGenRenderbuffersEXTFn) {
-    fn.glGenRenderbuffersEXTFn = reinterpret_cast<glGenRenderbuffersEXTProc>(
-        GetGLProcAddress("glGenRenderbuffers"));
-  }
+  } else {
+    fn.glGenQueriesARBFn =
+        reinterpret_cast<glGenQueriesARBProc>(glGenQueriesARBNotBound);
+  }
+  DCHECK(fn.glGenQueriesARBFn);
+
+  fn.glGenSamplersFn = 0;
+  debug_fn.glGenSamplersFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGenSamplersFn =
+        reinterpret_cast<glGenSamplersProc>(GetGLProcAddress("glGenSamplers"));
+  } else {
+    fn.glGenSamplersFn =
+        reinterpret_cast<glGenSamplersProc>(glGenSamplersNotBound);
+  }
+  DCHECK(fn.glGenSamplersFn);
+
+  fn.glGenTransformFeedbacksFn = 0;
+  debug_fn.glGenTransformFeedbacksFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es && (ver->major_version >= 4u)))) {
+    fn.glGenTransformFeedbacksFn =
+        reinterpret_cast<glGenTransformFeedbacksProc>(
+            GetGLProcAddress("glGenTransformFeedbacks"));
+  } else {
+    fn.glGenTransformFeedbacksFn =
+        reinterpret_cast<glGenTransformFeedbacksProc>(
+            glGenTransformFeedbacksNotBound);
+  }
+  DCHECK(fn.glGenTransformFeedbacksFn);
 
   fn.glGenVertexArraysOESFn = 0;
   debug_fn.glGenVertexArraysOESFn = 0;
-  if ((ver->is_gl3 || ver->is_gl4 || ver->is_es3) ||
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
       ext.b_GL_ARB_vertex_array_object) {
     fn.glGenVertexArraysOESFn = reinterpret_cast<glGenVertexArraysOESProc>(
         GetGLProcAddress("glGenVertexArrays"));
-  }
-  if (!fn.glGenVertexArraysOESFn && (ext.b_GL_OES_vertex_array_object)) {
+  } else if (ext.b_GL_OES_vertex_array_object) {
     fn.glGenVertexArraysOESFn = reinterpret_cast<glGenVertexArraysOESProc>(
         GetGLProcAddress("glGenVertexArraysOES"));
-  }
-  if (!fn.glGenVertexArraysOESFn) {
+  } else if (ext.b_GL_APPLE_vertex_array_object) {
     fn.glGenVertexArraysOESFn = reinterpret_cast<glGenVertexArraysOESProc>(
         GetGLProcAddress("glGenVertexArraysAPPLE"));
-  }
-
-  fn.glGetFramebufferAttachmentParameterivEXTFn = 0;
-  debug_fn.glGetFramebufferAttachmentParameterivEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glGetFramebufferAttachmentParameterivEXTFn =
-        reinterpret_cast<glGetFramebufferAttachmentParameterivEXTProc>(
-            GetGLProcAddress("glGetFramebufferAttachmentParameterivEXT"));
-  }
-  if (!fn.glGetFramebufferAttachmentParameterivEXTFn) {
-    fn.glGetFramebufferAttachmentParameterivEXTFn =
-        reinterpret_cast<glGetFramebufferAttachmentParameterivEXTProc>(
-            GetGLProcAddress("glGetFramebufferAttachmentParameteriv"));
-  }
+  } else {
+    fn.glGenVertexArraysOESFn = reinterpret_cast<glGenVertexArraysOESProc>(
+        glGenVertexArraysOESNotBound);
+  }
+  DCHECK(fn.glGenVertexArraysOESFn);
+
+  fn.glGetActiveUniformBlockivFn = 0;
+  debug_fn.glGetActiveUniformBlockivFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 1u))))) {
+    fn.glGetActiveUniformBlockivFn =
+        reinterpret_cast<glGetActiveUniformBlockivProc>(
+            GetGLProcAddress("glGetActiveUniformBlockiv"));
+  } else {
+    fn.glGetActiveUniformBlockivFn =
+        reinterpret_cast<glGetActiveUniformBlockivProc>(
+            glGetActiveUniformBlockivNotBound);
+  }
+  DCHECK(fn.glGetActiveUniformBlockivFn);
+
+  fn.glGetActiveUniformBlockNameFn = 0;
+  debug_fn.glGetActiveUniformBlockNameFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 1u))))) {
+    fn.glGetActiveUniformBlockNameFn =
+        reinterpret_cast<glGetActiveUniformBlockNameProc>(
+            GetGLProcAddress("glGetActiveUniformBlockName"));
+  } else {
+    fn.glGetActiveUniformBlockNameFn =
+        reinterpret_cast<glGetActiveUniformBlockNameProc>(
+            glGetActiveUniformBlockNameNotBound);
+  }
+  DCHECK(fn.glGetActiveUniformBlockNameFn);
+
+  fn.glGetActiveUniformsivFn = 0;
+  debug_fn.glGetActiveUniformsivFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 1u))))) {
+    fn.glGetActiveUniformsivFn = reinterpret_cast<glGetActiveUniformsivProc>(
+        GetGLProcAddress("glGetActiveUniformsiv"));
+  } else {
+    fn.glGetActiveUniformsivFn = reinterpret_cast<glGetActiveUniformsivProc>(
+        glGetActiveUniformsivNotBound);
+  }
+  DCHECK(fn.glGetActiveUniformsivFn);
+
+  fn.glGetFenceivNVFn = 0;
+  debug_fn.glGetFenceivNVFn = 0;
+  if (ext.b_GL_NV_fence) {
+    fn.glGetFenceivNVFn = reinterpret_cast<glGetFenceivNVProc>(
+        GetGLProcAddress("glGetFenceivNV"));
+  } else {
+    fn.glGetFenceivNVFn =
+        reinterpret_cast<glGetFenceivNVProc>(glGetFenceivNVNotBound);
+  }
+  DCHECK(fn.glGetFenceivNVFn);
+
+  fn.glGetFragDataLocationFn = 0;
+  debug_fn.glGetFragDataLocationFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGetFragDataLocationFn = reinterpret_cast<glGetFragDataLocationProc>(
+        GetGLProcAddress("glGetFragDataLocation"));
+  } else {
+    fn.glGetFragDataLocationFn = reinterpret_cast<glGetFragDataLocationProc>(
+        glGetFragDataLocationNotBound);
+  }
+  DCHECK(fn.glGetFragDataLocationFn);
 
   fn.glGetGraphicsResetStatusARBFn = 0;
   debug_fn.glGetGraphicsResetStatusARBFn = 0;
-  if (ext.b_GL_ARB_robustness) {
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 5u))))) {
+    fn.glGetGraphicsResetStatusARBFn =
+        reinterpret_cast<glGetGraphicsResetStatusARBProc>(
+            GetGLProcAddress("glGetGraphicsResetStatus"));
+  } else if (ext.b_GL_ARB_robustness) {
     fn.glGetGraphicsResetStatusARBFn =
         reinterpret_cast<glGetGraphicsResetStatusARBProc>(
             GetGLProcAddress("glGetGraphicsResetStatusARB"));
-  }
-  if (!fn.glGetGraphicsResetStatusARBFn && (ext.b_GL_KHR_robustness)) {
+  } else if (ext.b_GL_KHR_robustness) {
     fn.glGetGraphicsResetStatusARBFn =
         reinterpret_cast<glGetGraphicsResetStatusARBProc>(
             GetGLProcAddress("glGetGraphicsResetStatusKHR"));
-  }
-  if (!fn.glGetGraphicsResetStatusARBFn && (ext.b_GL_EXT_robustness)) {
+  } else if (ext.b_GL_EXT_robustness) {
     fn.glGetGraphicsResetStatusARBFn =
         reinterpret_cast<glGetGraphicsResetStatusARBProc>(
             GetGLProcAddress("glGetGraphicsResetStatusEXT"));
-  }
-  if (!fn.glGetGraphicsResetStatusARBFn) {
+  } else {
     fn.glGetGraphicsResetStatusARBFn =
         reinterpret_cast<glGetGraphicsResetStatusARBProc>(
-            GetGLProcAddress("glGetGraphicsResetStatus"));
-  }
+            glGetGraphicsResetStatusARBNotBound);
+  }
+  DCHECK(fn.glGetGraphicsResetStatusARBFn);
+
+  fn.glGetInteger64i_vFn = 0;
+  debug_fn.glGetInteger64i_vFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGetInteger64i_vFn = reinterpret_cast<glGetInteger64i_vProc>(
+        GetGLProcAddress("glGetInteger64i_v"));
+  } else {
+    fn.glGetInteger64i_vFn =
+        reinterpret_cast<glGetInteger64i_vProc>(glGetInteger64i_vNotBound);
+  }
+  DCHECK(fn.glGetInteger64i_vFn);
+
+  fn.glGetInteger64vFn = 0;
+  debug_fn.glGetInteger64vFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGetInteger64vFn = reinterpret_cast<glGetInteger64vProc>(
+        GetGLProcAddress("glGetInteger64v"));
+  } else {
+    fn.glGetInteger64vFn =
+        reinterpret_cast<glGetInteger64vProc>(glGetInteger64vNotBound);
+  }
+  DCHECK(fn.glGetInteger64vFn);
+
+  fn.glGetIntegeri_vFn = 0;
+  debug_fn.glGetIntegeri_vFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGetIntegeri_vFn = reinterpret_cast<glGetIntegeri_vProc>(
+        GetGLProcAddress("glGetIntegeri_v"));
+  } else {
+    fn.glGetIntegeri_vFn =
+        reinterpret_cast<glGetIntegeri_vProc>(glGetIntegeri_vNotBound);
+  }
+  DCHECK(fn.glGetIntegeri_vFn);
+
+  fn.glGetInternalformativFn = 0;
+  debug_fn.glGetInternalformativFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGetInternalformativFn = reinterpret_cast<glGetInternalformativProc>(
+        GetGLProcAddress("glGetInternalformativ"));
+  } else {
+    fn.glGetInternalformativFn = reinterpret_cast<glGetInternalformativProc>(
+        glGetInternalformativNotBound);
+  }
+  DCHECK(fn.glGetInternalformativFn);
 
   fn.glGetProgramBinaryFn = 0;
   debug_fn.glGetProgramBinaryFn = 0;
-  if (ext.b_GL_OES_get_program_binary) {
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 1u))) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
+      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"));
+  } else {
+    fn.glGetProgramBinaryFn =
+        reinterpret_cast<glGetProgramBinaryProc>(glGetProgramBinaryNotBound);
   }
-  if (!fn.glGetProgramBinaryFn) {
-    fn.glGetProgramBinaryFn = reinterpret_cast<glGetProgramBinaryProc>(
-        GetGLProcAddress("glGetProgramBinary"));
+  DCHECK(fn.glGetProgramBinaryFn);
+
+  fn.glGetQueryivFn = 0;
+  debug_fn.glGetQueryivFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGetQueryivFn =
+        reinterpret_cast<glGetQueryivProc>(GetGLProcAddress("glGetQueryiv"));
+  } else {
+    fn.glGetQueryivFn =
+        reinterpret_cast<glGetQueryivProc>(glGetQueryivNotBound);
   }
+  DCHECK(fn.glGetQueryivFn);
 
   fn.glGetQueryivARBFn = 0;
   debug_fn.glGetQueryivARBFn = 0;
   if (ext.b_GL_ARB_occlusion_query) {
     fn.glGetQueryivARBFn = reinterpret_cast<glGetQueryivARBProc>(
         GetGLProcAddress("glGetQueryivARB"));
-  }
-  if (!fn.glGetQueryivARBFn) {
+  } else if ((ext.b_GL_EXT_disjoint_timer_query ||
+              ext.b_GL_EXT_occlusion_query_boolean)) {
     fn.glGetQueryivARBFn = reinterpret_cast<glGetQueryivARBProc>(
         GetGLProcAddress("glGetQueryivEXT"));
-  }
+  } else {
+    fn.glGetQueryivARBFn =
+        reinterpret_cast<glGetQueryivARBProc>(glGetQueryivARBNotBound);
+  }
+  DCHECK(fn.glGetQueryivARBFn);
+
+  fn.glGetQueryObjecti64vFn = 0;
+  debug_fn.glGetQueryObjecti64vFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 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"));
+  } else {
+    fn.glGetQueryObjecti64vFn = reinterpret_cast<glGetQueryObjecti64vProc>(
+        glGetQueryObjecti64vNotBound);
+  }
+  DCHECK(fn.glGetQueryObjecti64vFn);
+
+  fn.glGetQueryObjectivFn = 0;
+  debug_fn.glGetQueryObjectivFn = 0;
+  if (!ver->is_es) {
+    fn.glGetQueryObjectivFn = reinterpret_cast<glGetQueryObjectivProc>(
+        GetGLProcAddress("glGetQueryObjectiv"));
+  } else {
+    fn.glGetQueryObjectivFn =
+        reinterpret_cast<glGetQueryObjectivProc>(glGetQueryObjectivNotBound);
+  }
+  DCHECK(fn.glGetQueryObjectivFn);
 
   fn.glGetQueryObjectivARBFn = 0;
   debug_fn.glGetQueryObjectivARBFn = 0;
   if (ext.b_GL_ARB_occlusion_query) {
     fn.glGetQueryObjectivARBFn = reinterpret_cast<glGetQueryObjectivARBProc>(
         GetGLProcAddress("glGetQueryObjectivARB"));
-  }
-  if (!fn.glGetQueryObjectivARBFn) {
+  } else if (ext.b_GL_EXT_disjoint_timer_query) {
     fn.glGetQueryObjectivARBFn = reinterpret_cast<glGetQueryObjectivARBProc>(
         GetGLProcAddress("glGetQueryObjectivEXT"));
+  } else {
+    fn.glGetQueryObjectivARBFn = reinterpret_cast<glGetQueryObjectivARBProc>(
+        glGetQueryObjectivARBNotBound);
   }
+  DCHECK(fn.glGetQueryObjectivARBFn);
 
   fn.glGetQueryObjectui64vFn = 0;
   debug_fn.glGetQueryObjectui64vFn = 0;
-  if (ext.b_GL_ARB_timer_query) {
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u)))) ||
+      ext.b_GL_ARB_timer_query) {
     fn.glGetQueryObjectui64vFn = reinterpret_cast<glGetQueryObjectui64vProc>(
         GetGLProcAddress("glGetQueryObjectui64v"));
-  }
-  if (!fn.glGetQueryObjectui64vFn) {
+  } else if ((ext.b_GL_EXT_timer_query || ext.b_GL_EXT_disjoint_timer_query)) {
     fn.glGetQueryObjectui64vFn = reinterpret_cast<glGetQueryObjectui64vProc>(
         GetGLProcAddress("glGetQueryObjectui64vEXT"));
+  } else {
+    fn.glGetQueryObjectui64vFn = reinterpret_cast<glGetQueryObjectui64vProc>(
+        glGetQueryObjectui64vNotBound);
+  }
+  DCHECK(fn.glGetQueryObjectui64vFn);
+
+  fn.glGetQueryObjectuivFn = 0;
+  debug_fn.glGetQueryObjectuivFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGetQueryObjectuivFn = reinterpret_cast<glGetQueryObjectuivProc>(
+        GetGLProcAddress("glGetQueryObjectuiv"));
+  } else {
+    fn.glGetQueryObjectuivFn =
+        reinterpret_cast<glGetQueryObjectuivProc>(glGetQueryObjectuivNotBound);
   }
+  DCHECK(fn.glGetQueryObjectuivFn);
 
   fn.glGetQueryObjectuivARBFn = 0;
   debug_fn.glGetQueryObjectuivARBFn = 0;
   if (ext.b_GL_ARB_occlusion_query) {
     fn.glGetQueryObjectuivARBFn = reinterpret_cast<glGetQueryObjectuivARBProc>(
         GetGLProcAddress("glGetQueryObjectuivARB"));
-  }
-  if (!fn.glGetQueryObjectuivARBFn) {
+  } else if ((ext.b_GL_EXT_disjoint_timer_query ||
+              ext.b_GL_EXT_occlusion_query_boolean)) {
     fn.glGetQueryObjectuivARBFn = reinterpret_cast<glGetQueryObjectuivARBProc>(
         GetGLProcAddress("glGetQueryObjectuivEXT"));
-  }
-
-  fn.glGetRenderbufferParameterivEXTFn = 0;
-  debug_fn.glGetRenderbufferParameterivEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glGetRenderbufferParameterivEXTFn =
-        reinterpret_cast<glGetRenderbufferParameterivEXTProc>(
-            GetGLProcAddress("glGetRenderbufferParameterivEXT"));
-  }
-  if (!fn.glGetRenderbufferParameterivEXTFn) {
-    fn.glGetRenderbufferParameterivEXTFn =
-        reinterpret_cast<glGetRenderbufferParameterivEXTProc>(
-            GetGLProcAddress("glGetRenderbufferParameteriv"));
-  }
-
-  fn.glIsFramebufferEXTFn = 0;
-  debug_fn.glIsFramebufferEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glIsFramebufferEXTFn = reinterpret_cast<glIsFramebufferEXTProc>(
-        GetGLProcAddress("glIsFramebufferEXT"));
-  }
-  if (!fn.glIsFramebufferEXTFn) {
-    fn.glIsFramebufferEXTFn = reinterpret_cast<glIsFramebufferEXTProc>(
-        GetGLProcAddress("glIsFramebuffer"));
-  }
+  } else {
+    fn.glGetQueryObjectuivARBFn = reinterpret_cast<glGetQueryObjectuivARBProc>(
+        glGetQueryObjectuivARBNotBound);
+  }
+  DCHECK(fn.glGetQueryObjectuivARBFn);
+
+  fn.glGetSamplerParameterfvFn = 0;
+  debug_fn.glGetSamplerParameterfvFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGetSamplerParameterfvFn =
+        reinterpret_cast<glGetSamplerParameterfvProc>(
+            GetGLProcAddress("glGetSamplerParameterfv"));
+  } else {
+    fn.glGetSamplerParameterfvFn =
+        reinterpret_cast<glGetSamplerParameterfvProc>(
+            glGetSamplerParameterfvNotBound);
+  }
+  DCHECK(fn.glGetSamplerParameterfvFn);
+
+  fn.glGetSamplerParameterivFn = 0;
+  debug_fn.glGetSamplerParameterivFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGetSamplerParameterivFn =
+        reinterpret_cast<glGetSamplerParameterivProc>(
+            GetGLProcAddress("glGetSamplerParameteriv"));
+  } else {
+    fn.glGetSamplerParameterivFn =
+        reinterpret_cast<glGetSamplerParameterivProc>(
+            glGetSamplerParameterivNotBound);
+  }
+  DCHECK(fn.glGetSamplerParameterivFn);
+
+  fn.glGetShaderPrecisionFormatFn = 0;
+  debug_fn.glGetShaderPrecisionFormatFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 1u))) ||
+       ver->is_es)) {
+    fn.glGetShaderPrecisionFormatFn =
+        reinterpret_cast<glGetShaderPrecisionFormatProc>(
+            GetGLProcAddress("glGetShaderPrecisionFormat"));
+  } else {
+    fn.glGetShaderPrecisionFormatFn =
+        reinterpret_cast<glGetShaderPrecisionFormatProc>(
+            glGetShaderPrecisionFormatNotBound);
+  }
+  DCHECK(fn.glGetShaderPrecisionFormatFn);
+
+  fn.glGetSyncivFn = 0;
+  debug_fn.glGetSyncivFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
+      ext.b_GL_ARB_sync) {
+    fn.glGetSyncivFn =
+        reinterpret_cast<glGetSyncivProc>(GetGLProcAddress("glGetSynciv"));
+  } else {
+    fn.glGetSyncivFn = reinterpret_cast<glGetSyncivProc>(glGetSyncivNotBound);
+  }
+  DCHECK(fn.glGetSyncivFn);
+
+  fn.glGetTexLevelParameterfvFn = 0;
+  debug_fn.glGetTexLevelParameterfvFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version > 3u ||
+                                      (ver->major_version == 3u &&
+                                       ver->minor_version >= 1u))))) {
+    fn.glGetTexLevelParameterfvFn =
+        reinterpret_cast<glGetTexLevelParameterfvProc>(
+            GetGLProcAddress("glGetTexLevelParameterfv"));
+  } else {
+    fn.glGetTexLevelParameterfvFn =
+        reinterpret_cast<glGetTexLevelParameterfvProc>(
+            glGetTexLevelParameterfvNotBound);
+  }
+  DCHECK(fn.glGetTexLevelParameterfvFn);
+
+  fn.glGetTexLevelParameterivFn = 0;
+  debug_fn.glGetTexLevelParameterivFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version > 3u ||
+                                      (ver->major_version == 3u &&
+                                       ver->minor_version >= 1u))))) {
+    fn.glGetTexLevelParameterivFn =
+        reinterpret_cast<glGetTexLevelParameterivProc>(
+            GetGLProcAddress("glGetTexLevelParameteriv"));
+  } else {
+    fn.glGetTexLevelParameterivFn =
+        reinterpret_cast<glGetTexLevelParameterivProc>(
+            glGetTexLevelParameterivNotBound);
+  }
+  DCHECK(fn.glGetTexLevelParameterivFn);
+
+  fn.glGetTransformFeedbackVaryingFn = 0;
+  debug_fn.glGetTransformFeedbackVaryingFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glGetTransformFeedbackVaryingFn =
+        reinterpret_cast<glGetTransformFeedbackVaryingProc>(
+            GetGLProcAddress("glGetTransformFeedbackVarying"));
+  } else {
+    fn.glGetTransformFeedbackVaryingFn =
+        reinterpret_cast<glGetTransformFeedbackVaryingProc>(
+            glGetTransformFeedbackVaryingNotBound);
+  }
+  DCHECK(fn.glGetTransformFeedbackVaryingFn);
+
+  fn.glGetTranslatedShaderSourceANGLEFn = 0;
+  debug_fn.glGetTranslatedShaderSourceANGLEFn = 0;
+  if (ext.b_GL_ANGLE_translated_shader_source) {
+    fn.glGetTranslatedShaderSourceANGLEFn =
+        reinterpret_cast<glGetTranslatedShaderSourceANGLEProc>(
+            GetGLProcAddress("glGetTranslatedShaderSourceANGLE"));
+  } else {
+    fn.glGetTranslatedShaderSourceANGLEFn =
+        reinterpret_cast<glGetTranslatedShaderSourceANGLEProc>(
+            glGetTranslatedShaderSourceANGLENotBound);
+  }
+  DCHECK(fn.glGetTranslatedShaderSourceANGLEFn);
+
+  fn.glGetUniformBlockIndexFn = 0;
+  debug_fn.glGetUniformBlockIndexFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 1u))))) {
+    fn.glGetUniformBlockIndexFn = reinterpret_cast<glGetUniformBlockIndexProc>(
+        GetGLProcAddress("glGetUniformBlockIndex"));
+  } else {
+    fn.glGetUniformBlockIndexFn = reinterpret_cast<glGetUniformBlockIndexProc>(
+        glGetUniformBlockIndexNotBound);
+  }
+  DCHECK(fn.glGetUniformBlockIndexFn);
+
+  fn.glGetUniformIndicesFn = 0;
+  debug_fn.glGetUniformIndicesFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 1u))))) {
+    fn.glGetUniformIndicesFn = reinterpret_cast<glGetUniformIndicesProc>(
+        GetGLProcAddress("glGetUniformIndices"));
+  } else {
+    fn.glGetUniformIndicesFn =
+        reinterpret_cast<glGetUniformIndicesProc>(glGetUniformIndicesNotBound);
+  }
+  DCHECK(fn.glGetUniformIndicesFn);
+
+  fn.glInsertEventMarkerEXTFn = 0;
+  debug_fn.glInsertEventMarkerEXTFn = 0;
+  if (ext.b_GL_EXT_debug_marker) {
+    fn.glInsertEventMarkerEXTFn = reinterpret_cast<glInsertEventMarkerEXTProc>(
+        GetGLProcAddress("glInsertEventMarkerEXT"));
+  } else {
+    fn.glInsertEventMarkerEXTFn = reinterpret_cast<glInsertEventMarkerEXTProc>(
+        glInsertEventMarkerEXTNotBound);
+  }
+  DCHECK(fn.glInsertEventMarkerEXTFn);
+
+  fn.glInvalidateFramebufferFn = 0;
+  debug_fn.glInvalidateFramebufferFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glInvalidateFramebufferFn =
+        reinterpret_cast<glInvalidateFramebufferProc>(
+            GetGLProcAddress("glInvalidateFramebuffer"));
+  } else {
+    fn.glInvalidateFramebufferFn =
+        reinterpret_cast<glInvalidateFramebufferProc>(
+            glInvalidateFramebufferNotBound);
+  }
+  DCHECK(fn.glInvalidateFramebufferFn);
+
+  fn.glInvalidateSubFramebufferFn = 0;
+  debug_fn.glInvalidateSubFramebufferFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glInvalidateSubFramebufferFn =
+        reinterpret_cast<glInvalidateSubFramebufferProc>(
+            GetGLProcAddress("glInvalidateSubFramebuffer"));
+  } else {
+    fn.glInvalidateSubFramebufferFn =
+        reinterpret_cast<glInvalidateSubFramebufferProc>(
+            glInvalidateSubFramebufferNotBound);
+  }
+  DCHECK(fn.glInvalidateSubFramebufferFn);
+
+  fn.glIsFenceAPPLEFn = 0;
+  debug_fn.glIsFenceAPPLEFn = 0;
+  if (ext.b_GL_APPLE_fence) {
+    fn.glIsFenceAPPLEFn = reinterpret_cast<glIsFenceAPPLEProc>(
+        GetGLProcAddress("glIsFenceAPPLE"));
+  } else {
+    fn.glIsFenceAPPLEFn =
+        reinterpret_cast<glIsFenceAPPLEProc>(glIsFenceAPPLENotBound);
+  }
+  DCHECK(fn.glIsFenceAPPLEFn);
+
+  fn.glIsFenceNVFn = 0;
+  debug_fn.glIsFenceNVFn = 0;
+  if (ext.b_GL_NV_fence) {
+    fn.glIsFenceNVFn =
+        reinterpret_cast<glIsFenceNVProc>(GetGLProcAddress("glIsFenceNV"));
+  } else {
+    fn.glIsFenceNVFn = reinterpret_cast<glIsFenceNVProc>(glIsFenceNVNotBound);
+  }
+  DCHECK(fn.glIsFenceNVFn);
+
+  fn.glIsQueryFn = 0;
+  debug_fn.glIsQueryFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glIsQueryFn =
+        reinterpret_cast<glIsQueryProc>(GetGLProcAddress("glIsQuery"));
+  } else {
+    fn.glIsQueryFn = reinterpret_cast<glIsQueryProc>(glIsQueryNotBound);
+  }
+  DCHECK(fn.glIsQueryFn);
 
   fn.glIsQueryARBFn = 0;
   debug_fn.glIsQueryARBFn = 0;
   if (ext.b_GL_ARB_occlusion_query) {
     fn.glIsQueryARBFn =
         reinterpret_cast<glIsQueryARBProc>(GetGLProcAddress("glIsQueryARB"));
-  }
-  if (!fn.glIsQueryARBFn) {
+  } else if ((ext.b_GL_EXT_disjoint_timer_query ||
+              ext.b_GL_EXT_occlusion_query_boolean)) {
     fn.glIsQueryARBFn =
         reinterpret_cast<glIsQueryARBProc>(GetGLProcAddress("glIsQueryEXT"));
-  }
-
-  fn.glIsRenderbufferEXTFn = 0;
-  debug_fn.glIsRenderbufferEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glIsRenderbufferEXTFn = reinterpret_cast<glIsRenderbufferEXTProc>(
-        GetGLProcAddress("glIsRenderbufferEXT"));
-  }
-  if (!fn.glIsRenderbufferEXTFn) {
-    fn.glIsRenderbufferEXTFn = reinterpret_cast<glIsRenderbufferEXTProc>(
-        GetGLProcAddress("glIsRenderbuffer"));
-  }
+  } else {
+    fn.glIsQueryARBFn =
+        reinterpret_cast<glIsQueryARBProc>(glIsQueryARBNotBound);
+  }
+  DCHECK(fn.glIsQueryARBFn);
+
+  fn.glIsSamplerFn = 0;
+  debug_fn.glIsSamplerFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glIsSamplerFn =
+        reinterpret_cast<glIsSamplerProc>(GetGLProcAddress("glIsSampler"));
+  } else {
+    fn.glIsSamplerFn = reinterpret_cast<glIsSamplerProc>(glIsSamplerNotBound);
+  }
+  DCHECK(fn.glIsSamplerFn);
+
+  fn.glIsSyncFn = 0;
+  debug_fn.glIsSyncFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
+      ext.b_GL_ARB_sync) {
+    fn.glIsSyncFn =
+        reinterpret_cast<glIsSyncProc>(GetGLProcAddress("glIsSync"));
+  } else {
+    fn.glIsSyncFn = reinterpret_cast<glIsSyncProc>(glIsSyncNotBound);
+  }
+  DCHECK(fn.glIsSyncFn);
+
+  fn.glIsTransformFeedbackFn = 0;
+  debug_fn.glIsTransformFeedbackFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es && (ver->major_version >= 4u)))) {
+    fn.glIsTransformFeedbackFn = reinterpret_cast<glIsTransformFeedbackProc>(
+        GetGLProcAddress("glIsTransformFeedback"));
+  } else {
+    fn.glIsTransformFeedbackFn = reinterpret_cast<glIsTransformFeedbackProc>(
+        glIsTransformFeedbackNotBound);
+  }
+  DCHECK(fn.glIsTransformFeedbackFn);
 
   fn.glIsVertexArrayOESFn = 0;
   debug_fn.glIsVertexArrayOESFn = 0;
-  if ((ver->is_gl3 || ver->is_gl4 || ver->is_es3) ||
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
       ext.b_GL_ARB_vertex_array_object) {
     fn.glIsVertexArrayOESFn = reinterpret_cast<glIsVertexArrayOESProc>(
         GetGLProcAddress("glIsVertexArray"));
-  }
-  if (!fn.glIsVertexArrayOESFn && (ext.b_GL_OES_vertex_array_object)) {
+  } else if (ext.b_GL_OES_vertex_array_object) {
     fn.glIsVertexArrayOESFn = reinterpret_cast<glIsVertexArrayOESProc>(
         GetGLProcAddress("glIsVertexArrayOES"));
-  }
-  if (!fn.glIsVertexArrayOESFn) {
+  } else if (ext.b_GL_APPLE_vertex_array_object) {
     fn.glIsVertexArrayOESFn = reinterpret_cast<glIsVertexArrayOESProc>(
         GetGLProcAddress("glIsVertexArrayAPPLE"));
+  } else {
+    fn.glIsVertexArrayOESFn =
+        reinterpret_cast<glIsVertexArrayOESProc>(glIsVertexArrayOESNotBound);
   }
+  DCHECK(fn.glIsVertexArrayOESFn);
 
   fn.glMapBufferFn = 0;
   debug_fn.glMapBufferFn = 0;
-  if (ext.b_GL_OES_mapbuffer) {
-    fn.glMapBufferFn =
-        reinterpret_cast<glMapBufferProc>(GetGLProcAddress("glMapBufferOES"));
-  }
-  if (!fn.glMapBufferFn) {
+  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"));
+  } else {
+    fn.glMapBufferFn = reinterpret_cast<glMapBufferProc>(glMapBufferNotBound);
   }
+  DCHECK(fn.glMapBufferFn);
 
   fn.glMapBufferRangeFn = 0;
   debug_fn.glMapBufferRangeFn = 0;
-  if ((ver->is_gl3 || ver->is_gl4 || ver->is_es3) ||
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
       ext.b_GL_ARB_map_buffer_range) {
     fn.glMapBufferRangeFn = reinterpret_cast<glMapBufferRangeProc>(
         GetGLProcAddress("glMapBufferRange"));
-  }
-  if (!fn.glMapBufferRangeFn) {
+  } else if (ext.b_GL_EXT_map_buffer_range) {
     fn.glMapBufferRangeFn = reinterpret_cast<glMapBufferRangeProc>(
         GetGLProcAddress("glMapBufferRangeEXT"));
-  }
+  } else {
+    fn.glMapBufferRangeFn =
+        reinterpret_cast<glMapBufferRangeProc>(glMapBufferRangeNotBound);
+  }
+  DCHECK(fn.glMapBufferRangeFn);
+
+  fn.glMatrixLoadfEXTFn = 0;
+  debug_fn.glMatrixLoadfEXTFn = 0;
+  if ((ext.b_GL_EXT_direct_state_access || ext.b_GL_NV_path_rendering)) {
+    fn.glMatrixLoadfEXTFn = reinterpret_cast<glMatrixLoadfEXTProc>(
+        GetGLProcAddress("glMatrixLoadfEXT"));
+  } else {
+    fn.glMatrixLoadfEXTFn =
+        reinterpret_cast<glMatrixLoadfEXTProc>(glMatrixLoadfEXTNotBound);
+  }
+  DCHECK(fn.glMatrixLoadfEXTFn);
+
+  fn.glMatrixLoadIdentityEXTFn = 0;
+  debug_fn.glMatrixLoadIdentityEXTFn = 0;
+  if ((ext.b_GL_EXT_direct_state_access || ext.b_GL_NV_path_rendering)) {
+    fn.glMatrixLoadIdentityEXTFn =
+        reinterpret_cast<glMatrixLoadIdentityEXTProc>(
+            GetGLProcAddress("glMatrixLoadIdentityEXT"));
+  } else {
+    fn.glMatrixLoadIdentityEXTFn =
+        reinterpret_cast<glMatrixLoadIdentityEXTProc>(
+            glMatrixLoadIdentityEXTNotBound);
+  }
+  DCHECK(fn.glMatrixLoadIdentityEXTFn);
+
+  fn.glPauseTransformFeedbackFn = 0;
+  debug_fn.glPauseTransformFeedbackFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es && (ver->major_version >= 4u)))) {
+    fn.glPauseTransformFeedbackFn =
+        reinterpret_cast<glPauseTransformFeedbackProc>(
+            GetGLProcAddress("glPauseTransformFeedback"));
+  } else {
+    fn.glPauseTransformFeedbackFn =
+        reinterpret_cast<glPauseTransformFeedbackProc>(
+            glPauseTransformFeedbackNotBound);
+  }
+  DCHECK(fn.glPauseTransformFeedbackFn);
+
+  fn.glPointParameteriFn = 0;
+  debug_fn.glPointParameteriFn = 0;
+  if (!ver->is_es) {
+    fn.glPointParameteriFn = reinterpret_cast<glPointParameteriProc>(
+        GetGLProcAddress("glPointParameteri"));
+  } else {
+    fn.glPointParameteriFn =
+        reinterpret_cast<glPointParameteriProc>(glPointParameteriNotBound);
+  }
+  DCHECK(fn.glPointParameteriFn);
+
+  fn.glPopGroupMarkerEXTFn = 0;
+  debug_fn.glPopGroupMarkerEXTFn = 0;
+  if (ext.b_GL_EXT_debug_marker) {
+    fn.glPopGroupMarkerEXTFn = reinterpret_cast<glPopGroupMarkerEXTProc>(
+        GetGLProcAddress("glPopGroupMarkerEXT"));
+  } else {
+    fn.glPopGroupMarkerEXTFn =
+        reinterpret_cast<glPopGroupMarkerEXTProc>(glPopGroupMarkerEXTNotBound);
+  }
+  DCHECK(fn.glPopGroupMarkerEXTFn);
 
   fn.glProgramBinaryFn = 0;
   debug_fn.glProgramBinaryFn = 0;
-  if (ext.b_GL_OES_get_program_binary) {
-    fn.glProgramBinaryFn = reinterpret_cast<glProgramBinaryProc>(
-        GetGLProcAddress("glProgramBinaryOES"));
-  }
-  if (!fn.glProgramBinaryFn) {
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 1u))) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
+      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"));
+  } else {
+    fn.glProgramBinaryFn =
+        reinterpret_cast<glProgramBinaryProc>(glProgramBinaryNotBound);
+  }
+  DCHECK(fn.glProgramBinaryFn);
+
+  fn.glProgramParameteriFn = 0;
+  debug_fn.glProgramParameteriFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 1u))) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
+      ext.b_GL_ARB_get_program_binary) {
+    fn.glProgramParameteriFn = reinterpret_cast<glProgramParameteriProc>(
+        GetGLProcAddress("glProgramParameteri"));
+  } else {
+    fn.glProgramParameteriFn =
+        reinterpret_cast<glProgramParameteriProc>(glProgramParameteriNotBound);
+  }
+  DCHECK(fn.glProgramParameteriFn);
+
+  fn.glPushGroupMarkerEXTFn = 0;
+  debug_fn.glPushGroupMarkerEXTFn = 0;
+  if (ext.b_GL_EXT_debug_marker) {
+    fn.glPushGroupMarkerEXTFn = reinterpret_cast<glPushGroupMarkerEXTProc>(
+        GetGLProcAddress("glPushGroupMarkerEXT"));
+  } else {
+    fn.glPushGroupMarkerEXTFn = reinterpret_cast<glPushGroupMarkerEXTProc>(
+        glPushGroupMarkerEXTNotBound);
+  }
+  DCHECK(fn.glPushGroupMarkerEXTFn);
 
   fn.glQueryCounterFn = 0;
   debug_fn.glQueryCounterFn = 0;
-  if (ext.b_GL_ARB_timer_query) {
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u)))) ||
+      ext.b_GL_ARB_timer_query) {
     fn.glQueryCounterFn = reinterpret_cast<glQueryCounterProc>(
         GetGLProcAddress("glQueryCounter"));
-  }
-  if (!fn.glQueryCounterFn) {
+  } else if (ext.b_GL_EXT_disjoint_timer_query) {
     fn.glQueryCounterFn = reinterpret_cast<glQueryCounterProc>(
         GetGLProcAddress("glQueryCounterEXT"));
+  } else {
+    fn.glQueryCounterFn =
+        reinterpret_cast<glQueryCounterProc>(glQueryCounterNotBound);
+  }
+  DCHECK(fn.glQueryCounterFn);
+
+  fn.glReadBufferFn = 0;
+  debug_fn.glReadBufferFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glReadBufferFn =
+        reinterpret_cast<glReadBufferProc>(GetGLProcAddress("glReadBuffer"));
+  } else {
+    fn.glReadBufferFn =
+        reinterpret_cast<glReadBufferProc>(glReadBufferNotBound);
+  }
+  DCHECK(fn.glReadBufferFn);
+
+  fn.glReleaseShaderCompilerFn = 0;
+  debug_fn.glReleaseShaderCompilerFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 1u))) ||
+       ver->is_es)) {
+    fn.glReleaseShaderCompilerFn =
+        reinterpret_cast<glReleaseShaderCompilerProc>(
+            GetGLProcAddress("glReleaseShaderCompiler"));
+  } else {
+    fn.glReleaseShaderCompilerFn =
+        reinterpret_cast<glReleaseShaderCompilerProc>(
+            glReleaseShaderCompilerNotBound);
+  }
+  DCHECK(fn.glReleaseShaderCompilerFn);
+
+  fn.glRenderbufferStorageMultisampleFn = 0;
+  debug_fn.glRenderbufferStorageMultisampleFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glRenderbufferStorageMultisampleFn =
+        reinterpret_cast<glRenderbufferStorageMultisampleProc>(
+            GetGLProcAddress("glRenderbufferStorageMultisample"));
+  } else {
+    fn.glRenderbufferStorageMultisampleFn =
+        reinterpret_cast<glRenderbufferStorageMultisampleProc>(
+            glRenderbufferStorageMultisampleNotBound);
   }
-
-  fn.glRenderbufferStorageEXTFn = 0;
-  debug_fn.glRenderbufferStorageEXTFn = 0;
-  if (ext.b_GL_EXT_framebuffer_object) {
-    fn.glRenderbufferStorageEXTFn =
-        reinterpret_cast<glRenderbufferStorageEXTProc>(
-            GetGLProcAddress("glRenderbufferStorageEXT"));
-  }
-  if (!fn.glRenderbufferStorageEXTFn) {
-    fn.glRenderbufferStorageEXTFn =
-        reinterpret_cast<glRenderbufferStorageEXTProc>(
-            GetGLProcAddress("glRenderbufferStorage"));
-  }
+  DCHECK(fn.glRenderbufferStorageMultisampleFn);
 
   fn.glRenderbufferStorageMultisampleANGLEFn = 0;
   debug_fn.glRenderbufferStorageMultisampleANGLEFn = 0;
-  if (ext.b_GL_ANGLE_framebuffer_multisample) {
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glRenderbufferStorageMultisampleANGLEFn =
+        reinterpret_cast<glRenderbufferStorageMultisampleANGLEProc>(
+            GetGLProcAddress("glRenderbufferStorageMultisample"));
+  } else if (ext.b_GL_ANGLE_framebuffer_multisample) {
     fn.glRenderbufferStorageMultisampleANGLEFn =
         reinterpret_cast<glRenderbufferStorageMultisampleANGLEProc>(
             GetGLProcAddress("glRenderbufferStorageMultisampleANGLE"));
-  }
-  if (!fn.glRenderbufferStorageMultisampleANGLEFn) {
+  } else {
     fn.glRenderbufferStorageMultisampleANGLEFn =
         reinterpret_cast<glRenderbufferStorageMultisampleANGLEProc>(
-            GetGLProcAddress("glRenderbufferStorageMultisample"));
+            glRenderbufferStorageMultisampleANGLENotBound);
   }
+  DCHECK(fn.glRenderbufferStorageMultisampleANGLEFn);
 
   fn.glRenderbufferStorageMultisampleEXTFn = 0;
   debug_fn.glRenderbufferStorageMultisampleEXTFn = 0;
-  if ((ext.b_GL_EXT_framebuffer_multisample ||
-       ext.b_GL_EXT_multisampled_render_to_texture)) {
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glRenderbufferStorageMultisampleEXTFn =
+        reinterpret_cast<glRenderbufferStorageMultisampleEXTProc>(
+            GetGLProcAddress("glRenderbufferStorageMultisample"));
+  } else if ((ext.b_GL_EXT_multisampled_render_to_texture ||
+              ext.b_GL_EXT_framebuffer_multisample)) {
     fn.glRenderbufferStorageMultisampleEXTFn =
         reinterpret_cast<glRenderbufferStorageMultisampleEXTProc>(
             GetGLProcAddress("glRenderbufferStorageMultisampleEXT"));
-  }
-  if (!fn.glRenderbufferStorageMultisampleEXTFn) {
+  } else {
     fn.glRenderbufferStorageMultisampleEXTFn =
         reinterpret_cast<glRenderbufferStorageMultisampleEXTProc>(
-            GetGLProcAddress("glRenderbufferStorageMultisample"));
+            glRenderbufferStorageMultisampleEXTNotBound);
   }
+  DCHECK(fn.glRenderbufferStorageMultisampleEXTFn);
+
+  fn.glRenderbufferStorageMultisampleIMGFn = 0;
+  debug_fn.glRenderbufferStorageMultisampleIMGFn = 0;
+  if (ext.b_GL_IMG_multisampled_render_to_texture) {
+    fn.glRenderbufferStorageMultisampleIMGFn =
+        reinterpret_cast<glRenderbufferStorageMultisampleIMGProc>(
+            GetGLProcAddress("glRenderbufferStorageMultisampleIMG"));
+  } else {
+    fn.glRenderbufferStorageMultisampleIMGFn =
+        reinterpret_cast<glRenderbufferStorageMultisampleIMGProc>(
+            glRenderbufferStorageMultisampleIMGNotBound);
+  }
+  DCHECK(fn.glRenderbufferStorageMultisampleIMGFn);
+
+  fn.glResumeTransformFeedbackFn = 0;
+  debug_fn.glResumeTransformFeedbackFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es && (ver->major_version >= 4u)))) {
+    fn.glResumeTransformFeedbackFn =
+        reinterpret_cast<glResumeTransformFeedbackProc>(
+            GetGLProcAddress("glResumeTransformFeedback"));
+  } else {
+    fn.glResumeTransformFeedbackFn =
+        reinterpret_cast<glResumeTransformFeedbackProc>(
+            glResumeTransformFeedbackNotBound);
+  }
+  DCHECK(fn.glResumeTransformFeedbackFn);
+
+  fn.glSamplerParameterfFn = 0;
+  debug_fn.glSamplerParameterfFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glSamplerParameterfFn = reinterpret_cast<glSamplerParameterfProc>(
+        GetGLProcAddress("glSamplerParameterf"));
+  } else {
+    fn.glSamplerParameterfFn =
+        reinterpret_cast<glSamplerParameterfProc>(glSamplerParameterfNotBound);
+  }
+  DCHECK(fn.glSamplerParameterfFn);
+
+  fn.glSamplerParameterfvFn = 0;
+  debug_fn.glSamplerParameterfvFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glSamplerParameterfvFn = reinterpret_cast<glSamplerParameterfvProc>(
+        GetGLProcAddress("glSamplerParameterfv"));
+  } else {
+    fn.glSamplerParameterfvFn = reinterpret_cast<glSamplerParameterfvProc>(
+        glSamplerParameterfvNotBound);
+  }
+  DCHECK(fn.glSamplerParameterfvFn);
+
+  fn.glSamplerParameteriFn = 0;
+  debug_fn.glSamplerParameteriFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glSamplerParameteriFn = reinterpret_cast<glSamplerParameteriProc>(
+        GetGLProcAddress("glSamplerParameteri"));
+  } else {
+    fn.glSamplerParameteriFn =
+        reinterpret_cast<glSamplerParameteriProc>(glSamplerParameteriNotBound);
+  }
+  DCHECK(fn.glSamplerParameteriFn);
+
+  fn.glSamplerParameterivFn = 0;
+  debug_fn.glSamplerParameterivFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glSamplerParameterivFn = reinterpret_cast<glSamplerParameterivProc>(
+        GetGLProcAddress("glSamplerParameteriv"));
+  } else {
+    fn.glSamplerParameterivFn = reinterpret_cast<glSamplerParameterivProc>(
+        glSamplerParameterivNotBound);
+  }
+  DCHECK(fn.glSamplerParameterivFn);
+
+  fn.glSetFenceAPPLEFn = 0;
+  debug_fn.glSetFenceAPPLEFn = 0;
+  if (ext.b_GL_APPLE_fence) {
+    fn.glSetFenceAPPLEFn = reinterpret_cast<glSetFenceAPPLEProc>(
+        GetGLProcAddress("glSetFenceAPPLE"));
+  } else {
+    fn.glSetFenceAPPLEFn =
+        reinterpret_cast<glSetFenceAPPLEProc>(glSetFenceAPPLENotBound);
+  }
+  DCHECK(fn.glSetFenceAPPLEFn);
+
+  fn.glSetFenceNVFn = 0;
+  debug_fn.glSetFenceNVFn = 0;
+  if (ext.b_GL_NV_fence) {
+    fn.glSetFenceNVFn =
+        reinterpret_cast<glSetFenceNVProc>(GetGLProcAddress("glSetFenceNV"));
+  } else {
+    fn.glSetFenceNVFn =
+        reinterpret_cast<glSetFenceNVProc>(glSetFenceNVNotBound);
+  }
+  DCHECK(fn.glSetFenceNVFn);
+
+  fn.glShaderBinaryFn = 0;
+  debug_fn.glShaderBinaryFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 1u))) ||
+       ver->is_es)) {
+    fn.glShaderBinaryFn = reinterpret_cast<glShaderBinaryProc>(
+        GetGLProcAddress("glShaderBinary"));
+  } else {
+    fn.glShaderBinaryFn =
+        reinterpret_cast<glShaderBinaryProc>(glShaderBinaryNotBound);
+  }
+  DCHECK(fn.glShaderBinaryFn);
+
+  fn.glTestFenceAPPLEFn = 0;
+  debug_fn.glTestFenceAPPLEFn = 0;
+  if (ext.b_GL_APPLE_fence) {
+    fn.glTestFenceAPPLEFn = reinterpret_cast<glTestFenceAPPLEProc>(
+        GetGLProcAddress("glTestFenceAPPLE"));
+  } else {
+    fn.glTestFenceAPPLEFn =
+        reinterpret_cast<glTestFenceAPPLEProc>(glTestFenceAPPLENotBound);
+  }
+  DCHECK(fn.glTestFenceAPPLEFn);
+
+  fn.glTestFenceNVFn = 0;
+  debug_fn.glTestFenceNVFn = 0;
+  if (ext.b_GL_NV_fence) {
+    fn.glTestFenceNVFn =
+        reinterpret_cast<glTestFenceNVProc>(GetGLProcAddress("glTestFenceNV"));
+  } else {
+    fn.glTestFenceNVFn =
+        reinterpret_cast<glTestFenceNVProc>(glTestFenceNVNotBound);
+  }
+  DCHECK(fn.glTestFenceNVFn);
+
+  fn.glTexImage3DFn = 0;
+  debug_fn.glTexImage3DFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glTexImage3DFn =
+        reinterpret_cast<glTexImage3DProc>(GetGLProcAddress("glTexImage3D"));
+  } else {
+    fn.glTexImage3DFn =
+        reinterpret_cast<glTexImage3DProc>(glTexImage3DNotBound);
+  }
+  DCHECK(fn.glTexImage3DFn);
 
   fn.glTexStorage2DEXTFn = 0;
   debug_fn.glTexStorage2DEXTFn = 0;
-  if (ver->is_es3 || ext.b_GL_ARB_texture_storage) {
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
+      ext.b_GL_ARB_texture_storage) {
     fn.glTexStorage2DEXTFn = reinterpret_cast<glTexStorage2DEXTProc>(
         GetGLProcAddress("glTexStorage2D"));
-  }
-  if (!fn.glTexStorage2DEXTFn) {
+  } else if (ext.b_GL_EXT_texture_storage) {
     fn.glTexStorage2DEXTFn = reinterpret_cast<glTexStorage2DEXTProc>(
         GetGLProcAddress("glTexStorage2DEXT"));
-  }
+  } else {
+    fn.glTexStorage2DEXTFn =
+        reinterpret_cast<glTexStorage2DEXTProc>(glTexStorage2DEXTNotBound);
+  }
+  DCHECK(fn.glTexStorage2DEXTFn);
+
+  fn.glTexStorage3DFn = 0;
+  debug_fn.glTexStorage3DFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 4u ||
+         (ver->major_version == 4u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glTexStorage3DFn = reinterpret_cast<glTexStorage3DProc>(
+        GetGLProcAddress("glTexStorage3D"));
+  } else {
+    fn.glTexStorage3DFn =
+        reinterpret_cast<glTexStorage3DProc>(glTexStorage3DNotBound);
+  }
+  DCHECK(fn.glTexStorage3DFn);
+
+  fn.glTransformFeedbackVaryingsFn = 0;
+  debug_fn.glTransformFeedbackVaryingsFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glTransformFeedbackVaryingsFn =
+        reinterpret_cast<glTransformFeedbackVaryingsProc>(
+            GetGLProcAddress("glTransformFeedbackVaryings"));
+  } else {
+    fn.glTransformFeedbackVaryingsFn =
+        reinterpret_cast<glTransformFeedbackVaryingsProc>(
+            glTransformFeedbackVaryingsNotBound);
+  }
+  DCHECK(fn.glTransformFeedbackVaryingsFn);
+
+  fn.glUniform1uiFn = 0;
+  debug_fn.glUniform1uiFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniform1uiFn =
+        reinterpret_cast<glUniform1uiProc>(GetGLProcAddress("glUniform1ui"));
+  } else {
+    fn.glUniform1uiFn =
+        reinterpret_cast<glUniform1uiProc>(glUniform1uiNotBound);
+  }
+  DCHECK(fn.glUniform1uiFn);
+
+  fn.glUniform1uivFn = 0;
+  debug_fn.glUniform1uivFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniform1uivFn =
+        reinterpret_cast<glUniform1uivProc>(GetGLProcAddress("glUniform1uiv"));
+  } else {
+    fn.glUniform1uivFn =
+        reinterpret_cast<glUniform1uivProc>(glUniform1uivNotBound);
+  }
+  DCHECK(fn.glUniform1uivFn);
+
+  fn.glUniform2uiFn = 0;
+  debug_fn.glUniform2uiFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniform2uiFn =
+        reinterpret_cast<glUniform2uiProc>(GetGLProcAddress("glUniform2ui"));
+  } else {
+    fn.glUniform2uiFn =
+        reinterpret_cast<glUniform2uiProc>(glUniform2uiNotBound);
+  }
+  DCHECK(fn.glUniform2uiFn);
+
+  fn.glUniform2uivFn = 0;
+  debug_fn.glUniform2uivFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniform2uivFn =
+        reinterpret_cast<glUniform2uivProc>(GetGLProcAddress("glUniform2uiv"));
+  } else {
+    fn.glUniform2uivFn =
+        reinterpret_cast<glUniform2uivProc>(glUniform2uivNotBound);
+  }
+  DCHECK(fn.glUniform2uivFn);
+
+  fn.glUniform3uiFn = 0;
+  debug_fn.glUniform3uiFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniform3uiFn =
+        reinterpret_cast<glUniform3uiProc>(GetGLProcAddress("glUniform3ui"));
+  } else {
+    fn.glUniform3uiFn =
+        reinterpret_cast<glUniform3uiProc>(glUniform3uiNotBound);
+  }
+  DCHECK(fn.glUniform3uiFn);
+
+  fn.glUniform3uivFn = 0;
+  debug_fn.glUniform3uivFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniform3uivFn =
+        reinterpret_cast<glUniform3uivProc>(GetGLProcAddress("glUniform3uiv"));
+  } else {
+    fn.glUniform3uivFn =
+        reinterpret_cast<glUniform3uivProc>(glUniform3uivNotBound);
+  }
+  DCHECK(fn.glUniform3uivFn);
+
+  fn.glUniform4uiFn = 0;
+  debug_fn.glUniform4uiFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniform4uiFn =
+        reinterpret_cast<glUniform4uiProc>(GetGLProcAddress("glUniform4ui"));
+  } else {
+    fn.glUniform4uiFn =
+        reinterpret_cast<glUniform4uiProc>(glUniform4uiNotBound);
+  }
+  DCHECK(fn.glUniform4uiFn);
+
+  fn.glUniform4uivFn = 0;
+  debug_fn.glUniform4uivFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniform4uivFn =
+        reinterpret_cast<glUniform4uivProc>(GetGLProcAddress("glUniform4uiv"));
+  } else {
+    fn.glUniform4uivFn =
+        reinterpret_cast<glUniform4uivProc>(glUniform4uivNotBound);
+  }
+  DCHECK(fn.glUniform4uivFn);
+
+  fn.glUniformBlockBindingFn = 0;
+  debug_fn.glUniformBlockBindingFn = 0;
+  if (((ver->is_es && (ver->major_version >= 3u)) ||
+       (!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 1u))))) {
+    fn.glUniformBlockBindingFn = reinterpret_cast<glUniformBlockBindingProc>(
+        GetGLProcAddress("glUniformBlockBinding"));
+  } else {
+    fn.glUniformBlockBindingFn = reinterpret_cast<glUniformBlockBindingProc>(
+        glUniformBlockBindingNotBound);
+  }
+  DCHECK(fn.glUniformBlockBindingFn);
+
+  fn.glUniformMatrix2x3fvFn = 0;
+  debug_fn.glUniformMatrix2x3fvFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniformMatrix2x3fvFn = reinterpret_cast<glUniformMatrix2x3fvProc>(
+        GetGLProcAddress("glUniformMatrix2x3fv"));
+  } else {
+    fn.glUniformMatrix2x3fvFn = reinterpret_cast<glUniformMatrix2x3fvProc>(
+        glUniformMatrix2x3fvNotBound);
+  }
+  DCHECK(fn.glUniformMatrix2x3fvFn);
+
+  fn.glUniformMatrix2x4fvFn = 0;
+  debug_fn.glUniformMatrix2x4fvFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniformMatrix2x4fvFn = reinterpret_cast<glUniformMatrix2x4fvProc>(
+        GetGLProcAddress("glUniformMatrix2x4fv"));
+  } else {
+    fn.glUniformMatrix2x4fvFn = reinterpret_cast<glUniformMatrix2x4fvProc>(
+        glUniformMatrix2x4fvNotBound);
+  }
+  DCHECK(fn.glUniformMatrix2x4fvFn);
+
+  fn.glUniformMatrix3x2fvFn = 0;
+  debug_fn.glUniformMatrix3x2fvFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniformMatrix3x2fvFn = reinterpret_cast<glUniformMatrix3x2fvProc>(
+        GetGLProcAddress("glUniformMatrix3x2fv"));
+  } else {
+    fn.glUniformMatrix3x2fvFn = reinterpret_cast<glUniformMatrix3x2fvProc>(
+        glUniformMatrix3x2fvNotBound);
+  }
+  DCHECK(fn.glUniformMatrix3x2fvFn);
+
+  fn.glUniformMatrix3x4fvFn = 0;
+  debug_fn.glUniformMatrix3x4fvFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniformMatrix3x4fvFn = reinterpret_cast<glUniformMatrix3x4fvProc>(
+        GetGLProcAddress("glUniformMatrix3x4fv"));
+  } else {
+    fn.glUniformMatrix3x4fvFn = reinterpret_cast<glUniformMatrix3x4fvProc>(
+        glUniformMatrix3x4fvNotBound);
+  }
+  DCHECK(fn.glUniformMatrix3x4fvFn);
+
+  fn.glUniformMatrix4x2fvFn = 0;
+  debug_fn.glUniformMatrix4x2fvFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniformMatrix4x2fvFn = reinterpret_cast<glUniformMatrix4x2fvProc>(
+        GetGLProcAddress("glUniformMatrix4x2fv"));
+  } else {
+    fn.glUniformMatrix4x2fvFn = reinterpret_cast<glUniformMatrix4x2fvProc>(
+        glUniformMatrix4x2fvNotBound);
+  }
+  DCHECK(fn.glUniformMatrix4x2fvFn);
+
+  fn.glUniformMatrix4x3fvFn = 0;
+  debug_fn.glUniformMatrix4x3fvFn = 0;
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUniformMatrix4x3fvFn = reinterpret_cast<glUniformMatrix4x3fvProc>(
+        GetGLProcAddress("glUniformMatrix4x3fv"));
+  } else {
+    fn.glUniformMatrix4x3fvFn = reinterpret_cast<glUniformMatrix4x3fvProc>(
+        glUniformMatrix4x3fvNotBound);
+  }
+  DCHECK(fn.glUniformMatrix4x3fvFn);
 
   fn.glUnmapBufferFn = 0;
   debug_fn.glUnmapBufferFn = 0;
-  if (ext.b_GL_OES_mapbuffer) {
+  if ((!ver->is_es || (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glUnmapBufferFn =
+        reinterpret_cast<glUnmapBufferProc>(GetGLProcAddress("glUnmapBuffer"));
+  } else if (ext.b_GL_OES_mapbuffer) {
     fn.glUnmapBufferFn = reinterpret_cast<glUnmapBufferProc>(
         GetGLProcAddress("glUnmapBufferOES"));
-  }
-  if (!fn.glUnmapBufferFn) {
+  } else {
     fn.glUnmapBufferFn =
-        reinterpret_cast<glUnmapBufferProc>(GetGLProcAddress("glUnmapBuffer"));
+        reinterpret_cast<glUnmapBufferProc>(glUnmapBufferNotBound);
   }
+  DCHECK(fn.glUnmapBufferFn);
 
   fn.glVertexAttribDivisorANGLEFn = 0;
   debug_fn.glVertexAttribDivisorANGLEFn = 0;
-  if (ext.b_GL_ARB_instanced_arrays) {
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 3u))) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glVertexAttribDivisorANGLEFn =
+        reinterpret_cast<glVertexAttribDivisorANGLEProc>(
+            GetGLProcAddress("glVertexAttribDivisor"));
+  } else if (ext.b_GL_ARB_instanced_arrays) {
     fn.glVertexAttribDivisorANGLEFn =
         reinterpret_cast<glVertexAttribDivisorANGLEProc>(
             GetGLProcAddress("glVertexAttribDivisorARB"));
-  }
-  if (!fn.glVertexAttribDivisorANGLEFn && (ext.b_GL_ANGLE_instanced_arrays)) {
+  } else if (ext.b_GL_ANGLE_instanced_arrays) {
     fn.glVertexAttribDivisorANGLEFn =
         reinterpret_cast<glVertexAttribDivisorANGLEProc>(
             GetGLProcAddress("glVertexAttribDivisorANGLE"));
-  }
-  if (!fn.glVertexAttribDivisorANGLEFn) {
+  } else {
     fn.glVertexAttribDivisorANGLEFn =
         reinterpret_cast<glVertexAttribDivisorANGLEProc>(
-            GetGLProcAddress("glVertexAttribDivisor"));
-  }
+            glVertexAttribDivisorANGLENotBound);
+  }
+  DCHECK(fn.glVertexAttribDivisorANGLEFn);
+
+  fn.glVertexAttribI4iFn = 0;
+  debug_fn.glVertexAttribI4iFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glVertexAttribI4iFn = reinterpret_cast<glVertexAttribI4iProc>(
+        GetGLProcAddress("glVertexAttribI4i"));
+  } else {
+    fn.glVertexAttribI4iFn =
+        reinterpret_cast<glVertexAttribI4iProc>(glVertexAttribI4iNotBound);
+  }
+  DCHECK(fn.glVertexAttribI4iFn);
+
+  fn.glVertexAttribI4ivFn = 0;
+  debug_fn.glVertexAttribI4ivFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glVertexAttribI4ivFn = reinterpret_cast<glVertexAttribI4ivProc>(
+        GetGLProcAddress("glVertexAttribI4iv"));
+  } else {
+    fn.glVertexAttribI4ivFn =
+        reinterpret_cast<glVertexAttribI4ivProc>(glVertexAttribI4ivNotBound);
+  }
+  DCHECK(fn.glVertexAttribI4ivFn);
+
+  fn.glVertexAttribI4uiFn = 0;
+  debug_fn.glVertexAttribI4uiFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glVertexAttribI4uiFn = reinterpret_cast<glVertexAttribI4uiProc>(
+        GetGLProcAddress("glVertexAttribI4ui"));
+  } else {
+    fn.glVertexAttribI4uiFn =
+        reinterpret_cast<glVertexAttribI4uiProc>(glVertexAttribI4uiNotBound);
+  }
+  DCHECK(fn.glVertexAttribI4uiFn);
+
+  fn.glVertexAttribI4uivFn = 0;
+  debug_fn.glVertexAttribI4uivFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glVertexAttribI4uivFn = reinterpret_cast<glVertexAttribI4uivProc>(
+        GetGLProcAddress("glVertexAttribI4uiv"));
+  } else {
+    fn.glVertexAttribI4uivFn =
+        reinterpret_cast<glVertexAttribI4uivProc>(glVertexAttribI4uivNotBound);
+  }
+  DCHECK(fn.glVertexAttribI4uivFn);
+
+  fn.glVertexAttribIPointerFn = 0;
+  debug_fn.glVertexAttribIPointerFn = 0;
+  if (((!ver->is_es && (ver->major_version >= 3u)) ||
+       (ver->is_es && (ver->major_version >= 3u)))) {
+    fn.glVertexAttribIPointerFn = reinterpret_cast<glVertexAttribIPointerProc>(
+        GetGLProcAddress("glVertexAttribIPointer"));
+  } else {
+    fn.glVertexAttribIPointerFn = reinterpret_cast<glVertexAttribIPointerProc>(
+        glVertexAttribIPointerNotBound);
+  }
+  DCHECK(fn.glVertexAttribIPointerFn);
+
+  fn.glWaitSyncFn = 0;
+  debug_fn.glWaitSyncFn = 0;
+  if (((!ver->is_es &&
+        (ver->major_version > 3u ||
+         (ver->major_version == 3u && ver->minor_version >= 2u))) ||
+       (ver->is_es && (ver->major_version >= 3u))) ||
+      ext.b_GL_ARB_sync) {
+    fn.glWaitSyncFn =
+        reinterpret_cast<glWaitSyncProc>(GetGLProcAddress("glWaitSync"));
+  } else {
+    fn.glWaitSyncFn = reinterpret_cast<glWaitSyncProc>(glWaitSyncNotBound);
+  }
+  DCHECK(fn.glWaitSyncFn);
 
   if (g_debugBindingsInitialized)
     InitializeDebugBindings();