gpu: Add calling convention for win32

I'm in the process of making a command buffer gles2 dll that can be consumed
by skia.  Skia, on windows 32, uses __stdcall for it's gl functions, so to
expose the gl interface to skia, we need to be using the same calling
convention.

Angle and GL both use __stdcall on win32.

Review URL: https://codereview.chromium.org/1260253003

Cr-Commit-Position: refs/heads/master@{#341953}

29 files changed, 1286 insertions, 977 deletions

diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index 8c84b1f..b53cb45 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -4741,7 +4741,7 @@ TEST_P(%(test_name)s, %(name)sInvalidArgs%(arg_index)d_%(value_index)d) {
       f.write("\n")
 
   def WriteGLES2CLibImplementation(self, func, f):
-    f.write("%s GLES2%s(%s) {\n" %
+    f.write("%s GL_APIENTRY GLES2%s(%s) {\n" %
                (func.return_type, func.name,
                 func.MakeTypedOriginalArgString("")))
     result_string = "return "
diff --git a/gpu/command_buffer/client/gles2_c_lib_autogen.h b/gpu/command_buffer/client/gles2_c_lib_autogen.h
index 09ed1ee..20a745a 100644
--- a/gpu/command_buffer/client/gles2_c_lib_autogen.h
+++ b/gpu/command_buffer/client/gles2_c_lib_autogen.h
@@ -12,1470 +12,1584 @@
 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_C_LIB_AUTOGEN_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_C_LIB_AUTOGEN_H_
 
-void GLES2ActiveTexture(GLenum texture) {
+void GL_APIENTRY GLES2ActiveTexture(GLenum texture) {
   gles2::GetGLContext()->ActiveTexture(texture);
 }
-void GLES2AttachShader(GLuint program, GLuint shader) {
+void GL_APIENTRY GLES2AttachShader(GLuint program, GLuint shader) {
   gles2::GetGLContext()->AttachShader(program, shader);
 }
-void GLES2BindAttribLocation(GLuint program, GLuint index, const char* name) {
+void GL_APIENTRY GLES2BindAttribLocation(GLuint program,
+                                         GLuint index,
+                                         const char* name) {
   gles2::GetGLContext()->BindAttribLocation(program, index, name);
 }
-void GLES2BindBuffer(GLenum target, GLuint buffer) {
+void GL_APIENTRY GLES2BindBuffer(GLenum target, GLuint buffer) {
   gles2::GetGLContext()->BindBuffer(target, buffer);
 }
-void GLES2BindBufferBase(GLenum target, GLuint index, GLuint buffer) {
+void GL_APIENTRY GLES2BindBufferBase(GLenum target,
+                                     GLuint index,
+                                     GLuint buffer) {
   gles2::GetGLContext()->BindBufferBase(target, index, buffer);
 }
-void GLES2BindBufferRange(GLenum target,
-                          GLuint index,
-                          GLuint buffer,
-                          GLintptr offset,
-                          GLsizeiptr size) {
+void GL_APIENTRY GLES2BindBufferRange(GLenum target,
+                                      GLuint index,
+                                      GLuint buffer,
+                                      GLintptr offset,
+                                      GLsizeiptr size) {
   gles2::GetGLContext()->BindBufferRange(target, index, buffer, offset, size);
 }
-void GLES2BindFramebuffer(GLenum target, GLuint framebuffer) {
+void GL_APIENTRY GLES2BindFramebuffer(GLenum target, GLuint framebuffer) {
   gles2::GetGLContext()->BindFramebuffer(target, framebuffer);
 }
-void GLES2BindRenderbuffer(GLenum target, GLuint renderbuffer) {
+void GL_APIENTRY GLES2BindRenderbuffer(GLenum target, GLuint renderbuffer) {
   gles2::GetGLContext()->BindRenderbuffer(target, renderbuffer);
 }
-void GLES2BindSampler(GLuint unit, GLuint sampler) {
+void GL_APIENTRY GLES2BindSampler(GLuint unit, GLuint sampler) {
   gles2::GetGLContext()->BindSampler(unit, sampler);
 }
-void GLES2BindTexture(GLenum target, GLuint texture) {
+void GL_APIENTRY GLES2BindTexture(GLenum target, GLuint texture) {
   gles2::GetGLContext()->BindTexture(target, texture);
 }
-void GLES2BindTransformFeedback(GLenum target, GLuint transformfeedback) {
+void GL_APIENTRY GLES2BindTransformFeedback(GLenum target,
+                                            GLuint transformfeedback) {
   gles2::GetGLContext()->BindTransformFeedback(target, transformfeedback);
 }
-void GLES2BlendColor(GLclampf red,
-                     GLclampf green,
-                     GLclampf blue,
-                     GLclampf alpha) {
+void GL_APIENTRY GLES2BlendColor(GLclampf red,
+                                 GLclampf green,
+                                 GLclampf blue,
+                                 GLclampf alpha) {
   gles2::GetGLContext()->BlendColor(red, green, blue, alpha);
 }
-void GLES2BlendEquation(GLenum mode) {
+void GL_APIENTRY GLES2BlendEquation(GLenum mode) {
   gles2::GetGLContext()->BlendEquation(mode);
 }
-void GLES2BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
+void GL_APIENTRY GLES2BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
   gles2::GetGLContext()->BlendEquationSeparate(modeRGB, modeAlpha);
 }
-void GLES2BlendFunc(GLenum sfactor, GLenum dfactor) {
+void GL_APIENTRY GLES2BlendFunc(GLenum sfactor, GLenum dfactor) {
   gles2::GetGLContext()->BlendFunc(sfactor, dfactor);
 }
-void GLES2BlendFuncSeparate(GLenum srcRGB,
-                            GLenum dstRGB,
-                            GLenum srcAlpha,
-                            GLenum dstAlpha) {
+void GL_APIENTRY GLES2BlendFuncSeparate(GLenum srcRGB,
+                                        GLenum dstRGB,
+                                        GLenum srcAlpha,
+                                        GLenum dstAlpha) {
   gles2::GetGLContext()->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
-void GLES2BufferData(GLenum target,
-                     GLsizeiptr size,
-                     const void* data,
-                     GLenum usage) {
+void GL_APIENTRY GLES2BufferData(GLenum target,
+                                 GLsizeiptr size,
+                                 const void* data,
+                                 GLenum usage) {
   gles2::GetGLContext()->BufferData(target, size, data, usage);
 }
-void GLES2BufferSubData(GLenum target,
-                        GLintptr offset,
-                        GLsizeiptr size,
-                        const void* data) {
+void GL_APIENTRY GLES2BufferSubData(GLenum target,
+                                    GLintptr offset,
+                                    GLsizeiptr size,
+                                    const void* data) {
   gles2::GetGLContext()->BufferSubData(target, offset, size, data);
 }
-GLenum GLES2CheckFramebufferStatus(GLenum target) {
+GLenum GL_APIENTRY GLES2CheckFramebufferStatus(GLenum target) {
   return gles2::GetGLContext()->CheckFramebufferStatus(target);
 }
-void GLES2Clear(GLbitfield mask) {
+void GL_APIENTRY GLES2Clear(GLbitfield mask) {
   gles2::GetGLContext()->Clear(mask);
 }
-void GLES2ClearBufferfi(GLenum buffer,
-                        GLint drawbuffers,
-                        GLfloat depth,
-                        GLint stencil) {
+void GL_APIENTRY GLES2ClearBufferfi(GLenum buffer,
+                                    GLint drawbuffers,
+                                    GLfloat depth,
+                                    GLint stencil) {
   gles2::GetGLContext()->ClearBufferfi(buffer, drawbuffers, depth, stencil);
 }
-void GLES2ClearBufferfv(GLenum buffer,
-                        GLint drawbuffers,
-                        const GLfloat* value) {
+void GL_APIENTRY GLES2ClearBufferfv(GLenum buffer,
+                                    GLint drawbuffers,
+                                    const GLfloat* value) {
   gles2::GetGLContext()->ClearBufferfv(buffer, drawbuffers, value);
 }
-void GLES2ClearBufferiv(GLenum buffer, GLint drawbuffers, const GLint* value) {
+void GL_APIENTRY GLES2ClearBufferiv(GLenum buffer,
+                                    GLint drawbuffers,
+                                    const GLint* value) {
   gles2::GetGLContext()->ClearBufferiv(buffer, drawbuffers, value);
 }
-void GLES2ClearBufferuiv(GLenum buffer,
-                         GLint drawbuffers,
-                         const GLuint* value) {
+void GL_APIENTRY GLES2ClearBufferuiv(GLenum buffer,
+                                     GLint drawbuffers,
+                                     const GLuint* value) {
   gles2::GetGLContext()->ClearBufferuiv(buffer, drawbuffers, value);
 }
-void GLES2ClearColor(GLclampf red,
-                     GLclampf green,
-                     GLclampf blue,
-                     GLclampf alpha) {
+void GL_APIENTRY GLES2ClearColor(GLclampf red,
+                                 GLclampf green,
+                                 GLclampf blue,
+                                 GLclampf alpha) {
   gles2::GetGLContext()->ClearColor(red, green, blue, alpha);
 }
-void GLES2ClearDepthf(GLclampf depth) {
+void GL_APIENTRY GLES2ClearDepthf(GLclampf depth) {
   gles2::GetGLContext()->ClearDepthf(depth);
 }
-void GLES2ClearStencil(GLint s) {
+void GL_APIENTRY GLES2ClearStencil(GLint s) {
   gles2::GetGLContext()->ClearStencil(s);
 }
-GLenum GLES2ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
+GLenum GL_APIENTRY GLES2ClientWaitSync(GLsync sync,
+                                       GLbitfield flags,
+                                       GLuint64 timeout) {
   return gles2::GetGLContext()->ClientWaitSync(sync, flags, timeout);
 }
-void GLES2ColorMask(GLboolean red,
-                    GLboolean green,
-                    GLboolean blue,
-                    GLboolean alpha) {
+void GL_APIENTRY GLES2ColorMask(GLboolean red,
+                                GLboolean green,
+                                GLboolean blue,
+                                GLboolean alpha) {
   gles2::GetGLContext()->ColorMask(red, green, blue, alpha);
 }
-void GLES2CompileShader(GLuint shader) {
+void GL_APIENTRY GLES2CompileShader(GLuint shader) {
   gles2::GetGLContext()->CompileShader(shader);
 }
-void GLES2CompressedTexImage2D(GLenum target,
-                               GLint level,
-                               GLenum internalformat,
-                               GLsizei width,
-                               GLsizei height,
-                               GLint border,
-                               GLsizei imageSize,
-                               const void* data) {
+void GL_APIENTRY GLES2CompressedTexImage2D(GLenum target,
+                                           GLint level,
+                                           GLenum internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLint border,
+                                           GLsizei imageSize,
+                                           const void* data) {
   gles2::GetGLContext()->CompressedTexImage2D(
       target, level, internalformat, width, height, border, imageSize, data);
 }
-void GLES2CompressedTexSubImage2D(GLenum target,
-                                  GLint level,
-                                  GLint xoffset,
-                                  GLint yoffset,
-                                  GLsizei width,
-                                  GLsizei height,
-                                  GLenum format,
-                                  GLsizei imageSize,
-                                  const void* data) {
+void GL_APIENTRY GLES2CompressedTexSubImage2D(GLenum target,
+                                              GLint level,
+                                              GLint xoffset,
+                                              GLint yoffset,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLenum format,
+                                              GLsizei imageSize,
+                                              const void* data) {
   gles2::GetGLContext()->CompressedTexSubImage2D(
       target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
-void GLES2CompressedTexImage3D(GLenum target,
-                               GLint level,
-                               GLenum internalformat,
-                               GLsizei width,
-                               GLsizei height,
-                               GLsizei depth,
-                               GLint border,
-                               GLsizei imageSize,
-                               const void* data) {
+void GL_APIENTRY GLES2CompressedTexImage3D(GLenum target,
+                                           GLint level,
+                                           GLenum internalformat,
+                                           GLsizei width,
+                                           GLsizei height,
+                                           GLsizei depth,
+                                           GLint border,
+                                           GLsizei imageSize,
+                                           const void* data) {
   gles2::GetGLContext()->CompressedTexImage3D(target, level, internalformat,
                                               width, height, depth, border,
                                               imageSize, data);
 }
-void GLES2CompressedTexSubImage3D(GLenum target,
-                                  GLint level,
-                                  GLint xoffset,
-                                  GLint yoffset,
-                                  GLint zoffset,
-                                  GLsizei width,
-                                  GLsizei height,
-                                  GLsizei depth,
-                                  GLenum format,
-                                  GLsizei imageSize,
-                                  const void* data) {
+void GL_APIENTRY GLES2CompressedTexSubImage3D(GLenum target,
+                                              GLint level,
+                                              GLint xoffset,
+                                              GLint yoffset,
+                                              GLint zoffset,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLsizei depth,
+                                              GLenum format,
+                                              GLsizei imageSize,
+                                              const void* data) {
   gles2::GetGLContext()->CompressedTexSubImage3D(
       target, level, xoffset, yoffset, zoffset, width, height, depth, format,
       imageSize, data);
 }
-void GLES2CopyBufferSubData(GLenum readtarget,
-                            GLenum writetarget,
-                            GLintptr readoffset,
-                            GLintptr writeoffset,
-                            GLsizeiptr size) {
+void GL_APIENTRY GLES2CopyBufferSubData(GLenum readtarget,
+                                        GLenum writetarget,
+                                        GLintptr readoffset,
+                                        GLintptr writeoffset,
+                                        GLsizeiptr size) {
   gles2::GetGLContext()->CopyBufferSubData(readtarget, writetarget, readoffset,
                                            writeoffset, size);
 }
-void GLES2CopyTexImage2D(GLenum target,
-                         GLint level,
-                         GLenum internalformat,
-                         GLint x,
-                         GLint y,
-                         GLsizei width,
-                         GLsizei height,
-                         GLint border) {
+void GL_APIENTRY GLES2CopyTexImage2D(GLenum target,
+                                     GLint level,
+                                     GLenum internalformat,
+                                     GLint x,
+                                     GLint y,
+                                     GLsizei width,
+                                     GLsizei height,
+                                     GLint border) {
   gles2::GetGLContext()->CopyTexImage2D(target, level, internalformat, x, y,
                                         width, height, border);
 }
-void GLES2CopyTexSubImage2D(GLenum target,
-                            GLint level,
-                            GLint xoffset,
-                            GLint yoffset,
-                            GLint x,
-                            GLint y,
-                            GLsizei width,
-                            GLsizei height) {
+void GL_APIENTRY GLES2CopyTexSubImage2D(GLenum target,
+                                        GLint level,
+                                        GLint xoffset,
+                                        GLint yoffset,
+                                        GLint x,
+                                        GLint y,
+                                        GLsizei width,
+                                        GLsizei height) {
   gles2::GetGLContext()->CopyTexSubImage2D(target, level, xoffset, yoffset, x,
                                            y, width, height);
 }
-void GLES2CopyTexSubImage3D(GLenum target,
-                            GLint level,
-                            GLint xoffset,
-                            GLint yoffset,
-                            GLint zoffset,
-                            GLint x,
-                            GLint y,
-                            GLsizei width,
-                            GLsizei height) {
+void GL_APIENTRY GLES2CopyTexSubImage3D(GLenum target,
+                                        GLint level,
+                                        GLint xoffset,
+                                        GLint yoffset,
+                                        GLint zoffset,
+                                        GLint x,
+                                        GLint y,
+                                        GLsizei width,
+                                        GLsizei height) {
   gles2::GetGLContext()->CopyTexSubImage3D(target, level, xoffset, yoffset,
                                            zoffset, x, y, width, height);
 }
-GLuint GLES2CreateProgram() {
+GLuint GL_APIENTRY GLES2CreateProgram() {
   return gles2::GetGLContext()->CreateProgram();
 }
-GLuint GLES2CreateShader(GLenum type) {
+GLuint GL_APIENTRY GLES2CreateShader(GLenum type) {
   return gles2::GetGLContext()->CreateShader(type);
 }
-void GLES2CullFace(GLenum mode) {
+void GL_APIENTRY GLES2CullFace(GLenum mode) {
   gles2::GetGLContext()->CullFace(mode);
 }
-void GLES2DeleteBuffers(GLsizei n, const GLuint* buffers) {
+void GL_APIENTRY GLES2DeleteBuffers(GLsizei n, const GLuint* buffers) {
   gles2::GetGLContext()->DeleteBuffers(n, buffers);
 }
-void GLES2DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
+void GL_APIENTRY GLES2DeleteFramebuffers(GLsizei n,
+                                         const GLuint* framebuffers) {
   gles2::GetGLContext()->DeleteFramebuffers(n, framebuffers);
 }
-void GLES2DeleteProgram(GLuint program) {
+void GL_APIENTRY GLES2DeleteProgram(GLuint program) {
   gles2::GetGLContext()->DeleteProgram(program);
 }
-void GLES2DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
+void GL_APIENTRY GLES2DeleteRenderbuffers(GLsizei n,
+                                          const GLuint* renderbuffers) {
   gles2::GetGLContext()->DeleteRenderbuffers(n, renderbuffers);
 }
-void GLES2DeleteSamplers(GLsizei n, const GLuint* samplers) {
+void GL_APIENTRY GLES2DeleteSamplers(GLsizei n, const GLuint* samplers) {
   gles2::GetGLContext()->DeleteSamplers(n, samplers);
 }
-void GLES2DeleteSync(GLsync sync) {
+void GL_APIENTRY GLES2DeleteSync(GLsync sync) {
   gles2::GetGLContext()->DeleteSync(sync);
 }
-void GLES2DeleteShader(GLuint shader) {
+void GL_APIENTRY GLES2DeleteShader(GLuint shader) {
   gles2::GetGLContext()->DeleteShader(shader);
 }
-void GLES2DeleteTextures(GLsizei n, const GLuint* textures) {
+void GL_APIENTRY GLES2DeleteTextures(GLsizei n, const GLuint* textures) {
   gles2::GetGLContext()->DeleteTextures(n, textures);
 }
-void GLES2DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
+void GL_APIENTRY GLES2DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
   gles2::GetGLContext()->DeleteTransformFeedbacks(n, ids);
 }
-void GLES2DepthFunc(GLenum func) {
+void GL_APIENTRY GLES2DepthFunc(GLenum func) {
   gles2::GetGLContext()->DepthFunc(func);
 }
-void GLES2DepthMask(GLboolean flag) {
+void GL_APIENTRY GLES2DepthMask(GLboolean flag) {
   gles2::GetGLContext()->DepthMask(flag);
 }
-void GLES2DepthRangef(GLclampf zNear, GLclampf zFar) {
+void GL_APIENTRY GLES2DepthRangef(GLclampf zNear, GLclampf zFar) {
   gles2::GetGLContext()->DepthRangef(zNear, zFar);
 }
-void GLES2DetachShader(GLuint program, GLuint shader) {
+void GL_APIENTRY GLES2DetachShader(GLuint program, GLuint shader) {
   gles2::GetGLContext()->DetachShader(program, shader);
 }
-void GLES2Disable(GLenum cap) {
+void GL_APIENTRY GLES2Disable(GLenum cap) {
   gles2::GetGLContext()->Disable(cap);
 }
-void GLES2DisableVertexAttribArray(GLuint index) {
+void GL_APIENTRY GLES2DisableVertexAttribArray(GLuint index) {
   gles2::GetGLContext()->DisableVertexAttribArray(index);
 }
-void GLES2DrawArrays(GLenum mode, GLint first, GLsizei count) {
+void GL_APIENTRY GLES2DrawArrays(GLenum mode, GLint first, GLsizei count) {
   gles2::GetGLContext()->DrawArrays(mode, first, count);
 }
-void GLES2DrawElements(GLenum mode,
-                       GLsizei count,
-                       GLenum type,
-                       const void* indices) {
+void GL_APIENTRY GLES2DrawElements(GLenum mode,
+                                   GLsizei count,
+                                   GLenum type,
+                                   const void* indices) {
   gles2::GetGLContext()->DrawElements(mode, count, type, indices);
 }
-void GLES2DrawRangeElements(GLenum mode,
-                            GLuint start,
-                            GLuint end,
-                            GLsizei count,
-                            GLenum type,
-                            const void* indices) {
+void GL_APIENTRY GLES2DrawRangeElements(GLenum mode,
+                                        GLuint start,
+                                        GLuint end,
+                                        GLsizei count,
+                                        GLenum type,
+                                        const void* indices) {
   gles2::GetGLContext()->DrawRangeElements(mode, start, end, count, type,
                                            indices);
 }
-void GLES2Enable(GLenum cap) {
+void GL_APIENTRY GLES2Enable(GLenum cap) {
   gles2::GetGLContext()->Enable(cap);
 }
-void GLES2EnableVertexAttribArray(GLuint index) {
+void GL_APIENTRY GLES2EnableVertexAttribArray(GLuint index) {
   gles2::GetGLContext()->EnableVertexAttribArray(index);
 }
-GLsync GLES2FenceSync(GLenum condition, GLbitfield flags) {
+GLsync GL_APIENTRY GLES2FenceSync(GLenum condition, GLbitfield flags) {
   return gles2::GetGLContext()->FenceSync(condition, flags);
 }
-void GLES2Finish() {
+void GL_APIENTRY GLES2Finish() {
   gles2::GetGLContext()->Finish();
 }
-void GLES2Flush() {
+void GL_APIENTRY GLES2Flush() {
   gles2::GetGLContext()->Flush();
 }
-void GLES2FramebufferRenderbuffer(GLenum target,
-                                  GLenum attachment,
-                                  GLenum renderbuffertarget,
-                                  GLuint renderbuffer) {
+void GL_APIENTRY GLES2FramebufferRenderbuffer(GLenum target,
+                                              GLenum attachment,
+                                              GLenum renderbuffertarget,
+                                              GLuint renderbuffer) {
   gles2::GetGLContext()->FramebufferRenderbuffer(
       target, attachment, renderbuffertarget, renderbuffer);
 }
-void GLES2FramebufferTexture2D(GLenum target,
-                               GLenum attachment,
-                               GLenum textarget,
-                               GLuint texture,
-                               GLint level) {
+void GL_APIENTRY GLES2FramebufferTexture2D(GLenum target,
+                                           GLenum attachment,
+                                           GLenum textarget,
+                                           GLuint texture,
+                                           GLint level) {
   gles2::GetGLContext()->FramebufferTexture2D(target, attachment, textarget,
                                               texture, level);
 }
-void GLES2FramebufferTextureLayer(GLenum target,
-                                  GLenum attachment,
-                                  GLuint texture,
-                                  GLint level,
-                                  GLint layer) {
+void GL_APIENTRY GLES2FramebufferTextureLayer(GLenum target,
+                                              GLenum attachment,
+                                              GLuint texture,
+                                              GLint level,
+                                              GLint layer) {
   gles2::GetGLContext()->FramebufferTextureLayer(target, attachment, texture,
                                                  level, layer);
 }
-void GLES2FrontFace(GLenum mode) {
+void GL_APIENTRY GLES2FrontFace(GLenum mode) {
   gles2::GetGLContext()->FrontFace(mode);
 }
-void GLES2GenBuffers(GLsizei n, GLuint* buffers) {
+void GL_APIENTRY GLES2GenBuffers(GLsizei n, GLuint* buffers) {
   gles2::GetGLContext()->GenBuffers(n, buffers);
 }
-void GLES2GenerateMipmap(GLenum target) {
+void GL_APIENTRY GLES2GenerateMipmap(GLenum target) {
   gles2::GetGLContext()->GenerateMipmap(target);
 }
-void GLES2GenFramebuffers(GLsizei n, GLuint* framebuffers) {
+void GL_APIENTRY GLES2GenFramebuffers(GLsizei n, GLuint* framebuffers) {
   gles2::GetGLContext()->GenFramebuffers(n, framebuffers);
 }
-void GLES2GenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
+void GL_APIENTRY GLES2GenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
   gles2::GetGLContext()->GenRenderbuffers(n, renderbuffers);
 }
-void GLES2GenSamplers(GLsizei n, GLuint* samplers) {
+void GL_APIENTRY GLES2GenSamplers(GLsizei n, GLuint* samplers) {
   gles2::GetGLContext()->GenSamplers(n, samplers);
 }
-void GLES2GenTextures(GLsizei n, GLuint* textures) {
+void GL_APIENTRY GLES2GenTextures(GLsizei n, GLuint* textures) {
   gles2::GetGLContext()->GenTextures(n, textures);
 }
-void GLES2GenTransformFeedbacks(GLsizei n, GLuint* ids) {
+void GL_APIENTRY GLES2GenTransformFeedbacks(GLsizei n, GLuint* ids) {
   gles2::GetGLContext()->GenTransformFeedbacks(n, ids);
 }
-void GLES2GetActiveAttrib(GLuint program,
-                          GLuint index,
-                          GLsizei bufsize,
-                          GLsizei* length,
-                          GLint* size,
-                          GLenum* type,
-                          char* name) {
+void GL_APIENTRY GLES2GetActiveAttrib(GLuint program,
+                                      GLuint index,
+                                      GLsizei bufsize,
+                                      GLsizei* length,
+                                      GLint* size,
+                                      GLenum* type,
+                                      char* name) {
   gles2::GetGLContext()->GetActiveAttrib(program, index, bufsize, length, size,
                                          type, name);
 }
-void GLES2GetActiveUniform(GLuint program,
-                           GLuint index,
-                           GLsizei bufsize,
-                           GLsizei* length,
-                           GLint* size,
-                           GLenum* type,
-                           char* name) {
+void GL_APIENTRY GLES2GetActiveUniform(GLuint program,
+                                       GLuint index,
+                                       GLsizei bufsize,
+                                       GLsizei* length,
+                                       GLint* size,
+                                       GLenum* type,
+                                       char* name) {
   gles2::GetGLContext()->GetActiveUniform(program, index, bufsize, length, size,
                                           type, name);
 }
-void GLES2GetActiveUniformBlockiv(GLuint program,
-                                  GLuint index,
-                                  GLenum pname,
-                                  GLint* params) {
+void GL_APIENTRY GLES2GetActiveUniformBlockiv(GLuint program,
+                                              GLuint index,
+                                              GLenum pname,
+                                              GLint* params) {
   gles2::GetGLContext()->GetActiveUniformBlockiv(program, index, pname, params);
 }
-void GLES2GetActiveUniformBlockName(GLuint program,
-                                    GLuint index,
-                                    GLsizei bufsize,
-                                    GLsizei* length,
-                                    char* name) {
+void GL_APIENTRY GLES2GetActiveUniformBlockName(GLuint program,
+                                                GLuint index,
+                                                GLsizei bufsize,
+                                                GLsizei* length,
+                                                char* name) {
   gles2::GetGLContext()->GetActiveUniformBlockName(program, index, bufsize,
                                                    length, name);
 }
-void GLES2GetActiveUniformsiv(GLuint program,
-                              GLsizei count,
-                              const GLuint* indices,
-                              GLenum pname,
-                              GLint* params) {
+void GL_APIENTRY GLES2GetActiveUniformsiv(GLuint program,
+                                          GLsizei count,
+                                          const GLuint* indices,
+                                          GLenum pname,
+                                          GLint* params) {
   gles2::GetGLContext()->GetActiveUniformsiv(program, count, indices, pname,
                                              params);
 }
-void GLES2GetAttachedShaders(GLuint program,
-                             GLsizei maxcount,
-                             GLsizei* count,
-                             GLuint* shaders) {
+void GL_APIENTRY GLES2GetAttachedShaders(GLuint program,
+                                         GLsizei maxcount,
+                                         GLsizei* count,
+                                         GLuint* shaders) {
   gles2::GetGLContext()->GetAttachedShaders(program, maxcount, count, shaders);
 }
-GLint GLES2GetAttribLocation(GLuint program, const char* name) {
+GLint GL_APIENTRY GLES2GetAttribLocation(GLuint program, const char* name) {
   return gles2::GetGLContext()->GetAttribLocation(program, name);
 }
-void GLES2GetBooleanv(GLenum pname, GLboolean* params) {
+void GL_APIENTRY GLES2GetBooleanv(GLenum pname, GLboolean* params) {
   gles2::GetGLContext()->GetBooleanv(pname, params);
 }
-void GLES2GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) {
+void GL_APIENTRY GLES2GetBufferParameteri64v(GLenum target,
+                                             GLenum pname,
+                                             GLint64* params) {
   gles2::GetGLContext()->GetBufferParameteri64v(target, pname, params);
 }
-void GLES2GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
+void GL_APIENTRY GLES2GetBufferParameteriv(GLenum target,
+                                           GLenum pname,
+                                           GLint* params) {
   gles2::GetGLContext()->GetBufferParameteriv(target, pname, params);
 }
-GLenum GLES2GetError() {
+GLenum GL_APIENTRY GLES2GetError() {
   return gles2::GetGLContext()->GetError();
 }
-void GLES2GetFloatv(GLenum pname, GLfloat* params) {
+void GL_APIENTRY GLES2GetFloatv(GLenum pname, GLfloat* params) {
   gles2::GetGLContext()->GetFloatv(pname, params);
 }
-GLint GLES2GetFragDataLocation(GLuint program, const char* name) {
+GLint GL_APIENTRY GLES2GetFragDataLocation(GLuint program, const char* name) {
   return gles2::GetGLContext()->GetFragDataLocation(program, name);
 }
-void GLES2GetFramebufferAttachmentParameteriv(GLenum target,
-                                              GLenum attachment,
-                                              GLenum pname,
-                                              GLint* params) {
+void GL_APIENTRY GLES2GetFramebufferAttachmentParameteriv(GLenum target,
+                                                          GLenum attachment,
+                                                          GLenum pname,
+                                                          GLint* params) {
   gles2::GetGLContext()->GetFramebufferAttachmentParameteriv(target, attachment,
                                                              pname, params);
 }
-void GLES2GetInteger64v(GLenum pname, GLint64* params) {
+void GL_APIENTRY GLES2GetInteger64v(GLenum pname, GLint64* params) {
   gles2::GetGLContext()->GetInteger64v(pname, params);
 }
-void GLES2GetIntegeri_v(GLenum pname, GLuint index, GLint* data) {
+void GL_APIENTRY GLES2GetIntegeri_v(GLenum pname, GLuint index, GLint* data) {
   gles2::GetGLContext()->GetIntegeri_v(pname, index, data);
 }
-void GLES2GetInteger64i_v(GLenum pname, GLuint index, GLint64* data) {
+void GL_APIENTRY GLES2GetInteger64i_v(GLenum pname,
+                                      GLuint index,
+                                      GLint64* data) {
   gles2::GetGLContext()->GetInteger64i_v(pname, index, data);
 }
-void GLES2GetIntegerv(GLenum pname, GLint* params) {
+void GL_APIENTRY GLES2GetIntegerv(GLenum pname, GLint* params) {
   gles2::GetGLContext()->GetIntegerv(pname, params);
 }
-void GLES2GetInternalformativ(GLenum target,
-                              GLenum format,
-                              GLenum pname,
-                              GLsizei bufSize,
-                              GLint* params) {
+void GL_APIENTRY GLES2GetInternalformativ(GLenum target,
+                                          GLenum format,
+                                          GLenum pname,
+                                          GLsizei bufSize,
+                                          GLint* params) {
   gles2::GetGLContext()->GetInternalformativ(target, format, pname, bufSize,
                                              params);
 }
-void GLES2GetProgramiv(GLuint program, GLenum pname, GLint* params) {
+void GL_APIENTRY GLES2GetProgramiv(GLuint program,
+                                   GLenum pname,
+                                   GLint* params) {
   gles2::GetGLContext()->GetProgramiv(program, pname, params);
 }
-void GLES2GetProgramInfoLog(GLuint program,
-                            GLsizei bufsize,
-                            GLsizei* length,
-                            char* infolog) {
+void GL_APIENTRY GLES2GetProgramInfoLog(GLuint program,
+                                        GLsizei bufsize,
+                                        GLsizei* length,
+                                        char* infolog) {
   gles2::GetGLContext()->GetProgramInfoLog(program, bufsize, length, infolog);
 }
-void GLES2GetRenderbufferParameteriv(GLenum target,
-                                     GLenum pname,
-                                     GLint* params) {
+void GL_APIENTRY GLES2GetRenderbufferParameteriv(GLenum target,
+                                                 GLenum pname,
+                                                 GLint* params) {
   gles2::GetGLContext()->GetRenderbufferParameteriv(target, pname, params);
 }
-void GLES2GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) {
+void GL_APIENTRY GLES2GetSamplerParameterfv(GLuint sampler,
+                                            GLenum pname,
+                                            GLfloat* params) {
   gles2::GetGLContext()->GetSamplerParameterfv(sampler, pname, params);
 }
-void GLES2GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) {
+void GL_APIENTRY GLES2GetSamplerParameteriv(GLuint sampler,
+                                            GLenum pname,
+                                            GLint* params) {
   gles2::GetGLContext()->GetSamplerParameteriv(sampler, pname, params);
 }
-void GLES2GetShaderiv(GLuint shader, GLenum pname, GLint* params) {
+void GL_APIENTRY GLES2GetShaderiv(GLuint shader, GLenum pname, GLint* params) {
   gles2::GetGLContext()->GetShaderiv(shader, pname, params);
 }
-void GLES2GetShaderInfoLog(GLuint shader,
-                           GLsizei bufsize,
-                           GLsizei* length,
-                           char* infolog) {
+void GL_APIENTRY GLES2GetShaderInfoLog(GLuint shader,
+                                       GLsizei bufsize,
+                                       GLsizei* length,
+                                       char* infolog) {
   gles2::GetGLContext()->GetShaderInfoLog(shader, bufsize, length, infolog);
 }
-void GLES2GetShaderPrecisionFormat(GLenum shadertype,
-                                   GLenum precisiontype,
-                                   GLint* range,
-                                   GLint* precision) {
+void GL_APIENTRY GLES2GetShaderPrecisionFormat(GLenum shadertype,
+                                               GLenum precisiontype,
+                                               GLint* range,
+                                               GLint* precision) {
   gles2::GetGLContext()->GetShaderPrecisionFormat(shadertype, precisiontype,
                                                   range, precision);
 }
-void GLES2GetShaderSource(GLuint shader,
-                          GLsizei bufsize,
-                          GLsizei* length,
-                          char* source) {
+void GL_APIENTRY GLES2GetShaderSource(GLuint shader,
+                                      GLsizei bufsize,
+                                      GLsizei* length,
+                                      char* source) {
   gles2::GetGLContext()->GetShaderSource(shader, bufsize, length, source);
 }
-const GLubyte* GLES2GetString(GLenum name) {
+const GLubyte* GL_APIENTRY GLES2GetString(GLenum name) {
   return gles2::GetGLContext()->GetString(name);
 }
-void GLES2GetSynciv(GLsync sync,
-                    GLenum pname,
-                    GLsizei bufsize,
-                    GLsizei* length,
-                    GLint* values) {
+void GL_APIENTRY GLES2GetSynciv(GLsync sync,
+                                GLenum pname,
+                                GLsizei bufsize,
+                                GLsizei* length,
+                                GLint* values) {
   gles2::GetGLContext()->GetSynciv(sync, pname, bufsize, length, values);
 }
-void GLES2GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
+void GL_APIENTRY GLES2GetTexParameterfv(GLenum target,
+                                        GLenum pname,
+                                        GLfloat* params) {
   gles2::GetGLContext()->GetTexParameterfv(target, pname, params);
 }
-void GLES2GetTexParameteriv(GLenum target, GLenum pname, GLint* params) {
+void GL_APIENTRY GLES2GetTexParameteriv(GLenum target,
+                                        GLenum pname,
+                                        GLint* params) {
   gles2::GetGLContext()->GetTexParameteriv(target, pname, params);
 }
-void GLES2GetTransformFeedbackVarying(GLuint program,
-                                      GLuint index,
-                                      GLsizei bufsize,
-                                      GLsizei* length,
-                                      GLsizei* size,
-                                      GLenum* type,
-                                      char* name) {
+void GL_APIENTRY GLES2GetTransformFeedbackVarying(GLuint program,
+                                                  GLuint index,
+                                                  GLsizei bufsize,
+                                                  GLsizei* length,
+                                                  GLsizei* size,
+                                                  GLenum* type,
+                                                  char* name) {
   gles2::GetGLContext()->GetTransformFeedbackVarying(program, index, bufsize,
                                                      length, size, type, name);
 }
-GLuint GLES2GetUniformBlockIndex(GLuint program, const char* name) {
+GLuint GL_APIENTRY GLES2GetUniformBlockIndex(GLuint program, const char* name) {
   return gles2::GetGLContext()->GetUniformBlockIndex(program, name);
 }
-void GLES2GetUniformfv(GLuint program, GLint location, GLfloat* params) {
+void GL_APIENTRY GLES2GetUniformfv(GLuint program,
+                                   GLint location,
+                                   GLfloat* params) {
   gles2::GetGLContext()->GetUniformfv(program, location, params);
 }
-void GLES2GetUniformiv(GLuint program, GLint location, GLint* params) {
+void GL_APIENTRY GLES2GetUniformiv(GLuint program,
+                                   GLint location,
+                                   GLint* params) {
   gles2::GetGLContext()->GetUniformiv(program, location, params);
 }
-void GLES2GetUniformuiv(GLuint program, GLint location, GLuint* params) {
+void GL_APIENTRY GLES2GetUniformuiv(GLuint program,
+                                    GLint location,
+                                    GLuint* params) {
   gles2::GetGLContext()->GetUniformuiv(program, location, params);
 }
-void GLES2GetUniformIndices(GLuint program,
-                            GLsizei count,
-                            const char* const* names,
-                            GLuint* indices) {
+void GL_APIENTRY GLES2GetUniformIndices(GLuint program,
+                                        GLsizei count,
+                                        const char* const* names,
+                                        GLuint* indices) {
   gles2::GetGLContext()->GetUniformIndices(program, count, names, indices);
 }
-GLint GLES2GetUniformLocation(GLuint program, const char* name) {
+GLint GL_APIENTRY GLES2GetUniformLocation(GLuint program, const char* name) {
   return gles2::GetGLContext()->GetUniformLocation(program, name);
 }
-void GLES2GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) {
+void GL_APIENTRY GLES2GetVertexAttribfv(GLuint index,
+                                        GLenum pname,
+                                        GLfloat* params) {
   gles2::GetGLContext()->GetVertexAttribfv(index, pname, params);
 }
-void GLES2GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) {
+void GL_APIENTRY GLES2GetVertexAttribiv(GLuint index,
+                                        GLenum pname,
+                                        GLint* params) {
   gles2::GetGLContext()->GetVertexAttribiv(index, pname, params);
 }
-void GLES2GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) {
+void GL_APIENTRY GLES2GetVertexAttribIiv(GLuint index,
+                                         GLenum pname,
+                                         GLint* params) {
   gles2::GetGLContext()->GetVertexAttribIiv(index, pname, params);
 }
-void GLES2GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) {
+void GL_APIENTRY GLES2GetVertexAttribIuiv(GLuint index,
+                                          GLenum pname,
+                                          GLuint* params) {
   gles2::GetGLContext()->GetVertexAttribIuiv(index, pname, params);
 }
-void GLES2GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) {
+void GL_APIENTRY GLES2GetVertexAttribPointerv(GLuint index,
+                                              GLenum pname,
+                                              void** pointer) {
   gles2::GetGLContext()->GetVertexAttribPointerv(index, pname, pointer);
 }
-void GLES2Hint(GLenum target, GLenum mode) {
+void GL_APIENTRY GLES2Hint(GLenum target, GLenum mode) {
   gles2::GetGLContext()->Hint(target, mode);
 }
-void GLES2InvalidateFramebuffer(GLenum target,
-                                GLsizei count,
-                                const GLenum* attachments) {
+void GL_APIENTRY GLES2InvalidateFramebuffer(GLenum target,
+                                            GLsizei count,
+                                            const GLenum* attachments) {
   gles2::GetGLContext()->InvalidateFramebuffer(target, count, attachments);
 }
-void GLES2InvalidateSubFramebuffer(GLenum target,
-                                   GLsizei count,
-                                   const GLenum* attachments,
-                                   GLint x,
-                                   GLint y,
-                                   GLsizei width,
-                                   GLsizei height) {
+void GL_APIENTRY GLES2InvalidateSubFramebuffer(GLenum target,
+                                               GLsizei count,
+                                               const GLenum* attachments,
+                                               GLint x,
+                                               GLint y,
+                                               GLsizei width,
+                                               GLsizei height) {
   gles2::GetGLContext()->InvalidateSubFramebuffer(target, count, attachments, x,
                                                   y, width, height);
 }
-GLboolean GLES2IsBuffer(GLuint buffer) {
+GLboolean GL_APIENTRY GLES2IsBuffer(GLuint buffer) {
   return gles2::GetGLContext()->IsBuffer(buffer);
 }
-GLboolean GLES2IsEnabled(GLenum cap) {
+GLboolean GL_APIENTRY GLES2IsEnabled(GLenum cap) {
   return gles2::GetGLContext()->IsEnabled(cap);
 }
-GLboolean GLES2IsFramebuffer(GLuint framebuffer) {
+GLboolean GL_APIENTRY GLES2IsFramebuffer(GLuint framebuffer) {
   return gles2::GetGLContext()->IsFramebuffer(framebuffer);
 }
-GLboolean GLES2IsProgram(GLuint program) {
+GLboolean GL_APIENTRY GLES2IsProgram(GLuint program) {
   return gles2::GetGLContext()->IsProgram(program);
 }
-GLboolean GLES2IsRenderbuffer(GLuint renderbuffer) {
+GLboolean GL_APIENTRY GLES2IsRenderbuffer(GLuint renderbuffer) {
   return gles2::GetGLContext()->IsRenderbuffer(renderbuffer);
 }
-GLboolean GLES2IsSampler(GLuint sampler) {
+GLboolean GL_APIENTRY GLES2IsSampler(GLuint sampler) {
   return gles2::GetGLContext()->IsSampler(sampler);
 }
-GLboolean GLES2IsShader(GLuint shader) {
+GLboolean GL_APIENTRY GLES2IsShader(GLuint shader) {
   return gles2::GetGLContext()->IsShader(shader);
 }
-GLboolean GLES2IsSync(GLsync sync) {
+GLboolean GL_APIENTRY GLES2IsSync(GLsync sync) {
   return gles2::GetGLContext()->IsSync(sync);
 }
-GLboolean GLES2IsTexture(GLuint texture) {
+GLboolean GL_APIENTRY GLES2IsTexture(GLuint texture) {
   return gles2::GetGLContext()->IsTexture(texture);
 }
-GLboolean GLES2IsTransformFeedback(GLuint transformfeedback) {
+GLboolean GL_APIENTRY GLES2IsTransformFeedback(GLuint transformfeedback) {
   return gles2::GetGLContext()->IsTransformFeedback(transformfeedback);
 }
-void GLES2LineWidth(GLfloat width) {
+void GL_APIENTRY GLES2LineWidth(GLfloat width) {
   gles2::GetGLContext()->LineWidth(width);
 }
-void GLES2LinkProgram(GLuint program) {
+void GL_APIENTRY GLES2LinkProgram(GLuint program) {
   gles2::GetGLContext()->LinkProgram(program);
 }
-void GLES2PauseTransformFeedback() {
+void GL_APIENTRY GLES2PauseTransformFeedback() {
   gles2::GetGLContext()->PauseTransformFeedback();
 }
-void GLES2PixelStorei(GLenum pname, GLint param) {
+void GL_APIENTRY GLES2PixelStorei(GLenum pname, GLint param) {
   gles2::GetGLContext()->PixelStorei(pname, param);
 }
-void GLES2PolygonOffset(GLfloat factor, GLfloat units) {
+void GL_APIENTRY GLES2PolygonOffset(GLfloat factor, GLfloat units) {
   gles2::GetGLContext()->PolygonOffset(factor, units);
 }
-void GLES2ReadBuffer(GLenum src) {
+void GL_APIENTRY GLES2ReadBuffer(GLenum src) {
   gles2::GetGLContext()->ReadBuffer(src);
 }
-void GLES2ReadPixels(GLint x,
-                     GLint y,
-                     GLsizei width,
-                     GLsizei height,
-                     GLenum format,
-                     GLenum type,
-                     void* pixels) {
+void GL_APIENTRY GLES2ReadPixels(GLint x,
+                                 GLint y,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLenum format,
+                                 GLenum type,
+                                 void* pixels) {
   gles2::GetGLContext()->ReadPixels(x, y, width, height, format, type, pixels);
 }
-void GLES2ReleaseShaderCompiler() {
+void GL_APIENTRY GLES2ReleaseShaderCompiler() {
   gles2::GetGLContext()->ReleaseShaderCompiler();
 }
-void GLES2RenderbufferStorage(GLenum target,
-                              GLenum internalformat,
-                              GLsizei width,
-                              GLsizei height) {
+void GL_APIENTRY GLES2RenderbufferStorage(GLenum target,
+                                          GLenum internalformat,
+                                          GLsizei width,
+                                          GLsizei height) {
   gles2::GetGLContext()->RenderbufferStorage(target, internalformat, width,
                                              height);
 }
-void GLES2ResumeTransformFeedback() {
+void GL_APIENTRY GLES2ResumeTransformFeedback() {
   gles2::GetGLContext()->ResumeTransformFeedback();
 }
-void GLES2SampleCoverage(GLclampf value, GLboolean invert) {
+void GL_APIENTRY GLES2SampleCoverage(GLclampf value, GLboolean invert) {
   gles2::GetGLContext()->SampleCoverage(value, invert);
 }
-void GLES2SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) {
+void GL_APIENTRY GLES2SamplerParameterf(GLuint sampler,
+                                        GLenum pname,
+                                        GLfloat param) {
   gles2::GetGLContext()->SamplerParameterf(sampler, pname, param);
 }
-void GLES2SamplerParameterfv(GLuint sampler,
-                             GLenum pname,
-                             const GLfloat* params) {
+void GL_APIENTRY GLES2SamplerParameterfv(GLuint sampler,
+                                         GLenum pname,
+                                         const GLfloat* params) {
   gles2::GetGLContext()->SamplerParameterfv(sampler, pname, params);
 }
-void GLES2SamplerParameteri(GLuint sampler, GLenum pname, GLint param) {
+void GL_APIENTRY GLES2SamplerParameteri(GLuint sampler,
+                                        GLenum pname,
+                                        GLint param) {
   gles2::GetGLContext()->SamplerParameteri(sampler, pname, param);
 }
-void GLES2SamplerParameteriv(GLuint sampler,
-                             GLenum pname,
-                             const GLint* params) {
+void GL_APIENTRY GLES2SamplerParameteriv(GLuint sampler,
+                                         GLenum pname,
+                                         const GLint* params) {
   gles2::GetGLContext()->SamplerParameteriv(sampler, pname, params);
 }
-void GLES2Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
+void GL_APIENTRY GLES2Scissor(GLint x, GLint y, GLsizei width, GLsizei height) {
   gles2::GetGLContext()->Scissor(x, y, width, height);
 }
-void GLES2ShaderBinary(GLsizei n,
-                       const GLuint* shaders,
-                       GLenum binaryformat,
-                       const void* binary,
-                       GLsizei length) {
+void GL_APIENTRY GLES2ShaderBinary(GLsizei n,
+                                   const GLuint* shaders,
+                                   GLenum binaryformat,
+                                   const void* binary,
+                                   GLsizei length) {
   gles2::GetGLContext()->ShaderBinary(n, shaders, binaryformat, binary, length);
 }
-void GLES2ShaderSource(GLuint shader,
-                       GLsizei count,
-                       const GLchar* const* str,
-                       const GLint* length) {
+void GL_APIENTRY GLES2ShaderSource(GLuint shader,
+                                   GLsizei count,
+                                   const GLchar* const* str,
+                                   const GLint* length) {
   gles2::GetGLContext()->ShaderSource(shader, count, str, length);
 }
-void GLES2ShallowFinishCHROMIUM() {
+void GL_APIENTRY GLES2ShallowFinishCHROMIUM() {
   gles2::GetGLContext()->ShallowFinishCHROMIUM();
 }
-void GLES2ShallowFlushCHROMIUM() {
+void GL_APIENTRY GLES2ShallowFlushCHROMIUM() {
   gles2::GetGLContext()->ShallowFlushCHROMIUM();
 }
-void GLES2OrderingBarrierCHROMIUM() {
+void GL_APIENTRY GLES2OrderingBarrierCHROMIUM() {
   gles2::GetGLContext()->OrderingBarrierCHROMIUM();
 }
-void GLES2StencilFunc(GLenum func, GLint ref, GLuint mask) {
+void GL_APIENTRY GLES2StencilFunc(GLenum func, GLint ref, GLuint mask) {
   gles2::GetGLContext()->StencilFunc(func, ref, mask);
 }
-void GLES2StencilFuncSeparate(GLenum face,
-                              GLenum func,
-                              GLint ref,
-                              GLuint mask) {
+void GL_APIENTRY GLES2StencilFuncSeparate(GLenum face,
+                                          GLenum func,
+                                          GLint ref,
+                                          GLuint mask) {
   gles2::GetGLContext()->StencilFuncSeparate(face, func, ref, mask);
 }
-void GLES2StencilMask(GLuint mask) {
+void GL_APIENTRY GLES2StencilMask(GLuint mask) {
   gles2::GetGLContext()->StencilMask(mask);
 }
-void GLES2StencilMaskSeparate(GLenum face, GLuint mask) {
+void GL_APIENTRY GLES2StencilMaskSeparate(GLenum face, GLuint mask) {
   gles2::GetGLContext()->StencilMaskSeparate(face, mask);
 }
-void GLES2StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
+void GL_APIENTRY GLES2StencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
   gles2::GetGLContext()->StencilOp(fail, zfail, zpass);
 }
-void GLES2StencilOpSeparate(GLenum face,
-                            GLenum fail,
-                            GLenum zfail,
-                            GLenum zpass) {
+void GL_APIENTRY GLES2StencilOpSeparate(GLenum face,
+                                        GLenum fail,
+                                        GLenum zfail,
+                                        GLenum zpass) {
   gles2::GetGLContext()->StencilOpSeparate(face, fail, zfail, zpass);
 }
-void GLES2TexImage2D(GLenum target,
-                     GLint level,
-                     GLint internalformat,
-                     GLsizei width,
-                     GLsizei height,
-                     GLint border,
-                     GLenum format,
-                     GLenum type,
-                     const void* pixels) {
+void GL_APIENTRY GLES2TexImage2D(GLenum target,
+                                 GLint level,
+                                 GLint internalformat,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLint border,
+                                 GLenum format,
+                                 GLenum type,
+                                 const void* pixels) {
   gles2::GetGLContext()->TexImage2D(target, level, internalformat, width,
                                     height, border, format, type, pixels);
 }
-void GLES2TexImage3D(GLenum target,
-                     GLint level,
-                     GLint internalformat,
-                     GLsizei width,
-                     GLsizei height,
-                     GLsizei depth,
-                     GLint border,
-                     GLenum format,
-                     GLenum type,
-                     const void* pixels) {
+void GL_APIENTRY GLES2TexImage3D(GLenum target,
+                                 GLint level,
+                                 GLint internalformat,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 GLsizei depth,
+                                 GLint border,
+                                 GLenum format,
+                                 GLenum type,
+                                 const void* pixels) {
   gles2::GetGLContext()->TexImage3D(target, level, internalformat, width,
                                     height, depth, border, format, type,
                                     pixels);
 }
-void GLES2TexParameterf(GLenum target, GLenum pname, GLfloat param) {
+void GL_APIENTRY GLES2TexParameterf(GLenum target,
+                                    GLenum pname,
+                                    GLfloat param) {
   gles2::GetGLContext()->TexParameterf(target, pname, param);
 }
-void GLES2TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) {
+void GL_APIENTRY GLES2TexParameterfv(GLenum target,
+                                     GLenum pname,
+                                     const GLfloat* params) {
   gles2::GetGLContext()->TexParameterfv(target, pname, params);
 }
-void GLES2TexParameteri(GLenum target, GLenum pname, GLint param) {
+void GL_APIENTRY GLES2TexParameteri(GLenum target, GLenum pname, GLint param) {
   gles2::GetGLContext()->TexParameteri(target, pname, param);
 }
-void GLES2TexParameteriv(GLenum target, GLenum pname, const GLint* params) {
+void GL_APIENTRY GLES2TexParameteriv(GLenum target,
+                                     GLenum pname,
+                                     const GLint* params) {
   gles2::GetGLContext()->TexParameteriv(target, pname, params);
 }
-void GLES2TexStorage3D(GLenum target,
-                       GLsizei levels,
-                       GLenum internalFormat,
-                       GLsizei width,
-                       GLsizei height,
-                       GLsizei depth) {
+void GL_APIENTRY GLES2TexStorage3D(GLenum target,
+                                   GLsizei levels,
+                                   GLenum internalFormat,
+                                   GLsizei width,
+                                   GLsizei height,
+                                   GLsizei depth) {
   gles2::GetGLContext()->TexStorage3D(target, levels, internalFormat, width,
                                       height, depth);
 }
-void GLES2TexSubImage2D(GLenum target,
-                        GLint level,
-                        GLint xoffset,
-                        GLint yoffset,
-                        GLsizei width,
-                        GLsizei height,
-                        GLenum format,
-                        GLenum type,
-                        const void* pixels) {
+void GL_APIENTRY GLES2TexSubImage2D(GLenum target,
+                                    GLint level,
+                                    GLint xoffset,
+                                    GLint yoffset,
+                                    GLsizei width,
+                                    GLsizei height,
+                                    GLenum format,
+                                    GLenum type,
+                                    const void* pixels) {
   gles2::GetGLContext()->TexSubImage2D(target, level, xoffset, yoffset, width,
                                        height, format, type, pixels);
 }
-void GLES2TexSubImage3D(GLenum target,
-                        GLint level,
-                        GLint xoffset,
-                        GLint yoffset,
-                        GLint zoffset,
-                        GLsizei width,
-                        GLsizei height,
-                        GLsizei depth,
-                        GLenum format,
-                        GLenum type,
-                        const void* pixels) {
+void GL_APIENTRY GLES2TexSubImage3D(GLenum target,
+                                    GLint level,
+                                    GLint xoffset,
+                                    GLint yoffset,
+                                    GLint zoffset,
+                                    GLsizei width,
+                                    GLsizei height,
+                                    GLsizei depth,
+                                    GLenum format,
+                                    GLenum type,
+                                    const void* pixels) {
   gles2::GetGLContext()->TexSubImage3D(target, level, xoffset, yoffset, zoffset,
                                        width, height, depth, format, type,
                                        pixels);
 }
-void GLES2TransformFeedbackVaryings(GLuint program,
-                                    GLsizei count,
-                                    const char* const* varyings,
-                                    GLenum buffermode) {
+void GL_APIENTRY GLES2TransformFeedbackVaryings(GLuint program,
+                                                GLsizei count,
+                                                const char* const* varyings,
+                                                GLenum buffermode) {
   gles2::GetGLContext()->TransformFeedbackVaryings(program, count, varyings,
                                                    buffermode);
 }
-void GLES2Uniform1f(GLint location, GLfloat x) {
+void GL_APIENTRY GLES2Uniform1f(GLint location, GLfloat x) {
   gles2::GetGLContext()->Uniform1f(location, x);
 }
-void GLES2Uniform1fv(GLint location, GLsizei count, const GLfloat* v) {
+void GL_APIENTRY GLES2Uniform1fv(GLint location,
+                                 GLsizei count,
+                                 const GLfloat* v) {
   gles2::GetGLContext()->Uniform1fv(location, count, v);
 }
-void GLES2Uniform1i(GLint location, GLint x) {
+void GL_APIENTRY GLES2Uniform1i(GLint location, GLint x) {
   gles2::GetGLContext()->Uniform1i(location, x);
 }
-void GLES2Uniform1iv(GLint location, GLsizei count, const GLint* v) {
+void GL_APIENTRY GLES2Uniform1iv(GLint location,
+                                 GLsizei count,
+                                 const GLint* v) {
   gles2::GetGLContext()->Uniform1iv(location, count, v);
 }
-void GLES2Uniform1ui(GLint location, GLuint x) {
+void GL_APIENTRY GLES2Uniform1ui(GLint location, GLuint x) {
   gles2::GetGLContext()->Uniform1ui(location, x);
 }
-void GLES2Uniform1uiv(GLint location, GLsizei count, const GLuint* v) {
+void GL_APIENTRY GLES2Uniform1uiv(GLint location,
+                                  GLsizei count,
+                                  const GLuint* v) {
   gles2::GetGLContext()->Uniform1uiv(location, count, v);
 }
-void GLES2Uniform2f(GLint location, GLfloat x, GLfloat y) {
+void GL_APIENTRY GLES2Uniform2f(GLint location, GLfloat x, GLfloat y) {
   gles2::GetGLContext()->Uniform2f(location, x, y);
 }
-void GLES2Uniform2fv(GLint location, GLsizei count, const GLfloat* v) {
+void GL_APIENTRY GLES2Uniform2fv(GLint location,
+                                 GLsizei count,
+                                 const GLfloat* v) {
   gles2::GetGLContext()->Uniform2fv(location, count, v);
 }
-void GLES2Uniform2i(GLint location, GLint x, GLint y) {
+void GL_APIENTRY GLES2Uniform2i(GLint location, GLint x, GLint y) {
   gles2::GetGLContext()->Uniform2i(location, x, y);
 }
-void GLES2Uniform2iv(GLint location, GLsizei count, const GLint* v) {
+void GL_APIENTRY GLES2Uniform2iv(GLint location,
+                                 GLsizei count,
+                                 const GLint* v) {
   gles2::GetGLContext()->Uniform2iv(location, count, v);
 }
-void GLES2Uniform2ui(GLint location, GLuint x, GLuint y) {
+void GL_APIENTRY GLES2Uniform2ui(GLint location, GLuint x, GLuint y) {
   gles2::GetGLContext()->Uniform2ui(location, x, y);
 }
-void GLES2Uniform2uiv(GLint location, GLsizei count, const GLuint* v) {
+void GL_APIENTRY GLES2Uniform2uiv(GLint location,
+                                  GLsizei count,
+                                  const GLuint* v) {
   gles2::GetGLContext()->Uniform2uiv(location, count, v);
 }
-void GLES2Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) {
+void GL_APIENTRY GLES2Uniform3f(GLint location,
+                                GLfloat x,
+                                GLfloat y,
+                                GLfloat z) {
   gles2::GetGLContext()->Uniform3f(location, x, y, z);
 }
-void GLES2Uniform3fv(GLint location, GLsizei count, const GLfloat* v) {
+void GL_APIENTRY GLES2Uniform3fv(GLint location,
+                                 GLsizei count,
+                                 const GLfloat* v) {
   gles2::GetGLContext()->Uniform3fv(location, count, v);
 }
-void GLES2Uniform3i(GLint location, GLint x, GLint y, GLint z) {
+void GL_APIENTRY GLES2Uniform3i(GLint location, GLint x, GLint y, GLint z) {
   gles2::GetGLContext()->Uniform3i(location, x, y, z);
 }
-void GLES2Uniform3iv(GLint location, GLsizei count, const GLint* v) {
+void GL_APIENTRY GLES2Uniform3iv(GLint location,
+                                 GLsizei count,
+                                 const GLint* v) {
   gles2::GetGLContext()->Uniform3iv(location, count, v);
 }
-void GLES2Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z) {
+void GL_APIENTRY GLES2Uniform3ui(GLint location, GLuint x, GLuint y, GLuint z) {
   gles2::GetGLContext()->Uniform3ui(location, x, y, z);
 }
-void GLES2Uniform3uiv(GLint location, GLsizei count, const GLuint* v) {
+void GL_APIENTRY GLES2Uniform3uiv(GLint location,
+                                  GLsizei count,
+                                  const GLuint* v) {
   gles2::GetGLContext()->Uniform3uiv(location, count, v);
 }
-void GLES2Uniform4f(GLint location,
-                    GLfloat x,
-                    GLfloat y,
-                    GLfloat z,
-                    GLfloat w) {
+void GL_APIENTRY
+GLES2Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
   gles2::GetGLContext()->Uniform4f(location, x, y, z, w);
 }
-void GLES2Uniform4fv(GLint location, GLsizei count, const GLfloat* v) {
+void GL_APIENTRY GLES2Uniform4fv(GLint location,
+                                 GLsizei count,
+                                 const GLfloat* v) {
   gles2::GetGLContext()->Uniform4fv(location, count, v);
 }
-void GLES2Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
+void GL_APIENTRY
+GLES2Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
   gles2::GetGLContext()->Uniform4i(location, x, y, z, w);
 }
-void GLES2Uniform4iv(GLint location, GLsizei count, const GLint* v) {
+void GL_APIENTRY GLES2Uniform4iv(GLint location,
+                                 GLsizei count,
+                                 const GLint* v) {
   gles2::GetGLContext()->Uniform4iv(location, count, v);
 }
-void GLES2Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w) {
+void GL_APIENTRY
+GLES2Uniform4ui(GLint location, GLuint x, GLuint y, GLuint z, GLuint w) {
   gles2::GetGLContext()->Uniform4ui(location, x, y, z, w);
 }
-void GLES2Uniform4uiv(GLint location, GLsizei count, const GLuint* v) {
+void GL_APIENTRY GLES2Uniform4uiv(GLint location,
+                                  GLsizei count,
+                                  const GLuint* v) {
   gles2::GetGLContext()->Uniform4uiv(location, count, v);
 }
-void GLES2UniformBlockBinding(GLuint program, GLuint index, GLuint binding) {
+void GL_APIENTRY GLES2UniformBlockBinding(GLuint program,
+                                          GLuint index,
+                                          GLuint binding) {
   gles2::GetGLContext()->UniformBlockBinding(program, index, binding);
 }
-void GLES2UniformMatrix2fv(GLint location,
-                           GLsizei count,
-                           GLboolean transpose,
-                           const GLfloat* value) {
+void GL_APIENTRY GLES2UniformMatrix2fv(GLint location,
+                                       GLsizei count,
+                                       GLboolean transpose,
+                                       const GLfloat* value) {
   gles2::GetGLContext()->UniformMatrix2fv(location, count, transpose, value);
 }
-void GLES2UniformMatrix2x3fv(GLint location,
-                             GLsizei count,
-                             GLboolean transpose,
-                             const GLfloat* value) {
+void GL_APIENTRY GLES2UniformMatrix2x3fv(GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat* value) {
   gles2::GetGLContext()->UniformMatrix2x3fv(location, count, transpose, value);
 }
-void GLES2UniformMatrix2x4fv(GLint location,
-                             GLsizei count,
-                             GLboolean transpose,
-                             const GLfloat* value) {
+void GL_APIENTRY GLES2UniformMatrix2x4fv(GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat* value) {
   gles2::GetGLContext()->UniformMatrix2x4fv(location, count, transpose, value);
 }
-void GLES2UniformMatrix3fv(GLint location,
-                           GLsizei count,
-                           GLboolean transpose,
-                           const GLfloat* value) {
+void GL_APIENTRY GLES2UniformMatrix3fv(GLint location,
+                                       GLsizei count,
+                                       GLboolean transpose,
+                                       const GLfloat* value) {
   gles2::GetGLContext()->UniformMatrix3fv(location, count, transpose, value);
 }
-void GLES2UniformMatrix3x2fv(GLint location,
-                             GLsizei count,
-                             GLboolean transpose,
-                             const GLfloat* value) {
+void GL_APIENTRY GLES2UniformMatrix3x2fv(GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat* value) {
   gles2::GetGLContext()->UniformMatrix3x2fv(location, count, transpose, value);
 }
-void GLES2UniformMatrix3x4fv(GLint location,
-                             GLsizei count,
-                             GLboolean transpose,
-                             const GLfloat* value) {
+void GL_APIENTRY GLES2UniformMatrix3x4fv(GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat* value) {
   gles2::GetGLContext()->UniformMatrix3x4fv(location, count, transpose, value);
 }
-void GLES2UniformMatrix4fv(GLint location,
-                           GLsizei count,
-                           GLboolean transpose,
-                           const GLfloat* value) {
+void GL_APIENTRY GLES2UniformMatrix4fv(GLint location,
+                                       GLsizei count,
+                                       GLboolean transpose,
+                                       const GLfloat* value) {
   gles2::GetGLContext()->UniformMatrix4fv(location, count, transpose, value);
 }
-void GLES2UniformMatrix4x2fv(GLint location,
-                             GLsizei count,
-                             GLboolean transpose,
-                             const GLfloat* value) {
+void GL_APIENTRY GLES2UniformMatrix4x2fv(GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat* value) {
   gles2::GetGLContext()->UniformMatrix4x2fv(location, count, transpose, value);
 }
-void GLES2UniformMatrix4x3fv(GLint location,
-                             GLsizei count,
-                             GLboolean transpose,
-                             const GLfloat* value) {
+void GL_APIENTRY GLES2UniformMatrix4x3fv(GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat* value) {
   gles2::GetGLContext()->UniformMatrix4x3fv(location, count, transpose, value);
 }
-void GLES2UseProgram(GLuint program) {
+void GL_APIENTRY GLES2UseProgram(GLuint program) {
   gles2::GetGLContext()->UseProgram(program);
 }
-void GLES2ValidateProgram(GLuint program) {
+void GL_APIENTRY GLES2ValidateProgram(GLuint program) {
   gles2::GetGLContext()->ValidateProgram(program);
 }
-void GLES2VertexAttrib1f(GLuint indx, GLfloat x) {
+void GL_APIENTRY GLES2VertexAttrib1f(GLuint indx, GLfloat x) {
   gles2::GetGLContext()->VertexAttrib1f(indx, x);
 }
-void GLES2VertexAttrib1fv(GLuint indx, const GLfloat* values) {
+void GL_APIENTRY GLES2VertexAttrib1fv(GLuint indx, const GLfloat* values) {
   gles2::GetGLContext()->VertexAttrib1fv(indx, values);
 }
-void GLES2VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
+void GL_APIENTRY GLES2VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) {
   gles2::GetGLContext()->VertexAttrib2f(indx, x, y);
 }
-void GLES2VertexAttrib2fv(GLuint indx, const GLfloat* values) {
+void GL_APIENTRY GLES2VertexAttrib2fv(GLuint indx, const GLfloat* values) {
   gles2::GetGLContext()->VertexAttrib2fv(indx, values);
 }
-void GLES2VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) {
+void GL_APIENTRY GLES2VertexAttrib3f(GLuint indx,
+                                     GLfloat x,
+                                     GLfloat y,
+                                     GLfloat z) {
   gles2::GetGLContext()->VertexAttrib3f(indx, x, y, z);
 }
-void GLES2VertexAttrib3fv(GLuint indx, const GLfloat* values) {
+void GL_APIENTRY GLES2VertexAttrib3fv(GLuint indx, const GLfloat* values) {
   gles2::GetGLContext()->VertexAttrib3fv(indx, values);
 }
-void GLES2VertexAttrib4f(GLuint indx,
-                         GLfloat x,
-                         GLfloat y,
-                         GLfloat z,
-                         GLfloat w) {
+void GL_APIENTRY
+GLES2VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
   gles2::GetGLContext()->VertexAttrib4f(indx, x, y, z, w);
 }
-void GLES2VertexAttrib4fv(GLuint indx, const GLfloat* values) {
+void GL_APIENTRY GLES2VertexAttrib4fv(GLuint indx, const GLfloat* values) {
   gles2::GetGLContext()->VertexAttrib4fv(indx, values);
 }
-void GLES2VertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w) {
+void GL_APIENTRY
+GLES2VertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w) {
   gles2::GetGLContext()->VertexAttribI4i(indx, x, y, z, w);
 }
-void GLES2VertexAttribI4iv(GLuint indx, const GLint* values) {
+void GL_APIENTRY GLES2VertexAttribI4iv(GLuint indx, const GLint* values) {
   gles2::GetGLContext()->VertexAttribI4iv(indx, values);
 }
-void GLES2VertexAttribI4ui(GLuint indx,
-                           GLuint x,
-                           GLuint y,
-                           GLuint z,
-                           GLuint w) {
+void GL_APIENTRY
+GLES2VertexAttribI4ui(GLuint indx, GLuint x, GLuint y, GLuint z, GLuint w) {
   gles2::GetGLContext()->VertexAttribI4ui(indx, x, y, z, w);
 }
-void GLES2VertexAttribI4uiv(GLuint indx, const GLuint* values) {
+void GL_APIENTRY GLES2VertexAttribI4uiv(GLuint indx, const GLuint* values) {
   gles2::GetGLContext()->VertexAttribI4uiv(indx, values);
 }
-void GLES2VertexAttribIPointer(GLuint indx,
-                               GLint size,
-                               GLenum type,
-                               GLsizei stride,
-                               const void* ptr) {
+void GL_APIENTRY GLES2VertexAttribIPointer(GLuint indx,
+                                           GLint size,
+                                           GLenum type,
+                                           GLsizei stride,
+                                           const void* ptr) {
   gles2::GetGLContext()->VertexAttribIPointer(indx, size, type, stride, ptr);
 }
-void GLES2VertexAttribPointer(GLuint indx,
-                              GLint size,
-                              GLenum type,
-                              GLboolean normalized,
-                              GLsizei stride,
-                              const void* ptr) {
+void GL_APIENTRY GLES2VertexAttribPointer(GLuint indx,
+                                          GLint size,
+                                          GLenum type,
+                                          GLboolean normalized,
+                                          GLsizei stride,
+                                          const void* ptr) {
   gles2::GetGLContext()->VertexAttribPointer(indx, size, type, normalized,
                                              stride, ptr);
 }
-void GLES2Viewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+void GL_APIENTRY GLES2Viewport(GLint x,
+                               GLint y,
+                               GLsizei width,
+                               GLsizei height) {
   gles2::GetGLContext()->Viewport(x, y, width, height);
 }
-void GLES2WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
+void GL_APIENTRY GLES2WaitSync(GLsync sync,
+                               GLbitfield flags,
+                               GLuint64 timeout) {
   gles2::GetGLContext()->WaitSync(sync, flags, timeout);
 }
-void GLES2BlitFramebufferCHROMIUM(GLint srcX0,
-                                  GLint srcY0,
-                                  GLint srcX1,
-                                  GLint srcY1,
-                                  GLint dstX0,
-                                  GLint dstY0,
-                                  GLint dstX1,
-                                  GLint dstY1,
-                                  GLbitfield mask,
-                                  GLenum filter) {
+void GL_APIENTRY GLES2BlitFramebufferCHROMIUM(GLint srcX0,
+                                              GLint srcY0,
+                                              GLint srcX1,
+                                              GLint srcY1,
+                                              GLint dstX0,
+                                              GLint dstY0,
+                                              GLint dstX1,
+                                              GLint dstY1,
+                                              GLbitfield mask,
+                                              GLenum filter) {
   gles2::GetGLContext()->BlitFramebufferCHROMIUM(
       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
-void GLES2RenderbufferStorageMultisampleCHROMIUM(GLenum target,
-                                                 GLsizei samples,
-                                                 GLenum internalformat,
-                                                 GLsizei width,
-                                                 GLsizei height) {
-  gles2::GetGLContext()->RenderbufferStorageMultisampleCHROMIUM(
-      target, samples, internalformat, width, height);
-}
-void GLES2RenderbufferStorageMultisampleEXT(GLenum target,
+void GL_APIENTRY
+GLES2RenderbufferStorageMultisampleCHROMIUM(GLenum target,
                                             GLsizei samples,
                                             GLenum internalformat,
                                             GLsizei width,
                                             GLsizei height) {
+  gles2::GetGLContext()->RenderbufferStorageMultisampleCHROMIUM(
+      target, samples, internalformat, width, height);
+}
+void GL_APIENTRY GLES2RenderbufferStorageMultisampleEXT(GLenum target,
+                                                        GLsizei samples,
+                                                        GLenum internalformat,
+                                                        GLsizei width,
+                                                        GLsizei height) {
   gles2::GetGLContext()->RenderbufferStorageMultisampleEXT(
       target, samples, internalformat, width, height);
 }
-void GLES2FramebufferTexture2DMultisampleEXT(GLenum target,
-                                             GLenum attachment,
-                                             GLenum textarget,
-                                             GLuint texture,
-                                             GLint level,
-                                             GLsizei samples) {
+void GL_APIENTRY GLES2FramebufferTexture2DMultisampleEXT(GLenum target,
+                                                         GLenum attachment,
+                                                         GLenum textarget,
+                                                         GLuint texture,
+                                                         GLint level,
+                                                         GLsizei samples) {
   gles2::GetGLContext()->FramebufferTexture2DMultisampleEXT(
       target, attachment, textarget, texture, level, samples);
 }
-void GLES2TexStorage2DEXT(GLenum target,
-                          GLsizei levels,
-                          GLenum internalFormat,
-                          GLsizei width,
-                          GLsizei height) {
+void GL_APIENTRY GLES2TexStorage2DEXT(GLenum target,
+                                      GLsizei levels,
+                                      GLenum internalFormat,
+                                      GLsizei width,
+                                      GLsizei height) {
   gles2::GetGLContext()->TexStorage2DEXT(target, levels, internalFormat, width,
                                          height);
 }
-void GLES2GenQueriesEXT(GLsizei n, GLuint* queries) {
+void GL_APIENTRY GLES2GenQueriesEXT(GLsizei n, GLuint* queries) {
   gles2::GetGLContext()->GenQueriesEXT(n, queries);
 }
-void GLES2DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
+void GL_APIENTRY GLES2DeleteQueriesEXT(GLsizei n, const GLuint* queries) {
   gles2::GetGLContext()->DeleteQueriesEXT(n, queries);
 }
-void GLES2QueryCounterEXT(GLuint id, GLenum target) {
+void GL_APIENTRY GLES2QueryCounterEXT(GLuint id, GLenum target) {
   gles2::GetGLContext()->QueryCounterEXT(id, target);
 }
-GLboolean GLES2IsQueryEXT(GLuint id) {
+GLboolean GL_APIENTRY GLES2IsQueryEXT(GLuint id) {
   return gles2::GetGLContext()->IsQueryEXT(id);
 }
-void GLES2BeginQueryEXT(GLenum target, GLuint id) {
+void GL_APIENTRY GLES2BeginQueryEXT(GLenum target, GLuint id) {
   gles2::GetGLContext()->BeginQueryEXT(target, id);
 }
-void GLES2BeginTransformFeedback(GLenum primitivemode) {
+void GL_APIENTRY GLES2BeginTransformFeedback(GLenum primitivemode) {
   gles2::GetGLContext()->BeginTransformFeedback(primitivemode);
 }
-void GLES2EndQueryEXT(GLenum target) {
+void GL_APIENTRY GLES2EndQueryEXT(GLenum target) {
   gles2::GetGLContext()->EndQueryEXT(target);
 }
-void GLES2EndTransformFeedback() {
+void GL_APIENTRY GLES2EndTransformFeedback() {
   gles2::GetGLContext()->EndTransformFeedback();
 }
-void GLES2GetQueryivEXT(GLenum target, GLenum pname, GLint* params) {
+void GL_APIENTRY GLES2GetQueryivEXT(GLenum target,
+                                    GLenum pname,
+                                    GLint* params) {
   gles2::GetGLContext()->GetQueryivEXT(target, pname, params);
 }
-void GLES2GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint* params) {
+void GL_APIENTRY GLES2GetQueryObjectuivEXT(GLuint id,
+                                           GLenum pname,
+                                           GLuint* params) {
   gles2::GetGLContext()->GetQueryObjectuivEXT(id, pname, params);
 }
-void GLES2GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64* params) {
+void GL_APIENTRY GLES2GetQueryObjectui64vEXT(GLuint id,
+                                             GLenum pname,
+                                             GLuint64* params) {
   gles2::GetGLContext()->GetQueryObjectui64vEXT(id, pname, params);
 }
-void GLES2InsertEventMarkerEXT(GLsizei length, const GLchar* marker) {
+void GL_APIENTRY GLES2InsertEventMarkerEXT(GLsizei length,
+                                           const GLchar* marker) {
   gles2::GetGLContext()->InsertEventMarkerEXT(length, marker);
 }
-void GLES2PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
+void GL_APIENTRY GLES2PushGroupMarkerEXT(GLsizei length, const GLchar* marker) {
   gles2::GetGLContext()->PushGroupMarkerEXT(length, marker);
 }
-void GLES2PopGroupMarkerEXT() {
+void GL_APIENTRY GLES2PopGroupMarkerEXT() {
   gles2::GetGLContext()->PopGroupMarkerEXT();
 }
-void GLES2GenVertexArraysOES(GLsizei n, GLuint* arrays) {
+void GL_APIENTRY GLES2GenVertexArraysOES(GLsizei n, GLuint* arrays) {
   gles2::GetGLContext()->GenVertexArraysOES(n, arrays);
 }
-void GLES2DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
+void GL_APIENTRY GLES2DeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
   gles2::GetGLContext()->DeleteVertexArraysOES(n, arrays);
 }
-GLboolean GLES2IsVertexArrayOES(GLuint array) {
+GLboolean GL_APIENTRY GLES2IsVertexArrayOES(GLuint array) {
   return gles2::GetGLContext()->IsVertexArrayOES(array);
 }
-void GLES2BindVertexArrayOES(GLuint array) {
+void GL_APIENTRY GLES2BindVertexArrayOES(GLuint array) {
   gles2::GetGLContext()->BindVertexArrayOES(array);
 }
-void GLES2SwapBuffers() {
+void GL_APIENTRY GLES2SwapBuffers() {
   gles2::GetGLContext()->SwapBuffers();
 }
-GLuint GLES2GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
-                                        GLsizei count,
-                                        GLenum type,
-                                        GLuint offset) {
+GLuint GL_APIENTRY GLES2GetMaxValueInBufferCHROMIUM(GLuint buffer_id,
+                                                    GLsizei count,
+                                                    GLenum type,
+                                                    GLuint offset) {
   return gles2::GetGLContext()->GetMaxValueInBufferCHROMIUM(buffer_id, count,
                                                             type, offset);
 }
-GLboolean GLES2EnableFeatureCHROMIUM(const char* feature) {
+GLboolean GL_APIENTRY GLES2EnableFeatureCHROMIUM(const char* feature) {
   return gles2::GetGLContext()->EnableFeatureCHROMIUM(feature);
 }
-void* GLES2MapBufferCHROMIUM(GLuint target, GLenum access) {
+void* GL_APIENTRY GLES2MapBufferCHROMIUM(GLuint target, GLenum access) {
   return gles2::GetGLContext()->MapBufferCHROMIUM(target, access);
 }
-GLboolean GLES2UnmapBufferCHROMIUM(GLuint target) {
+GLboolean GL_APIENTRY GLES2UnmapBufferCHROMIUM(GLuint target) {
   return gles2::GetGLContext()->UnmapBufferCHROMIUM(target);
 }
-void* GLES2MapBufferSubDataCHROMIUM(GLuint target,
-                                    GLintptr offset,
-                                    GLsizeiptr size,
-                                    GLenum access) {
+void* GL_APIENTRY GLES2MapBufferSubDataCHROMIUM(GLuint target,
+                                                GLintptr offset,
+                                                GLsizeiptr size,
+                                                GLenum access) {
   return gles2::GetGLContext()->MapBufferSubDataCHROMIUM(target, offset, size,
                                                          access);
 }
-void GLES2UnmapBufferSubDataCHROMIUM(const void* mem) {
+void GL_APIENTRY GLES2UnmapBufferSubDataCHROMIUM(const void* mem) {
   gles2::GetGLContext()->UnmapBufferSubDataCHROMIUM(mem);
 }
-void* GLES2MapBufferRange(GLenum target,
-                          GLintptr offset,
-                          GLsizeiptr size,
-                          GLbitfield access) {
+void* GL_APIENTRY GLES2MapBufferRange(GLenum target,
+                                      GLintptr offset,
+                                      GLsizeiptr size,
+                                      GLbitfield access) {
   return gles2::GetGLContext()->MapBufferRange(target, offset, size, access);
 }
-GLboolean GLES2UnmapBuffer(GLenum target) {
+GLboolean GL_APIENTRY GLES2UnmapBuffer(GLenum target) {
   return gles2::GetGLContext()->UnmapBuffer(target);
 }
-void* GLES2MapTexSubImage2DCHROMIUM(GLenum target,
-                                    GLint level,
-                                    GLint xoffset,
-                                    GLint yoffset,
-                                    GLsizei width,
-                                    GLsizei height,
-                                    GLenum format,
-                                    GLenum type,
-                                    GLenum access) {
+void* GL_APIENTRY GLES2MapTexSubImage2DCHROMIUM(GLenum target,
+                                                GLint level,
+                                                GLint xoffset,
+                                                GLint yoffset,
+                                                GLsizei width,
+                                                GLsizei height,
+                                                GLenum format,
+                                                GLenum type,
+                                                GLenum access) {
   return gles2::GetGLContext()->MapTexSubImage2DCHROMIUM(
       target, level, xoffset, yoffset, width, height, format, type, access);
 }
-void GLES2UnmapTexSubImage2DCHROMIUM(const void* mem) {
+void GL_APIENTRY GLES2UnmapTexSubImage2DCHROMIUM(const void* mem) {
   gles2::GetGLContext()->UnmapTexSubImage2DCHROMIUM(mem);
 }
-void GLES2ResizeCHROMIUM(GLuint width, GLuint height, GLfloat scale_factor) {
+void GL_APIENTRY GLES2ResizeCHROMIUM(GLuint width,
+                                     GLuint height,
+                                     GLfloat scale_factor) {
   gles2::GetGLContext()->ResizeCHROMIUM(width, height, scale_factor);
 }
-const GLchar* GLES2GetRequestableExtensionsCHROMIUM() {
+const GLchar* GL_APIENTRY GLES2GetRequestableExtensionsCHROMIUM() {
   return gles2::GetGLContext()->GetRequestableExtensionsCHROMIUM();
 }
-void GLES2RequestExtensionCHROMIUM(const char* extension) {
+void GL_APIENTRY GLES2RequestExtensionCHROMIUM(const char* extension) {
   gles2::GetGLContext()->RequestExtensionCHROMIUM(extension);
 }
-void GLES2RateLimitOffscreenContextCHROMIUM() {
+void GL_APIENTRY GLES2RateLimitOffscreenContextCHROMIUM() {
   gles2::GetGLContext()->RateLimitOffscreenContextCHROMIUM();
 }
-void GLES2GetProgramInfoCHROMIUM(GLuint program,
-                                 GLsizei bufsize,
-                                 GLsizei* size,
-                                 void* info) {
+void GL_APIENTRY GLES2GetProgramInfoCHROMIUM(GLuint program,
+                                             GLsizei bufsize,
+                                             GLsizei* size,
+                                             void* info) {
   gles2::GetGLContext()->GetProgramInfoCHROMIUM(program, bufsize, size, info);
 }
-void GLES2GetUniformBlocksCHROMIUM(GLuint program,
-                                   GLsizei bufsize,
-                                   GLsizei* size,
-                                   void* info) {
-  gles2::GetGLContext()->GetUniformBlocksCHROMIUM(program, bufsize, size, info);
-}
-void GLES2GetTransformFeedbackVaryingsCHROMIUM(GLuint program,
+void GL_APIENTRY GLES2GetUniformBlocksCHROMIUM(GLuint program,
                                                GLsizei bufsize,
                                                GLsizei* size,
                                                void* info) {
+  gles2::GetGLContext()->GetUniformBlocksCHROMIUM(program, bufsize, size, info);
+}
+void GL_APIENTRY GLES2GetTransformFeedbackVaryingsCHROMIUM(GLuint program,
+                                                           GLsizei bufsize,
+                                                           GLsizei* size,
+                                                           void* info) {
   gles2::GetGLContext()->GetTransformFeedbackVaryingsCHROMIUM(program, bufsize,
                                                               size, info);
 }
-void GLES2GetUniformsES3CHROMIUM(GLuint program,
-                                 GLsizei bufsize,
-                                 GLsizei* size,
-                                 void* info) {
+void GL_APIENTRY GLES2GetUniformsES3CHROMIUM(GLuint program,
+                                             GLsizei bufsize,
+                                             GLsizei* size,
+                                             void* info) {
   gles2::GetGLContext()->GetUniformsES3CHROMIUM(program, bufsize, size, info);
 }
-GLuint GLES2CreateStreamTextureCHROMIUM(GLuint texture) {
+GLuint GL_APIENTRY GLES2CreateStreamTextureCHROMIUM(GLuint texture) {
   return gles2::GetGLContext()->CreateStreamTextureCHROMIUM(texture);
 }
-GLuint GLES2CreateImageCHROMIUM(ClientBuffer buffer,
-                                GLsizei width,
-                                GLsizei height,
-                                GLenum internalformat) {
+GLuint GL_APIENTRY GLES2CreateImageCHROMIUM(ClientBuffer buffer,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum internalformat) {
   return gles2::GetGLContext()->CreateImageCHROMIUM(buffer, width, height,
                                                     internalformat);
 }
-void GLES2DestroyImageCHROMIUM(GLuint image_id) {
+void GL_APIENTRY GLES2DestroyImageCHROMIUM(GLuint image_id) {
   gles2::GetGLContext()->DestroyImageCHROMIUM(image_id);
 }
-GLuint GLES2CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
-                                               GLsizei height,
-                                               GLenum internalformat,
-                                               GLenum usage) {
+GLuint GL_APIENTRY
+GLES2CreateGpuMemoryBufferImageCHROMIUM(GLsizei width,
+                                        GLsizei height,
+                                        GLenum internalformat,
+                                        GLenum usage) {
   return gles2::GetGLContext()->CreateGpuMemoryBufferImageCHROMIUM(
       width, height, internalformat, usage);
 }
-void GLES2GetTranslatedShaderSourceANGLE(GLuint shader,
-                                         GLsizei bufsize,
-                                         GLsizei* length,
-                                         char* source) {
+void GL_APIENTRY GLES2GetTranslatedShaderSourceANGLE(GLuint shader,
+                                                     GLsizei bufsize,
+                                                     GLsizei* length,
+                                                     char* source) {
   gles2::GetGLContext()->GetTranslatedShaderSourceANGLE(shader, bufsize, length,
                                                         source);
 }
-void GLES2PostSubBufferCHROMIUM(GLint x, GLint y, GLint width, GLint height) {
+void GL_APIENTRY GLES2PostSubBufferCHROMIUM(GLint x,
+                                            GLint y,
+                                            GLint width,
+                                            GLint height) {
   gles2::GetGLContext()->PostSubBufferCHROMIUM(x, y, width, height);
 }
-void GLES2TexImageIOSurface2DCHROMIUM(GLenum target,
-                                      GLsizei width,
-                                      GLsizei height,
-                                      GLuint ioSurfaceId,
-                                      GLuint plane) {
+void GL_APIENTRY GLES2TexImageIOSurface2DCHROMIUM(GLenum target,
+                                                  GLsizei width,
+                                                  GLsizei height,
+                                                  GLuint ioSurfaceId,
+                                                  GLuint plane) {
   gles2::GetGLContext()->TexImageIOSurface2DCHROMIUM(target, width, height,
                                                      ioSurfaceId, plane);
 }
-void GLES2CopyTextureCHROMIUM(GLenum target,
-                              GLenum source_id,
-                              GLenum dest_id,
-                              GLint internalformat,
-                              GLenum dest_type,
-                              GLboolean unpack_flip_y,
-                              GLboolean unpack_premultiply_alpha,
-                              GLboolean unpack_unmultiply_alpha) {
+void GL_APIENTRY GLES2CopyTextureCHROMIUM(GLenum target,
+                                          GLenum source_id,
+                                          GLenum dest_id,
+                                          GLint internalformat,
+                                          GLenum dest_type,
+                                          GLboolean unpack_flip_y,
+                                          GLboolean unpack_premultiply_alpha,
+                                          GLboolean unpack_unmultiply_alpha) {
   gles2::GetGLContext()->CopyTextureCHROMIUM(
       target, source_id, dest_id, internalformat, dest_type, unpack_flip_y,
       unpack_premultiply_alpha, unpack_unmultiply_alpha);
 }
-void GLES2CopySubTextureCHROMIUM(GLenum target,
-                                 GLenum source_id,
-                                 GLenum dest_id,
-                                 GLint xoffset,
-                                 GLint yoffset,
-                                 GLint x,
-                                 GLint y,
-                                 GLsizei width,
-                                 GLsizei height,
-                                 GLboolean unpack_flip_y,
-                                 GLboolean unpack_premultiply_alpha,
-                                 GLboolean unpack_unmultiply_alpha) {
+void GL_APIENTRY
+GLES2CopySubTextureCHROMIUM(GLenum target,
+                            GLenum source_id,
+                            GLenum dest_id,
+                            GLint xoffset,
+                            GLint yoffset,
+                            GLint x,
+                            GLint y,
+                            GLsizei width,
+                            GLsizei height,
+                            GLboolean unpack_flip_y,
+                            GLboolean unpack_premultiply_alpha,
+                            GLboolean unpack_unmultiply_alpha) {
   gles2::GetGLContext()->CopySubTextureCHROMIUM(
       target, source_id, dest_id, xoffset, yoffset, x, y, width, height,
       unpack_flip_y, unpack_premultiply_alpha, unpack_unmultiply_alpha);
 }
-void GLES2CompressedCopyTextureCHROMIUM(GLenum target,
-                                        GLenum source_id,
-                                        GLenum dest_id) {
+void GL_APIENTRY GLES2CompressedCopyTextureCHROMIUM(GLenum target,
+                                                    GLenum source_id,
+                                                    GLenum dest_id) {
   gles2::GetGLContext()->CompressedCopyTextureCHROMIUM(target, source_id,
                                                        dest_id);
 }
-void GLES2DrawArraysInstancedANGLE(GLenum mode,
-                                   GLint first,
-                                   GLsizei count,
-                                   GLsizei primcount) {
+void GL_APIENTRY GLES2DrawArraysInstancedANGLE(GLenum mode,
+                                               GLint first,
+                                               GLsizei count,
+                                               GLsizei primcount) {
   gles2::GetGLContext()->DrawArraysInstancedANGLE(mode, first, count,
                                                   primcount);
 }
-void GLES2DrawElementsInstancedANGLE(GLenum mode,
-                                     GLsizei count,
-                                     GLenum type,
-                                     const void* indices,
-                                     GLsizei primcount) {
+void GL_APIENTRY GLES2DrawElementsInstancedANGLE(GLenum mode,
+                                                 GLsizei count,
+                                                 GLenum type,
+                                                 const void* indices,
+                                                 GLsizei primcount) {
   gles2::GetGLContext()->DrawElementsInstancedANGLE(mode, count, type, indices,
                                                     primcount);
 }
-void GLES2VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
+void GL_APIENTRY GLES2VertexAttribDivisorANGLE(GLuint index, GLuint divisor) {
   gles2::GetGLContext()->VertexAttribDivisorANGLE(index, divisor);
 }
-void GLES2GenMailboxCHROMIUM(GLbyte* mailbox) {
+void GL_APIENTRY GLES2GenMailboxCHROMIUM(GLbyte* mailbox) {
   gles2::GetGLContext()->GenMailboxCHROMIUM(mailbox);
 }
-void GLES2ProduceTextureCHROMIUM(GLenum target, const GLbyte* mailbox) {
+void GL_APIENTRY GLES2ProduceTextureCHROMIUM(GLenum target,
+                                             const GLbyte* mailbox) {
   gles2::GetGLContext()->ProduceTextureCHROMIUM(target, mailbox);
 }
-void GLES2ProduceTextureDirectCHROMIUM(GLuint texture,
-                                       GLenum target,
-                                       const GLbyte* mailbox) {
+void GL_APIENTRY GLES2ProduceTextureDirectCHROMIUM(GLuint texture,
+                                                   GLenum target,
+                                                   const GLbyte* mailbox) {
   gles2::GetGLContext()->ProduceTextureDirectCHROMIUM(texture, target, mailbox);
 }
-void GLES2ConsumeTextureCHROMIUM(GLenum target, const GLbyte* mailbox) {
+void GL_APIENTRY GLES2ConsumeTextureCHROMIUM(GLenum target,
+                                             const GLbyte* mailbox) {
   gles2::GetGLContext()->ConsumeTextureCHROMIUM(target, mailbox);
 }
-GLuint GLES2CreateAndConsumeTextureCHROMIUM(GLenum target,
-                                            const GLbyte* mailbox) {
+GLuint GL_APIENTRY GLES2CreateAndConsumeTextureCHROMIUM(GLenum target,
+                                                        const GLbyte* mailbox) {
   return gles2::GetGLContext()->CreateAndConsumeTextureCHROMIUM(target,
                                                                 mailbox);
 }
-void GLES2BindUniformLocationCHROMIUM(GLuint program,
-                                      GLint location,
-                                      const char* name) {
+void GL_APIENTRY GLES2BindUniformLocationCHROMIUM(GLuint program,
+                                                  GLint location,
+                                                  const char* name) {
   gles2::GetGLContext()->BindUniformLocationCHROMIUM(program, location, name);
 }
-void GLES2GenValuebuffersCHROMIUM(GLsizei n, GLuint* buffers) {
+void GL_APIENTRY GLES2GenValuebuffersCHROMIUM(GLsizei n, GLuint* buffers) {
   gles2::GetGLContext()->GenValuebuffersCHROMIUM(n, buffers);
 }
-void GLES2DeleteValuebuffersCHROMIUM(GLsizei n, const GLuint* valuebuffers) {
+void GL_APIENTRY GLES2DeleteValuebuffersCHROMIUM(GLsizei n,
+                                                 const GLuint* valuebuffers) {
   gles2::GetGLContext()->DeleteValuebuffersCHROMIUM(n, valuebuffers);
 }
-GLboolean GLES2IsValuebufferCHROMIUM(GLuint valuebuffer) {
+GLboolean GL_APIENTRY GLES2IsValuebufferCHROMIUM(GLuint valuebuffer) {
   return gles2::GetGLContext()->IsValuebufferCHROMIUM(valuebuffer);
 }
-void GLES2BindValuebufferCHROMIUM(GLenum target, GLuint valuebuffer) {
+void GL_APIENTRY GLES2BindValuebufferCHROMIUM(GLenum target,
+                                              GLuint valuebuffer) {
   gles2::GetGLContext()->BindValuebufferCHROMIUM(target, valuebuffer);
 }
-void GLES2SubscribeValueCHROMIUM(GLenum target, GLenum subscription) {
+void GL_APIENTRY GLES2SubscribeValueCHROMIUM(GLenum target,
+                                             GLenum subscription) {
   gles2::GetGLContext()->SubscribeValueCHROMIUM(target, subscription);
 }
-void GLES2PopulateSubscribedValuesCHROMIUM(GLenum target) {
+void GL_APIENTRY GLES2PopulateSubscribedValuesCHROMIUM(GLenum target) {
   gles2::GetGLContext()->PopulateSubscribedValuesCHROMIUM(target);
 }
-void GLES2UniformValuebufferCHROMIUM(GLint location,
-                                     GLenum target,
-                                     GLenum subscription) {
+void GL_APIENTRY GLES2UniformValuebufferCHROMIUM(GLint location,
+                                                 GLenum target,
+                                                 GLenum subscription) {
   gles2::GetGLContext()->UniformValuebufferCHROMIUM(location, target,
                                                     subscription);
 }
-void GLES2BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
+void GL_APIENTRY GLES2BindTexImage2DCHROMIUM(GLenum target, GLint imageId) {
   gles2::GetGLContext()->BindTexImage2DCHROMIUM(target, imageId);
 }
-void GLES2ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
+void GL_APIENTRY GLES2ReleaseTexImage2DCHROMIUM(GLenum target, GLint imageId) {
   gles2::GetGLContext()->ReleaseTexImage2DCHROMIUM(target, imageId);
 }
-void GLES2TraceBeginCHROMIUM(const char* category_name,
-                             const char* trace_name) {
+void GL_APIENTRY GLES2TraceBeginCHROMIUM(const char* category_name,
+                                         const char* trace_name) {
   gles2::GetGLContext()->TraceBeginCHROMIUM(category_name, trace_name);
 }
-void GLES2TraceEndCHROMIUM() {
+void GL_APIENTRY GLES2TraceEndCHROMIUM() {
   gles2::GetGLContext()->TraceEndCHROMIUM();
 }
-void GLES2AsyncTexSubImage2DCHROMIUM(GLenum target,
-                                     GLint level,
-                                     GLint xoffset,
-                                     GLint yoffset,
-                                     GLsizei width,
-                                     GLsizei height,
-                                     GLenum format,
-                                     GLenum type,
-                                     const void* data) {
+void GL_APIENTRY GLES2AsyncTexSubImage2DCHROMIUM(GLenum target,
+                                                 GLint level,
+                                                 GLint xoffset,
+                                                 GLint yoffset,
+                                                 GLsizei width,
+                                                 GLsizei height,
+                                                 GLenum format,
+                                                 GLenum type,
+                                                 const void* data) {
   gles2::GetGLContext()->AsyncTexSubImage2DCHROMIUM(
       target, level, xoffset, yoffset, width, height, format, type, data);
 }
-void GLES2AsyncTexImage2DCHROMIUM(GLenum target,
-                                  GLint level,
-                                  GLenum internalformat,
-                                  GLsizei width,
-                                  GLsizei height,
-                                  GLint border,
-                                  GLenum format,
-                                  GLenum type,
-                                  const void* pixels) {
+void GL_APIENTRY GLES2AsyncTexImage2DCHROMIUM(GLenum target,
+                                              GLint level,
+                                              GLenum internalformat,
+                                              GLsizei width,
+                                              GLsizei height,
+                                              GLint border,
+                                              GLenum format,
+                                              GLenum type,
+                                              const void* pixels) {
   gles2::GetGLContext()->AsyncTexImage2DCHROMIUM(target, level, internalformat,
                                                  width, height, border, format,
                                                  type, pixels);
 }
-void GLES2WaitAsyncTexImage2DCHROMIUM(GLenum target) {
+void GL_APIENTRY GLES2WaitAsyncTexImage2DCHROMIUM(GLenum target) {
   gles2::GetGLContext()->WaitAsyncTexImage2DCHROMIUM(target);
 }
-void GLES2WaitAllAsyncTexImage2DCHROMIUM() {
+void GL_APIENTRY GLES2WaitAllAsyncTexImage2DCHROMIUM() {
   gles2::GetGLContext()->WaitAllAsyncTexImage2DCHROMIUM();
 }
-void GLES2DiscardFramebufferEXT(GLenum target,
-                                GLsizei count,
-                                const GLenum* attachments) {
+void GL_APIENTRY GLES2DiscardFramebufferEXT(GLenum target,
+                                            GLsizei count,
+                                            const GLenum* attachments) {
   gles2::GetGLContext()->DiscardFramebufferEXT(target, count, attachments);
 }
-void GLES2LoseContextCHROMIUM(GLenum current, GLenum other) {
+void GL_APIENTRY GLES2LoseContextCHROMIUM(GLenum current, GLenum other) {
   gles2::GetGLContext()->LoseContextCHROMIUM(current, other);
 }
-GLuint GLES2InsertSyncPointCHROMIUM() {
+GLuint GL_APIENTRY GLES2InsertSyncPointCHROMIUM() {
   return gles2::GetGLContext()->InsertSyncPointCHROMIUM();
 }
-void GLES2WaitSyncPointCHROMIUM(GLuint sync_point) {
+void GL_APIENTRY GLES2WaitSyncPointCHROMIUM(GLuint sync_point) {
   gles2::GetGLContext()->WaitSyncPointCHROMIUM(sync_point);
 }
-void GLES2DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
+void GL_APIENTRY GLES2DrawBuffersEXT(GLsizei count, const GLenum* bufs) {
   gles2::GetGLContext()->DrawBuffersEXT(count, bufs);
 }
-void GLES2DiscardBackbufferCHROMIUM() {
+void GL_APIENTRY GLES2DiscardBackbufferCHROMIUM() {
   gles2::GetGLContext()->DiscardBackbufferCHROMIUM();
 }
-void GLES2ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
-                                       GLenum plane_transform,
-                                       GLuint overlay_texture_id,
-                                       GLint bounds_x,
-                                       GLint bounds_y,
-                                       GLint bounds_width,
-                                       GLint bounds_height,
-                                       GLfloat uv_x,
-                                       GLfloat uv_y,
-                                       GLfloat uv_width,
-                                       GLfloat uv_height) {
+void GL_APIENTRY GLES2ScheduleOverlayPlaneCHROMIUM(GLint plane_z_order,
+                                                   GLenum plane_transform,
+                                                   GLuint overlay_texture_id,
+                                                   GLint bounds_x,
+                                                   GLint bounds_y,
+                                                   GLint bounds_width,
+                                                   GLint bounds_height,
+                                                   GLfloat uv_x,
+                                                   GLfloat uv_y,
+                                                   GLfloat uv_width,
+                                                   GLfloat uv_height) {
   gles2::GetGLContext()->ScheduleOverlayPlaneCHROMIUM(
       plane_z_order, plane_transform, overlay_texture_id, bounds_x, bounds_y,
       bounds_width, bounds_height, uv_x, uv_y, uv_width, uv_height);
 }
-void GLES2SwapInterval(GLint interval) {
+void GL_APIENTRY GLES2SwapInterval(GLint interval) {
   gles2::GetGLContext()->SwapInterval(interval);
 }
-void GLES2FlushDriverCachesCHROMIUM() {
+void GL_APIENTRY GLES2FlushDriverCachesCHROMIUM() {
   gles2::GetGLContext()->FlushDriverCachesCHROMIUM();
 }
-void GLES2MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
+void GL_APIENTRY GLES2MatrixLoadfCHROMIUM(GLenum matrixMode, const GLfloat* m) {
   gles2::GetGLContext()->MatrixLoadfCHROMIUM(matrixMode, m);
 }
-void GLES2MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
+void GL_APIENTRY GLES2MatrixLoadIdentityCHROMIUM(GLenum matrixMode) {
   gles2::GetGLContext()->MatrixLoadIdentityCHROMIUM(matrixMode);
 }
-GLuint GLES2GenPathsCHROMIUM(GLsizei range) {
+GLuint GL_APIENTRY GLES2GenPathsCHROMIUM(GLsizei range) {
   return gles2::GetGLContext()->GenPathsCHROMIUM(range);
 }
-void GLES2DeletePathsCHROMIUM(GLuint path, GLsizei range) {
+void GL_APIENTRY GLES2DeletePathsCHROMIUM(GLuint path, GLsizei range) {
   gles2::GetGLContext()->DeletePathsCHROMIUM(path, range);
 }
-GLboolean GLES2IsPathCHROMIUM(GLuint path) {
+GLboolean GL_APIENTRY GLES2IsPathCHROMIUM(GLuint path) {
   return gles2::GetGLContext()->IsPathCHROMIUM(path);
 }
-void GLES2PathCommandsCHROMIUM(GLuint path,
-                               GLsizei numCommands,
-                               const GLubyte* commands,
-                               GLsizei numCoords,
-                               GLenum coordType,
-                               const GLvoid* coords) {
+void GL_APIENTRY GLES2PathCommandsCHROMIUM(GLuint path,
+                                           GLsizei numCommands,
+                                           const GLubyte* commands,
+                                           GLsizei numCoords,
+                                           GLenum coordType,
+                                           const GLvoid* coords) {
   gles2::GetGLContext()->PathCommandsCHROMIUM(path, numCommands, commands,
                                               numCoords, coordType, coords);
 }
-void GLES2PathParameterfCHROMIUM(GLuint path, GLenum pname, GLfloat value) {
+void GL_APIENTRY GLES2PathParameterfCHROMIUM(GLuint path,
+                                             GLenum pname,
+                                             GLfloat value) {
   gles2::GetGLContext()->PathParameterfCHROMIUM(path, pname, value);
 }
-void GLES2PathParameteriCHROMIUM(GLuint path, GLenum pname, GLint value) {
+void GL_APIENTRY GLES2PathParameteriCHROMIUM(GLuint path,
+                                             GLenum pname,
+                                             GLint value) {
   gles2::GetGLContext()->PathParameteriCHROMIUM(path, pname, value);
 }
-void GLES2PathStencilFuncCHROMIUM(GLenum func, GLint ref, GLuint mask) {
+void GL_APIENTRY GLES2PathStencilFuncCHROMIUM(GLenum func,
+                                              GLint ref,
+                                              GLuint mask) {
   gles2::GetGLContext()->PathStencilFuncCHROMIUM(func, ref, mask);
 }
-void GLES2StencilFillPathCHROMIUM(GLuint path, GLenum fillMode, GLuint mask) {
+void GL_APIENTRY GLES2StencilFillPathCHROMIUM(GLuint path,
+                                              GLenum fillMode,
+                                              GLuint mask) {
   gles2::GetGLContext()->StencilFillPathCHROMIUM(path, fillMode, mask);
 }
-void GLES2StencilStrokePathCHROMIUM(GLuint path, GLint reference, GLuint mask) {
+void GL_APIENTRY GLES2StencilStrokePathCHROMIUM(GLuint path,
+                                                GLint reference,
+                                                GLuint mask) {
   gles2::GetGLContext()->StencilStrokePathCHROMIUM(path, reference, mask);
 }
-void GLES2CoverFillPathCHROMIUM(GLuint path, GLenum coverMode) {
+void GL_APIENTRY GLES2CoverFillPathCHROMIUM(GLuint path, GLenum coverMode) {
   gles2::GetGLContext()->CoverFillPathCHROMIUM(path, coverMode);
 }
-void GLES2CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode) {
+void GL_APIENTRY GLES2CoverStrokePathCHROMIUM(GLuint path, GLenum coverMode) {
   gles2::GetGLContext()->CoverStrokePathCHROMIUM(path, coverMode);
 }
-void GLES2StencilThenCoverFillPathCHROMIUM(GLuint path,
-                                           GLenum fillMode,
-                                           GLuint mask,
-                                           GLenum coverMode) {
+void GL_APIENTRY GLES2StencilThenCoverFillPathCHROMIUM(GLuint path,
+                                                       GLenum fillMode,
+                                                       GLuint mask,
+                                                       GLenum coverMode) {
   gles2::GetGLContext()->StencilThenCoverFillPathCHROMIUM(path, fillMode, mask,
                                                           coverMode);
 }
-void GLES2StencilThenCoverStrokePathCHROMIUM(GLuint path,
-                                             GLint reference,
-                                             GLuint mask,
-                                             GLenum coverMode) {
+void GL_APIENTRY GLES2StencilThenCoverStrokePathCHROMIUM(GLuint path,
+                                                         GLint reference,
+                                                         GLuint mask,
+                                                         GLenum coverMode) {
   gles2::GetGLContext()->StencilThenCoverStrokePathCHROMIUM(path, reference,
                                                             mask, coverMode);
 }
-GLenum GLES2GetGraphicsResetStatusKHR() {
+GLenum GL_APIENTRY GLES2GetGraphicsResetStatusKHR() {
   return gles2::GetGLContext()->GetGraphicsResetStatusKHR();
 }
-void GLES2BlendBarrierKHR() {
+void GL_APIENTRY GLES2BlendBarrierKHR() {
   gles2::GetGLContext()->BlendBarrierKHR();
 }
 
diff --git a/gpu/command_buffer/client/gles2_lib.h b/gpu/command_buffer/client/gles2_lib.h
index b90a2d8..957ac69 100644
--- a/gpu/command_buffer/client/gles2_lib.h
+++ b/gpu/command_buffer/client/gles2_lib.h
@@ -12,7 +12,7 @@
 
 namespace gles2 {
 
-typedef void (*GLES2FunctionPointer)(void);
+typedef void(GL_APIENTRY* GLES2FunctionPointer)(void);
 
 struct NameToFunc {
   const char* name;
diff --git a/gpu/gles2_conform_support/egl/egl.cc b/gpu/gles2_conform_support/egl/egl.cc
index f23cf76..b777f23 100644
--- a/gpu/gles2_conform_support/egl/egl.cc
+++ b/gpu/gles2_conform_support/egl/egl.cc
@@ -399,6 +399,7 @@ EGLBoolean eglCopyBuffers(EGLDisplay dpy,
 /* Now, define eglGetProcAddress using the generic function ptr. type */
 __eglMustCastToProperFunctionPointerType
 eglGetProcAddress(const char* procname) {
-  return gles2::GetGLFunctionPointer(procname);
+  return reinterpret_cast<__eglMustCastToProperFunctionPointerType>(
+      gles2::GetGLFunctionPointer(procname));
 }
 }  // extern "C"
diff --git a/mojo/gles2/gles2_impl.cc b/mojo/gles2/gles2_impl.cc
index b031f94..4f308e9 100644
--- a/mojo/gles2/gles2_impl.cc
+++ b/mojo/gles2/gles2_impl.cc
@@ -76,7 +76,7 @@ void* MojoGLES2GetContextSupport(MojoGLES2Context context) {
 }
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType gl##Function PARAMETERS {                             \
+  ReturnType GL_APIENTRY gl##Function PARAMETERS {                 \
     DCHECK(g_gpu_interface.Get().Get());                           \
     return g_gpu_interface.Get().Get()->Function ARGUMENTS;        \
   }
diff --git a/skia/BUILD.gn b/skia/BUILD.gn
index f629c5a..0e448f4 100644
--- a/skia/BUILD.gn
+++ b/skia/BUILD.gn
@@ -169,6 +169,10 @@ config("skia_config") {
   if (is_mac) {
     defines += [ "SK_BUILD_FOR_MAC" ]
   }
+
+  if (is_win) {
+    defines += [ "GR_GL_FUNCTION_TYPE=__stdcall" ]
+  }
 }
 
 # Internal-facing config for Skia library code.
diff --git a/skia/skia.gyp b/skia/skia.gyp
index ca063d1..eea745c 100644
--- a/skia/skia.gyp
+++ b/skia/skia.gyp
@@ -38,6 +38,15 @@
             'skia_library',
             'skia_chrome',
           ],
+          'direct_dependent_settings': {
+            'conditions': [
+              [ 'OS == "win"', {
+                'defines': [
+                  'GR_GL_FUNCTION_TYPE=__stdcall',
+                ],
+              }],
+            ],
+          },
         },
         {
           'target_name': 'skia_chrome',
@@ -70,6 +79,13 @@
             'GR_GL_IGNORE_ES3_MSAA=0',
           ],
           'direct_dependent_settings': {
+            'conditions': [
+              [ 'OS == "win"', {
+                'defines': [
+                  'GR_GL_FUNCTION_TYPE=__stdcall',
+                ],
+              }],
+            ],
             'defines': [
               'SKIA_DLL',
               'GR_GL_IGNORE_ES3_MSAA=0',
diff --git a/skia/skia_common.gypi b/skia/skia_common.gypi
index 8880d98..594a646 100644
--- a/skia/skia_common.gypi
+++ b/skia/skia_common.gypi
@@ -54,6 +54,7 @@
         # size.
         # http://crbug.com/314387
         'SK_DEFAULT_FONT_CACHE_COUNT_LIMIT=256',
+        'GR_GL_FUNCTION_TYPE=__stdcall',
       ],
     }],
     [ 'desktop_linux == 0 and chromeos == 0', {
diff --git a/third_party/khronos/KHR/khrplatform.h b/third_party/khronos/KHR/khrplatform.h
index 026c9c7..ffe75db 100644
--- a/third_party/khronos/KHR/khrplatform.h
+++ b/third_party/khronos/KHR/khrplatform.h
@@ -131,9 +131,6 @@
 #define KHRONOS_APICALL GLES2_C_LIB_EXPORT
 #endif
 
-#undef KHRONOS_APIENTRY
-#define KHRONOS_APIENTRY
-
 /*-------------------------------------------------------------------------
  * Definition of KHRONOS_APIATTRIBUTES
  *-------------------------------------------------------------------------
diff --git a/third_party/khronos/README.chromium b/third_party/khronos/README.chromium
index 2ee108e..85ff60a 100644
--- a/third_party/khronos/README.chromium
+++ b/third_party/khronos/README.chromium
@@ -36,6 +36,6 @@ EGL/eglplatform.h
 EGL/eglext.h
  - Added EGL_ARM_implicit_external_sync extension tokens
 KHR/khrplatform.h
- - Modified KHRONOS_APICALL and KHRONOS_APIENTRY
+ - Modified KHRONOS_APICALL
 DEPS
  - Added DEPS file to prevent inclusion of external dependencies.
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_copy_texture_thunks.cc b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_copy_texture_thunks.cc
index 22b5d4b..c2c1dfe 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_copy_texture_thunks.cc
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_copy_texture_thunks.cc
@@ -12,7 +12,7 @@ extern "C" {
 static MojoGLES2ImplChromiumCopyTextureThunks g_impl_chromium_copy_texture_thunks = {0};
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType gl##Function PARAMETERS {                             \
+  ReturnType GL_APIENTRY gl##Function PARAMETERS {                    \
     assert(g_impl_chromium_copy_texture_thunks.Function);             \
     return g_impl_chromium_copy_texture_thunks.Function ARGUMENTS;    \
   }
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_copy_texture_thunks.h b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_copy_texture_thunks.h
index 372558b..a165b8f 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_copy_texture_thunks.h
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_copy_texture_thunks.h
@@ -15,7 +15,7 @@ struct MojoGLES2ImplChromiumCopyTextureThunks {
   size_t size;  // Should be set to sizeof(*this).
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType(*Function) PARAMETERS;
+  ReturnType(GL_APIENTRY *Function) PARAMETERS;
 #include "mojo/public/c/gles2/gles2_call_visitor_chromium_copy_texture_autogen.h"
 #undef VISIT_GL_CALL
 };
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_image_thunks.cc b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_image_thunks.cc
index 5d9f844..fc16eac 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_image_thunks.cc
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_image_thunks.cc
@@ -12,7 +12,7 @@ extern "C" {
 static MojoGLES2ImplChromiumImageThunks g_impl_chromium_image_thunks = {0};
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType gl##Function PARAMETERS {                             \
+  ReturnType GL_APIENTRY gl##Function PARAMETERS {             \
     assert(g_impl_chromium_image_thunks.Function);             \
     return g_impl_chromium_image_thunks.Function ARGUMENTS;    \
   }
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_image_thunks.h b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_image_thunks.h
index 5e5662d..9a2706c 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_image_thunks.h
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_image_thunks.h
@@ -15,7 +15,7 @@ struct MojoGLES2ImplChromiumImageThunks {
   size_t size;  // Should be set to sizeof(*this).
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType(*Function) PARAMETERS;
+  ReturnType(GL_APIENTRY *Function) PARAMETERS;
 #include "mojo/public/c/gles2/gles2_call_visitor_chromium_image_autogen.h"
 #undef VISIT_GL_CALL
 };
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_miscellaneous_thunks.cc b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_miscellaneous_thunks.cc
index 6e6b67d..b0d0c63 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_miscellaneous_thunks.cc
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_miscellaneous_thunks.cc
@@ -13,7 +13,7 @@ static MojoGLES2ImplChromiumMiscellaneousThunks
     g_impl_chromium_miscellaneous_thunks = {0};
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS)  \
-  ReturnType gl##Function PARAMETERS {                              \
+  ReturnType GL_APIENTRY gl##Function PARAMETERS {                  \
     assert(g_impl_chromium_miscellaneous_thunks.Function);          \
     return g_impl_chromium_miscellaneous_thunks.Function ARGUMENTS; \
   }
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_miscellaneous_thunks.h b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_miscellaneous_thunks.h
index d71b3d2..853a842 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_miscellaneous_thunks.h
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_miscellaneous_thunks.h
@@ -15,7 +15,7 @@ struct MojoGLES2ImplChromiumMiscellaneousThunks {
   size_t size;  // Should be set to sizeof(*this).
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType(*Function) PARAMETERS;
+  ReturnType(GL_APIENTRY *Function) PARAMETERS;
 #include "mojo/public/c/gles2/gles2_call_visitor_chromium_miscellaneous_autogen.h"
 #undef VISIT_GL_CALL
 };
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_pixel_transfer_buffer_object_thunks.cc b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_pixel_transfer_buffer_object_thunks.cc
index d027ea9..c57af21 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_pixel_transfer_buffer_object_thunks.cc
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_pixel_transfer_buffer_object_thunks.cc
@@ -12,7 +12,7 @@ extern "C" {
 static MojoGLES2ImplChromiumPixelTransferBufferObjectThunks g_impl_chromium_pixel_transfer_buffer_object_thunks = {0};
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType gl##Function PARAMETERS {                             \
+  ReturnType GL_APIENTRY gl##Function PARAMETERS {                 \
     assert(g_impl_chromium_pixel_transfer_buffer_object_thunks.Function);             \
     return g_impl_chromium_pixel_transfer_buffer_object_thunks.Function ARGUMENTS;    \
   }
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_pixel_transfer_buffer_object_thunks.h b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_pixel_transfer_buffer_object_thunks.h
index 9a0f925..fb59e50 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_pixel_transfer_buffer_object_thunks.h
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_pixel_transfer_buffer_object_thunks.h
@@ -15,7 +15,7 @@ struct MojoGLES2ImplChromiumPixelTransferBufferObjectThunks {
   size_t size;  // Should be set to sizeof(*this).
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType(*Function) PARAMETERS;
+  ReturnType(GL_APIENTRY *Function) PARAMETERS;
 #include "mojo/public/c/gles2/gles2_call_visitor_chromium_pixel_transfer_buffer_object_autogen.h"
 #undef VISIT_GL_CALL
 };
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sub_image_thunks.cc b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sub_image_thunks.cc
index eae2467..9b16e5d 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sub_image_thunks.cc
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sub_image_thunks.cc
@@ -13,7 +13,7 @@ static MojoGLES2ImplChromiumSubImageThunks g_impl_chromium_sub_image_thunks = {
     0};
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType gl##Function PARAMETERS {                             \
+  ReturnType GL_APIENTRY gl##Function PARAMETERS {                 \
     assert(g_impl_chromium_sub_image_thunks.Function);             \
     return g_impl_chromium_sub_image_thunks.Function ARGUMENTS;    \
   }
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sub_image_thunks.h b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sub_image_thunks.h
index af37a91..cc8778d 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sub_image_thunks.h
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sub_image_thunks.h
@@ -15,7 +15,7 @@ struct MojoGLES2ImplChromiumSubImageThunks {
   size_t size;  // Should be set to sizeof(*this).
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType(*Function) PARAMETERS;
+  ReturnType(GL_APIENTRY *Function) PARAMETERS;
 #include "mojo/public/c/gles2/gles2_call_visitor_chromium_sub_image_autogen.h"
 #undef VISIT_GL_CALL
 };
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sync_point_thunks.cc b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sync_point_thunks.cc
index 0a47f33..c74b485 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sync_point_thunks.cc
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sync_point_thunks.cc
@@ -13,7 +13,7 @@ static MojoGLES2ImplChromiumSyncPointThunks g_impl_chromium_sync_point_thunks =
     {0};
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType gl##Function PARAMETERS {                             \
+  ReturnType GL_APIENTRY gl##Function PARAMETERS {                 \
     assert(g_impl_chromium_sync_point_thunks.Function);            \
     return g_impl_chromium_sync_point_thunks.Function ARGUMENTS;   \
   }
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sync_point_thunks.h b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sync_point_thunks.h
index af6817e..2e9876a 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sync_point_thunks.h
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_sync_point_thunks.h
@@ -15,7 +15,7 @@ struct MojoGLES2ImplChromiumSyncPointThunks {
   size_t size;  // Should be set to sizeof(*this).
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType(*Function) PARAMETERS;
+  ReturnType(GL_APIENTRY *Function) PARAMETERS;
 #include "mojo/public/c/gles2/gles2_call_visitor_chromium_sync_point_autogen.h"
 #undef VISIT_GL_CALL
 };
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_texture_mailbox_thunks.cc b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_texture_mailbox_thunks.cc
index db2bc81..e84bc91 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_texture_mailbox_thunks.cc
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_texture_mailbox_thunks.cc
@@ -13,7 +13,7 @@ static MojoGLES2ImplChromiumTextureMailboxThunks
     g_impl_chromium_texture_mailbox_thunks = {0};
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS)    \
-  ReturnType gl##Function PARAMETERS {                                \
+  ReturnType GL_APIENTRY gl##Function PARAMETERS {                    \
     assert(g_impl_chromium_texture_mailbox_thunks.Function);          \
     return g_impl_chromium_texture_mailbox_thunks.Function ARGUMENTS; \
   }
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_texture_mailbox_thunks.h b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_texture_mailbox_thunks.h
index 839e441..4574e72 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_texture_mailbox_thunks.h
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_chromium_texture_mailbox_thunks.h
@@ -15,7 +15,7 @@ struct MojoGLES2ImplChromiumTextureMailboxThunks {
   size_t size;  // Should be set to sizeof(*this).
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType(*Function) PARAMETERS;
+  ReturnType(GL_APIENTRY *Function) PARAMETERS;
 #include "mojo/public/c/gles2/gles2_call_visitor_chromium_texture_mailbox_autogen.h"
 #undef VISIT_GL_CALL
 };
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_occlusion_query_ext_thunks.cc b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_occlusion_query_ext_thunks.cc
index a5f7b06..b673a25 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_occlusion_query_ext_thunks.cc
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_occlusion_query_ext_thunks.cc
@@ -13,7 +13,7 @@ static MojoGLES2ImplOcclusionQueryExtThunks g_impl_occlusion_query_ext_thunks =
     {0};
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType gl##Function PARAMETERS {                             \
+  ReturnType GL_APIENTRY gl##Function PARAMETERS {                 \
     assert(g_impl_occlusion_query_ext_thunks.Function);            \
     return g_impl_occlusion_query_ext_thunks.Function ARGUMENTS;   \
   }
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_occlusion_query_ext_thunks.h b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_occlusion_query_ext_thunks.h
index 57f1c61..4339188 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_occlusion_query_ext_thunks.h
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_occlusion_query_ext_thunks.h
@@ -15,7 +15,7 @@ struct MojoGLES2ImplOcclusionQueryExtThunks {
   size_t size;  // Should be set to sizeof(*this).
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType(*Function) PARAMETERS;
+  ReturnType(GL_APIENTRY *Function) PARAMETERS;
 #include "mojo/public/c/gles2/gles2_call_visitor_occlusion_query_ext_autogen.h"
 #undef VISIT_GL_CALL
 };
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_thunks.cc b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_thunks.cc
index 66dbc39..1acf5a4 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_thunks.cc
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_thunks.cc
@@ -12,7 +12,7 @@ extern "C" {
 static MojoGLES2ImplThunks g_impl_thunks = {0};
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType gl##Function PARAMETERS {                             \
+  ReturnType GL_APIENTRY gl##Function PARAMETERS {                 \
     assert(g_impl_thunks.Function);                                \
     return g_impl_thunks.Function ARGUMENTS;                       \
   }
diff --git a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_thunks.h b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_thunks.h
index 04174fa..47765f2 100644
--- a/third_party/mojo/src/mojo/public/platform/native/gles2_impl_thunks.h
+++ b/third_party/mojo/src/mojo/public/platform/native/gles2_impl_thunks.h
@@ -17,7 +17,7 @@ struct MojoGLES2ImplThunks {
   size_t size;  // Should be set to sizeof(MojoGLES2ImplThunks).
 
 #define VISIT_GL_CALL(Function, ReturnType, PARAMETERS, ARGUMENTS) \
-  ReturnType(*Function) PARAMETERS;
+  ReturnType(GL_APIENTRY *Function) PARAMETERS;
 #include "mojo/public/c/gles2/gles2_call_visitor_autogen.h"
 #undef VISIT_GL_CALL
 };
diff --git a/ui/gl/gl_bindings_skia_in_process.cc b/ui/gl/gl_bindings_skia_in_process.cc
index fe44954..d76bd7a 100644
--- a/ui/gl/gl_bindings_skia_in_process.cc
+++ b/ui/gl/gl_bindings_skia_in_process.cc
@@ -17,618 +17,794 @@ extern "C" {
 // via gl_bindings.h use call-type GL_BINDING_CALL, which on Windows is stdcall.
 // Skia has been built such that its GrGLInterface GL pointers are __cdecl.
 
-GLvoid StubGLActiveTexture(GLenum texture) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLActiveTexture(GLenum texture) {
   glActiveTexture(texture);
 }
 
-GLvoid StubGLAttachShader(GLuint program, GLuint shader) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLAttachShader(GLuint program, GLuint shader) {
   glAttachShader(program, shader);
 }
 
-GLvoid StubGLBeginQuery(GLenum target, GLuint id) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBeginQuery(GLenum target, GLuint id) {
   glBeginQuery(target, id);
 }
 
-GLvoid StubGLBindAttribLocation(GLuint program, GLuint index,
-                                const char* name) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindAttribLocation(GLuint program,
+                                                    GLuint index,
+                                                    const char* name) {
   glBindAttribLocation(program, index, name);
 }
 
-GLvoid StubGLBindBuffer(GLenum target, GLuint buffer) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindBuffer(GLenum target, GLuint buffer) {
   glBindBuffer(target, buffer);
 }
 
-GLvoid StubGLBindFragDataLocation(GLuint program, GLuint colorNumber,
-                                  const GLchar * name) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindFragDataLocation(GLuint program,
+                                                      GLuint colorNumber,
+                                                      const GLchar* name) {
   glBindFragDataLocation(program, colorNumber, name);
 }
 
-GLvoid StubGLBindFragDataLocationIndexed(GLuint program, GLuint colorNumber,
-                                         GLuint index, const GLchar * name) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLBindFragDataLocationIndexed(GLuint program,
+                                  GLuint colorNumber,
+                                  GLuint index,
+                                  const GLchar* name) {
   glBindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
-GLvoid StubGLBindFramebuffer(GLenum target, GLuint framebuffer) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindFramebuffer(GLenum target,
+                                                 GLuint framebuffer) {
   glBindFramebufferEXT(target, framebuffer);
 }
 
-GLvoid StubGLBindRenderbuffer(GLenum target, GLuint renderbuffer) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindRenderbuffer(GLenum target,
+                                                  GLuint renderbuffer) {
   glBindRenderbufferEXT(target, renderbuffer);
 }
 
-GLvoid StubGLBindTexture(GLenum target, GLuint texture) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindTexture(GLenum target, GLuint texture) {
   glBindTexture(target, texture);
 }
 
-GLvoid StubGLBindVertexArray(GLuint array) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBindVertexArray(GLuint array) {
   glBindVertexArrayOES(array);
 }
 
-GLvoid StubGLBlendBarrier() {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBlendBarrier() {
   glBlendBarrierKHR();
 }
 
-GLvoid StubGLBlendColor(GLclampf red, GLclampf green, GLclampf blue,
-                        GLclampf alpha) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBlendColor(GLclampf red,
+                                            GLclampf green,
+                                            GLclampf blue,
+                                            GLclampf alpha) {
   glBlendColor(red, green, blue, alpha);
 }
 
-GLvoid StubGLBlendEquation(GLenum mode) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBlendEquation(GLenum mode) {
   glBlendEquation(mode);
 }
 
-GLvoid StubGLBlendFunc(GLenum sfactor, GLenum dfactor) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBlendFunc(GLenum sfactor, GLenum dfactor) {
   glBlendFunc(sfactor, dfactor);
 }
 
-GLvoid StubGLBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
-                             GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
-                             GLbitfield mask, GLenum filter) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBlitFramebuffer(GLint srcX0,
+                                                 GLint srcY0,
+                                                 GLint srcX1,
+                                                 GLint srcY1,
+                                                 GLint dstX0,
+                                                 GLint dstY0,
+                                                 GLint dstX1,
+                                                 GLint dstY1,
+                                                 GLbitfield mask,
+                                                 GLenum filter) {
   glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1,
                        mask, filter);
 }
 
-GLvoid StubGLBufferData(GLenum target, GLsizeiptr size, const void* data,
-                        GLenum usage) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBufferData(GLenum target,
+                                            GLsizeiptr size,
+                                            const void* data,
+                                            GLenum usage) {
   glBufferData(target, size, data, usage);
 }
 
-GLvoid StubGLBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
-                           const void* data) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLBufferSubData(GLenum target,
+                                               GLintptr offset,
+                                               GLsizeiptr size,
+                                               const void* data) {
   glBufferSubData(target, offset, size, data);
 }
 
-GLenum StubGLCheckFramebufferStatus(GLenum target) {
+GLenum GR_GL_FUNCTION_TYPE StubGLCheckFramebufferStatus(GLenum target) {
   return glCheckFramebufferStatusEXT(target);
 }
 
-GLvoid StubGLClear(GLbitfield mask) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLClear(GLbitfield mask) {
   glClear(mask);
 }
 
-GLvoid StubGLClearColor(GLclampf red, GLclampf green, GLclampf blue,
-                        GLclampf alpha) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLClearColor(GLclampf red,
+                                            GLclampf green,
+                                            GLclampf blue,
+                                            GLclampf alpha) {
   glClearColor(red, green, blue, alpha);
 }
 
-GLvoid StubGLClearStencil(GLint s) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLClearStencil(GLint s) {
   glClearStencil(s);
 }
 
-GLvoid StubGLColorMask(GLboolean red, GLboolean green, GLboolean blue,
-                       GLboolean alpha) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLColorMask(GLboolean red,
+                                           GLboolean green,
+                                           GLboolean blue,
+                                           GLboolean alpha) {
   glColorMask(red, green, blue, alpha);
 }
 
-GLvoid StubGLCompileShader(GLuint shader) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLCompileShader(GLuint shader) {
   glCompileShader(shader);
 }
 
-GLvoid StubGLCompressedTexImage2D(GLenum target, GLint level,
-                                  GLenum internalformat, GLsizei width,
-                                  GLsizei height, GLint border,
-                                  GLsizei imageSize, const void* data) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLCompressedTexImage2D(GLenum target,
+                                                      GLint level,
+                                                      GLenum internalformat,
+                                                      GLsizei width,
+                                                      GLsizei height,
+                                                      GLint border,
+                                                      GLsizei imageSize,
+                                                      const void* data) {
   glCompressedTexImage2D(target, level, internalformat, width, height, border,
                          imageSize, data);
 }
 
-GLvoid StubGLCopyTexSubImage2D(GLenum target, GLint level,
-                               GLint xoffset, GLint yoffset,
-                               GLint x, GLint y,
-                               GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLCopyTexSubImage2D(GLenum target,
+                                                   GLint level,
+                                                   GLint xoffset,
+                                                   GLint yoffset,
+                                                   GLint x,
+                                                   GLint y,
+                                                   GLsizei width,
+                                                   GLsizei height) {
   glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
-GLuint StubGLCreateProgram(void) {
+GLuint GR_GL_FUNCTION_TYPE StubGLCreateProgram(void) {
   return glCreateProgram();
 }
 
-GLuint StubGLCreateShader(GLenum type) {
+GLuint GR_GL_FUNCTION_TYPE StubGLCreateShader(GLenum type) {
   return glCreateShader(type);
 }
 
-GLvoid StubGLCullFace(GLenum mode) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLCullFace(GLenum mode) {
   glCullFace(mode);
 }
 
-GLvoid StubGLDeleteBuffers(GLsizei n, const GLuint* buffers) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteBuffers(GLsizei n,
+                                               const GLuint* buffers) {
   glDeleteBuffersARB(n, buffers);
 }
 
-GLvoid StubGLDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLDeleteFramebuffers(GLsizei n, const GLuint* framebuffers) {
   glDeleteFramebuffersEXT(n, framebuffers);
 }
 
-GLvoid StubGLDeleteQueries(GLsizei n, const GLuint* ids) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteQueries(GLsizei n, const GLuint* ids) {
   glDeleteQueries(n, ids);
 }
 
-GLvoid StubGLDeleteProgram(GLuint program) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteProgram(GLuint program) {
   glDeleteProgram(program);
 }
 
-GLvoid StubGLDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) {
   glDeleteRenderbuffersEXT(n, renderbuffers);
 }
 
-GLvoid StubGLDeleteShader(GLuint shader) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteShader(GLuint shader) {
   glDeleteShader(shader);
 }
 
-GLvoid StubGLDeleteTextures(GLsizei n, const GLuint* textures) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteTextures(GLsizei n,
+                                                const GLuint* textures) {
   glDeleteTextures(n, textures);
 }
 
-GLvoid StubGLDeleteVertexArrays(GLsizei n, const GLuint* arrays) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDeleteVertexArrays(GLsizei n,
+                                                    const GLuint* arrays) {
   glDeleteVertexArraysOES(n, arrays);
 }
 
-GLvoid StubGLDepthMask(GLboolean flag) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDepthMask(GLboolean flag) {
   glDepthMask(flag);
 }
 
-GLvoid StubGLDisable(GLenum cap) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDisable(GLenum cap) {
   glDisable(cap);
 }
 
-GLvoid StubGLDisableVertexAttribArray(GLuint index) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDisableVertexAttribArray(GLuint index) {
   glDisableVertexAttribArray(index);
 }
 
-GLvoid StubGLDiscardFramebuffer(GLenum target, GLsizei numAttachments,
-                                const GLenum *attachments) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDiscardFramebuffer(GLenum target,
+                                                    GLsizei numAttachments,
+                                                    const GLenum* attachments) {
   glDiscardFramebufferEXT(target, numAttachments, attachments);
 }
 
-GLvoid StubGLDrawArrays(GLenum mode, GLint first, GLsizei count) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDrawArrays(GLenum mode,
+                                            GLint first,
+                                            GLsizei count) {
   glDrawArrays(mode, first, count);
 }
 
-GLvoid StubGLDrawBuffer(GLenum mode) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDrawBuffer(GLenum mode) {
   glDrawBuffer(mode);
 }
 
-GLvoid StubGLDrawBuffers(GLsizei n, const GLenum* bufs) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDrawBuffers(GLsizei n, const GLenum* bufs) {
   glDrawBuffersARB(n, bufs);
 }
 
-GLvoid StubGLDrawElements(GLenum mode, GLsizei count, GLenum type,
-                          const void* indices) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLDrawElements(GLenum mode,
+                                              GLsizei count,
+                                              GLenum type,
+                                              const void* indices) {
   glDrawElements(mode, count, type, indices);
 }
 
-GLvoid StubGLEnable(GLenum cap) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLEnable(GLenum cap) {
   glEnable(cap);
 }
 
-GLvoid StubGLEnableVertexAttribArray(GLuint index) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLEnableVertexAttribArray(GLuint index) {
   glEnableVertexAttribArray(index);
 }
 
-GLvoid StubGLEndQuery(GLenum target) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLEndQuery(GLenum target) {
   glEndQuery(target);
 }
 
-GLvoid StubGLFinish() {
+GLvoid GR_GL_FUNCTION_TYPE StubGLFinish() {
   glFinish();
 }
 
-GLvoid StubGLFlush() {
+GLvoid GR_GL_FUNCTION_TYPE StubGLFlush() {
   glFlush();
 }
 
-GLvoid StubGLFlushMappedBufferRange(GLenum target, GLintptr offset,
-                                    GLsizeiptr length) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLFlushMappedBufferRange(GLenum target,
+                                                        GLintptr offset,
+                                                        GLsizeiptr length) {
   glFlushMappedBufferRange(target, offset, length);
 }
 
-GLvoid StubGLFramebufferRenderbuffer(GLenum target, GLenum attachment,
-                                     GLenum renderbuffertarget,
-                                     GLuint renderbuffer) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLFramebufferRenderbuffer(GLenum target,
+                              GLenum attachment,
+                              GLenum renderbuffertarget,
+                              GLuint renderbuffer) {
   glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget,
                                renderbuffer);
 }
 
-GLvoid StubGLFramebufferTexture2D(GLenum target, GLenum attachment,
-                                  GLenum textarget, GLuint texture,
-                                  GLint level) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLFramebufferTexture2D(GLenum target,
+                                                      GLenum attachment,
+                                                      GLenum textarget,
+                                                      GLuint texture,
+                                                      GLint level) {
   glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
 }
 
-GLvoid StubGLFramebufferTexture2DMultisample(GLenum target, GLenum attachment,
-                                  GLenum textarget, GLuint texture,
-                                  GLint level, GLsizei samples) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLFramebufferTexture2DMultisample(GLenum target,
+                                      GLenum attachment,
+                                      GLenum textarget,
+                                      GLuint texture,
+                                      GLint level,
+                                      GLsizei samples) {
   glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture,
       level, samples);
 }
 
-GLvoid StubGLFrontFace(GLenum mode) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLFrontFace(GLenum mode) {
   glFrontFace(mode);
 }
 
-GLvoid StubGLGenBuffers(GLsizei n, GLuint* buffers) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenBuffers(GLsizei n, GLuint* buffers) {
   glGenBuffersARB(n, buffers);
 }
 
-GLvoid StubGLGenFramebuffers(GLsizei n, GLuint* framebuffers) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenFramebuffers(GLsizei n,
+                                                 GLuint* framebuffers) {
   glGenFramebuffersEXT(n, framebuffers);
 }
 
-GLvoid StubGLGenQueries(GLsizei n, GLuint* ids) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenQueries(GLsizei n, GLuint* ids) {
   glGenQueries(n, ids);
 }
 
-GLvoid StubGLGenRenderbuffers(GLsizei n, GLuint* renderbuffers) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenRenderbuffers(GLsizei n,
+                                                  GLuint* renderbuffers) {
   glGenRenderbuffersEXT(n, renderbuffers);
 }
 
-GLvoid StubGLGenTextures(GLsizei n, GLuint* textures) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenTextures(GLsizei n, GLuint* textures) {
   glGenTextures(n, textures);
 }
 
-GLvoid StubGLGenVertexArrays(GLsizei n, GLuint* arrays) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenVertexArrays(GLsizei n, GLuint* arrays) {
   glGenVertexArraysOES(n, arrays);
 }
 
-GLvoid StubGLGenerateMipmap(GLenum target){
+GLvoid GR_GL_FUNCTION_TYPE StubGLGenerateMipmap(GLenum target) {
   glGenerateMipmapEXT(target);
 }
 
-GLvoid StubGLGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetBufferParameteriv(GLenum target,
+                                                      GLenum pname,
+                                                      GLint* params) {
   glGetBufferParameteriv(target, pname, params);
 }
 
-GLvoid StubGLGetFramebufferAttachmentParameteriv(GLenum target,
-                                                 GLenum attachment,
-                                                 GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLGetFramebufferAttachmentParameteriv(GLenum target,
+                                          GLenum attachment,
+                                          GLenum pname,
+                                          GLint* params) {
   glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
 }
 
-GLenum StubGLGetError() {
+GLenum GR_GL_FUNCTION_TYPE StubGLGetError() {
   return glGetError();
 }
 
-GLvoid StubGLGetIntegerv(GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetIntegerv(GLenum pname, GLint* params) {
   glGetIntegerv(pname, params);
 }
 
-GLvoid StubGLGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length,
-                               char* infolog) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetProgramInfoLog(GLuint program,
+                                                   GLsizei bufsize,
+                                                   GLsizei* length,
+                                                   char* infolog) {
   glGetProgramInfoLog(program, bufsize, length, infolog);
 }
 
-GLvoid StubGLGetProgramiv(GLuint program, GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetProgramiv(GLuint program,
+                                              GLenum pname,
+                                              GLint* params) {
   glGetProgramiv(program, pname, params);
 }
 
-GLvoid StubGLGetRenderbufferParameteriv(GLenum target,
-                                        GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetRenderbufferParameteriv(GLenum target,
+                                                            GLenum pname,
+                                                            GLint* params) {
   glGetRenderbufferParameterivEXT(target, pname, params);
 }
 
-GLvoid StubGLGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length,
-                              char* infolog) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetShaderInfoLog(GLuint shader,
+                                                  GLsizei bufsize,
+                                                  GLsizei* length,
+                                                  char* infolog) {
   glGetShaderInfoLog(shader, bufsize, length, infolog);
 }
 
-GLvoid StubGLGetShaderiv(GLuint shader, GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetShaderiv(GLuint shader,
+                                             GLenum pname,
+                                             GLint* params) {
   glGetShaderiv(shader, pname, params);
 }
 
-GLvoid StubGLGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
-                                      GLint *range, GLint *precision) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetShaderPrecisionFormat(GLenum shadertype,
+                                                          GLenum precisiontype,
+                                                          GLint* range,
+                                                          GLint* precision) {
   glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
-const GLubyte* StubGLGetString(GLenum name) {
+const GLubyte* GR_GL_FUNCTION_TYPE StubGLGetString(GLenum name) {
   return glGetString(name);
 }
 
-const GLubyte* StubGLGetStringi(GLenum name, GLuint index) {
+const GLubyte* GR_GL_FUNCTION_TYPE StubGLGetStringi(GLenum name, GLuint index) {
   return glGetStringi(name, index);
 }
 
-GLvoid StubGLGetQueryiv(GLenum target, GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetQueryiv(GLenum target,
+                                            GLenum pname,
+                                            GLint* params) {
   glGetQueryiv(target, pname, params);
 }
 
-GLvoid StubGLGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetQueryObjecti64v(GLuint id,
+                                                    GLenum pname,
+                                                    GLint64* params) {
   glGetQueryObjecti64v(id, pname, params);
 }
 
-GLvoid StubGLGetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetQueryObjectiv(GLuint id,
+                                                  GLenum pname,
+                                                  GLint* params) {
   glGetQueryObjectiv(id, pname, params);
 }
 
-GLvoid StubGLGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetQueryObjectui64v(GLuint id,
+                                                     GLenum pname,
+                                                     GLuint64* params) {
   glGetQueryObjectui64v(id, pname, params);
 }
 
-GLvoid StubGLGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetQueryObjectuiv(GLuint id,
+                                                   GLenum pname,
+                                                   GLuint* params) {
   glGetQueryObjectuiv(id, pname, params);
 }
 
-GLvoid StubGLGetTexLevelParameteriv(GLenum target, GLint level,
-                                    GLenum pname, GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLGetTexLevelParameteriv(GLenum target,
+                                                        GLint level,
+                                                        GLenum pname,
+                                                        GLint* params) {
   glGetTexLevelParameteriv(target, level, pname, params);
 }
 
-GLint StubGLGetUniformLocation(GLuint program, const char* name) {
+GLint GR_GL_FUNCTION_TYPE StubGLGetUniformLocation(GLuint program,
+                                                   const char* name) {
   return glGetUniformLocation(program, name);
 }
 
-GLvoid StubGLInsertEventMarker(GLsizei length, const char* marker) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLInsertEventMarker(GLsizei length,
+                                                   const char* marker) {
   glInsertEventMarkerEXT(length, marker);
 }
 
-GLvoid StubGLInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
-                                   const GLenum* attachments) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLInvalidateFramebuffer(GLenum target,
+                            GLsizei numAttachments,
+                            const GLenum* attachments) {
   glInvalidateFramebuffer(target, numAttachments, attachments);
 }
 
-GLvoid StubGLInvalidateSubFramebuffer(GLenum target,
-                                      GLsizei numAttachments,
-                                      const GLenum* attachments,
-                                      GLint x, GLint y,
-                                      GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLInvalidateSubFramebuffer(GLenum target,
+                               GLsizei numAttachments,
+                               const GLenum* attachments,
+                               GLint x,
+                               GLint y,
+                               GLsizei width,
+                               GLsizei height) {
   glInvalidateSubFramebuffer(target, numAttachments, attachments,
                              x, y, width, height);
 }
 
-GLvoid StubGLLineWidth(GLfloat width) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLLineWidth(GLfloat width) {
   glLineWidth(width);
 }
 
-GLvoid StubGLLinkProgram(GLuint program) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLLinkProgram(GLuint program) {
   glLinkProgram(program);
 }
 
-void* StubGLMapBuffer(GLenum target, GLenum access) {
+void* GR_GL_FUNCTION_TYPE StubGLMapBuffer(GLenum target, GLenum access) {
   return glMapBuffer(target, access);
 }
 
-void* StubGLMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
-                           GLbitfield access) {
+void* GR_GL_FUNCTION_TYPE StubGLMapBufferRange(GLenum target,
+                                               GLintptr offset,
+                                               GLsizeiptr length,
+                                               GLbitfield access) {
   return glMapBufferRange(target, offset, length, access);
 }
 
-GLvoid StubGLPixelStorei(GLenum pname, GLint param) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLPixelStorei(GLenum pname, GLint param) {
   glPixelStorei(pname, param);
 }
 
-GLvoid StubGLPopGroupMarker() {
+GLvoid GR_GL_FUNCTION_TYPE StubGLPopGroupMarker() {
   glPopGroupMarkerEXT();
 }
 
-GLvoid StubGLPushGroupMarker(GLsizei length, const char* marker) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLPushGroupMarker(GLsizei length,
+                                                 const char* marker) {
   glPushGroupMarkerEXT(length, marker);
 }
 
-GLvoid StubGLQueryCounter(GLuint id, GLenum target) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLQueryCounter(GLuint id, GLenum target) {
   glQueryCounter(id, target);
 }
 
-GLvoid StubGLReadBuffer(GLenum src) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLReadBuffer(GLenum src) {
   glReadBuffer(src);
 }
 
-GLvoid StubGLReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
-                        GLenum format, GLenum type, void* pixels) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLReadPixels(GLint x,
+                                            GLint y,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLenum format,
+                                            GLenum type,
+                                            void* pixels) {
   glReadPixels(x, y, width, height, format, type, pixels);
 }
 
-GLvoid StubGLRenderbufferStorage(GLenum target, GLenum internalformat,
-                                 GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLRenderbufferStorage(GLenum target,
+                                                     GLenum internalformat,
+                                                     GLsizei width,
+                                                     GLsizei height) {
   glRenderbufferStorageEXT(target, internalformat, width, height);
 }
 
-GLvoid StubGLRenderbufferStorageMultisample(GLenum target, GLsizei samples,
-                                            GLenum internalformat,
-                                            GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLRenderbufferStorageMultisample(GLenum target,
+                                     GLsizei samples,
+                                     GLenum internalformat,
+                                     GLsizei width,
+                                     GLsizei height) {
   glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width,
                                       height);
 }
 
-GLvoid StubGLScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLScissor(GLint x,
+                                         GLint y,
+                                         GLsizei width,
+                                         GLsizei height) {
   glScissor(x, y, width, height);
 }
 
-GLvoid StubGLShaderSource(GLuint shader, GLsizei count, const char* const* str,
-                          const GLint* length) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLShaderSource(GLuint shader,
+                                              GLsizei count,
+                                              const char* const* str,
+                                              const GLint* length) {
   glShaderSource(shader, count, str, length);
 }
 
-GLvoid StubGLStencilFunc(GLenum func, GLint ref, GLuint mask) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilFunc(GLenum func,
+                                             GLint ref,
+                                             GLuint mask) {
   glStencilFunc(func, ref, mask);
 }
 
-GLvoid StubGLStencilFuncSeparate(GLenum face, GLenum func, GLint ref,
-                                 GLuint mask) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilFuncSeparate(GLenum face,
+                                                     GLenum func,
+                                                     GLint ref,
+                                                     GLuint mask) {
   glStencilFuncSeparate(face, func, ref, mask);
 }
 
-GLvoid StubGLStencilMask(GLuint mask) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilMask(GLuint mask) {
   glStencilMask(mask);
 }
 
-GLvoid StubGLStencilMaskSeparate(GLenum face, GLuint mask) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilMaskSeparate(GLenum face, GLuint mask) {
   glStencilMaskSeparate(face, mask);
 }
 
-GLvoid StubGLStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilOp(GLenum fail,
+                                           GLenum zfail,
+                                           GLenum zpass) {
   glStencilOp(fail, zfail, zpass);
 }
 
-GLvoid StubGLStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail,
-                               GLenum zpass) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLStencilOpSeparate(GLenum face,
+                                                   GLenum fail,
+                                                   GLenum zfail,
+                                                   GLenum zpass) {
   glStencilOpSeparate(face, fail, zfail, zpass);
 }
 
-GLvoid StubGLTexImage2D(GLenum target, GLint level, GLint internalformat,
-                        GLsizei width, GLsizei height, GLint border,
-                        GLenum format, GLenum type, const void* pixels) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLTexImage2D(GLenum target,
+                                            GLint level,
+                                            GLint internalformat,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLint border,
+                                            GLenum format,
+                                            GLenum type,
+                                            const void* pixels) {
   glTexImage2D(target, level, internalformat, width, height, border, format,
                type, pixels);
 }
 
-GLvoid StubGLTexParameteri(GLenum target, GLenum pname, GLint param) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLTexParameteri(GLenum target,
+                                               GLenum pname,
+                                               GLint param) {
   glTexParameteri(target, pname, param);
 }
 
-GLvoid StubGLTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLTexParameteriv(GLenum target,
+                                                GLenum pname,
+                                                const GLint* params) {
   glTexParameteriv(target, pname, params);
 }
 
-GLvoid StubGLTexStorage2D(GLenum target, GLsizei levels, GLenum internalFormat,
-                          GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLTexStorage2D(GLenum target,
+                                              GLsizei levels,
+                                              GLenum internalFormat,
+                                              GLsizei width,
+                                              GLsizei height) {
   glTexStorage2DEXT(target, levels, internalFormat, width, height);
 }
 
-GLvoid StubGLTexSubImage2D(GLenum target, GLint level, GLint xoffset,
-                           GLint yoffset, GLsizei width, GLsizei height,
-                           GLenum format, GLenum type, const void* pixels) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLTexSubImage2D(GLenum target,
+                                               GLint level,
+                                               GLint xoffset,
+                                               GLint yoffset,
+                                               GLsizei width,
+                                               GLsizei height,
+                                               GLenum format,
+                                               GLenum type,
+                                               const void* pixels) {
   glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type,
                   pixels);
 }
 
-GLvoid StubGLUniform1f(GLint location, GLfloat v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform1f(GLint location, GLfloat v) {
   glUniform1f(location, v);
 }
 
-GLvoid StubGLUniform1i(GLint location, GLint v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform1i(GLint location, GLint v) {
   glUniform1i(location, v);
 }
 
-GLvoid StubGLUniform1fv(GLint location, GLsizei count, const GLfloat* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform1fv(GLint location,
+                                            GLsizei count,
+                                            const GLfloat* v) {
   glUniform1fv(location, count, v);
 }
 
-GLvoid StubGLUniform1iv(GLint location, GLsizei count, const GLint* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform1iv(GLint location,
+                                            GLsizei count,
+                                            const GLint* v) {
   glUniform1iv(location, count, v);
 }
 
-GLvoid StubGLUniform2f(GLint location, GLfloat v0, GLfloat v1) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform2f(GLint location,
+                                           GLfloat v0,
+                                           GLfloat v1) {
   glUniform2f(location, v0, v1);
 }
 
-GLvoid StubGLUniform2i(GLint location, GLint v0, GLint v1) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform2i(GLint location, GLint v0, GLint v1) {
   glUniform2i(location, v0, v1);
 }
 
-GLvoid StubGLUniform2fv(GLint location, GLsizei count, const GLfloat* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform2fv(GLint location,
+                                            GLsizei count,
+                                            const GLfloat* v) {
   glUniform2fv(location, count, v);
 }
 
-GLvoid StubGLUniform2iv(GLint location, GLsizei count, const GLint* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform2iv(GLint location,
+                                            GLsizei count,
+                                            const GLint* v) {
   glUniform2iv(location, count, v);
 }
 
-GLvoid StubGLUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform3f(GLint location,
+                                           GLfloat v0,
+                                           GLfloat v1,
+                                           GLfloat v2) {
   glUniform3f(location, v0, v1, v2);
 }
 
-GLvoid StubGLUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform3i(GLint location,
+                                           GLint v0,
+                                           GLint v1,
+                                           GLint v2) {
   glUniform3i(location, v0, v1, v2);
 }
 
-GLvoid StubGLUniform3fv(GLint location, GLsizei count, const GLfloat* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform3fv(GLint location,
+                                            GLsizei count,
+                                            const GLfloat* v) {
   glUniform3fv(location, count, v);
 }
 
-GLvoid StubGLUniform3iv(GLint location, GLsizei count, const GLint* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform3iv(GLint location,
+                                            GLsizei count,
+                                            const GLint* v) {
   glUniform3iv(location, count, v);
 }
 
-GLvoid StubGLUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2,
-                       GLfloat v3) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform4f(GLint location,
+                                           GLfloat v0,
+                                           GLfloat v1,
+                                           GLfloat v2,
+                                           GLfloat v3) {
   glUniform4f(location, v0, v1, v2, v3);
 }
 
-GLvoid StubGLUniform4i(GLint location, GLint v0, GLint v1, GLint v2,
-                       GLint v3) {
+GLvoid GR_GL_FUNCTION_TYPE
+StubGLUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
   glUniform4i(location, v0, v1, v2, v3);
 }
 
-GLvoid StubGLUniform4fv(GLint location, GLsizei count, const GLfloat* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform4fv(GLint location,
+                                            GLsizei count,
+                                            const GLfloat* v) {
   glUniform4fv(location, count, v);
 }
 
-GLvoid StubGLUniform4iv(GLint location, GLsizei count, const GLint* v) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniform4iv(GLint location,
+                                            GLsizei count,
+                                            const GLint* v) {
   glUniform4iv(location, count, v);
 }
 
-GLvoid StubGLUniformMatrix2fv(GLint location, GLsizei count,
-                              GLboolean transpose, const GLfloat* value) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniformMatrix2fv(GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat* value) {
   glUniformMatrix2fv(location, count, transpose, value);
 }
 
-GLvoid StubGLUniformMatrix3fv(GLint location, GLsizei count,
-                              GLboolean transpose, const GLfloat* value) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniformMatrix3fv(GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat* value) {
   glUniformMatrix3fv(location, count, transpose, value);
 }
 
-GLvoid StubGLUniformMatrix4fv(GLint location, GLsizei count,
-                              GLboolean transpose, const GLfloat* value) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUniformMatrix4fv(GLint location,
+                                                  GLsizei count,
+                                                  GLboolean transpose,
+                                                  const GLfloat* value) {
   glUniformMatrix4fv(location, count, transpose, value);
 }
 
-GLboolean StubGLUnmapBuffer(GLenum target) {
+GLboolean GR_GL_FUNCTION_TYPE StubGLUnmapBuffer(GLenum target) {
   return glUnmapBuffer(target);
 }
 
-GLvoid StubGLUseProgram(GLuint program) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLUseProgram(GLuint program) {
   glUseProgram(program);
 }
 
-GLvoid StubGLVertexAttrib1f(GLuint indx, const GLfloat value) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLVertexAttrib1f(GLuint indx,
+                                                const GLfloat value) {
   glVertexAttrib1f(indx, value);
 }
 
-GLvoid StubGLVertexAttrib2fv(GLuint indx, const GLfloat* values) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLVertexAttrib2fv(GLuint indx,
+                                                 const GLfloat* values) {
   glVertexAttrib2fv(indx, values);
 }
 
-GLvoid StubGLVertexAttrib3fv(GLuint indx, const GLfloat* values) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLVertexAttrib3fv(GLuint indx,
+                                                 const GLfloat* values) {
   glVertexAttrib3fv(indx, values);
 }
 
-GLvoid StubGLVertexAttrib4fv(GLuint indx, const GLfloat* values) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLVertexAttrib4fv(GLuint indx,
+                                                 const GLfloat* values) {
   glVertexAttrib4fv(indx, values);
 }
 
-GLvoid StubGLVertexAttribPointer(GLuint indx, GLint size, GLenum type,
-                                 GLboolean normalized, GLsizei stride,
-                                 const void* ptr) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLVertexAttribPointer(GLuint indx,
+                                                     GLint size,
+                                                     GLenum type,
+                                                     GLboolean normalized,
+                                                     GLsizei stride,
+                                                     const void* ptr) {
   glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
 }
 
-GLvoid StubGLViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
+GLvoid GR_GL_FUNCTION_TYPE StubGLViewport(GLint x,
+                                          GLint y,
+                                          GLsizei width,
+                                          GLsizei height) {
   glViewport(x, y, width, height);
 }
 
-GLint StubGLGetProgramResourceLocation(GLuint program,
-                                       GLenum programInterface,
-                                       const char* name) {
+GLint GR_GL_FUNCTION_TYPE
+StubGLGetProgramResourceLocation(GLuint program,
+                                 GLenum programInterface,
+                                 const char* name) {
   return glGetProgramResourceLocation(program, programInterface, name);
 }