Add m-esr52 at 52.6.0

1 files changed, 704 insertions, 0 deletions

diff --git a/gfx/gl/GLLibraryEGL.h b/gfx/gl/GLLibraryEGL.h
new file mode 100644
index 000000000..fa6ea748b
--- /dev/null
+++ b/gfx/gl/GLLibraryEGL.h
@@ -0,0 +1,704 @@
+/* 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 GLLIBRARYEGL_H_
+#define GLLIBRARYEGL_H_
+
+#if defined(MOZ_X11)
+#include "mozilla/X11Util.h"
+#endif
+
+#include "GLLibraryLoader.h"
+#include "mozilla/StaticMutex.h"
+#include "mozilla/ThreadLocal.h"
+#include "nsIFile.h"
+#include "GeckoProfiler.h"
+
+#include <bitset>
+#include <vector>
+
+#ifdef XP_WIN
+    #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN 1
+    #endif
+
+    #include <windows.h>
+
+    typedef HDC EGLNativeDisplayType;
+    typedef HBITMAP EGLNativePixmapType;
+    typedef HWND EGLNativeWindowType;
+#else
+    typedef void* EGLNativeDisplayType;
+    typedef void* EGLNativePixmapType;
+    typedef void* EGLNativeWindowType;
+
+    #ifdef ANDROID
+        // We only need to explicitly dlopen egltrace
+        // on android as we can use LD_PRELOAD or other tricks
+        // on other platforms. We look for it in /data/local
+        // as that's writeable by all users
+        //
+        // This should really go in GLLibraryEGL.cpp but we currently reference
+        // APITRACE_LIB in GLContextProviderEGL.cpp. Further refactoring
+        // will come in subsequent patches on Bug 732865
+        #define APITRACE_LIB "/data/local/tmp/egltrace.so"
+    #endif
+#endif
+
+#if defined(MOZ_X11)
+#define EGL_DEFAULT_DISPLAY  ((EGLNativeDisplayType)mozilla::DefaultXDisplay())
+#else
+#define EGL_DEFAULT_DISPLAY  ((EGLNativeDisplayType)0)
+#endif
+
+namespace angle {
+class Platform;
+}
+
+namespace mozilla {
+
+namespace gfx {
+class DataSourceSurface;
+}
+
+namespace gl {
+
+#undef BEFORE_GL_CALL
+#undef AFTER_GL_CALL
+
+#ifdef DEBUG
+
+#ifndef MOZ_FUNCTION_NAME
+# ifdef __GNUC__
+#  define MOZ_FUNCTION_NAME __PRETTY_FUNCTION__
+# elif defined(_MSC_VER)
+#  define MOZ_FUNCTION_NAME __FUNCTION__
+# else
+#  define MOZ_FUNCTION_NAME __func__  // defined in C99, supported in various C++ compilers. Just raw function name.
+# endif
+#endif
+
+#ifdef MOZ_WIDGET_ANDROID
+// Record the name of the GL call for better hang stacks on Android.
+#define BEFORE_GL_CALL                      \
+    PROFILER_LABEL_FUNC(                    \
+      js::ProfileEntry::Category::GRAPHICS);\
+    BeforeGLCall(MOZ_FUNCTION_NAME)
+#else
+#define BEFORE_GL_CALL do {          \
+    BeforeGLCall(MOZ_FUNCTION_NAME); \
+} while (0)
+#endif
+
+#define AFTER_GL_CALL do {           \
+    AfterGLCall(MOZ_FUNCTION_NAME);  \
+} while (0)
+#else
+#ifdef MOZ_WIDGET_ANDROID
+// Record the name of the GL call for better hang stacks on Android.
+#define BEFORE_GL_CALL PROFILER_LABEL_FUNC(js::ProfileEntry::Category::GRAPHICS)
+#else
+#define BEFORE_GL_CALL
+#endif
+#define AFTER_GL_CALL
+#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.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;
+    }
+
+    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.
+     * If you add to this array, remember to add to the string names
+     * in GLContext.cpp.
+     */
+    enum EGLExtensions {
+        KHR_image_base,
+        KHR_image_pixmap,
+        KHR_gl_texture_2D_image,
+        KHR_lock_surface,
+        ANGLE_surface_d3d_texture_2d_share_handle,
+        EXT_create_context_robustness,
+        KHR_image,
+        KHR_fence_sync,
+        ANDROID_native_fence_sync,
+        EGL_ANDROID_image_crop,
+        ANGLE_platform_angle,
+        ANGLE_platform_angle_d3d,
+        Extensions_Max
+    };
+
+    bool IsExtensionSupported(EGLExtensions aKnownExtension) const {
+        return mAvailableExtensions[aKnownExtension];
+    }
+
+    void MarkExtensionUnsupported(EGLExtensions aKnownExtension) {
+        mAvailableExtensions[aKnownExtension] = false;
+    }
+
+protected:
+    std::bitset<Extensions_Max> mAvailableExtensions;
+
+public:
+
+    EGLDisplay fGetDisplay(void* display_id)
+    {
+        BEFORE_GL_CALL;
+        EGLDisplay disp = mSymbols.fGetDisplay(display_id);
+        AFTER_GL_CALL;
+        return disp;
+    }
+
+    EGLDisplay fGetPlatformDisplayEXT(EGLenum platform, void* native_display, const EGLint* attrib_list)
+    {
+        BEFORE_GL_CALL;
+        EGLDisplay disp = mSymbols.fGetPlatformDisplayEXT(platform, native_display, attrib_list);
+        AFTER_GL_CALL;
+        return disp;
+    }
+
+    EGLBoolean fTerminate(EGLDisplay display)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean ret = mSymbols.fTerminate(display);
+        AFTER_GL_CALL;
+        return ret;
+    }
+
+    EGLSurface fGetCurrentSurface(EGLint id)
+    {
+        BEFORE_GL_CALL;
+        EGLSurface surf = mSymbols.fGetCurrentSurface(id);
+        AFTER_GL_CALL;
+        return surf;
+    }
+
+    EGLContext fGetCurrentContext()
+    {
+        BEFORE_GL_CALL;
+        EGLContext context = mSymbols.fGetCurrentContext();
+        AFTER_GL_CALL;
+        return context;
+    }
+
+    EGLBoolean fMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fMakeCurrent(dpy, draw, read, ctx);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLBoolean fDestroyContext(EGLDisplay dpy, EGLContext ctx)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fDestroyContext(dpy, ctx);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLContext fCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint* attrib_list)
+    {
+        BEFORE_GL_CALL;
+        EGLContext ctx = mSymbols.fCreateContext(dpy, config, share_context, attrib_list);
+        AFTER_GL_CALL;
+        return ctx;
+    }
+
+    EGLBoolean fDestroySurface(EGLDisplay dpy, EGLSurface surface)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fDestroySurface(dpy, surface);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLSurface fCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint* attrib_list)
+    {
+        BEFORE_GL_CALL;
+        EGLSurface surf = mSymbols.fCreateWindowSurface(dpy, config, win, attrib_list);
+        AFTER_GL_CALL;
+        return surf;
+    }
+
+    EGLSurface fCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint* attrib_list)
+    {
+        BEFORE_GL_CALL;
+        EGLSurface surf = mSymbols.fCreatePbufferSurface(dpy, config, attrib_list);
+        AFTER_GL_CALL;
+        return surf;
+    }
+
+    EGLSurface fCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint* attrib_list)
+    {
+        BEFORE_GL_CALL;
+        EGLSurface surf = mSymbols.fCreatePixmapSurface(dpy, config, pixmap, attrib_list);
+        AFTER_GL_CALL;
+        return surf;
+    }
+
+    EGLBoolean fBindAPI(EGLenum api)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fBindAPI(api);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLBoolean fInitialize(EGLDisplay dpy, EGLint* major, EGLint* minor)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fInitialize(dpy, major, minor);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLBoolean fChooseConfig(EGLDisplay dpy, const EGLint* attrib_list, EGLConfig* configs, EGLint config_size, EGLint* num_config)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fChooseConfig(dpy, attrib_list, configs, config_size, num_config);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLint fGetError()
+    {
+        BEFORE_GL_CALL;
+        EGLint i = mSymbols.fGetError();
+        AFTER_GL_CALL;
+        return i;
+    }
+
+    EGLBoolean fGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint* value)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fGetConfigAttrib(dpy, config, attribute, value);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLBoolean fGetConfigs(EGLDisplay dpy, EGLConfig* configs, EGLint config_size, EGLint* num_config)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fGetConfigs(dpy, configs, config_size, num_config);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLBoolean fWaitNative(EGLint engine)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fWaitNative(engine);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLCastToRelevantPtr fGetProcAddress(const char* procname)
+    {
+        BEFORE_GL_CALL;
+        EGLCastToRelevantPtr p = mSymbols.fGetProcAddress(procname);
+        AFTER_GL_CALL;
+        return p;
+    }
+
+    EGLBoolean fSwapBuffers(EGLDisplay dpy, EGLSurface surface)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fSwapBuffers(dpy, surface);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLBoolean fCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
+    {
+        BEFORE_GL_CALL;
+        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);
+        }
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    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;
+    }
+
+    EGLBoolean fBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fBindTexImage(dpy, surface, buffer);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLBoolean fReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
+    {
+        BEFORE_GL_CALL;
+        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);
+         AFTER_GL_CALL;
+         return i;
+    }
+
+    EGLBoolean fDestroyImage(EGLDisplay dpy, EGLImage image)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fDestroyImage(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);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLBoolean fUnlockSurface(EGLDisplay dpy, EGLSurface surface)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fUnlockSurface(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);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLBoolean fQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void** value)
+    {
+        BEFORE_GL_CALL;
+        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);
+        AFTER_GL_CALL;
+        return ret;
+    }
+
+    EGLBoolean fDestroySync(EGLDisplay dpy, EGLSync sync)
+    {
+        BEFORE_GL_CALL;
+        EGLBoolean b = mSymbols.fDestroySync(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);
+        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);
+        AFTER_GL_CALL;
+        return b;
+    }
+
+    EGLint fDupNativeFenceFDANDROID(EGLDisplay dpy, EGLSync sync)
+    {
+        MOZ_ASSERT(mSymbols.fDupNativeFenceFDANDROID);
+        BEFORE_GL_CALL;
+        EGLint ret = mSymbols.fDupNativeFenceFDANDROID(dpy, sync);
+        AFTER_GL_CALL;
+        return ret;
+    }
+
+    void fANGLEPlatformInitialize(angle::Platform* platform)
+    {
+        MOZ_ASSERT(mSymbols.fANGLEPlatformInitialize);
+        BEFORE_GL_CALL;
+        mSymbols.fANGLEPlatformInitialize(platform);
+        AFTER_GL_CALL;
+    }
+
+    void fANGLEPlatformShutdown()
+    {
+        MOZ_ASSERT(mSymbols.fANGLEPlatformShutdown);
+        BEFORE_GL_CALL;
+        mSymbols.fANGLEPlatformShutdown();
+        AFTER_GL_CALL;
+    }
+
+    EGLDisplay Display() {
+        MOZ_ASSERT(mInitialized);
+        return mEGLDisplay;
+    }
+
+    bool IsANGLE() const {
+        MOZ_ASSERT(mInitialized);
+        return mIsANGLE;
+    }
+
+    bool IsWARP() const {
+        MOZ_ASSERT(mInitialized);
+        return mIsWARP;
+    }
+
+    bool HasKHRImageBase() {
+        return IsExtensionSupported(KHR_image) || IsExtensionSupported(KHR_image_base);
+    }
+
+    bool HasKHRImagePixmap() {
+        return IsExtensionSupported(KHR_image) || IsExtensionSupported(KHR_image_pixmap);
+    }
+
+    bool HasKHRImageTexture2D() {
+        return IsExtensionSupported(KHR_gl_texture_2D_image);
+    }
+
+    bool HasANGLESurfaceD3DTexture2DShareHandle() {
+        return IsExtensionSupported(ANGLE_surface_d3d_texture_2d_share_handle);
+    }
+
+    bool HasRobustness() const {
+        return IsExtensionSupported(EXT_create_context_robustness);
+    }
+
+    bool ReadbackEGLImage(EGLImage image, gfx::DataSourceSurface* out_surface);
+
+    bool EnsureInitialized(bool forceAccel, nsACString* const out_failureId);
+
+    void DumpEGLConfig(EGLConfig cfg);
+    void DumpEGLConfigs();
+
+    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 * 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;
+
+        // 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;
+    } mSymbols;
+
+#ifdef DEBUG
+    static void BeforeGLCall(const char* glFunction);
+    static void AfterGLCall(const char* glFunction);
+#endif
+
+#ifdef MOZ_B2G
+    EGLContext CachedCurrentContext() {
+        return sCurrentContext.get();
+    }
+    void UnsetCachedCurrentContext() {
+        sCurrentContext.set(nullptr);
+    }
+    void SetCachedCurrentContext(EGLContext aCtx) {
+        sCurrentContext.set(aCtx);
+    }
+    bool CachedCurrentContextMatches() {
+        return sCurrentContext.get() == fGetCurrentContext();
+    }
+
+private:
+    static MOZ_THREAD_LOCAL(EGLContext) sCurrentContext;
+public:
+
+#else
+    EGLContext CachedCurrentContext() {
+        return nullptr;
+    }
+    void UnsetCachedCurrentContext() {}
+    void SetCachedCurrentContext(EGLContext aCtx) { }
+    bool CachedCurrentContextMatches() { return true; }
+#endif
+
+private:
+    bool mInitialized;
+    PRLibrary* mEGLLibrary;
+    EGLDisplay mEGLDisplay;
+    RefPtr<GLContext> mReadbackGL;
+
+    bool mIsANGLE;
+    bool mIsWARP;
+    static StaticMutex sMutex;
+};
+
+extern GLLibraryEGL sEGLLibrary;
+#define EGL_DISPLAY()        sEGLLibrary.Display()
+
+} /* namespace gl */
+} /* namespace mozilla */
+
+#endif /* GLLIBRARYEGL_H_ */
+