Bug 1344433 - Reformat. - r=daoshengmu
authorJeff Gilbert <jgilbert@mozilla.com>
Fri, 03 Mar 2017 16:49:49 -0800
changeset 346138 a2624aa679c189d22240dc3dabedccae97e246f5
parent 346137 5dd77a2bc068928d1b6cedbc322b42865d507ad3
child 346139 b90bf52c69ead6ea8623d01b318c2cd69b40b9de
push id87740
push userjgilbert@mozilla.com
push dateMon, 06 Mar 2017 23:45:23 +0000
treeherdermozilla-inbound@c726adc9b217 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdaoshengmu
bugs1344433
milestone54.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1344433 - Reformat. - r=daoshengmu MozReview-Commit-ID: 8W0oGeHBYtR
gfx/gl/GLContextProviderCGL.mm
gfx/gl/GLContextProviderEGL.cpp
gfx/gl/GLContextProviderGLX.cpp
gfx/gl/GLContextProviderWGL.cpp
gfx/gl/GLLibraryEGL.cpp
gfx/gl/GLLibraryEGL.h
gfx/gl/GLLibraryLoader.cpp
gfx/gl/GLLibraryLoader.h
gfx/gl/GLXLibrary.h
gfx/gl/SharedSurfaceD3D11Interop.cpp
gfx/gl/WGLLibrary.h
--- a/gfx/gl/GLContextProviderCGL.mm
+++ b/gfx/gl/GLContextProviderCGL.mm
@@ -89,17 +89,16 @@ GLContextCGL::~GLContextCGL()
         if ([NSOpenGLContext currentContext] == mContext) {
             // Clear the current context before releasing. If we don't do
             // this, the next time we call [NSOpenGLContext currentContext],
             // "invalid context" will be printed to the console.
             [NSOpenGLContext clearCurrentContext];
         }
         [mContext release];
     }
-
 }
 
 bool
 GLContextCGL::Init()
 {
     if (!InitWithPrefix("gl", true))
         return false;
 
--- a/gfx/gl/GLContextProviderEGL.cpp
+++ b/gfx/gl/GLContextProviderEGL.cpp
@@ -417,17 +417,17 @@ GLContextEGL::ReleaseSurface() {
         mSurfaceOverride = EGL_NO_SURFACE;
     }
     mSurface = EGL_NO_SURFACE;
 }
 
 bool
 GLContextEGL::SetupLookupFunction()
 {
-    mLookupFunc = (PlatformLookupFunction)sEGLLibrary.mSymbols.fGetProcAddress;
+    mLookupFunc = sEGLLibrary.GetLookupFunction();
     return true;
 }
 
 bool
 GLContextEGL::SwapBuffers()
 {
     EGLSurface surface = mSurfaceOverride != EGL_NO_SURFACE
                           ? mSurfaceOverride
--- a/gfx/gl/GLContextProviderGLX.cpp
+++ b/gfx/gl/GLContextProviderGLX.cpp
@@ -94,66 +94,69 @@ GLXLibrary::EnsureInitialized()
         }
         reporter.SetSuccessful();
     }
 
     if (gfxEnv::GlxDebug()) {
         mDebug = true;
     }
 
-    GLLibraryLoader::SymLoadStruct symbols[] = {
+#define SYMBOL(X) { (PRFuncPtr*)&mSymbols.f##X, { "glX" #X, nullptr } }
+#define END_OF_SYMBOLS { nullptr, { nullptr } }
+
+    const GLLibraryLoader::SymLoadStruct symbols[] = {
         /* functions that were in GLX 1.0 */
-        { (PRFuncPtr*) &xDestroyContextInternal, { "glXDestroyContext", nullptr } },
-        { (PRFuncPtr*) &xMakeCurrentInternal, { "glXMakeCurrent", nullptr } },
-        { (PRFuncPtr*) &xSwapBuffersInternal, { "glXSwapBuffers", nullptr } },
-        { (PRFuncPtr*) &xQueryVersionInternal, { "glXQueryVersion", nullptr } },
-        { (PRFuncPtr*) &xGetCurrentContextInternal, { "glXGetCurrentContext", nullptr } },
-        { (PRFuncPtr*) &xWaitGLInternal, { "glXWaitGL", nullptr } },
-        { (PRFuncPtr*) &xWaitXInternal, { "glXWaitX", nullptr } },
+        SYMBOL(DestroyContext),
+        SYMBOL(MakeCurrent),
+        SYMBOL(SwapBuffers),
+        SYMBOL(QueryVersion),
+        SYMBOL(GetCurrentContext),
+        SYMBOL(WaitGL),
+        SYMBOL(WaitX),
         /* functions introduced in GLX 1.1 */
-        { (PRFuncPtr*) &xQueryExtensionsStringInternal, { "glXQueryExtensionsString", nullptr } },
-        { (PRFuncPtr*) &xGetClientStringInternal, { "glXGetClientString", nullptr } },
-        { (PRFuncPtr*) &xQueryServerStringInternal, { "glXQueryServerString", nullptr } },
+        SYMBOL(QueryExtensionsString),
+        SYMBOL(GetClientString),
+        SYMBOL(QueryServerString),
         /* functions introduced in GLX 1.3 */
-        { (PRFuncPtr*) &xChooseFBConfigInternal, { "glXChooseFBConfig", nullptr } },
-        { (PRFuncPtr*) &xGetFBConfigAttribInternal, { "glXGetFBConfigAttrib", nullptr } },
+        SYMBOL(ChooseFBConfig),
+        SYMBOL(GetFBConfigAttrib),
         // WARNING: xGetFBConfigs not set in symbols13_ext
-        { (PRFuncPtr*) &xGetFBConfigsInternal, { "glXGetFBConfigs", nullptr } },
+        SYMBOL(GetFBConfigs),
         // WARNING: symbols13_ext sets xCreateGLXPixmapWithConfig instead
-        { (PRFuncPtr*) &xCreatePixmapInternal, { "glXCreatePixmap", nullptr } },
-        { (PRFuncPtr*) &xDestroyPixmapInternal, { "glXDestroyPixmap", nullptr } },
-        { (PRFuncPtr*) &xCreateNewContextInternal, { "glXCreateNewContext", nullptr } },
+        SYMBOL(CreatePixmap),
+        SYMBOL(DestroyPixmap),
+        SYMBOL(CreateNewContext),
         /* functions introduced in GLX 1.4 */
-        { (PRFuncPtr*) &xGetProcAddressInternal, { "glXGetProcAddress", nullptr } },
-        { nullptr, { nullptr } }
+        SYMBOL(GetProcAddress),
+        END_OF_SYMBOLS
     };
 
-    GLLibraryLoader::SymLoadStruct symbols_texturefrompixmap[] = {
-        { (PRFuncPtr*) &xBindTexImageInternal, { "glXBindTexImageEXT", nullptr } },
-        { (PRFuncPtr*) &xReleaseTexImageInternal, { "glXReleaseTexImageEXT", nullptr } },
-        { nullptr, { nullptr } }
+    const GLLibraryLoader::SymLoadStruct symbols_texturefrompixmap[] = {
+        SYMBOL(BindTexImageEXT),
+        SYMBOL(ReleaseTexImageEXT),
+        END_OF_SYMBOLS
     };
 
-    GLLibraryLoader::SymLoadStruct symbols_createcontext[] = {
-        { (PRFuncPtr*) &xCreateContextAttribsInternal, { "glXCreateContextAttribsARB", nullptr } },
-        { nullptr, { nullptr } }
+    const GLLibraryLoader::SymLoadStruct symbols_createcontext[] = {
+        SYMBOL(CreateContextAttribsARB),
+        END_OF_SYMBOLS
     };
 
-    GLLibraryLoader::SymLoadStruct symbols_videosync[] = {
-      { (PRFuncPtr*) &xGetVideoSyncInternal, { "glXGetVideoSyncSGI", nullptr } },
-      { (PRFuncPtr*) &xWaitVideoSyncInternal, { "glXWaitVideoSyncSGI", nullptr } },
-      { nullptr, { nullptr } }
+    const GLLibraryLoader::SymLoadStruct symbols_videosync[] = {
+        SYMBOL(GetVideoSyncSGI),
+        SYMBOL(WaitVideoSyncSGI),
+        END_OF_SYMBOLS
     };
 
-    GLLibraryLoader::SymLoadStruct symbols_swapcontrol[] = {
-      { (PRFuncPtr*) &xSwapIntervalInternal, { "glXSwapIntervalEXT", nullptr } },
-      { nullptr, { nullptr } }
+    const GLLibraryLoader::SymLoadStruct symbols_swapcontrol[] = {
+        SYMBOL(SwapIntervalEXT),
+        END_OF_SYMBOLS
     };
 
-    if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, &symbols[0])) {
+    if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, symbols)) {
         NS_WARNING("Couldn't find required entry point in OpenGL shared library");
         return false;
     }
 
     Display* display = DefaultXDisplay();
     int screen = DefaultScreen(display);
 
     {
@@ -161,52 +164,59 @@ GLXLibrary::EnsureInitialized()
         if (!xQueryVersion(display, &major, &minor) ||
             major != 1 || minor < 4)
         {
             NS_ERROR("GLX version older than 1.4. (released in 2005)");
             return false;
         }
     }
 
+    const auto lookupFunction =
+        (GLLibraryLoader::PlatformLookupFunction)mSymbols.fGetProcAddress;
+
+    const auto fnLoadSymbols = [&](const GLLibraryLoader::SymLoadStruct* symbols) {
+        if (GLLibraryLoader::LoadSymbols(mOGLLibrary, symbols, lookupFunction))
+            return true;
+
+        GLLibraryLoader::ClearSymbols(symbols);
+        return false;
+    };
+
     const char* clientVendor = xGetClientString(display, LOCAL_GLX_VENDOR);
     const char* serverVendor = xQueryServerString(display, screen, LOCAL_GLX_VENDOR);
     const char* extensionsStr = xQueryExtensionsString(display, screen);
 
     if (HasExtension(extensionsStr, "GLX_EXT_texture_from_pixmap") &&
-        GLLibraryLoader::LoadSymbols(mOGLLibrary, symbols_texturefrompixmap,
-                                         (GLLibraryLoader::PlatformLookupFunction)&xGetProcAddress))
+        fnLoadSymbols(symbols_texturefrompixmap))
     {
         mUseTextureFromPixmap = gfxPrefs::UseGLXTextureFromPixmap();
     } else {
         mUseTextureFromPixmap = false;
         NS_WARNING("Texture from pixmap disabled");
     }
 
     if (HasExtension(extensionsStr, "GLX_ARB_create_context") &&
         HasExtension(extensionsStr, "GLX_ARB_create_context_profile") &&
-        GLLibraryLoader::LoadSymbols(mOGLLibrary, symbols_createcontext,
-                                     (GLLibraryLoader::PlatformLookupFunction)&xGetProcAddress))
+        fnLoadSymbols(symbols_createcontext))
     {
         mHasCreateContextAttribs = true;
     }
 
-    if (HasExtension(extensionsStr, "GLX_ARB_create_context_robustness"))
-    {
+    if (HasExtension(extensionsStr, "GLX_ARB_create_context_robustness")) {
         mHasRobustness = true;
     }
 
     if (HasExtension(extensionsStr, "GLX_SGI_video_sync") &&
-        GLLibraryLoader::LoadSymbols(mOGLLibrary, symbols_videosync,
-                                     (GLLibraryLoader::PlatformLookupFunction)&xGetProcAddress))
+        fnLoadSymbols(symbols_videosync))
     {
         mHasVideoSync = true;
     }
 
-    if (!(HasExtension(extensionsStr, "GLX_EXT_swap_control") &&
-          GLLibraryLoader::LoadSymbols(mOGLLibrary, symbols_swapcontrol)))
+    if (!HasExtension(extensionsStr, "GLX_EXT_swap_control") ||
+        !fnLoadSymbols(symbols_swapcontrol))
     {
         NS_WARNING("GLX_swap_control unsupported, ASAP mode may still block on buffer swaps.");
     }
 
     mIsATI = serverVendor && DoesStringMatch(serverVendor, "ATI");
     mIsNVIDIA = serverVendor && DoesStringMatch(serverVendor, "NVIDIA Corporation");
     mClientIsMesa = clientVendor && DoesStringMatch(clientVendor, "Mesa");
 
@@ -484,258 +494,244 @@ GLXLibrary::AfterGLXCall()
 #define AFTER_GLX_CALL do { } while(0)
 
 #endif
 
 void
 GLXLibrary::xDestroyContext(Display* display, GLXContext context)
 {
     BEFORE_GLX_CALL;
-    xDestroyContextInternal(display, context);
+    mSymbols.fDestroyContext(display, context);
     AFTER_GLX_CALL;
 }
 
 Bool
 GLXLibrary::xMakeCurrent(Display* display,
                          GLXDrawable drawable,
                          GLXContext context)
 {
     BEFORE_GLX_CALL;
-    Bool result = xMakeCurrentInternal(display, drawable, context);
+    const auto result = mSymbols.fMakeCurrent(display, drawable, context);
     AFTER_GLX_CALL;
     return result;
 }
 
 GLXContext
 GLXLibrary::xGetCurrentContext()
 {
     BEFORE_GLX_CALL;
-    GLXContext result = xGetCurrentContextInternal();
-    AFTER_GLX_CALL;
-    return result;
-}
-
-/* static */ void*
-GLXLibrary::xGetProcAddress(const char* procName)
-{
-    BEFORE_GLX_CALL;
-    void* result = sGLXLibrary.xGetProcAddressInternal(procName);
+    const auto result = mSymbols.fGetCurrentContext();
     AFTER_GLX_CALL;
     return result;
 }
 
 GLXFBConfig*
 GLXLibrary::xChooseFBConfig(Display* display,
                             int screen,
                             const int* attrib_list,
                             int* nelements)
 {
     BEFORE_GLX_CALL;
-    GLXFBConfig* result = xChooseFBConfigInternal(display, screen, attrib_list, nelements);
+    const auto result = mSymbols.fChooseFBConfig(display, screen, attrib_list, nelements);
     AFTER_GLX_CALL;
     return result;
 }
 
 GLXFBConfig*
 GLXLibrary::xGetFBConfigs(Display* display,
                           int screen,
                           int* nelements)
 {
     BEFORE_GLX_CALL;
-    GLXFBConfig* result = xGetFBConfigsInternal(display, screen, nelements);
+    const auto result = mSymbols.fGetFBConfigs(display, screen, nelements);
     AFTER_GLX_CALL;
     return result;
 }
 
 GLXContext
 GLXLibrary::xCreateNewContext(Display* display,
                               GLXFBConfig config,
                               int render_type,
                               GLXContext share_list,
                               Bool direct)
 {
     BEFORE_GLX_CALL;
-    GLXContext result = xCreateNewContextInternal(display, config,
-                                                  render_type,
-                                                  share_list, direct);
+    const auto result = mSymbols.fCreateNewContext(display, config, render_type,
+                                                   share_list, direct);
     AFTER_GLX_CALL;
     return result;
 }
 
 int
 GLXLibrary::xGetFBConfigAttrib(Display* display,
                                GLXFBConfig config,
                                int attribute,
                                int* value)
 {
     BEFORE_GLX_CALL;
-    int result = xGetFBConfigAttribInternal(display, config,
-                                            attribute, value);
+    const auto result = mSymbols.fGetFBConfigAttrib(display, config, attribute, value);
     AFTER_GLX_CALL;
     return result;
 }
 
 void
 GLXLibrary::xSwapBuffers(Display* display, GLXDrawable drawable)
 {
     BEFORE_GLX_CALL;
-    xSwapBuffersInternal(display, drawable);
+    mSymbols.fSwapBuffers(display, drawable);
     AFTER_GLX_CALL;
 }
 
 const char*
 GLXLibrary::xQueryExtensionsString(Display* display,
                                    int screen)
 {
     BEFORE_GLX_CALL;
-    const char* result = xQueryExtensionsStringInternal(display, screen);
+    const auto result = mSymbols.fQueryExtensionsString(display, screen);
     AFTER_GLX_CALL;
     return result;
 }
 
 const char*
 GLXLibrary::xGetClientString(Display* display,
                              int screen)
 {
     BEFORE_GLX_CALL;
-    const char* result = xGetClientStringInternal(display, screen);
+    const auto result = mSymbols.fGetClientString(display, screen);
     AFTER_GLX_CALL;
     return result;
 }
 
 const char*
 GLXLibrary::xQueryServerString(Display* display,
                                int screen, int name)
 {
     BEFORE_GLX_CALL;
-    const char* result = xQueryServerStringInternal(display, screen, name);
+    const auto result = mSymbols.fQueryServerString(display, screen, name);
     AFTER_GLX_CALL;
     return result;
 }
 
 GLXPixmap
 GLXLibrary::xCreatePixmap(Display* display,
                           GLXFBConfig config,
                           Pixmap pixmap,
                           const int* attrib_list)
 {
     BEFORE_GLX_CALL;
-    GLXPixmap result = xCreatePixmapInternal(display, config,
+    const auto result = mSymbols.fCreatePixmap(display, config,
                                              pixmap, attrib_list);
     AFTER_GLX_CALL;
     return result;
 }
 
 GLXPixmap
 GLXLibrary::xCreateGLXPixmapWithConfig(Display* display,
                                        GLXFBConfig config,
                                        Pixmap pixmap)
 {
     BEFORE_GLX_CALL;
-    GLXPixmap result = xCreateGLXPixmapWithConfigInternal(display, config, pixmap);
+    const auto result = mSymbols.fCreateGLXPixmapWithConfig(display, config, pixmap);
     AFTER_GLX_CALL;
     return result;
 }
 
 void
 GLXLibrary::xDestroyPixmap(Display* display, GLXPixmap pixmap)
 {
     BEFORE_GLX_CALL;
-    xDestroyPixmapInternal(display, pixmap);
+    mSymbols.fDestroyPixmap(display, pixmap);
     AFTER_GLX_CALL;
 }
 
 Bool
 GLXLibrary::xQueryVersion(Display* display,
                           int* major,
                           int* minor)
 {
     BEFORE_GLX_CALL;
-    Bool result = xQueryVersionInternal(display, major, minor);
+    const auto result = mSymbols.fQueryVersion(display, major, minor);
     AFTER_GLX_CALL;
     return result;
 }
 
 void
 GLXLibrary::xBindTexImage(Display* display,
                           GLXDrawable drawable,
                           int buffer,
                           const int* attrib_list)
 {
     BEFORE_GLX_CALL;
-    xBindTexImageInternal(display, drawable, buffer, attrib_list);
+    mSymbols.fBindTexImageEXT(display, drawable, buffer, attrib_list);
     AFTER_GLX_CALL;
 }
 
 void
 GLXLibrary::xReleaseTexImage(Display* display,
                              GLXDrawable drawable,
                              int buffer)
 {
     BEFORE_GLX_CALL;
-    xReleaseTexImageInternal(display, drawable, buffer);
+    mSymbols.fReleaseTexImageEXT(display, drawable, buffer);
     AFTER_GLX_CALL;
 }
 
 void
 GLXLibrary::xWaitGL()
 {
     BEFORE_GLX_CALL;
-    xWaitGLInternal();
+    mSymbols.fWaitGL();
     AFTER_GLX_CALL;
 }
 
 void
 GLXLibrary::xWaitX()
 {
     BEFORE_GLX_CALL;
-    xWaitXInternal();
+    mSymbols.fWaitX();
     AFTER_GLX_CALL;
 }
 
 GLXContext
 GLXLibrary::xCreateContextAttribs(Display* display,
                                   GLXFBConfig config,
                                   GLXContext share_list,
                                   Bool direct,
                                   const int* attrib_list)
 {
     BEFORE_GLX_CALL;
-    GLXContext result = xCreateContextAttribsInternal(display,
-                                                      config,
-                                                      share_list,
-                                                      direct,
-                                                      attrib_list);
+    const auto result = mSymbols.fCreateContextAttribsARB(display, config, share_list,
+                                                          direct, attrib_list);
     AFTER_GLX_CALL;
     return result;
 }
 
 int
 GLXLibrary::xGetVideoSync(unsigned int* count)
 {
     BEFORE_GLX_CALL;
-    int result = xGetVideoSyncInternal(count);
+    const auto result = mSymbols.fGetVideoSyncSGI(count);
     AFTER_GLX_CALL;
     return result;
 }
 
 int
 GLXLibrary::xWaitVideoSync(int divisor, int remainder, unsigned int* count)
 {
     BEFORE_GLX_CALL;
-    int result = xWaitVideoSyncInternal(divisor, remainder, count);
+    const auto result = mSymbols.fWaitVideoSyncSGI(divisor, remainder, count);
     AFTER_GLX_CALL;
     return result;
 }
 
 void
 GLXLibrary::xSwapInterval(Display* display, GLXDrawable drawable, int interval)
 {
     BEFORE_GLX_CALL;
-    xSwapIntervalInternal(display, drawable, interval);
+    mSymbols.fSwapIntervalEXT(display, drawable, interval);
     AFTER_GLX_CALL;
 }
 
 already_AddRefed<GLContextGLX>
 GLContextGLX::CreateGLContext(CreateContextFlags flags, const SurfaceCaps& caps,
                               GLContextGLX* shareContext, bool isOffscreen,
                               Display* display, GLXDrawable drawable, GLXFBConfig cfg,
                               bool deleteDrawable, gfxXlibSurface* pixmap,
@@ -901,17 +897,17 @@ GLContextGLX::MakeCurrentImpl(bool aForc
 bool
 GLContextGLX::IsCurrent() {
     return mGLX->xGetCurrentContext() == mContext;
 }
 
 bool
 GLContextGLX::SetupLookupFunction()
 {
-    mLookupFunc = (PlatformLookupFunction)&GLXLibrary::xGetProcAddress;
+    mLookupFunc = (PlatformLookupFunction)sGLXLibrary.GetGetProcAddress();
     return true;
 }
 
 bool
 GLContextGLX::IsDoubleBuffered() const
 {
     return mDoubleBuffered;
 }
--- a/gfx/gl/GLContextProviderWGL.cpp
+++ b/gfx/gl/GLContextProviderWGL.cpp
@@ -114,166 +114,165 @@ WGLLibrary::EnsureInitialized()
     if (!mOGLLibrary) {
         mOGLLibrary = PR_LoadLibrary(libGLFilename.c_str());
         if (!mOGLLibrary) {
             NS_WARNING("Couldn't load OpenGL library.");
             return false;
         }
     }
 
+#define SYMBOL(X) { (PRFuncPtr*)&mSymbols.f##X, { "wgl" #X, nullptr } }
+#define END_OF_SYMBOLS { nullptr, { nullptr } }
+
     const GLLibraryLoader::SymLoadStruct earlySymbols[] = {
-        { (PRFuncPtr*) &fCreateContext, { "wglCreateContext", nullptr } },
-        { (PRFuncPtr*) &fMakeCurrent, { "wglMakeCurrent", nullptr } },
-        { (PRFuncPtr*) &fGetProcAddress, { "wglGetProcAddress", nullptr } },
-        { (PRFuncPtr*) &fDeleteContext, { "wglDeleteContext", nullptr } },
-        { (PRFuncPtr*) &fGetCurrentContext, { "wglGetCurrentContext", nullptr } },
-        { (PRFuncPtr*) &fGetCurrentDC, { "wglGetCurrentDC", nullptr } },
-        { nullptr, { nullptr } }
+        SYMBOL(CreateContext),
+        SYMBOL(MakeCurrent),
+        SYMBOL(GetProcAddress),
+        SYMBOL(DeleteContext),
+        SYMBOL(GetCurrentContext),
+        SYMBOL(GetCurrentDC),
+        END_OF_SYMBOLS
     };
 
     if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, &earlySymbols[0])) {
         NS_WARNING("Couldn't find required entry points in OpenGL DLL (early init)");
         return false;
     }
 
     // This is ridiculous -- we have to actually create a context to
     // get the OpenGL ICD to load.
     mWindow = CreateDummyWindow(&mWindowDC);
     NS_ENSURE_TRUE(mWindow, false);
 
     // create rendering context
-    mWindowGLContext = fCreateContext(mWindowDC);
+    mWindowGLContext = mSymbols.fCreateContext(mWindowDC);
     NS_ENSURE_TRUE(mWindowGLContext, false);
 
-    if (!fMakeCurrent(mWindowDC, mWindowGLContext)) {
+    if (!mSymbols.fMakeCurrent(mWindowDC, mWindowGLContext)) {
         NS_WARNING("wglMakeCurrent failed");
         return false;
     }
 
-    const auto curCtx = fGetCurrentContext();
-    const auto curDC = fGetCurrentDC();
+    const auto& curCtx = mSymbols.fGetCurrentContext();
+    const auto& curDC = mSymbols.fGetCurrentDC();
 
-    const auto lookupFunc = (GLLibraryLoader::PlatformLookupFunction)fGetProcAddress;
+    const auto& lookupFunc = (GLLibraryLoader::PlatformLookupFunction)mSymbols.fGetProcAddress;
 
     // Now we can grab all the other symbols that we couldn't without having
     // a context current.
     const GLLibraryLoader::SymLoadStruct pbufferSymbols[] = {
-        { (PRFuncPtr*) &fCreatePbuffer, { "wglCreatePbufferARB", "wglCreatePbufferEXT", nullptr } },
-        { (PRFuncPtr*) &fDestroyPbuffer, { "wglDestroyPbufferARB", "wglDestroyPbufferEXT", nullptr } },
-        { (PRFuncPtr*) &fGetPbufferDC, { "wglGetPbufferDCARB", "wglGetPbufferDCEXT", nullptr } },
-        { (PRFuncPtr*) &fBindTexImage, { "wglBindTexImageARB", "wglBindTexImageEXT", nullptr } },
-        { (PRFuncPtr*) &fReleaseTexImage, { "wglReleaseTexImageARB", "wglReleaseTexImageEXT", nullptr } },
-        { nullptr, { nullptr } }
+        { (PRFuncPtr*)&mSymbols.fCreatePbuffer, { "wglCreatePbufferARB", "wglCreatePbufferEXT", nullptr } },
+        { (PRFuncPtr*)&mSymbols.fDestroyPbuffer, { "wglDestroyPbufferARB", "wglDestroyPbufferEXT", nullptr } },
+        { (PRFuncPtr*)&mSymbols.fGetPbufferDC, { "wglGetPbufferDCARB", "wglGetPbufferDCEXT", nullptr } },
+        { (PRFuncPtr*)&mSymbols.fBindTexImage, { "wglBindTexImageARB", "wglBindTexImageEXT", nullptr } },
+        { (PRFuncPtr*)&mSymbols.fReleaseTexImage, { "wglReleaseTexImageARB", "wglReleaseTexImageEXT", nullptr } },
+        END_OF_SYMBOLS
     };
 
     const GLLibraryLoader::SymLoadStruct pixFmtSymbols[] = {
-        { (PRFuncPtr*) &fChoosePixelFormat, { "wglChoosePixelFormatARB", "wglChoosePixelFormatEXT", nullptr } },
-        { (PRFuncPtr*) &fGetPixelFormatAttribiv, { "wglGetPixelFormatAttribivARB", "wglGetPixelFormatAttribivEXT", nullptr } },
-        { nullptr, { nullptr } }
+        { (PRFuncPtr*)&mSymbols.fChoosePixelFormat, { "wglChoosePixelFormatARB", "wglChoosePixelFormatEXT", nullptr } },
+        { (PRFuncPtr*)&mSymbols.fGetPixelFormatAttribiv, { "wglGetPixelFormatAttribivARB", "wglGetPixelFormatAttribivEXT", nullptr } },
+        END_OF_SYMBOLS
     };
 
-    if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, &pbufferSymbols[0], lookupFunc)) {
+    if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, pbufferSymbols, lookupFunc)) {
         // this isn't an error, just means that pbuffers aren't supported
-        fCreatePbuffer = nullptr;
+        ClearSymbols(pbufferSymbols);
     }
 
-    if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, &pixFmtSymbols[0], lookupFunc)) {
+    if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, pixFmtSymbols, lookupFunc)) {
         // this isn't an error, just means that we don't have the pixel format extension
-        fChoosePixelFormat = nullptr;
+        ClearSymbols(pixFmtSymbols);
     }
 
     const GLLibraryLoader::SymLoadStruct extensionsSymbols[] = {
-        { (PRFuncPtr*) &fGetExtensionsString, { "wglGetExtensionsStringARB", nullptr} },
-        { nullptr, { nullptr } }
+        SYMBOL(GetExtensionsStringARB),
+        END_OF_SYMBOLS
     };
 
     const GLLibraryLoader::SymLoadStruct robustnessSymbols[] = {
-        { (PRFuncPtr*) &fCreateContextAttribs, { "wglCreateContextAttribsARB", nullptr} },
-        { nullptr, { nullptr } }
+        SYMBOL(CreateContextAttribsARB),
+        END_OF_SYMBOLS
     };
 
     const GLLibraryLoader::SymLoadStruct dxInteropSymbols[] = {
-        { (PRFuncPtr*)&fDXSetResourceShareHandle,{ "wglDXSetResourceShareHandleNV", nullptr } },
-        { (PRFuncPtr*)&fDXOpenDevice,            { "wglDXOpenDeviceNV",             nullptr } },
-        { (PRFuncPtr*)&fDXCloseDevice,           { "wglDXCloseDeviceNV",            nullptr } },
-        { (PRFuncPtr*)&fDXRegisterObject,        { "wglDXRegisterObjectNV",         nullptr } },
-        { (PRFuncPtr*)&fDXUnregisterObject,      { "wglDXUnregisterObjectNV",       nullptr } },
-        { (PRFuncPtr*)&fDXObjectAccess,          { "wglDXObjectAccessNV",           nullptr } },
-        { (PRFuncPtr*)&fDXLockObjects,           { "wglDXLockObjectsNV",            nullptr } },
-        { (PRFuncPtr*)&fDXUnlockObjects,         { "wglDXUnlockObjectsNV",          nullptr } },
-        { nullptr, { nullptr } }
+        SYMBOL(DXSetResourceShareHandleNV),
+        SYMBOL(DXOpenDeviceNV),
+        SYMBOL(DXCloseDeviceNV),
+        SYMBOL(DXRegisterObjectNV),
+        SYMBOL(DXUnregisterObjectNV),
+        SYMBOL(DXObjectAccessNV),
+        SYMBOL(DXLockObjectsNV),
+        SYMBOL(DXUnlockObjectsNV),
+        END_OF_SYMBOLS
     };
 
-    if (GLLibraryLoader::LoadSymbols(mOGLLibrary, &extensionsSymbols[0], lookupFunc)) {
-        const char* extString = fGetExtensionsString(mWindowDC);
+    if (GLLibraryLoader::LoadSymbols(mOGLLibrary, extensionsSymbols, lookupFunc)) {
+        const char* extString = mSymbols.fGetExtensionsStringARB(mWindowDC);
         MOZ_ASSERT(extString);
         MOZ_ASSERT(HasExtension(extString, "WGL_ARB_extensions_string"));
 
         if (HasExtension(extString, "WGL_ARB_create_context")) {
-            if (GLLibraryLoader::LoadSymbols(mOGLLibrary, &robustnessSymbols[0], lookupFunc)) {
+            if (GLLibraryLoader::LoadSymbols(mOGLLibrary, robustnessSymbols, lookupFunc)) {
                 if (HasExtension(extString, "WGL_ARB_create_context_robustness")) {
                     mHasRobustness = true;
                 }
             } else {
                 NS_ERROR("WGL supports ARB_create_context without supplying its functions.");
-                fCreateContextAttribs = nullptr;
+                ClearSymbols(robustnessSymbols);
             }
         }
 
         ////
 
         bool hasDXInterop2 = HasExtension(extString, "WGL_NV_DX_interop2");
         if (gfxVars::DXInterop2Blocked() &&
             !gfxPrefs::IgnoreDXInterop2Blacklist())
         {
             hasDXInterop2 = false;
         }
 
         if (hasDXInterop2) {
-            if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, &dxInteropSymbols[0],
+            if (!GLLibraryLoader::LoadSymbols(mOGLLibrary, dxInteropSymbols,
                                               lookupFunc))
             {
                 NS_ERROR("WGL supports NV_DX_interop(2) without supplying its functions.");
-                fDXSetResourceShareHandle = nullptr;
-                fDXOpenDevice = nullptr;
-                fDXCloseDevice = nullptr;
-                fDXRegisterObject = nullptr;
-                fDXUnregisterObject = nullptr;
-                fDXObjectAccess = nullptr;
-                fDXLockObjects = nullptr;
-                fDXUnlockObjects = nullptr;
+                ClearSymbols(dxInteropSymbols);
             }
         }
     }
 
     // reset back to the previous context, just in case
-    fMakeCurrent(curDC, curCtx);
+    mSymbols.fMakeCurrent(curDC, curCtx);
 
     if (mHasRobustness) {
-        fDeleteContext(mWindowGLContext);
+        mSymbols.fDeleteContext(mWindowGLContext);
 
         const int attribs[] = {
             LOCAL_WGL_CONTEXT_FLAGS_ARB, LOCAL_WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB,
             LOCAL_WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, LOCAL_WGL_LOSE_CONTEXT_ON_RESET_ARB,
             0
         };
 
-        mWindowGLContext = fCreateContextAttribs(mWindowDC, nullptr, attribs);
+        mWindowGLContext = mSymbols.fCreateContextAttribsARB(mWindowDC, nullptr, attribs);
         if (!mWindowGLContext) {
             mHasRobustness = false;
-            mWindowGLContext = fCreateContext(mWindowDC);
+            mWindowGLContext = mSymbols.fCreateContext(mWindowDC);
         }
     }
 
     mInitialized = true;
 
     reporter.SetSuccessful();
     return true;
 }
 
+#undef SYMBOL
+#undef END_OF_SYMBOLS
+
 GLContextWGL::GLContextWGL(CreateContextFlags flags, const SurfaceCaps& caps,
                            bool isOffscreen, HDC aDC, HGLRC aContext, HWND aWindow)
     : GLContext(flags, caps, nullptr, isOffscreen),
       mDC(aDC),
       mContext(aContext),
       mWnd(aWindow),
       mPBuffer(nullptr),
       mPixelFormat(0),
@@ -297,32 +296,32 @@ GLContextWGL::GLContextWGL(CreateContext
     // See 899855
     SetProfileVersion(ContextProfile::OpenGLCompatibility, 200);
 }
 
 GLContextWGL::~GLContextWGL()
 {
     MarkDestroyed();
 
-    sWGLLib.fDeleteContext(mContext);
+    sWGLLib.mSymbols.fDeleteContext(mContext);
 
     if (mPBuffer)
-        sWGLLib.fDestroyPbuffer(mPBuffer);
+        sWGLLib.mSymbols.fDestroyPbuffer(mPBuffer);
     if (mWnd)
         DestroyWindow(mWnd);
 }
 
 bool
 GLContextWGL::Init()
 {
     if (!mDC || !mContext)
         return false;
 
     // see bug 929506 comment 29. wglGetProcAddress requires a current context.
-    if (!sWGLLib.fMakeCurrent(mDC, mContext))
+    if (!sWGLLib.mSymbols.fMakeCurrent(mDC, mContext))
         return false;
 
     SetupLookupFunction();
     if (!InitWithPrefix("gl", true))
         return false;
 
     return true;
 }
@@ -331,28 +330,28 @@ bool
 GLContextWGL::MakeCurrentImpl(bool aForce)
 {
     BOOL succeeded = true;
 
     // wglGetCurrentContext seems to just pull the HGLRC out
     // of its TLS slot, so no need to do our own tls slot.
     // You would think that wglMakeCurrent would avoid doing
     // work if mContext was already current, but not so much..
-    if (aForce || sWGLLib.fGetCurrentContext() != mContext) {
-        succeeded = sWGLLib.fMakeCurrent(mDC, mContext);
+    if (aForce || sWGLLib.mSymbols.fGetCurrentContext() != mContext) {
+        succeeded = sWGLLib.mSymbols.fMakeCurrent(mDC, mContext);
         NS_ASSERTION(succeeded, "Failed to make GL context current!");
     }
 
     return succeeded;
 }
 
 bool
 GLContextWGL::IsCurrent()
 {
-    return sWGLLib.fGetCurrentContext() == mContext;
+    return sWGLLib.mSymbols.fGetCurrentContext() == mContext;
 }
 
 void
 GLContextWGL::SetIsDoubleBuffered(bool aIsDB)
 {
     mIsDoubleBuffered = aIsDB;
 }
 
@@ -374,40 +373,40 @@ GLContextWGL::SwapBuffers() {
         return false;
     return ::SwapBuffers(mDC);
 }
 
 void
 GLContextWGL::GetWSIInfo(nsCString* const out) const
 {
     out->AppendLiteral("wglGetExtensionsString: ");
-    out->Append(sWGLLib.fGetExtensionsString(mDC));
+    out->Append(sWGLLib.mSymbols.fGetExtensionsStringARB(mDC));
 }
 
 bool
 GLContextWGL::SetupLookupFunction()
 {
     // Make sure that we have a ref to the OGL library;
     // when run under CodeXL, wglGetProcAddress won't return
     // the right thing for some core functions.
     MOZ_ASSERT(mLibrary == nullptr);
 
     mLibrary = sWGLLib.GetOGLLibrary();
-    mLookupFunc = (PlatformLookupFunction)sWGLLib.fGetProcAddress;
+    mLookupFunc = (PlatformLookupFunction)sWGLLib.mSymbols.fGetProcAddress;
     return true;
 }
 
 static bool
 GetMaxSize(HDC hDC, int format, IntSize& size)
 {
     int query[] = {LOCAL_WGL_MAX_PBUFFER_WIDTH_ARB, LOCAL_WGL_MAX_PBUFFER_HEIGHT_ARB};
     int result[2];
 
     // (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int* piAttributes, int* piValues)
-    if (!sWGLLib.fGetPixelFormatAttribiv(hDC, format, 0, 2, query, result))
+    if (!sWGLLib.mSymbols.fGetPixelFormatAttribiv(hDC, format, 0, 2, query, result))
         return false;
 
     size.width = result[0];
     size.height = result[1];
     return true;
 }
 
 static bool
@@ -454,19 +453,19 @@ CreateForWidget(HWND aHwnd,
 
     if (sWGLLib.HasRobustness()) {
         int attribs[] = {
             LOCAL_WGL_CONTEXT_FLAGS_ARB, LOCAL_WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB,
             LOCAL_WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, LOCAL_WGL_LOSE_CONTEXT_ON_RESET_ARB,
             0
         };
 
-        context = sWGLLib.fCreateContextAttribs(dc, nullptr, attribs);
+        context = sWGLLib.mSymbols.fCreateContextAttribsARB(dc, nullptr, attribs);
     } else {
-        context = sWGLLib.fCreateContext(dc);
+        context = sWGLLib.mSymbols.fCreateContext(dc);
     }
 
     if (!context) {
         return nullptr;
     }
 
     SurfaceCaps caps = SurfaceCaps::ForRGBA();
     RefPtr<GLContextWGL> glContext = new GLContextWGL(CreateContextFlags::NONE, caps,
@@ -510,52 +509,52 @@ CreatePBufferOffscreenContext(CreateCont
         0
     };
 
     // We only need one!
     static const uint32_t kMaxFormats = 1024;
     int formats[kMaxFormats];
     uint32_t foundFormats;
     HDC windowDC = wgl.GetWindowDC();
-    if (!wgl.fChoosePixelFormat(windowDC, pfAttribs, nullptr, kMaxFormats, formats,
-                                &foundFormats)
+    if (!wgl.mSymbols.fChoosePixelFormat(windowDC, pfAttribs, nullptr, kMaxFormats,
+                                         formats, &foundFormats)
         || foundFormats == 0)
     {
         return nullptr;
     }
 
     // We don't care; just pick the first one.
     int chosenFormat = formats[0];
     if (!IsValidSizeForFormat(windowDC, chosenFormat, aSize))
         return nullptr;
 
     const int pbAttribs[] = { 0 };
-    HANDLE pbuffer = wgl.fCreatePbuffer(windowDC, chosenFormat, aSize.width, aSize.height,
-                                        pbAttribs);
+    HANDLE pbuffer = wgl.mSymbols.fCreatePbuffer(windowDC, chosenFormat, aSize.width,
+                                                 aSize.height, pbAttribs);
     if (!pbuffer) {
         return nullptr;
     }
 
-    HDC pbdc = wgl.fGetPbufferDC(pbuffer);
+    HDC pbdc = wgl.mSymbols.fGetPbufferDC(pbuffer);
     NS_ASSERTION(pbdc, "expected a dc");
 
     HGLRC context;
     if (wgl.HasRobustness()) {
         const int attribs[] = {
             LOCAL_WGL_CONTEXT_FLAGS_ARB, LOCAL_WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB,
             LOCAL_WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, LOCAL_WGL_LOSE_CONTEXT_ON_RESET_ARB,
             0
         };
-        context = wgl.fCreateContextAttribs(pbdc, nullptr, attribs);
+        context = wgl.mSymbols.fCreateContextAttribsARB(pbdc, nullptr, attribs);
     } else {
-        context = wgl.fCreateContext(pbdc);
+        context = wgl.mSymbols.fCreateContext(pbdc);
     }
 
     if (!context) {
-        wgl.fDestroyPbuffer(pbuffer);
+        wgl.mSymbols.fDestroyPbuffer(pbuffer);
         return nullptr;
     }
 
     SurfaceCaps dummyCaps = SurfaceCaps::Any();
     RefPtr<GLContextWGL> glContext = new GLContextWGL(flags, dummyCaps, true, pbuffer,
                                                       pbdc, context, chosenFormat);
     return glContext.forget();
 }
@@ -564,27 +563,27 @@ static already_AddRefed<GLContextWGL>
 CreateWindowOffscreenContext()
 {
     HDC dc;
     HWND win = sWGLLib.CreateDummyWindow(&dc);
     if (!win) {
         return nullptr;
     }
 
-    HGLRC context = sWGLLib.fCreateContext(dc);
+    HGLRC context = sWGLLib.mSymbols.fCreateContext(dc);
     if (sWGLLib.HasRobustness()) {
         int attribs[] = {
             LOCAL_WGL_CONTEXT_FLAGS_ARB, LOCAL_WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB,
             LOCAL_WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, LOCAL_WGL_LOSE_CONTEXT_ON_RESET_ARB,
             0
         };
 
-        context = sWGLLib.fCreateContextAttribs(dc, nullptr, attribs);
+        context = sWGLLib.mSymbols.fCreateContextAttribsARB(dc, nullptr, attribs);
     } else {
-        context = sWGLLib.fCreateContext(dc);
+        context = sWGLLib.mSymbols.fCreateContext(dc);
     }
 
     if (!context) {
         return nullptr;
     }
 
     SurfaceCaps caps = SurfaceCaps::ForRGBA();
     RefPtr<GLContextWGL> glContext = new GLContextWGL(CreateContextFlags::NONE, caps,
@@ -599,18 +598,18 @@ GLContextProviderWGL::CreateHeadless(Cre
     if (!sWGLLib.EnsureInitialized()) {
         return nullptr;
     }
 
     RefPtr<GLContextWGL> glContext;
 
     // Always try to create a pbuffer context first, because we
     // want the context isolation.
-    if (sWGLLib.fCreatePbuffer &&
-        sWGLLib.fChoosePixelFormat)
+    if (sWGLLib.mSymbols.fCreatePbuffer &&
+        sWGLLib.mSymbols.fChoosePixelFormat)
     {
         IntSize dummySize = IntSize(16, 16);
         glContext = CreatePBufferOffscreenContext(flags, dummySize);
     }
 
     // If it failed, then create a window context and use a FBO.
     if (!glContext) {
         glContext = CreateWindowOffscreenContext();
--- a/gfx/gl/GLLibraryEGL.cpp
+++ b/gfx/gl/GLLibraryEGL.cpp
@@ -380,91 +380,88 @@ GLLibraryEGL::EnsureInitialized(bool for
     if (!mEGLLibrary) {
         NS_WARNING("Couldn't load EGL LIB.");
         *out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_EGL_LOAD_2");
         return false;
     }
 
 #endif // !Windows
 
-#define SYMBOL(name) \
-{ (PRFuncPtr*) &mSymbols.f##name, { "egl" #name, nullptr } }
+#define SYMBOL(X) { (PRFuncPtr*)&mSymbols.f##X, { "egl" #X, nullptr } }
+#define END_OF_SYMBOLS { nullptr, { nullptr } }
 
     GLLibraryLoader::SymLoadStruct earlySymbols[] = {
         SYMBOL(GetDisplay),
         SYMBOL(Terminate),
         SYMBOL(GetCurrentSurface),
         SYMBOL(GetCurrentContext),
         SYMBOL(MakeCurrent),
         SYMBOL(DestroyContext),
         SYMBOL(CreateContext),
         SYMBOL(DestroySurface),
         SYMBOL(CreateWindowSurface),
         SYMBOL(CreatePbufferSurface),
+        SYMBOL(CreatePbufferFromClientBuffer),
         SYMBOL(CreatePixmapSurface),
         SYMBOL(BindAPI),
         SYMBOL(Initialize),
         SYMBOL(ChooseConfig),
         SYMBOL(GetError),
         SYMBOL(GetConfigs),
         SYMBOL(GetConfigAttrib),
         SYMBOL(WaitNative),
         SYMBOL(GetProcAddress),
         SYMBOL(SwapBuffers),
         SYMBOL(CopyBuffers),
         SYMBOL(QueryString),
         SYMBOL(QueryContext),
         SYMBOL(BindTexImage),
         SYMBOL(ReleaseTexImage),
         SYMBOL(QuerySurface),
-        SYMBOL(CreatePbufferFromClientBuffer),
-        { nullptr, { nullptr } }
+        END_OF_SYMBOLS
     };
 
-    if (!GLLibraryLoader::LoadSymbols(mEGLLibrary, &earlySymbols[0])) {
+    if (!GLLibraryLoader::LoadSymbols(mEGLLibrary, earlySymbols)) {
         NS_WARNING("Couldn't find required entry points in EGL library (early init)");
         *out_failureId = NS_LITERAL_CSTRING("FEATURE_FAILURE_EGL_SYM");
         return false;
     }
 
-    GLLibraryLoader::SymLoadStruct optionalSymbols[] = {
-        // On Android 4.3 and up, certain features like ANDROID_native_fence_sync
-        // can only be queried by using a special eglQueryString.
-        { (PRFuncPtr*) &mSymbols.fQueryStringImplementationANDROID,
-          { "_Z35eglQueryStringImplementationANDROIDPvi", nullptr } },
-        { nullptr, { nullptr } }
-    };
-
-    // Do not warn about the failure to load this - see bug 1092191
-    Unused << GLLibraryLoader::LoadSymbols(mEGLLibrary, &optionalSymbols[0],
-                                           nullptr, nullptr, false);
+    {
+        const char internalFuncName[] = "_Z35eglQueryStringImplementationANDROIDPvi";
+        const auto& internalFunc = PR_FindFunctionSymbol(mEGLLibrary, internalFuncName);
+        if (internalFunc) {
+            *(PRFuncPtr*)&mSymbols.fQueryString = internalFunc;
+        }
+    }
 
     InitClientExtensions();
 
     const auto lookupFunction =
         (GLLibraryLoader::PlatformLookupFunction)mSymbols.fGetProcAddress;
 
+    const auto fnLoadSymbols = [&](const GLLibraryLoader::SymLoadStruct* symbols) {
+        if (GLLibraryLoader::LoadSymbols(mEGLLibrary, symbols, lookupFunction))
+            return true;
+
+        ClearSymbols(symbols);
+        return false;
+    };
+
     // Client exts are ready. (But not display exts!)
     if (IsExtensionSupported(ANGLE_platform_angle_d3d)) {
-        GLLibraryLoader::SymLoadStruct d3dSymbols[] = {
-            { (PRFuncPtr*)&mSymbols.fANGLEPlatformInitialize, { "ANGLEPlatformInitialize", nullptr } },
-            { (PRFuncPtr*)&mSymbols.fANGLEPlatformShutdown,   { "ANGLEPlatformShutdown", nullptr } },
-            { (PRFuncPtr*)&mSymbols.fGetPlatformDisplayEXT,   { "eglGetPlatformDisplayEXT", nullptr } },
-            { nullptr, { nullptr } }
+        const GLLibraryLoader::SymLoadStruct d3dSymbols[] = {
+            SYMBOL(ANGLEPlatformInitialize),
+            SYMBOL(ANGLEPlatformShutdown),
+            SYMBOL(GetPlatformDisplayEXT),
+            END_OF_SYMBOLS
         };
-
-        bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
-                                                    &d3dSymbols[0],
-                                                    lookupFunction);
-        if (!success) {
+        if (!fnLoadSymbols(d3dSymbols)) {
             NS_ERROR("EGL supports ANGLE_platform_angle_d3d without exposing its functions!");
-
             MarkExtensionUnsupported(ANGLE_platform_angle_d3d);
-
-            mSymbols.fGetPlatformDisplayEXT = nullptr;
         }
     }
 
     // Check the ANGLE support the system has
     nsCOMPtr<nsIGfxInfo> gfxInfo = do_GetService("@mozilla.org/gfx/info;1");
     mIsANGLE = IsExtensionSupported(ANGLE_platform_angle);
 
     EGLDisplay chosenDisplay = nullptr;
@@ -529,124 +526,87 @@ GLLibraryEGL::EnsureInitialized(bool for
     mEGLDisplay = chosenDisplay;
 
     InitDisplayExtensions();
 
     ////////////////////////////////////
     // Alright, load display exts.
 
     if (IsExtensionSupported(KHR_lock_surface)) {
-        GLLibraryLoader::SymLoadStruct lockSymbols[] = {
-            { (PRFuncPtr*) &mSymbols.fLockSurface,   { "eglLockSurfaceKHR",   nullptr } },
-            { (PRFuncPtr*) &mSymbols.fUnlockSurface, { "eglUnlockSurfaceKHR", nullptr } },
-            { nullptr, { nullptr } }
+        const GLLibraryLoader::SymLoadStruct lockSymbols[] = {
+            SYMBOL(LockSurfaceKHR),
+            SYMBOL(UnlockSurfaceKHR),
+            END_OF_SYMBOLS
         };
-
-        bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
-                                                    &lockSymbols[0],
-                                                    lookupFunction);
-        if (!success) {
+        if (!fnLoadSymbols(lockSymbols)) {
             NS_ERROR("EGL supports KHR_lock_surface without exposing its functions!");
-
             MarkExtensionUnsupported(KHR_lock_surface);
-
-            mSymbols.fLockSurface = nullptr;
-            mSymbols.fUnlockSurface = nullptr;
         }
     }
 
     if (IsExtensionSupported(ANGLE_surface_d3d_texture_2d_share_handle)) {
-        GLLibraryLoader::SymLoadStruct d3dSymbols[] = {
-            { (PRFuncPtr*) &mSymbols.fQuerySurfacePointerANGLE, { "eglQuerySurfacePointerANGLE", nullptr } },
-            { nullptr, { nullptr } }
+        const GLLibraryLoader::SymLoadStruct d3dSymbols[] = {
+            SYMBOL(QuerySurfacePointerANGLE),
+            END_OF_SYMBOLS
         };
-
-        bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
-                                                    &d3dSymbols[0],
-                                                    lookupFunction);
-        if (!success) {
+        if (!fnLoadSymbols(d3dSymbols)) {
             NS_ERROR("EGL supports ANGLE_surface_d3d_texture_2d_share_handle without exposing its functions!");
-
             MarkExtensionUnsupported(ANGLE_surface_d3d_texture_2d_share_handle);
-
-            mSymbols.fQuerySurfacePointerANGLE = nullptr;
         }
     }
 
     if (IsExtensionSupported(KHR_fence_sync)) {
-        GLLibraryLoader::SymLoadStruct syncSymbols[] = {
-            { (PRFuncPtr*) &mSymbols.fCreateSync,     { "eglCreateSyncKHR",     nullptr } },
-            { (PRFuncPtr*) &mSymbols.fDestroySync,    { "eglDestroySyncKHR",    nullptr } },
-            { (PRFuncPtr*) &mSymbols.fClientWaitSync, { "eglClientWaitSyncKHR", nullptr } },
-            { (PRFuncPtr*) &mSymbols.fGetSyncAttrib,  { "eglGetSyncAttribKHR",  nullptr } },
-            { nullptr, { nullptr } }
+        const GLLibraryLoader::SymLoadStruct syncSymbols[] = {
+            SYMBOL(CreateSyncKHR),
+            SYMBOL(DestroySyncKHR),
+            SYMBOL(ClientWaitSyncKHR),
+            SYMBOL(GetSyncAttribKHR),
+            END_OF_SYMBOLS
         };
-
-        bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
-                                                    &syncSymbols[0],
-                                                    lookupFunction);
-        if (!success) {
+        if (!fnLoadSymbols(syncSymbols)) {
             NS_ERROR("EGL supports KHR_fence_sync without exposing its functions!");
-
             MarkExtensionUnsupported(KHR_fence_sync);
-
-            mSymbols.fCreateSync = nullptr;
-            mSymbols.fDestroySync = nullptr;
-            mSymbols.fClientWaitSync = nullptr;
-            mSymbols.fGetSyncAttrib = nullptr;
         }
     }
 
     if (IsExtensionSupported(KHR_image) || IsExtensionSupported(KHR_image_base)) {
-        GLLibraryLoader::SymLoadStruct imageSymbols[] = {
-            { (PRFuncPtr*) &mSymbols.fCreateImage,  { "eglCreateImageKHR",  nullptr } },
-            { (PRFuncPtr*) &mSymbols.fDestroyImage, { "eglDestroyImageKHR", nullptr } },
-            { nullptr, { nullptr } }
+        const GLLibraryLoader::SymLoadStruct imageSymbols[] = {
+            SYMBOL(CreateImageKHR),
+            SYMBOL(DestroyImageKHR),
+            END_OF_SYMBOLS
         };
-
-        bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
-                                                    &imageSymbols[0],
-                                                    lookupFunction);
-        if (!success) {
+        if (!fnLoadSymbols(imageSymbols)) {
             NS_ERROR("EGL supports KHR_image(_base) without exposing its functions!");
-
             MarkExtensionUnsupported(KHR_image);
             MarkExtensionUnsupported(KHR_image_base);
             MarkExtensionUnsupported(KHR_image_pixmap);
-
-            mSymbols.fCreateImage = nullptr;
-            mSymbols.fDestroyImage = nullptr;
         }
     } else {
         MarkExtensionUnsupported(KHR_image_pixmap);
     }
 
     if (IsExtensionSupported(ANDROID_native_fence_sync)) {
-        GLLibraryLoader::SymLoadStruct nativeFenceSymbols[] = {
-            { (PRFuncPtr*) &mSymbols.fDupNativeFenceFDANDROID, { "eglDupNativeFenceFDANDROID", nullptr } },
-            { nullptr, { nullptr } }
+        const GLLibraryLoader::SymLoadStruct nativeFenceSymbols[] = {
+            SYMBOL(DupNativeFenceFDANDROID),
+            END_OF_SYMBOLS
         };
-
-        bool success = GLLibraryLoader::LoadSymbols(mEGLLibrary,
-                                                    &nativeFenceSymbols[0],
-                                                    lookupFunction);
-        if (!success) {
+        if (!fnLoadSymbols(nativeFenceSymbols)) {
             NS_ERROR("EGL supports ANDROID_native_fence_sync without exposing its functions!");
-
             MarkExtensionUnsupported(ANDROID_native_fence_sync);
-
-            mSymbols.fDupNativeFenceFDANDROID = nullptr;
         }
     }
 
     mInitialized = true;
     reporter.SetSuccessful();
     return true;
 }
 
+#undef SYMBOL
+#undef END_OF_SYMBOLS
+
 template<size_t N>
 static void
 MarkExtensions(const char* rawExtString, bool shouldDumpExts, const char* extType,
                std::bitset<N>* const out)
 {
     MOZ_ASSERT(rawExtString);
 
     const nsDependentCString extString(rawExtString);
--- a/gfx/gl/GLLibraryEGL.h
+++ b/gfx/gl/GLLibraryEGL.h
@@ -105,68 +105,23 @@ namespace gl {
 #endif
 
 class GLContext;
 
 class GLLibraryEGL
 {
 public:
     GLLibraryEGL()
-        : mInitialized(false),
-          mEGLLibrary(nullptr),
-          mEGLDisplay(EGL_NO_DISPLAY),
-          mIsANGLE(false),
-          mIsWARP(false)
-    {
-        ClearSymbols();
-    }
-
-    void ClearSymbols() {
-        mSymbols.fANGLEPlatformInitialize = nullptr;
-        mSymbols.fANGLEPlatformShutdown = nullptr;
-        mSymbols.fGetDisplay = nullptr;
-        mSymbols.fGetPlatformDisplayEXT = nullptr;
-        mSymbols.fTerminate = nullptr;
-        mSymbols.fGetCurrentSurface = nullptr;
-        mSymbols.fGetCurrentContext = nullptr;
-        mSymbols.fMakeCurrent = nullptr;
-        mSymbols.fDestroyContext = nullptr;
-        mSymbols.fCreateContext = nullptr;
-        mSymbols.fDestroySurface = nullptr;
-        mSymbols.fCreateWindowSurface = nullptr;
-        mSymbols.fCreatePbufferSurface = nullptr;
-        mSymbols.fCreatePbufferFromClientBuffer = nullptr;
-        mSymbols.fCreatePixmapSurface = nullptr;
-        mSymbols.fBindAPI = nullptr;
-        mSymbols.fInitialize = nullptr;
-        mSymbols.fChooseConfig = nullptr;
-        mSymbols.fGetError = nullptr;
-        mSymbols.fGetConfigAttrib = nullptr;
-        mSymbols.fGetConfigs = nullptr;
-        mSymbols.fWaitNative = nullptr;
-        mSymbols.fGetProcAddress = nullptr;
-        mSymbols.fSwapBuffers = nullptr;
-        mSymbols.fCopyBuffers = nullptr;
-        mSymbols.fQueryString = nullptr;
-        mSymbols.fQueryStringImplementationANDROID = nullptr;
-        mSymbols.fQueryContext = nullptr;
-        mSymbols.fBindTexImage = nullptr;
-        mSymbols.fReleaseTexImage = nullptr;
-        mSymbols.fCreateImage = nullptr;
-        mSymbols.fDestroyImage = nullptr;
-        mSymbols.fLockSurface = nullptr;
-        mSymbols.fUnlockSurface = nullptr;
-        mSymbols.fQuerySurface = nullptr;
-        mSymbols.fQuerySurfacePointerANGLE = nullptr;
-        mSymbols.fCreateSync = nullptr;
-        mSymbols.fDestroySync = nullptr;
-        mSymbols.fClientWaitSync = nullptr;
-        mSymbols.fGetSyncAttrib = nullptr;
-        mSymbols.fDupNativeFenceFDANDROID = nullptr;
-    }
+        : mSymbols{nullptr}
+        , mInitialized(false)
+        , mEGLLibrary(nullptr)
+        , mEGLDisplay(EGL_NO_DISPLAY)
+        , mIsANGLE(false)
+        , mIsWARP(false)
+    { }
 
     void InitClientExtensions();
     void InitDisplayExtensions();
 
     /**
      * Known GL extensions that can be queried by
      * IsExtensionSupported.  The results of this are cached, and as
      * such it's safe to use this even in performance critical code.
@@ -197,16 +152,19 @@ public:
     void MarkExtensionUnsupported(EGLExtensions aKnownExtension) {
         mAvailableExtensions[aKnownExtension] = false;
     }
 
 protected:
     std::bitset<Extensions_Max> mAvailableExtensions;
 
 public:
+    GLLibraryLoader::PlatformLookupFunction GetLookupFunction() const {
+        return (GLLibraryLoader::PlatformLookupFunction)mSymbols.fGetProcAddress;
+    }
 
     EGLDisplay fGetDisplay(void* display_id)
     {
         BEFORE_GL_CALL;
         EGLDisplay disp = mSymbols.fGetDisplay(display_id);
         AFTER_GL_CALL;
         return disp;
     }
@@ -385,24 +343,19 @@ public:
         EGLBoolean b = mSymbols.fCopyBuffers(dpy, surface, target);
         AFTER_GL_CALL;
         return b;
     }
 
     const GLubyte* fQueryString(EGLDisplay dpy, EGLint name)
     {
         BEFORE_GL_CALL;
-        const GLubyte* b;
-        if (mSymbols.fQueryStringImplementationANDROID) {
-          b = mSymbols.fQueryStringImplementationANDROID(dpy, name);
-        } else {
-          b = mSymbols.fQueryString(dpy, name);
-        }
+        const auto ret = mSymbols.fQueryString(dpy, name);
         AFTER_GL_CALL;
-        return b;
+        return ret;
     }
 
     EGLBoolean fQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint* value)
     {
         BEFORE_GL_CALL;
         EGLBoolean b = mSymbols.fQueryContext(dpy, ctx, attribute, value);
         AFTER_GL_CALL;
         return b;
@@ -422,42 +375,42 @@ public:
         EGLBoolean b = mSymbols.fReleaseTexImage(dpy, surface, buffer);
         AFTER_GL_CALL;
         return b;
     }
 
     EGLImage fCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint* attrib_list)
     {
          BEFORE_GL_CALL;
-         EGLImage i = mSymbols.fCreateImage(dpy, ctx, target, buffer, attrib_list);
+         EGLImage i = mSymbols.fCreateImageKHR(dpy, ctx, target, buffer, attrib_list);
          AFTER_GL_CALL;
          return i;
     }
 
     EGLBoolean fDestroyImage(EGLDisplay dpy, EGLImage image)
     {
         BEFORE_GL_CALL;
-        EGLBoolean b = mSymbols.fDestroyImage(dpy, image);
+        EGLBoolean b = mSymbols.fDestroyImageKHR(dpy, image);
         AFTER_GL_CALL;
         return b;
     }
 
     // New extension which allow us to lock texture and get raw image pointer
     EGLBoolean fLockSurface(EGLDisplay dpy, EGLSurface surface, const EGLint* attrib_list)
     {
         BEFORE_GL_CALL;
-        EGLBoolean b = mSymbols.fLockSurface(dpy, surface, attrib_list);
+        EGLBoolean b = mSymbols.fLockSurfaceKHR(dpy, surface, attrib_list);
         AFTER_GL_CALL;
         return b;
     }
 
     EGLBoolean fUnlockSurface(EGLDisplay dpy, EGLSurface surface)
     {
         BEFORE_GL_CALL;
-        EGLBoolean b = mSymbols.fUnlockSurface(dpy, surface);
+        EGLBoolean b = mSymbols.fUnlockSurfaceKHR(dpy, surface);
         AFTER_GL_CALL;
         return b;
     }
 
     EGLBoolean fQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint* value)
     {
         BEFORE_GL_CALL;
         EGLBoolean b = mSymbols.fQuerySurface(dpy, surface, attribute, value);
@@ -471,41 +424,41 @@ public:
         EGLBoolean b = mSymbols.fQuerySurfacePointerANGLE(dpy, surface, attribute, value);
         AFTER_GL_CALL;
         return b;
     }
 
     EGLSync fCreateSync(EGLDisplay dpy, EGLenum type, const EGLint* attrib_list)
     {
         BEFORE_GL_CALL;
-        EGLSync ret = mSymbols.fCreateSync(dpy, type, attrib_list);
+        EGLSync ret = mSymbols.fCreateSyncKHR(dpy, type, attrib_list);
         AFTER_GL_CALL;
         return ret;
     }
 
     EGLBoolean fDestroySync(EGLDisplay dpy, EGLSync sync)
     {
         BEFORE_GL_CALL;
-        EGLBoolean b = mSymbols.fDestroySync(dpy, sync);
+        EGLBoolean b = mSymbols.fDestroySyncKHR(dpy, sync);
         AFTER_GL_CALL;
         return b;
     }
 
     EGLint fClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout)
     {
         BEFORE_GL_CALL;
-        EGLint ret = mSymbols.fClientWaitSync(dpy, sync, flags, timeout);
+        EGLint ret = mSymbols.fClientWaitSyncKHR(dpy, sync, flags, timeout);
         AFTER_GL_CALL;
         return ret;
     }
 
     EGLBoolean fGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLint* value)
     {
         BEFORE_GL_CALL;
-        EGLBoolean b = mSymbols.fGetSyncAttrib(dpy, sync, attribute, value);
+        EGLBoolean b = mSymbols.fGetSyncAttribKHR(dpy, sync, attribute, value);
         AFTER_GL_CALL;
         return b;
     }
 
     EGLint fDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSync sync)
     {
         MOZ_ASSERT(mSymbols.fDupNativeFenceFDANDROID);
         BEFORE_GL_CALL;
@@ -567,112 +520,101 @@ public:
 
     bool ReadbackEGLImage(EGLImage image, gfx::DataSourceSurface* out_surface);
 
     bool EnsureInitialized(bool forceAccel, nsACString* const out_failureId);
 
     void DumpEGLConfig(EGLConfig cfg);
     void DumpEGLConfigs();
 
+private:
     struct {
-        typedef EGLDisplay (GLAPIENTRY * pfnGetDisplay)(void* display_id);
-        pfnGetDisplay fGetDisplay;
-        typedef EGLDisplay(GLAPIENTRY * pfnGetPlatformDisplayEXT)(EGLenum platform, void* native_display, const EGLint* attrib_list);
-        pfnGetPlatformDisplayEXT fGetPlatformDisplayEXT;
-        typedef EGLBoolean (GLAPIENTRY * pfnTerminate)(EGLDisplay dpy);
-        pfnTerminate fTerminate;
-        typedef EGLSurface (GLAPIENTRY * pfnGetCurrentSurface)(EGLint);
-        pfnGetCurrentSurface fGetCurrentSurface;
-        typedef EGLContext (GLAPIENTRY * pfnGetCurrentContext)(void);
-        pfnGetCurrentContext fGetCurrentContext;
-        typedef EGLBoolean (GLAPIENTRY * pfnMakeCurrent)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
-        pfnMakeCurrent fMakeCurrent;
-        typedef EGLBoolean (GLAPIENTRY * pfnDestroyContext)(EGLDisplay dpy, EGLContext ctx);
-        pfnDestroyContext fDestroyContext;
-        typedef EGLContext (GLAPIENTRY * pfnCreateContext)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list);
-        pfnCreateContext fCreateContext;
-        typedef EGLBoolean (GLAPIENTRY * pfnDestroySurface)(EGLDisplay dpy, EGLSurface surface);
-        pfnDestroySurface fDestroySurface;
-        typedef EGLSurface (GLAPIENTRY * pfnCreateWindowSurface)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list);
-        pfnCreateWindowSurface fCreateWindowSurface;
-        typedef EGLSurface (GLAPIENTRY * pfnCreatePbufferSurface)(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list);
-        pfnCreatePbufferSurface fCreatePbufferSurface;
-        typedef EGLSurface (GLAPIENTRY * pfnCreatePbufferFromClientBuffer)(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
-        pfnCreatePbufferFromClientBuffer fCreatePbufferFromClientBuffer;
-        typedef EGLSurface (GLAPIENTRY * pfnCreatePixmapSurface)(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint* attrib_list);
-        pfnCreatePixmapSurface fCreatePixmapSurface;
-        typedef EGLBoolean (GLAPIENTRY * pfnBindAPI)(EGLenum api);
-        pfnBindAPI fBindAPI;
-        typedef EGLBoolean (GLAPIENTRY * pfnInitialize)(EGLDisplay dpy, EGLint* major, EGLint* minor);
-        pfnInitialize fInitialize;
-        typedef EGLBoolean (GLAPIENTRY * pfnChooseConfig)(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config);
-        pfnChooseConfig fChooseConfig;
-        typedef EGLint (GLAPIENTRY * pfnGetError)(void);
-        pfnGetError fGetError;
-        typedef EGLBoolean (GLAPIENTRY * pfnGetConfigAttrib)(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value);
-        pfnGetConfigAttrib fGetConfigAttrib;
-        typedef EGLBoolean (GLAPIENTRY * pfnGetConfigs)(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config);
-        pfnGetConfigs fGetConfigs;
-        typedef EGLBoolean (GLAPIENTRY * pfnWaitNative)(EGLint engine);
-        pfnWaitNative fWaitNative;
-        typedef EGLCastToRelevantPtr (GLAPIENTRY * pfnGetProcAddress)(const char* procname);
-        pfnGetProcAddress fGetProcAddress;
-        typedef EGLBoolean (GLAPIENTRY * pfnSwapBuffers)(EGLDisplay dpy, EGLSurface surface);
-        pfnSwapBuffers fSwapBuffers;
-        typedef EGLBoolean (GLAPIENTRY * pfnCopyBuffers)(EGLDisplay dpy, EGLSurface surface,
-                                                         EGLNativePixmapType target);
-        pfnCopyBuffers fCopyBuffers;
-        typedef const GLubyte* (GLAPIENTRY * pfnQueryString)(EGLDisplay, EGLint name);
-        pfnQueryString fQueryString;
-        pfnQueryString fQueryStringImplementationANDROID;
-        typedef EGLBoolean (GLAPIENTRY * pfnQueryContext)(EGLDisplay dpy, EGLContext ctx,
-                                                          EGLint attribute, EGLint* value);
-        pfnQueryContext fQueryContext;
-        typedef EGLBoolean (GLAPIENTRY * pfnBindTexImage)(EGLDisplay, EGLSurface surface, EGLint buffer);
-        pfnBindTexImage fBindTexImage;
-        typedef EGLBoolean (GLAPIENTRY * pfnReleaseTexImage)(EGLDisplay, EGLSurface surface, EGLint buffer);
-        pfnReleaseTexImage fReleaseTexImage;
-        typedef EGLImage (GLAPIENTRY * pfnCreateImage)(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint* attrib_list);
-        pfnCreateImage fCreateImage;
-        typedef EGLBoolean (GLAPIENTRY * pfnDestroyImage)(EGLDisplay dpy, EGLImage image);
-        pfnDestroyImage fDestroyImage;
-
+        EGLCastToRelevantPtr (GLAPIENTRY * fGetProcAddress)(const char* procname);
+        EGLDisplay (GLAPIENTRY * fGetDisplay)(void* display_id);
+        EGLDisplay (GLAPIENTRY * fGetPlatformDisplayEXT)(EGLenum platform,
+                                                         void* native_display,
+                                                         const EGLint* attrib_list);
+        EGLBoolean (GLAPIENTRY * fTerminate)(EGLDisplay dpy);
+        EGLSurface (GLAPIENTRY * fGetCurrentSurface)(EGLint);
+        EGLContext (GLAPIENTRY * fGetCurrentContext)(void);
+        EGLBoolean (GLAPIENTRY * fMakeCurrent)(EGLDisplay dpy, EGLSurface draw,
+                                               EGLSurface read, EGLContext ctx);
+        EGLBoolean (GLAPIENTRY * fDestroyContext)(EGLDisplay dpy, EGLContext ctx);
+        EGLContext (GLAPIENTRY * fCreateContext)(EGLDisplay dpy, EGLConfig config,
+                                                 EGLContext share_context,
+                                                 const EGLint* attrib_list);
+        EGLBoolean (GLAPIENTRY * fDestroySurface)(EGLDisplay dpy, EGLSurface surface);
+        EGLSurface (GLAPIENTRY * fCreateWindowSurface)(EGLDisplay dpy, EGLConfig config,
+                                                       EGLNativeWindowType win,
+                                                       const EGLint* attrib_list);
+        EGLSurface (GLAPIENTRY * fCreatePbufferSurface)(EGLDisplay dpy, EGLConfig config,
+                                                        const EGLint* attrib_list);
+        EGLSurface (GLAPIENTRY * fCreatePbufferFromClientBuffer)(EGLDisplay dpy,
+                                                                 EGLenum buftype,
+                                                                 EGLClientBuffer buffer,
+                                                                 EGLConfig config,
+                                                                 const EGLint* attrib_list);
+        EGLSurface (GLAPIENTRY * fCreatePixmapSurface)(EGLDisplay dpy, EGLConfig config,
+                                                       EGLNativePixmapType pixmap,
+                                                       const EGLint* attrib_list);
+        EGLBoolean (GLAPIENTRY * fBindAPI)(EGLenum api);
+        EGLBoolean (GLAPIENTRY * fInitialize)(EGLDisplay dpy, EGLint* major,
+                                              EGLint* minor);
+        EGLBoolean (GLAPIENTRY * fChooseConfig)(EGLDisplay dpy, const EGLint* attrib_list,
+                                                EGLConfig* configs, EGLint config_size,
+                                                EGLint* num_config);
+        EGLint     (GLAPIENTRY * fGetError)(void);
+        EGLBoolean (GLAPIENTRY * fGetConfigAttrib)(EGLDisplay dpy, EGLConfig config,
+                                                   EGLint attribute, EGLint* value);
+        EGLBoolean (GLAPIENTRY * fGetConfigs)(EGLDisplay dpy, EGLConfig* configs,
+                                              EGLint config_size, EGLint* num_config);
+        EGLBoolean (GLAPIENTRY * fWaitNative)(EGLint engine);
+        EGLBoolean (GLAPIENTRY * fSwapBuffers)(EGLDisplay dpy, EGLSurface surface);
+        EGLBoolean (GLAPIENTRY * fCopyBuffers)(EGLDisplay dpy, EGLSurface surface,
+                                               EGLNativePixmapType target);
+        const GLubyte* (GLAPIENTRY * fQueryString)(EGLDisplay, EGLint name);
+        EGLBoolean (GLAPIENTRY * fQueryContext)(EGLDisplay dpy, EGLContext ctx,
+                                                EGLint attribute, EGLint* value);
+        EGLBoolean (GLAPIENTRY * fBindTexImage)(EGLDisplay, EGLSurface surface,
+                                                EGLint buffer);
+        EGLBoolean (GLAPIENTRY * fReleaseTexImage)(EGLDisplay, EGLSurface surface,
+                                                   EGLint buffer);
+        EGLImage   (GLAPIENTRY * fCreateImageKHR)(EGLDisplay dpy, EGLContext ctx,
+                                                  EGLenum target, EGLClientBuffer buffer,
+                                                  const EGLint* attrib_list);
+        EGLBoolean (GLAPIENTRY * fDestroyImageKHR)(EGLDisplay dpy, EGLImage image);
         // New extension which allow us to lock texture and get raw image pointer
-        typedef EGLBoolean (GLAPIENTRY * pfnLockSurface)(EGLDisplay dpy, EGLSurface surface, const EGLint* attrib_list);
-        pfnLockSurface fLockSurface;
-        typedef EGLBoolean (GLAPIENTRY * pfnUnlockSurface)(EGLDisplay dpy, EGLSurface surface);
-        pfnUnlockSurface fUnlockSurface;
-        typedef EGLBoolean (GLAPIENTRY * pfnQuerySurface)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint* value);
-        pfnQuerySurface fQuerySurface;
-
-        typedef EGLBoolean (GLAPIENTRY * pfnQuerySurfacePointerANGLE)(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void** value);
-        pfnQuerySurfacePointerANGLE fQuerySurfacePointerANGLE;
-
-        typedef EGLSync (GLAPIENTRY * pfnCreateSync)(EGLDisplay dpy, EGLenum type, const EGLint* attrib_list);
-        pfnCreateSync fCreateSync;
-        typedef EGLBoolean (GLAPIENTRY * pfnDestroySync)(EGLDisplay dpy, EGLSync sync);
-        pfnDestroySync fDestroySync;
-        typedef EGLint (GLAPIENTRY * pfnClientWaitSync)(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
-        pfnClientWaitSync fClientWaitSync;
-        typedef EGLBoolean (GLAPIENTRY * pfnGetSyncAttrib)(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLint* value);
-        pfnGetSyncAttrib fGetSyncAttrib;
-        typedef EGLint (GLAPIENTRY * pfnDupNativeFenceFDANDROID)(EGLDisplay dpy, EGLSync sync);
-        pfnDupNativeFenceFDANDROID fDupNativeFenceFDANDROID;
-
-        typedef void (GLAPIENTRY * pfnANGLEPlatformInitialize)(angle::Platform* platform);
-        pfnANGLEPlatformInitialize fANGLEPlatformInitialize;
-        typedef void (GLAPIENTRY * pfnANGLEPlatformShutdown)();
-        pfnANGLEPlatformShutdown fANGLEPlatformShutdown;
+        EGLBoolean (GLAPIENTRY * fLockSurfaceKHR)(EGLDisplay dpy, EGLSurface surface,
+                                                  const EGLint* attrib_list);
+        EGLBoolean (GLAPIENTRY * fUnlockSurfaceKHR)(EGLDisplay dpy, EGLSurface surface);
+        EGLBoolean (GLAPIENTRY * fQuerySurface)(EGLDisplay dpy, EGLSurface surface,
+                                                EGLint attribute, EGLint* value);
+        EGLBoolean (GLAPIENTRY * fQuerySurfacePointerANGLE)(EGLDisplay dpy,
+                                                            EGLSurface surface,
+                                                            EGLint attribute,
+                                                            void** value);
+        EGLSync    (GLAPIENTRY * fCreateSyncKHR)(EGLDisplay dpy, EGLenum type,
+                                                 const EGLint* attrib_list);
+        EGLBoolean (GLAPIENTRY * fDestroySyncKHR)(EGLDisplay dpy, EGLSync sync);
+        EGLint     (GLAPIENTRY * fClientWaitSyncKHR)(EGLDisplay dpy, EGLSync sync,
+                                                     EGLint flags,
+                                                     EGLTime timeout);
+        EGLBoolean (GLAPIENTRY * fGetSyncAttribKHR)(EGLDisplay dpy, EGLSync sync,
+                                                    EGLint attribute, EGLint* value);
+        EGLint     (GLAPIENTRY * fDupNativeFenceFDANDROID)(EGLDisplay dpy, EGLSync sync);
+        void       (GLAPIENTRY * fANGLEPlatformInitialize)(angle::Platform* platform);
+        void       (GLAPIENTRY * fANGLEPlatformShutdown)();
     } mSymbols;
 
 #ifdef DEBUG
     static void BeforeGLCall(const char* glFunction);
     static void AfterGLCall(const char* glFunction);
 #endif
 
+public:
 #ifdef MOZ_B2G
     EGLContext CachedCurrentContext() {
         return sCurrentContext.get();
     }
     void UnsetCachedCurrentContext() {
         sCurrentContext.set(nullptr);
     }
     void SetCachedCurrentContext(EGLContext aCtx) {
--- a/gfx/gl/GLLibraryLoader.cpp
+++ b/gfx/gl/GLLibraryLoader.cpp
@@ -113,11 +113,19 @@ GLLibraryLoader::LoadSymbols(PRLibrary* 
         }
 
         ss++;
     }
 
     return failCount == 0 ? true : false;
 }
 
+/*static*/ void
+GLLibraryLoader::ClearSymbols(const SymLoadStruct* const firstStruct)
+{
+    for (auto cur = firstStruct; cur->symPointer; ++cur) {
+        *cur->symPointer = nullptr;
+    }
+}
+
 } /* namespace gl */
 } /* namespace mozilla */
 
--- a/gfx/gl/GLLibraryLoader.h
+++ b/gfx/gl/GLLibraryLoader.h
@@ -31,16 +31,18 @@ public:
         const char* symNames[MAX_SYMBOL_NAMES];
     } SymLoadStruct;
 
     bool LoadSymbols(const SymLoadStruct* firstStruct,
                      bool tryplatform = false,
                      const char* prefix = nullptr,
                      bool warnOnFailure = true);
 
+    static void ClearSymbols(const SymLoadStruct* firstStruct);
+
     PRFuncPtr LookupSymbol(const char* symname);
 
     /*
      * Static version of the functions in this class
      */
     static PRFuncPtr LookupSymbol(PRLibrary* lib,
                                   const char* symname,
                                   PlatformLookupFunction lookupFunction = nullptr);
--- a/gfx/gl/GLXLibrary.h
+++ b/gfx/gl/GLXLibrary.h
@@ -2,82 +2,58 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef GFX_GLXLIBRARY_H
 #define GFX_GLXLIBRARY_H
 
 #include "GLContextTypes.h"
+#include "prlink.h"
 typedef realGLboolean GLboolean;
 
 // stuff from glx.h
 #include "X11/Xlib.h"
 typedef struct __GLXcontextRec* GLXContext;
 typedef XID GLXPixmap;
 typedef XID GLXDrawable;
 /* GLX 1.3 and later */
 typedef struct __GLXFBConfigRec* GLXFBConfig;
-typedef XID GLXFBConfigID;
-typedef XID GLXContextID;
-typedef XID GLXWindow;
-typedef XID GLXPbuffer;
 // end of stuff from glx.h
 #include "prenv.h"
 
 struct PRLibrary;
 class gfxASurface;
 
 namespace mozilla {
 namespace gl {
 
 class GLXLibrary
 {
 public:
-    constexpr GLXLibrary()
-    : xDestroyContextInternal(nullptr)
-    , xMakeCurrentInternal(nullptr)
-    , xGetCurrentContextInternal(nullptr)
-    , xGetProcAddressInternal(nullptr)
-    , xChooseFBConfigInternal(nullptr)
-    , xGetFBConfigsInternal(nullptr)
-    , xCreateNewContextInternal(nullptr)
-    , xGetFBConfigAttribInternal(nullptr)
-    , xSwapBuffersInternal(nullptr)
-    , xQueryExtensionsStringInternal(nullptr)
-    , xGetClientStringInternal(nullptr)
-    , xQueryServerStringInternal(nullptr)
-    , xCreatePixmapInternal(nullptr)
-    , xCreateGLXPixmapWithConfigInternal(nullptr)
-    , xDestroyPixmapInternal(nullptr)
-    , xQueryVersionInternal(nullptr)
-    , xBindTexImageInternal(nullptr)
-    , xReleaseTexImageInternal(nullptr)
-    , xWaitGLInternal(nullptr)
-    , xWaitXInternal(nullptr)
-    , xCreateContextAttribsInternal(nullptr)
-    , xGetVideoSyncInternal(nullptr)
-    , xWaitVideoSyncInternal(nullptr)
-    , xSwapIntervalInternal(nullptr)
-    , mInitialized(false), mTriedInitializing(false)
-    , mUseTextureFromPixmap(false), mDebug(false)
-    , mHasRobustness(false), mHasCreateContextAttribs(false)
-    , mHasVideoSync(false)
-    , mIsATI(false), mIsNVIDIA(false)
-    , mClientIsMesa(false)
-    , mOGLLibrary(nullptr)
+    GLXLibrary()
+        : mSymbols{nullptr}
+        , mInitialized(false)
+        , mTriedInitializing(false)
+        , mUseTextureFromPixmap(false)
+        , mDebug(false)
+        , mHasRobustness(false)
+        , mHasCreateContextAttribs(false)
+        , mHasVideoSync(false)
+        , mIsATI(false), mIsNVIDIA(false)
+        , mClientIsMesa(false)
+        , mOGLLibrary(nullptr)
     {}
 
     void xDestroyContext(Display* display, GLXContext context);
     Bool xMakeCurrent(Display* display,
                       GLXDrawable drawable,
                       GLXContext context);
 
     GLXContext xGetCurrentContext();
-    static void* xGetProcAddress(const char* procName);
     GLXFBConfig* xChooseFBConfig(Display* display,
                                  int screen,
                                  const int* attrib_list,
                                  int* nelements);
     GLXFBConfig* xGetFBConfigs(Display* display,
                                int screen,
                                int* nelements);
     GLXContext xCreateNewContext(Display* display,
@@ -135,118 +111,57 @@ public:
     void ReleaseTexImage(Display* aDisplay, GLXPixmap aPixmap);
     void UpdateTexImage(Display* aDisplay, GLXPixmap aPixmap);
 
     bool UseTextureFromPixmap() { return mUseTextureFromPixmap; }
     bool HasRobustness() { return mHasRobustness; }
     bool HasCreateContextAttribs() { return mHasCreateContextAttribs; }
     bool SupportsTextureFromPixmap(gfxASurface* aSurface);
     bool SupportsVideoSync();
-    bool SupportsSwapControl() const { return bool(xSwapIntervalInternal); }
+    bool SupportsSwapControl() const { return bool(mSymbols.fSwapIntervalEXT); }
     bool IsATI() { return mIsATI; }
     bool IsMesa() { return mClientIsMesa; }
 
-private:
-
-    typedef void (GLAPIENTRY * PFNGLXDESTROYCONTEXTPROC) (Display*,
-                                                          GLXContext);
-    PFNGLXDESTROYCONTEXTPROC xDestroyContextInternal;
-    typedef Bool (GLAPIENTRY * PFNGLXMAKECURRENTPROC) (Display*,
-                                                       GLXDrawable,
-                                                       GLXContext);
-    PFNGLXMAKECURRENTPROC xMakeCurrentInternal;
-    typedef GLXContext (GLAPIENTRY * PFNGLXGETCURRENTCONTEXT) ();
-    PFNGLXGETCURRENTCONTEXT xGetCurrentContextInternal;
-    typedef void* (GLAPIENTRY * PFNGLXGETPROCADDRESSPROC) (const char*);
-    PFNGLXGETPROCADDRESSPROC xGetProcAddressInternal;
-    typedef GLXFBConfig* (GLAPIENTRY * PFNGLXCHOOSEFBCONFIG) (Display*,
-                                                              int,
-                                                              const int*,
-                                                              int*);
-    PFNGLXCHOOSEFBCONFIG xChooseFBConfigInternal;
-    typedef GLXFBConfig* (GLAPIENTRY * PFNGLXGETFBCONFIGS) (Display*,
-                                                            int,
-                                                            int*);
-    PFNGLXGETFBCONFIGS xGetFBConfigsInternal;
-    typedef GLXContext (GLAPIENTRY * PFNGLXCREATENEWCONTEXT) (Display*,
-                                                              GLXFBConfig,
-                                                              int,
-                                                              GLXContext,
-                                                              Bool);
-    PFNGLXCREATENEWCONTEXT xCreateNewContextInternal;
-    typedef int (GLAPIENTRY * PFNGLXGETFBCONFIGATTRIB) (Display*,
-                                                        GLXFBConfig,
-                                                        int,
-                                                        int*);
-    PFNGLXGETFBCONFIGATTRIB xGetFBConfigAttribInternal;
-
-    typedef void (GLAPIENTRY * PFNGLXSWAPBUFFERS) (Display*,
-                                                   GLXDrawable);
-    PFNGLXSWAPBUFFERS xSwapBuffersInternal;
-    typedef const char* (GLAPIENTRY * PFNGLXQUERYEXTENSIONSSTRING) (Display*,
-                                                                    int);
-    PFNGLXQUERYEXTENSIONSSTRING xQueryExtensionsStringInternal;
-    typedef const char* (GLAPIENTRY * PFNGLXGETCLIENTSTRING) (Display*,
-                                                              int);
-    PFNGLXGETCLIENTSTRING xGetClientStringInternal;
-    typedef const char* (GLAPIENTRY * PFNGLXQUERYSERVERSTRING) (Display*,
-                                                                int,
-                                                                int);
-    PFNGLXQUERYSERVERSTRING xQueryServerStringInternal;
+    PRFuncPtr GetGetProcAddress() const {
+        return (PRFuncPtr)mSymbols.fGetProcAddress;
+    }
 
-    typedef GLXPixmap (GLAPIENTRY * PFNGLXCREATEPIXMAP) (Display*,
-                                                         GLXFBConfig,
-                                                         Pixmap,
-                                                         const int*);
-    PFNGLXCREATEPIXMAP xCreatePixmapInternal;
-    typedef GLXPixmap (GLAPIENTRY * PFNGLXCREATEGLXPIXMAPWITHCONFIG)
-                                                        (Display*,
-                                                         GLXFBConfig,
-                                                         Pixmap);
-    PFNGLXCREATEGLXPIXMAPWITHCONFIG xCreateGLXPixmapWithConfigInternal;
-    typedef void (GLAPIENTRY * PFNGLXDESTROYPIXMAP) (Display*,
-                                                     GLXPixmap);
-    PFNGLXDESTROYPIXMAP xDestroyPixmapInternal;
-    typedef Bool (GLAPIENTRY * PFNGLXQUERYVERSION) (Display*,
-                                                    int*,
-                                                    int*);
-    PFNGLXQUERYVERSION xQueryVersionInternal;
-
-    typedef void (GLAPIENTRY * PFNGLXBINDTEXIMAGE) (Display*,
-                                                    GLXDrawable,
-                                                    int,
-                                                    const int*);
-    PFNGLXBINDTEXIMAGE xBindTexImageInternal;
-
-    typedef void (GLAPIENTRY * PFNGLXRELEASETEXIMAGE) (Display*,
-                                                       GLXDrawable,
-                                                       int);
-    PFNGLXRELEASETEXIMAGE xReleaseTexImageInternal;
-
-    typedef void (GLAPIENTRY * PFNGLXWAITGL) ();
-    PFNGLXWAITGL xWaitGLInternal;
-
-    typedef void (GLAPIENTRY * PFNGLXWAITX) ();
-    PFNGLXWAITGL xWaitXInternal;
-
-    typedef GLXContext (GLAPIENTRY * PFNGLXCREATECONTEXTATTRIBS) (Display*,
-                                                                  GLXFBConfig,
-                                                                  GLXContext,
-                                                                  Bool,
-                                                                  const int*);
-    PFNGLXCREATECONTEXTATTRIBS xCreateContextAttribsInternal;
-
-    typedef int (GLAPIENTRY * PFNGLXGETVIDEOSYNCSGI) (unsigned int* count);
-    PFNGLXGETVIDEOSYNCSGI xGetVideoSyncInternal;
-
-    typedef int (GLAPIENTRY * PFNGLXWAITVIDEOSYNCSGI) (int divisor, int remainder, unsigned int* count);
-    PFNGLXWAITVIDEOSYNCSGI xWaitVideoSyncInternal;
-
-    typedef void (GLAPIENTRY * PFNGLXSWAPINTERVALEXT) (Display* dpy, GLXDrawable drawable, int interval);
-    PFNGLXSWAPINTERVALEXT xSwapIntervalInternal;
+private:
+    struct {
+        void         (GLAPIENTRY *fDestroyContext) (Display*, GLXContext);
+        Bool         (GLAPIENTRY *fMakeCurrent) (Display*, GLXDrawable, GLXContext);
+        GLXContext   (GLAPIENTRY *fGetCurrentContext) ();
+        void*        (GLAPIENTRY *fGetProcAddress) (const char*);
+        GLXFBConfig* (GLAPIENTRY *fChooseFBConfig) (Display*, int, const int*, int*);
+        GLXFBConfig* (GLAPIENTRY *fGetFBConfigs) (Display*, int, int*);
+        GLXContext   (GLAPIENTRY *fCreateNewContext) (Display*, GLXFBConfig, int,
+                                                      GLXContext, Bool);
+        int          (GLAPIENTRY *fGetFBConfigAttrib) (Display*, GLXFBConfig, int, int*);
+        void         (GLAPIENTRY *fSwapBuffers) (Display*, GLXDrawable);
+        const char*  (GLAPIENTRY *fQueryExtensionsString) (Display*, int);
+        const char*  (GLAPIENTRY *fGetClientString) (Display*, int);
+        const char*  (GLAPIENTRY *fQueryServerString) (Display*, int, int);
+        GLXPixmap    (GLAPIENTRY *fCreatePixmap) (Display*, GLXFBConfig, Pixmap,
+                                                  const int*);
+        GLXPixmap    (GLAPIENTRY *fCreateGLXPixmapWithConfig) (Display*, GLXFBConfig,
+                                                              Pixmap);
+        void         (GLAPIENTRY *fDestroyPixmap) (Display*, GLXPixmap);
+        Bool         (GLAPIENTRY *fQueryVersion) (Display*, int*, int*);
+        void         (GLAPIENTRY *fWaitGL) ();
+        void         (GLAPIENTRY *fWaitX) ();
+        void         (GLAPIENTRY *fBindTexImageEXT) (Display*, GLXDrawable, int,
+                                                     const int*);
+        void         (GLAPIENTRY *fReleaseTexImageEXT) (Display*, GLXDrawable, int);
+        GLXContext   (GLAPIENTRY *fCreateContextAttribsARB) (Display*, GLXFBConfig,
+                                                             GLXContext, Bool,
+                                                             const int*);
+        int          (GLAPIENTRY *fGetVideoSyncSGI) (unsigned int*);
+        int          (GLAPIENTRY *fWaitVideoSyncSGI) (int, int, unsigned int*);
+        void         (GLAPIENTRY *fSwapIntervalEXT) (Display*, GLXDrawable, int);
+    } mSymbols;
 
 #ifdef DEBUG
     void BeforeGLXCall();
     void AfterGLXCall();
 #endif
 
     bool mInitialized;
     bool mTriedInitializing;
--- a/gfx/gl/SharedSurfaceD3D11Interop.cpp
+++ b/gfx/gl/SharedSurfaceD3D11Interop.cpp
@@ -132,17 +132,17 @@ public:
         if (!d3d) {
             gfxCriticalNote << "DXInterop2Device::Open: Failed to create D3D11 device.";
             return nullptr;
         }
 
         if (!gl->MakeCurrent())
             return nullptr;
 
-        const auto interopDevice = wgl->fDXOpenDevice(d3d);
+        const auto interopDevice = wgl->mSymbols.fDXOpenDeviceNV(d3d);
         if (!interopDevice) {
             gfxCriticalNote << "DXInterop2Device::Open: DXOpenDevice failed.";
             return nullptr;
         }
 
         return MakeAndAddRef<DXInterop2Device>(wgl, d3d, interopDevice, gl);
     }
 
@@ -152,17 +152,17 @@ public:
         , mD3D(d3d)
         , mInteropDevice(interopDevice)
         , mGL(gl)
     { }
 
     ~DXInterop2Device() {
         const auto isCurrent = mGL->MakeCurrent();
 
-        if (mWGL->fDXCloseDevice(mInteropDevice))
+        if (mWGL->mSymbols.fDXCloseDeviceNV(mInteropDevice))
             return;
 
         if (isCurrent) {
             // That shouldn't have failed.
             const uint32_t error = GetLastError();
             const nsPrintfCString errorMessage("wglDXCloseDevice(0x%p) failed:"
                                                " GetLastError(): %u\n",
                                                mInteropDevice, error);
@@ -171,83 +171,83 @@ public:
     }
 
     HANDLE RegisterObject(void* d3dObject, GLuint name, GLenum type,
                           GLenum access) const
     {
         if (!mGL->MakeCurrent())
             return nullptr;
 
-        const auto ret = mWGL->fDXRegisterObject(mInteropDevice, d3dObject, name, type,
-                                                 access);
+        const auto& ret = mWGL->mSymbols.fDXRegisterObjectNV(mInteropDevice, d3dObject,
+                                                             name, type, access);
         if (ret)
             return ret;
 
         const uint32_t error = GetLastError();
         const nsPrintfCString errorMessage("wglDXRegisterObject(0x%p, 0x%p, %u, 0x%04x,"
                                            " 0x%04x) failed: GetLastError(): %u\n",
                                            mInteropDevice, d3dObject, name, type, access,
                                            error);
         gfxCriticalNote << errorMessage.BeginReading();
         return nullptr;
     }
 
     bool UnregisterObject(HANDLE lockHandle) const {
         const auto isCurrent = mGL->MakeCurrent();
 
-        if (mWGL->fDXUnregisterObject(mInteropDevice, lockHandle))
+        if (mWGL->mSymbols.fDXUnregisterObjectNV(mInteropDevice, lockHandle))
             return true;
 
         if (!isCurrent) {
             // That shouldn't have failed.
             const uint32_t error = GetLastError();
             const nsPrintfCString errorMessage("wglDXUnregisterObject(0x%p, 0x%p) failed:"
                                                " GetLastError(): %u\n",
                                                mInteropDevice, lockHandle, error);
             gfxCriticalError() << errorMessage.BeginReading();
         }
         return false;
     }
 
     bool LockObject(HANDLE lockHandle) const {
         MOZ_ASSERT(mGL->IsCurrent());
 
-        if (mWGL->fDXLockObjects(mInteropDevice, 1, &lockHandle))
+        if (mWGL->mSymbols.fDXLockObjectsNV(mInteropDevice, 1, &lockHandle))
             return true;
 
         if (!mGL->MakeCurrent())
             return false;
 
         gfxCriticalNote << "wglDXLockObjects called without mGL being current."
                         << " Retrying after MakeCurrent.";
 
-        if (mWGL->fDXLockObjects(mInteropDevice, 1, &lockHandle))
+        if (mWGL->mSymbols.fDXLockObjectsNV(mInteropDevice, 1, &lockHandle))
             return true;
 
         const uint32_t error = GetLastError();
         const nsPrintfCString errorMessage("wglDXLockObjects(0x%p, 1, {0x%p}) failed:"
                                            " GetLastError(): %u\n",
                                            mInteropDevice, lockHandle, error);
         gfxCriticalError() << errorMessage.BeginReading();
         return false;
     }
 
     bool UnlockObject(HANDLE lockHandle) const {
         MOZ_ASSERT(mGL->IsCurrent());
 
-        if (mWGL->fDXUnlockObjects(mInteropDevice, 1, &lockHandle))
+        if (mWGL->mSymbols.fDXUnlockObjectsNV(mInteropDevice, 1, &lockHandle))
             return true;
 
         if (!mGL->MakeCurrent())
             return false;
 
         gfxCriticalNote << "wglDXUnlockObjects called without mGL being current."
                         << " Retrying after MakeCurrent.";
 
-        if (mWGL->fDXUnlockObjects(mInteropDevice, 1, &lockHandle))
+        if (mWGL->mSymbols.fDXUnlockObjectsNV(mInteropDevice, 1, &lockHandle))
             return true;
 
         const uint32_t error = GetLastError();
         const nsPrintfCString errorMessage("wglDXUnlockObjects(0x%p, 1, {0x%p}) failed:"
                                            " GetLastError(): %u\n",
                                            mInteropDevice, lockHandle, error);
         gfxCriticalError() << errorMessage.BeginReading();
         return false;
--- a/gfx/gl/WGLLibrary.h
+++ b/gfx/gl/WGLLibrary.h
@@ -10,101 +10,72 @@ struct PRLibrary;
 
 namespace mozilla {
 namespace gl {
 
 class WGLLibrary
 {
 public:
     WGLLibrary()
-      : mInitialized(false)
+      : mSymbols{nullptr}
+      , mInitialized(false)
       , mOGLLibrary(nullptr)
       , mHasRobustness(false)
       , mWindow (0)
       , mWindowDC(0)
       , mWindowGLContext(0)
       , mWindowPixelFormat(0)
-    {}
-
-    typedef HGLRC (GLAPIENTRY * PFNWGLCREATECONTEXTPROC) (HDC);
-    PFNWGLCREATECONTEXTPROC fCreateContext;
-    typedef BOOL (GLAPIENTRY * PFNWGLDELETECONTEXTPROC) (HGLRC);
-    PFNWGLDELETECONTEXTPROC fDeleteContext;
-    typedef BOOL (GLAPIENTRY * PFNWGLMAKECURRENTPROC) (HDC, HGLRC);
-    PFNWGLMAKECURRENTPROC fMakeCurrent;
-    typedef PROC (GLAPIENTRY * PFNWGLGETPROCADDRESSPROC) (LPCSTR);
-    PFNWGLGETPROCADDRESSPROC fGetProcAddress;
-    typedef HGLRC (GLAPIENTRY * PFNWGLGETCURRENTCONTEXT) (void);
-    PFNWGLGETCURRENTCONTEXT fGetCurrentContext;
-    typedef HDC (GLAPIENTRY * PFNWGLGETCURRENTDC) (void);
-    PFNWGLGETCURRENTDC fGetCurrentDC;
-    typedef BOOL (GLAPIENTRY * PFNWGLSHARELISTS) (HGLRC oldContext, HGLRC newContext);
-    PFNWGLSHARELISTS fShareLists;
-
-    typedef HANDLE (WINAPI * PFNWGLCREATEPBUFFERPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int* piAttribList);
-    PFNWGLCREATEPBUFFERPROC fCreatePbuffer;
-    typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFERPROC) (HANDLE hPbuffer);
-    PFNWGLDESTROYPBUFFERPROC fDestroyPbuffer;
-    typedef HDC (WINAPI * PFNWGLGETPBUFFERDCPROC) (HANDLE hPbuffer);
-    PFNWGLGETPBUFFERDCPROC fGetPbufferDC;
-
-    typedef BOOL (WINAPI * PFNWGLBINDTEXIMAGEPROC) (HANDLE hPbuffer, int iBuffer);
-    PFNWGLBINDTEXIMAGEPROC fBindTexImage;
-    typedef BOOL (WINAPI * PFNWGLRELEASETEXIMAGEPROC) (HANDLE hPbuffer, int iBuffer);
-    PFNWGLRELEASETEXIMAGEPROC fReleaseTexImage;
-
-    typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATPROC) (HDC hdc, const int* piAttribIList, const FLOAT* pfAttribFList, UINT nMaxFormats, int* piFormats, UINT* nNumFormats);
-    PFNWGLCHOOSEPIXELFORMATPROC fChoosePixelFormat;
-    typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int* piAttributes, int* piValues);
-    PFNWGLGETPIXELFORMATATTRIBIVPROC fGetPixelFormatAttribiv;
+    { }
 
-    typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGPROC) (HDC hdc);
-    PFNWGLGETEXTENSIONSSTRINGPROC fGetExtensionsString;
-
-    typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSPROC) (HDC hdc, HGLRC hShareContext, const int* attribList);
-    PFNWGLCREATECONTEXTATTRIBSPROC fCreateContextAttribs;
-
-    // WGL_NV_DX_interop:
-    // BOOL wglDXSetResourceShareHandleNV(void* dxObject, HANDLE shareHandle);
-    typedef BOOL (WINAPI * PFNWGLDXSETRESOURCESHAREHANDLEPROC) (void* dxObject, HANDLE shareHandle);
-    PFNWGLDXSETRESOURCESHAREHANDLEPROC fDXSetResourceShareHandle;
-
-    // HANDLE wglDXOpenDeviceNV(void* dxDevice);
-    typedef HANDLE (WINAPI * PFNWGLDXOPENDEVICEPROC) (void* dxDevice);
-    PFNWGLDXOPENDEVICEPROC fDXOpenDevice;
-
-    // BOOL wglDXCloseDeviceNV(HANDLE hDevice);
-    typedef BOOL (WINAPI * PFNWGLDXCLOSEDEVICEPROC) (HANDLE hDevice);
-    PFNWGLDXCLOSEDEVICEPROC fDXCloseDevice;
-
-    // HANDLE wglDXRegisterObjectNV(HANDLE hDevice, void* dxObject, GLuint name, GLenum type, GLenum access);
-    typedef HANDLE (WINAPI * PFNWGLDXREGISTEROBJECTPROC) (HANDLE hDevice, void* dxObject, GLuint name, GLenum type, GLenum access);
-    PFNWGLDXREGISTEROBJECTPROC fDXRegisterObject;
-
-    // BOOL wglDXUnregisterObjectNV(HANDLE hDevice, HANDLE hObject);
-    typedef BOOL (WINAPI * PFNWGLDXUNREGISTEROBJECT) (HANDLE hDevice, HANDLE hObject);
-    PFNWGLDXUNREGISTEROBJECT fDXUnregisterObject;
-
-    // BOOL wglDXObjectAccessNV(HANDLE hObject, GLenum access);
-    typedef BOOL (WINAPI * PFNWGLDXOBJECTACCESSPROC) (HANDLE hObject, GLenum access);
-    PFNWGLDXOBJECTACCESSPROC fDXObjectAccess;
-
-    // BOOL wglDXLockObjectsNV(HANDLE hDevice, GLint count, HANDLE* hObjects);
-    typedef BOOL (WINAPI * PFNWGLDXLOCKOBJECTSPROC) (HANDLE hDevice, GLint count, HANDLE* hObjects);
-    PFNWGLDXLOCKOBJECTSPROC fDXLockObjects;
-
-    // BOOL wglDXUnlockObjectsNV(HANDLE hDevice, GLint count, HANDLE* hObjects);
-    typedef BOOL (WINAPI * PFNWGLDXUNLOCKOBJECTSPROC) (HANDLE hDevice, GLint count, HANDLE* hObjects);
-    PFNWGLDXUNLOCKOBJECTSPROC fDXUnlockObjects;
+public:
+    struct {
+        HGLRC  (GLAPIENTRY * fCreateContext) (HDC);
+        BOOL   (GLAPIENTRY * fDeleteContext) (HGLRC);
+        BOOL   (GLAPIENTRY * fMakeCurrent) (HDC, HGLRC);
+        PROC   (GLAPIENTRY * fGetProcAddress) (LPCSTR);
+        HGLRC  (GLAPIENTRY * fGetCurrentContext) (void);
+        HDC    (GLAPIENTRY * fGetCurrentDC) (void);
+        BOOL   (GLAPIENTRY * fShareLists) (HGLRC oldContext, HGLRC newContext);
+        HANDLE (GLAPIENTRY * fCreatePbuffer) (HDC hDC, int iPixelFormat, int iWidth,
+                                              int iHeight, const int* piAttribList);
+        BOOL (GLAPIENTRY * fDestroyPbuffer) (HANDLE hPbuffer);
+        HDC  (GLAPIENTRY * fGetPbufferDC) (HANDLE hPbuffer);
+        BOOL (GLAPIENTRY * fBindTexImage) (HANDLE hPbuffer, int iBuffer);
+        BOOL (GLAPIENTRY * fReleaseTexImage) (HANDLE hPbuffer, int iBuffer);
+        BOOL (GLAPIENTRY * fChoosePixelFormat) (HDC hdc, const int* piAttribIList,
+                                                const FLOAT* pfAttribFList,
+                                                UINT nMaxFormats, int* piFormats,
+                                                UINT* nNumFormats);
+        BOOL (GLAPIENTRY * fGetPixelFormatAttribiv) (HDC hdc, int iPixelFormat,
+                                                     int iLayerPlane, UINT nAttributes,
+                                                     int* piAttributes, int* piValues);
+        const char* (GLAPIENTRY * fGetExtensionsStringARB) (HDC hdc);
+        HGLRC (GLAPIENTRY * fCreateContextAttribsARB) (HDC hdc, HGLRC hShareContext,
+                                                       const int* attribList);
+        // WGL_NV_DX_interop:
+        BOOL   (GLAPIENTRY * fDXSetResourceShareHandleNV) (void* dxObject,
+                                                           HANDLE shareHandle);
+        HANDLE (GLAPIENTRY * fDXOpenDeviceNV) (void* dxDevice);
+        BOOL   (GLAPIENTRY * fDXCloseDeviceNV) (HANDLE hDevice);
+        HANDLE (GLAPIENTRY * fDXRegisterObjectNV) (HANDLE hDevice, void* dxObject,
+                                                   GLuint name, GLenum type,
+                                                   GLenum access);
+        BOOL   (GLAPIENTRY * fDXUnregisterObjectNV) (HANDLE hDevice, HANDLE hObject);
+        BOOL   (GLAPIENTRY * fDXObjectAccessNV) (HANDLE hObject, GLenum access);
+        BOOL   (GLAPIENTRY * fDXLockObjectsNV) (HANDLE hDevice, GLint count,
+                                                HANDLE* hObjects);
+        BOOL   (GLAPIENTRY * fDXUnlockObjectsNV) (HANDLE hDevice, GLint count,
+                                                  HANDLE* hObjects);
+    } mSymbols;
 
     bool EnsureInitialized();
     HWND CreateDummyWindow(HDC* aWindowDC = nullptr);
 
     bool HasRobustness() const { return mHasRobustness; }
-    bool HasDXInterop2() const { return bool(fDXOpenDevice); }
+    bool HasDXInterop2() const { return bool(mSymbols.fDXOpenDeviceNV); }
     bool IsInitialized() const { return mInitialized; }
     HWND GetWindow() const { return mWindow; }
     HDC GetWindowDC() const {return mWindowDC; }
     HGLRC GetWindowGLContext() const {return mWindowGLContext; }
     int GetWindowPixelFormat() const { return mWindowPixelFormat; }
     PRLibrary* GetOGLLibrary() { return mOGLLibrary; }
 
 private: