Make windows GrGLCreateNatriveInterface not us GL.h and not use linker to resolve gl functions. Instead load the GL library and use GetProcAddress.

R=robertphillips@google.com
Review URL: https://codereview.appspot.com/7308047

git-svn-id: http://skia.googlecode.com/svn/trunk@7582 2bbb7eff-a529-9590-31e7-b0007b416f81

1 files changed, 214 insertions, 190 deletions

diff --git a/src/gpu/gl/win/GrGLCreateNativeInterface_win.cpp b/src/gpu/gl/win/GrGLCreateNativeInterface_win.cpp
index ef8eccc2b9..3a7bdd5c8f 100644
--- a/src/gpu/gl/win/GrGLCreateNativeInterface_win.cpp
+++ b/src/gpu/gl/win/GrGLCreateNativeInterface_win.cpp
@@ -11,7 +11,6 @@
 #include "../GrGLUtil.h"
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
-#include <GL/GL.h>
 
 /*
  * Windows makes the GL funcs all be __stdcall instead of __cdecl :(
@@ -19,17 +18,42 @@
  * Otherwise, a springboard would be needed that hides the calling convention.
  */
 
-#define GR_GL_GET_PROC(F) interface->f ## F = (GrGL ## F ## Proc) wglGetProcAddress("gl" #F);
-#define GR_GL_GET_PROC_SUFFIX(F, S) interface->f ## F = (GrGL ## F ## Proc) wglGetProcAddress("gl" #F #S);
+#define SET_PROC(F) interface->f ## F = (GrGL ## F ## Proc) GetProcAddress(alu.get(), "gl" #F);
+#define WGL_SET_PROC(F) interface->f ## F = (GrGL ## F ## Proc) wglGetProcAddress("gl" #F);
+#define WGL_SET_PROC_SUFFIX(F, S) interface->f ## F = \
+                                  (GrGL ## F ## Proc) wglGetProcAddress("gl" #F #S);
+
+class AutoLibraryUnload {
+public:
+    AutoLibraryUnload(const char* moduleName) {
+        fModule = LoadLibrary(moduleName);
+    }
+    ~AutoLibraryUnload() {
+        if (NULL != fModule) {
+            FreeLibrary(fModule);
+        }
+    }
+    HMODULE get() const { return fModule; }
+
+private:
+    HMODULE fModule;
+};
 
 const GrGLInterface* GrGLCreateNativeInterface() {
     // wglGetProcAddress requires a context.
     // GL Function pointers retrieved in one context may not be valid in another
     // context. For that reason we create a new GrGLInterface each time we're
     // called.
+    AutoLibraryUnload alu("opengl32.dll");
+    if (NULL == alu.get()) {
+        return NULL;
+    }
+    GrGLGetStringProc glGetString =
+        (GrGLGetStringProc) GetProcAddress(alu.get(), "glGetString");
+    
     if (NULL != wglGetCurrentContext()) {
-        const char* versionString = (const char*) glGetString(GL_VERSION);
-        const char* extString = (const char*) glGetString(GL_EXTENSIONS);
+        const char* versionString = (const char*) glGetString(GR_GL_VERSION);
+        const char* extString = (const char*) glGetString(GR_GL_EXTENSIONS);
         GrGLVersion glVer = GrGLGetVersionFromString(versionString);
 
         if (glVer < GR_GL_VER(1,5)) {
@@ -40,226 +64,226 @@ const GrGLInterface* GrGLCreateNativeInterface() {
 
         // Functions that are part of GL 1.1 will return NULL in
         // wglGetProcAddress
-        interface->fBindTexture = glBindTexture;
-        interface->fBlendFunc = glBlendFunc;
+        SET_PROC(BindTexture)
+        SET_PROC(BlendFunc)
 
         if (glVer >= GR_GL_VER(1,4) ||
             GrGLHasExtensionFromString("GL_ARB_imaging", extString) ||
             GrGLHasExtensionFromString("GL_EXT_blend_color", extString)) {
-            GR_GL_GET_PROC(BlendColor);
+            WGL_SET_PROC(BlendColor);
         }
 
-        interface->fClear = glClear;
-        interface->fClearColor = glClearColor;
-        interface->fClearStencil = glClearStencil;
-        interface->fColorMask = glColorMask;
-        interface->fCullFace = glCullFace;
-        interface->fDeleteTextures = glDeleteTextures;
-        interface->fDepthMask = glDepthMask;
-        interface->fDisable = glDisable;
-        interface->fDrawArrays = glDrawArrays;
-        interface->fDrawElements = glDrawElements;
-        interface->fDrawBuffer = glDrawBuffer;
-        interface->fEnable = glEnable;
-        interface->fFrontFace = glFrontFace;
-        interface->fFinish = glFinish;
-        interface->fFlush = glFlush;
-        interface->fGenTextures = glGenTextures;
-        interface->fGetError = glGetError;
-        interface->fGetIntegerv = glGetIntegerv;
-        interface->fGetString = glGetString;
-        interface->fGetTexLevelParameteriv = glGetTexLevelParameteriv;
-        interface->fLineWidth = glLineWidth;
-        interface->fLoadIdentity = glLoadIdentity;
-        interface->fLoadMatrixf = glLoadMatrixf;
-        interface->fMatrixMode = glMatrixMode;
-        interface->fPixelStorei = glPixelStorei;
-        interface->fReadBuffer = glReadBuffer;
-        interface->fReadPixels = glReadPixels;
-        interface->fScissor = glScissor;
-        interface->fStencilFunc = glStencilFunc;
-        interface->fStencilMask = glStencilMask;
-        interface->fStencilOp = glStencilOp;
-        interface->fTexImage2D = glTexImage2D;
-        interface->fTexParameteri = glTexParameteri;
-        interface->fTexParameteriv = glTexParameteriv;
+        SET_PROC(Clear)
+        SET_PROC(ClearColor)
+        SET_PROC(ClearStencil)
+        SET_PROC(ColorMask)
+        SET_PROC(CullFace)
+        SET_PROC(DeleteTextures)
+        SET_PROC(DepthMask)
+        SET_PROC(Disable)
+        SET_PROC(DrawArrays)
+        SET_PROC(DrawElements)
+        SET_PROC(DrawBuffer)
+        SET_PROC(Enable)
+        SET_PROC(FrontFace)
+        SET_PROC(Finish)
+        SET_PROC(Flush)
+        SET_PROC(GenTextures)
+        SET_PROC(GetError)
+        SET_PROC(GetIntegerv)
+        SET_PROC(GetString)
+        SET_PROC(GetTexLevelParameteriv)
+        SET_PROC(LineWidth)
+        SET_PROC(LoadIdentity)
+        SET_PROC(LoadMatrixf)
+        SET_PROC(MatrixMode)
+        SET_PROC(PixelStorei)
+        SET_PROC(ReadBuffer)
+        SET_PROC(ReadPixels)
+        SET_PROC(Scissor)
+        SET_PROC(StencilFunc)
+        SET_PROC(StencilMask)
+        SET_PROC(StencilOp)
+        SET_PROC(TexImage2D)
+        SET_PROC(TexParameteri)
+        SET_PROC(TexParameteriv)
         if (glVer >= GR_GL_VER(4,2) ||
             GrGLHasExtensionFromString("GL_ARB_texture_storage", extString)) {
-            GR_GL_GET_PROC(TexStorage2D);
+            WGL_SET_PROC(TexStorage2D);
         } else if (GrGLHasExtensionFromString("GL_EXT_texture_storage", extString)) {
-            GR_GL_GET_PROC_SUFFIX(TexStorage2D, EXT);
+            WGL_SET_PROC_SUFFIX(TexStorage2D, EXT);
         }
-        interface->fTexSubImage2D = glTexSubImage2D;
-        interface->fViewport = glViewport;
+        SET_PROC(TexSubImage2D)
+        SET_PROC(Viewport)
 
-        GR_GL_GET_PROC(ActiveTexture);
-        GR_GL_GET_PROC(AttachShader);
-        GR_GL_GET_PROC(BeginQuery);
-        GR_GL_GET_PROC(BindAttribLocation);
-        GR_GL_GET_PROC(BindBuffer);
-        GR_GL_GET_PROC(BindFragDataLocation);
-        GR_GL_GET_PROC(BufferData);
-        GR_GL_GET_PROC(BufferSubData);
-        GR_GL_GET_PROC(CompileShader);
-        GR_GL_GET_PROC(CompressedTexImage2D);
-        GR_GL_GET_PROC(CreateProgram);
-        GR_GL_GET_PROC(CreateShader);
-        GR_GL_GET_PROC(DeleteBuffers);
-        GR_GL_GET_PROC(DeleteQueries);
-        GR_GL_GET_PROC(DeleteProgram);
-        GR_GL_GET_PROC(DeleteShader);
-        GR_GL_GET_PROC(DisableVertexAttribArray);
-        GR_GL_GET_PROC(DrawBuffers);
-        GR_GL_GET_PROC(EnableVertexAttribArray);
-        GR_GL_GET_PROC(EndQuery);
-        GR_GL_GET_PROC(GenBuffers);
-        GR_GL_GET_PROC(GenQueries);
-        GR_GL_GET_PROC(GetBufferParameteriv);
-        GR_GL_GET_PROC(GetQueryiv);
-        GR_GL_GET_PROC(GetQueryObjectiv);
-        GR_GL_GET_PROC(GetQueryObjectuiv);
+        WGL_SET_PROC(ActiveTexture);
+        WGL_SET_PROC(AttachShader);
+        WGL_SET_PROC(BeginQuery);
+        WGL_SET_PROC(BindAttribLocation);
+        WGL_SET_PROC(BindBuffer);
+        WGL_SET_PROC(BindFragDataLocation);
+        WGL_SET_PROC(BufferData);
+        WGL_SET_PROC(BufferSubData);
+        WGL_SET_PROC(CompileShader);
+        WGL_SET_PROC(CompressedTexImage2D);
+        WGL_SET_PROC(CreateProgram);
+        WGL_SET_PROC(CreateShader);
+        WGL_SET_PROC(DeleteBuffers);
+        WGL_SET_PROC(DeleteQueries);
+        WGL_SET_PROC(DeleteProgram);
+        WGL_SET_PROC(DeleteShader);
+        WGL_SET_PROC(DisableVertexAttribArray);
+        WGL_SET_PROC(DrawBuffers);
+        WGL_SET_PROC(EnableVertexAttribArray);
+        WGL_SET_PROC(EndQuery);
+        WGL_SET_PROC(GenBuffers);
+        WGL_SET_PROC(GenQueries);
+        WGL_SET_PROC(GetBufferParameteriv);
+        WGL_SET_PROC(GetQueryiv);
+        WGL_SET_PROC(GetQueryObjectiv);
+        WGL_SET_PROC(GetQueryObjectuiv);
         if (glVer > GR_GL_VER(3,3) ||
             GrGLHasExtensionFromString("GL_ARB_timer_query", extString)) {
-            GR_GL_GET_PROC(GetQueryObjecti64v);
-            GR_GL_GET_PROC(GetQueryObjectui64v);
-            GR_GL_GET_PROC(QueryCounter);
+            WGL_SET_PROC(GetQueryObjecti64v);
+            WGL_SET_PROC(GetQueryObjectui64v);
+            WGL_SET_PROC(QueryCounter);
         } else if (GrGLHasExtensionFromString("GL_EXT_timer_query", extString)) {
-            GR_GL_GET_PROC_SUFFIX(GetQueryObjecti64v, EXT);
-            GR_GL_GET_PROC_SUFFIX(GetQueryObjectui64v, EXT);
+            WGL_SET_PROC_SUFFIX(GetQueryObjecti64v, EXT);
+            WGL_SET_PROC_SUFFIX(GetQueryObjectui64v, EXT);
         }
-        GR_GL_GET_PROC(GetProgramInfoLog);
-        GR_GL_GET_PROC(GetProgramiv);
-        GR_GL_GET_PROC(GetShaderInfoLog);
-        GR_GL_GET_PROC(GetShaderiv);
-        GR_GL_GET_PROC(GetUniformLocation);
-        GR_GL_GET_PROC(LinkProgram);
+        WGL_SET_PROC(GetProgramInfoLog);
+        WGL_SET_PROC(GetProgramiv);
+        WGL_SET_PROC(GetShaderInfoLog);
+        WGL_SET_PROC(GetShaderiv);
+        WGL_SET_PROC(GetUniformLocation);
+        WGL_SET_PROC(LinkProgram);
         if (GrGLHasExtensionFromString("GL_NV_framebuffer_multisample_coverage", extString)) {
-            GR_GL_GET_PROC_SUFFIX(RenderbufferStorageMultisampleCoverage, NV);
+            WGL_SET_PROC_SUFFIX(RenderbufferStorageMultisampleCoverage, NV);
         }
-        GR_GL_GET_PROC(ShaderSource);
-        GR_GL_GET_PROC(StencilFuncSeparate);
-        GR_GL_GET_PROC(StencilMaskSeparate);
-        GR_GL_GET_PROC(StencilOpSeparate);
-        GR_GL_GET_PROC(Uniform1f);
-        GR_GL_GET_PROC(Uniform1i);
-        GR_GL_GET_PROC(Uniform1fv);
-        GR_GL_GET_PROC(Uniform1iv);
-        GR_GL_GET_PROC(Uniform2f);
-        GR_GL_GET_PROC(Uniform2i);
-        GR_GL_GET_PROC(Uniform2fv);
-        GR_GL_GET_PROC(Uniform2iv);
-        GR_GL_GET_PROC(Uniform3f);
-        GR_GL_GET_PROC(Uniform3i);
-        GR_GL_GET_PROC(Uniform3fv);
-        GR_GL_GET_PROC(Uniform3iv);
-        GR_GL_GET_PROC(Uniform4f);
-        GR_GL_GET_PROC(Uniform4i);
-        GR_GL_GET_PROC(Uniform4fv);
-        GR_GL_GET_PROC(Uniform4iv);
-        GR_GL_GET_PROC(UniformMatrix2fv);
-        GR_GL_GET_PROC(UniformMatrix3fv);
-        GR_GL_GET_PROC(UniformMatrix4fv);
-        GR_GL_GET_PROC(UseProgram);
-        GR_GL_GET_PROC(VertexAttrib4fv);
-        GR_GL_GET_PROC(VertexAttribPointer);
-        GR_GL_GET_PROC(BindFragDataLocationIndexed);
+        WGL_SET_PROC(ShaderSource);
+        WGL_SET_PROC(StencilFuncSeparate);
+        WGL_SET_PROC(StencilMaskSeparate);
+        WGL_SET_PROC(StencilOpSeparate);
+        WGL_SET_PROC(Uniform1f);
+        WGL_SET_PROC(Uniform1i);
+        WGL_SET_PROC(Uniform1fv);
+        WGL_SET_PROC(Uniform1iv);
+        WGL_SET_PROC(Uniform2f);
+        WGL_SET_PROC(Uniform2i);
+        WGL_SET_PROC(Uniform2fv);
+        WGL_SET_PROC(Uniform2iv);
+        WGL_SET_PROC(Uniform3f);
+        WGL_SET_PROC(Uniform3i);
+        WGL_SET_PROC(Uniform3fv);
+        WGL_SET_PROC(Uniform3iv);
+        WGL_SET_PROC(Uniform4f);
+        WGL_SET_PROC(Uniform4i);
+        WGL_SET_PROC(Uniform4fv);
+        WGL_SET_PROC(Uniform4iv);
+        WGL_SET_PROC(UniformMatrix2fv);
+        WGL_SET_PROC(UniformMatrix3fv);
+        WGL_SET_PROC(UniformMatrix4fv);
+        WGL_SET_PROC(UseProgram);
+        WGL_SET_PROC(VertexAttrib4fv);
+        WGL_SET_PROC(VertexAttribPointer);
+        WGL_SET_PROC(BindFragDataLocationIndexed);
 
         // First look for GL3.0 FBO or GL_ARB_framebuffer_object (same since
         // GL_ARB_framebuffer_object doesn't use ARB suffix.)
         if (glVer > GR_GL_VER(3,0) ||
             GrGLHasExtensionFromString("GL_ARB_framebuffer_object", extString)) {
-            GR_GL_GET_PROC(GenFramebuffers);
-            GR_GL_GET_PROC(GetFramebufferAttachmentParameteriv);
-            GR_GL_GET_PROC(GetRenderbufferParameteriv);
-            GR_GL_GET_PROC(BindFramebuffer);
-            GR_GL_GET_PROC(FramebufferTexture2D);
-            GR_GL_GET_PROC(CheckFramebufferStatus);
-            GR_GL_GET_PROC(DeleteFramebuffers);
-            GR_GL_GET_PROC(RenderbufferStorage);
-            GR_GL_GET_PROC(GenRenderbuffers);
-            GR_GL_GET_PROC(DeleteRenderbuffers);
-            GR_GL_GET_PROC(FramebufferRenderbuffer);
-            GR_GL_GET_PROC(BindRenderbuffer);
-            GR_GL_GET_PROC(RenderbufferStorageMultisample);
-            GR_GL_GET_PROC(BlitFramebuffer);
+            WGL_SET_PROC(GenFramebuffers);
+            WGL_SET_PROC(GetFramebufferAttachmentParameteriv);
+            WGL_SET_PROC(GetRenderbufferParameteriv);
+            WGL_SET_PROC(BindFramebuffer);
+            WGL_SET_PROC(FramebufferTexture2D);
+            WGL_SET_PROC(CheckFramebufferStatus);
+            WGL_SET_PROC(DeleteFramebuffers);
+            WGL_SET_PROC(RenderbufferStorage);
+            WGL_SET_PROC(GenRenderbuffers);
+            WGL_SET_PROC(DeleteRenderbuffers);
+            WGL_SET_PROC(FramebufferRenderbuffer);
+            WGL_SET_PROC(BindRenderbuffer);
+            WGL_SET_PROC(RenderbufferStorageMultisample);
+            WGL_SET_PROC(BlitFramebuffer);
         } else if (GrGLHasExtensionFromString("GL_EXT_framebuffer_object",
                    extString)) {
-            GR_GL_GET_PROC_SUFFIX(GenFramebuffers, EXT);
-            GR_GL_GET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT);
-            GR_GL_GET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT);
-            GR_GL_GET_PROC_SUFFIX(BindFramebuffer, EXT);
-            GR_GL_GET_PROC_SUFFIX(FramebufferTexture2D, EXT);
-            GR_GL_GET_PROC_SUFFIX(CheckFramebufferStatus, EXT);
-            GR_GL_GET_PROC_SUFFIX(DeleteFramebuffers, EXT);
-            GR_GL_GET_PROC_SUFFIX(RenderbufferStorage, EXT);
-            GR_GL_GET_PROC_SUFFIX(GenRenderbuffers, EXT);
-            GR_GL_GET_PROC_SUFFIX(DeleteRenderbuffers, EXT);
-            GR_GL_GET_PROC_SUFFIX(FramebufferRenderbuffer, EXT);
-            GR_GL_GET_PROC_SUFFIX(BindRenderbuffer, EXT);
+            WGL_SET_PROC_SUFFIX(GenFramebuffers, EXT);
+            WGL_SET_PROC_SUFFIX(GetFramebufferAttachmentParameteriv, EXT);
+            WGL_SET_PROC_SUFFIX(GetRenderbufferParameteriv, EXT);
+            WGL_SET_PROC_SUFFIX(BindFramebuffer, EXT);
+            WGL_SET_PROC_SUFFIX(FramebufferTexture2D, EXT);
+            WGL_SET_PROC_SUFFIX(CheckFramebufferStatus, EXT);
+            WGL_SET_PROC_SUFFIX(DeleteFramebuffers, EXT);
+            WGL_SET_PROC_SUFFIX(RenderbufferStorage, EXT);
+            WGL_SET_PROC_SUFFIX(GenRenderbuffers, EXT);
+            WGL_SET_PROC_SUFFIX(DeleteRenderbuffers, EXT);
+            WGL_SET_PROC_SUFFIX(FramebufferRenderbuffer, EXT);
+            WGL_SET_PROC_SUFFIX(BindRenderbuffer, EXT);
             if (GrGLHasExtensionFromString("GL_EXT_framebuffer_multisample", extString)) {
-                GR_GL_GET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT);
+                WGL_SET_PROC_SUFFIX(RenderbufferStorageMultisample, EXT);
             }
             if (GrGLHasExtensionFromString("GL_EXT_framebuffer_blit", extString)) {
-                GR_GL_GET_PROC_SUFFIX(BlitFramebuffer, EXT);
+                WGL_SET_PROC_SUFFIX(BlitFramebuffer, EXT);
             }
         } else {
             // we must have FBOs
             delete interface;
             return NULL;
         }
-        GR_GL_GET_PROC(MapBuffer);
-        GR_GL_GET_PROC(UnmapBuffer);
+        WGL_SET_PROC(MapBuffer);
+        WGL_SET_PROC(UnmapBuffer);
 
         if (GrGLHasExtensionFromString("GL_NV_path_rendering", extString)) {
-            GR_GL_GET_PROC_SUFFIX(PathCommands, NV);
-            GR_GL_GET_PROC_SUFFIX(PathCoords, NV);
-            GR_GL_GET_PROC_SUFFIX(PathSubCommands, NV);
-            GR_GL_GET_PROC_SUFFIX(PathSubCoords, NV);
-            GR_GL_GET_PROC_SUFFIX(PathString, NV);
-            GR_GL_GET_PROC_SUFFIX(PathGlyphs, NV);
-            GR_GL_GET_PROC_SUFFIX(PathGlyphRange, NV);
-            GR_GL_GET_PROC_SUFFIX(WeightPaths, NV);
-            GR_GL_GET_PROC_SUFFIX(CopyPath, NV);
-            GR_GL_GET_PROC_SUFFIX(InterpolatePaths, NV);
-            GR_GL_GET_PROC_SUFFIX(TransformPath, NV);
-            GR_GL_GET_PROC_SUFFIX(PathParameteriv, NV);
-            GR_GL_GET_PROC_SUFFIX(PathParameteri, NV);
-            GR_GL_GET_PROC_SUFFIX(PathParameterfv, NV);
-            GR_GL_GET_PROC_SUFFIX(PathParameterf, NV);
-            GR_GL_GET_PROC_SUFFIX(PathDashArray, NV);
-            GR_GL_GET_PROC_SUFFIX(GenPaths, NV);
-            GR_GL_GET_PROC_SUFFIX(DeletePaths, NV);
-            GR_GL_GET_PROC_SUFFIX(IsPath, NV);
-            GR_GL_GET_PROC_SUFFIX(PathStencilFunc, NV);
-            GR_GL_GET_PROC_SUFFIX(PathStencilDepthOffset, NV);
-            GR_GL_GET_PROC_SUFFIX(StencilFillPath, NV);
-            GR_GL_GET_PROC_SUFFIX(StencilStrokePath, NV);
-            GR_GL_GET_PROC_SUFFIX(StencilFillPathInstanced, NV);
-            GR_GL_GET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
-            GR_GL_GET_PROC_SUFFIX(PathCoverDepthFunc, NV);
-            GR_GL_GET_PROC_SUFFIX(PathColorGen, NV);
-            GR_GL_GET_PROC_SUFFIX(PathTexGen, NV);
-            GR_GL_GET_PROC_SUFFIX(PathFogGen, NV);
-            GR_GL_GET_PROC_SUFFIX(CoverFillPath, NV);
-            GR_GL_GET_PROC_SUFFIX(CoverStrokePath, NV);
-            GR_GL_GET_PROC_SUFFIX(CoverFillPathInstanced, NV);
-            GR_GL_GET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathParameteriv, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathParameterfv, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathCommands, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathCoords, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathDashArray, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathMetrics, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathMetricRange, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathSpacing, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathColorGeniv, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathColorGenfv, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathTexGeniv, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathTexGenfv, NV);
-            GR_GL_GET_PROC_SUFFIX(IsPointInFillPath, NV);
-            GR_GL_GET_PROC_SUFFIX(IsPointInStrokePath, NV);
-            GR_GL_GET_PROC_SUFFIX(GetPathLength, NV);
-            GR_GL_GET_PROC_SUFFIX(PointAlongPath, NV);
+            WGL_SET_PROC_SUFFIX(PathCommands, NV);
+            WGL_SET_PROC_SUFFIX(PathCoords, NV);
+            WGL_SET_PROC_SUFFIX(PathSubCommands, NV);
+            WGL_SET_PROC_SUFFIX(PathSubCoords, NV);
+            WGL_SET_PROC_SUFFIX(PathString, NV);
+            WGL_SET_PROC_SUFFIX(PathGlyphs, NV);
+            WGL_SET_PROC_SUFFIX(PathGlyphRange, NV);
+            WGL_SET_PROC_SUFFIX(WeightPaths, NV);
+            WGL_SET_PROC_SUFFIX(CopyPath, NV);
+            WGL_SET_PROC_SUFFIX(InterpolatePaths, NV);
+            WGL_SET_PROC_SUFFIX(TransformPath, NV);
+            WGL_SET_PROC_SUFFIX(PathParameteriv, NV);
+            WGL_SET_PROC_SUFFIX(PathParameteri, NV);
+            WGL_SET_PROC_SUFFIX(PathParameterfv, NV);
+            WGL_SET_PROC_SUFFIX(PathParameterf, NV);
+            WGL_SET_PROC_SUFFIX(PathDashArray, NV);
+            WGL_SET_PROC_SUFFIX(GenPaths, NV);
+            WGL_SET_PROC_SUFFIX(DeletePaths, NV);
+            WGL_SET_PROC_SUFFIX(IsPath, NV);
+            WGL_SET_PROC_SUFFIX(PathStencilFunc, NV);
+            WGL_SET_PROC_SUFFIX(PathStencilDepthOffset, NV);
+            WGL_SET_PROC_SUFFIX(StencilFillPath, NV);
+            WGL_SET_PROC_SUFFIX(StencilStrokePath, NV);
+            WGL_SET_PROC_SUFFIX(StencilFillPathInstanced, NV);
+            WGL_SET_PROC_SUFFIX(StencilStrokePathInstanced, NV);
+            WGL_SET_PROC_SUFFIX(PathCoverDepthFunc, NV);
+            WGL_SET_PROC_SUFFIX(PathColorGen, NV);
+            WGL_SET_PROC_SUFFIX(PathTexGen, NV);
+            WGL_SET_PROC_SUFFIX(PathFogGen, NV);
+            WGL_SET_PROC_SUFFIX(CoverFillPath, NV);
+            WGL_SET_PROC_SUFFIX(CoverStrokePath, NV);
+            WGL_SET_PROC_SUFFIX(CoverFillPathInstanced, NV);
+            WGL_SET_PROC_SUFFIX(CoverStrokePathInstanced, NV);
+            WGL_SET_PROC_SUFFIX(GetPathParameteriv, NV);
+            WGL_SET_PROC_SUFFIX(GetPathParameterfv, NV);
+            WGL_SET_PROC_SUFFIX(GetPathCommands, NV);
+            WGL_SET_PROC_SUFFIX(GetPathCoords, NV);
+            WGL_SET_PROC_SUFFIX(GetPathDashArray, NV);
+            WGL_SET_PROC_SUFFIX(GetPathMetrics, NV);
+            WGL_SET_PROC_SUFFIX(GetPathMetricRange, NV);
+            WGL_SET_PROC_SUFFIX(GetPathSpacing, NV);
+            WGL_SET_PROC_SUFFIX(GetPathColorGeniv, NV);
+            WGL_SET_PROC_SUFFIX(GetPathColorGenfv, NV);
+            WGL_SET_PROC_SUFFIX(GetPathTexGeniv, NV);
+            WGL_SET_PROC_SUFFIX(GetPathTexGenfv, NV);
+            WGL_SET_PROC_SUFFIX(IsPointInFillPath, NV);
+            WGL_SET_PROC_SUFFIX(IsPointInStrokePath, NV);
+            WGL_SET_PROC_SUFFIX(GetPathLength, NV);
+            WGL_SET_PROC_SUFFIX(PointAlongPath, NV);
         }
 
         interface->fBindingsExported = kDesktop_GrGLBinding;